Update esptool for Big Sur

Update boards.txt
Fix possible race condition in uart attach (#4569 )
2020-12-07 10:17:52 +02:00 · 2020-12-01 18:00:24 +02:00 · 2020-12-01 16:36:44 +02:00 · 2020-11-19 00:13:14 +02:00 · 2020-11-18 19:11:42 +02:00 · 2020-11-17 02:30:12 +02:00
3666 changed files with 15596 additions and 450096 deletions
--- a/.github/scripts/install-arduino-ide.sh
+++ b/.github/scripts/install-arduino-ide.sh
@ -98,8 +98,8 @@ function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
 		win_opts="-prefs=runtime.tools.ctags.path=$ARDUINO_IDE_PATH/tools-builder/ctags/$ctags_version -prefs=runtime.tools.arduino-preprocessor.path=$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/$preprocessor_version"
 	fi

-	#echo ""
-	#echo "Compiling '"$(basename "$sketch")"' ..."
+	echo ""
+	echo "Compiling '"$(basename "$sketch")"' ..."
 	mkdir -p "$ARDUINO_BUILD_DIR"
 	mkdir -p "$ARDUINO_CACHE_DIR"
 	$ARDUINO_IDE_PATH/arduino-builder -compile -logger=human -core-api-version=10810 \
@ -131,14 +131,14 @@ function count_sketches() # count_sketches <examples-path> <target-mcu>
        local sketchdir=$(dirname $sketch)
        local sketchdirname=$(basename $sketchdir)
        local sketchname=$(basename $sketch)
-        if [[ "$sketchdirname.ino" != "$sketchname" ]]; then
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
            continue
-        elif [[ -f "$sketchdir/.skip.$target" ]]; then
+        fi;
+        if [[ -f "$sketchdir/.skip.$target" ]]; then
            continue
-        else
-        	echo $sketch >> sketches.txt
-        	sketchnum=$(($sketchnum + 1))
        fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
    done
    return $sketchnum
 }
@ -168,13 +168,13 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
 		echo "ERROR: Chunks count must be positive number"
 		return 1
 	fi
-	if [ "$chunk_idex" -ge "$chunks_num" ] && [ "$chunks_num" -ge 2 ]; then
+	if [ "$chunk_idex" -ge "$chunks_num" ]; then
 		echo "ERROR: Chunk index must be less than chunks count"
 		return 1
 	fi

 	set +e
-    count_sketches "$examples" "$target"
+    count_sketches "$examples"
    local sketchcount=$?
 	set -e
    local sketches=$(cat sketches.txt)
@ -186,27 +186,19 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
    	chunk_size=$(( $chunk_size + 1 ))
    fi

-    local start_index=0
-    local end_index=0
-    if [ "$chunk_idex" -ge "$chunks_num" ]; then
-    	start_index=$chunk_idex
-    	end_index=$sketchcount
-    else
-	    start_index=$(( $chunk_idex * $chunk_size ))
-	    if [ "$sketchcount" -le "$start_index" ]; then
-	    	echo "Skipping job"
-	    	return 0
-	    fi
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+    	echo "Skipping job"
+    	return 0
+    fi

-	    end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
-	    if [ "$end_index" -gt "$sketchcount" ]; then
-	    	end_index=$sketchcount
-	    fi
-	fi
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+    	end_index=$sketchcount
+    fi

    local start_num=$(( $start_index + 1 ))
-    echo "Found $sketchcount Sketches for target '$target'";
-    echo "Chunk Index : $chunk_idex"
+    echo "Found $sketchcount Sketches";
    echo "Chunk Count : $chunks_num"
    echo "Chunk Size  : $chunk_size"
    echo "Start Sketch: $start_num"
@ -226,8 +218,6 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
        || [ "$sketchnum" -gt "$end_index" ]; then
        	continue
        fi
-        echo ""
-        echo "Building Sketch Index $(($sketchnum - 1)) - $sketchdirname"
        build_sketch "$fqbn" "$sketch" "$xtra_opts"
        local result=$?
        if [ $result -ne 0 ]; then
--- a/.github/scripts/on-pages.sh
+++ b/.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
--- a/.github/scripts/on-push.sh
+++ b/.github/scripts/on-push.sh
@ -24,7 +24,7 @@ BUILD_PIO=0
 if [ "$#" -lt 2 ] || [ "$CHUNKS_CNT" -le 0 ]; then
 	CHUNK_INDEX=0
 	CHUNKS_CNT=1
-elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ] &&  [ "$CHUNKS_CNT" -ge 2 ]; then
+elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ]; then
 	CHUNK_INDEX=$CHUNKS_CNT
 elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then
 	BUILD_PIO=1
@ -69,19 +69,6 @@ if [ "$BUILD_PIO" -eq 0 ]; then
 	else
 		build_sketches "$FQBN" "$TARGET" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
    fi
-
-	# ArduinoIDE ESP32C3 Test
-    TARGET="esp32c3"
-	FQBN="espressif:esp32:esp32c3:PartitionScheme=huge_app"
-	if [ "$OS_IS_WINDOWS" == "1" ]; then
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino"
-	elif [ "$OS_IS_MACOS" == "1" ]; then
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino"
-	else
-		build_sketches "$FQBN" "$TARGET" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
-    fi
 else
 	source ./.github/scripts/install-platformio-esp32.sh
 	# PlatformIO ESP32 Test
--- a/.github/scripts/on-release.sh
+++ b/.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..HEAD" > "$OUTPUT_DIR/commits.txt"
+    releaseNotes+=$'\r\n##### Commits\r\n'
+    IFS=$'\n'
+    for next in `cat $commitFile`
+    do
+        IFS=' ' read -r commitId commitMsg <<< "$next"
+        commitLine="- [$commitId](https://github.com/$GITHUB_REPOSITORY/commit/$commitId) $commitMsg"
+        releaseNotes+="$commitLine"
+        releaseNotes+=$'\r\n'
+    done
+    rm -f $commitFile
 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         
--- a/.github/stale.yml
+++ b/.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: >
--- a/.github/workflows/gh-pages.yml
+++ b/.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:

--- a/.github/workflows/release.yml
+++ b/.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'
--- a/.gitignore
+++ b/.gitignore
@ -1,11 +1,10 @@
 tools/xtensa-esp32-elf
 tools/xtensa-esp32s2-elf
-tools/riscv32-esp-elf
 tools/dist
 tools/esptool
 tools/esptool.exe
-tools/mkspiffs
-tools/mklittlefs
+tools/mkspiffs/mkspiffs
+tools/mkspiffs/mkspiffs.exe
 .DS_Store
 
 #Ignore files built by Visual Studio/Visual Micro
--- a/CMakeLists.txt
+++ b/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
@ -45,9 +44,6 @@ set(LIBRARY_SRCS
  libraries/ArduinoOTA/src/ArduinoOTA.cpp
  libraries/AsyncUDP/src/AsyncUDP.cpp
  libraries/BluetoothSerial/src/BluetoothSerial.cpp
-  libraries/BluetoothSerial/src/BTAddress.cpp
-  libraries/BluetoothSerial/src/BTAdvertisedDeviceSet.cpp
-  libraries/BluetoothSerial/src/BTScanResultsSet.cpp
  libraries/DNSServer/src/DNSServer.cpp
  libraries/EEPROM/src/EEPROM.cpp
  libraries/ESPmDNS/src/ESPmDNS.cpp
@ -59,11 +55,6 @@ set(LIBRARY_SRCS
  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
@ -127,7 +118,7 @@ set(BLE_SRCS


 set(includedirs
-  variants/${IDF_TARGET}/
+  variants/esp32/
  cores/esp32/
  libraries/ArduinoOTA/src
  libraries/AsyncUDP/src
@ -144,7 +135,6 @@ set(includedirs
  libraries/LITTLEFS/src
  libraries/NetBIOS/src
  libraries/Preferences/src
-  libraries/RainMaker/src
  libraries/SD_MMC/src
  libraries/SD/src
  libraries/SimpleBLE/src
@ -162,14 +152,7 @@ set(includedirs
 set(srcs ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 set(priv_includes cores/esp32/libb64)
 set(requires spi_flash mbedtls mdns esp_adc_cal)
-set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt arduino_tinyusb main)
-
-if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_ArduinoOTA)
-  list(APPEND priv_requires esp_https_ota)
-endif()
-if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_LITTLEFS)
-  list(APPEND priv_requires esp_littlefs)
-endif()
+set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt tinyusb main)

 idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})

--- a/Kconfig.projbuild
+++ b/Kconfig.projbuild
@ -40,12 +40,6 @@ config ARDUINO_RUNNING_CORE
    default 1 if ARDUINO_RUN_CORE1
    default -1 if ARDUINO_RUN_NO_AFFINITY

-config ARDUINO_LOOP_STACK_SIZE
-    int "Loop thread stack size"
-    default 8192
-    help
-        Amount of stack available for the Arduino task.
-
 choice ARDUINO_EVENT_RUNNING_CORE
    bool "Core on which Arduino's event handler is running"
    default ARDUINO_EVENT_RUN_CORE1
@ -271,12 +265,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 +331,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
--- a/README.md
+++ b/README.md
@ -44,8 +44,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
--- a/boards.txt
+++ b/boards.txt
--- a/cores/esp32/Esp.cpp
+++ b/cores/esp32/Esp.cpp
@ -37,8 +37,6 @@ extern "C" {
 #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
@ -267,10 +265,6 @@ const char * EspClass::getChipModel(void)
    }
 #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
 }

--- a/cores/esp32/HardwareSerial.cpp
+++ b/cores/esp32/HardwareSerial.cpp
@ -50,7 +50,7 @@ HardwareSerial Serial2(2);

 HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL) {}

-void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms, uint8_t rxfifo_full_thrhd)
+void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)
 {
    if(0 > _uart_nr || _uart_nr > 2) {
        log_e("Serial number is invalid, please use 0, 1 or 2");
@ -66,9 +66,6 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
 #elif CONFIG_IDF_TARGET_ESP32S2
        rxPin = 44;
        txPin = 43;
-#elif CONFIG_IDF_TARGET_ESP32C3
-        rxPin = 20;
-        txPin = 21;
 #endif
    }
    if(_uart_nr == 1 && rxPin < 0 && txPin < 0) {
@ -81,7 +78,7 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
        txPin = TX2;
    }
 #endif
-    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert, rxfifo_full_thrhd);
+    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
    _tx_pin = txPin;
    _rx_pin = rxPin;

@ -97,7 +94,7 @@ 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;
@ -117,7 +114,6 @@ 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);
    _uart = 0;
--- a/cores/esp32/HardwareSerial.h
+++ b/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);
--- a/cores/esp32/MD5Builder.h
+++ b/cores/esp32/MD5Builder.h
@ -28,8 +28,6 @@
 #include "esp32/rom/md5_hash.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/md5_hash.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/md5_hash.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
--- a/cores/esp32/Print.h
+++ b/cores/esp32/Print.h
@ -73,11 +73,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[]);
--- a/cores/esp32/USB.cpp
+++ b/cores/esp32/USB.cpp
@ -14,7 +14,7 @@
 #include "esp32-hal.h"
 #include "esp32-hal-tinyusb.h"
 #include "USB.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED

 #ifndef USB_VID
 #define USB_VID USB_ESPRESSIF_VID
@ -32,7 +32,11 @@
 #define USB_SERIAL "0"
 #endif

-#if CFG_TUD_DFU_RUNTIME
+extern "C" {
+#include "tinyusb.h"
+}
+
+#if CFG_TUD_DFU_RT
 static uint16_t load_dfu_descriptor(uint8_t * dst, uint8_t * itf)
 {
 #define DFU_ATTR_CAN_DOWNLOAD              1
@ -55,7 +59,7 @@ void tud_dfu_rt_reboot_to_dfu(void)
 {
    usb_persist_restart(RESTART_BOOTLOADER_DFU);
 }
-#endif /* CFG_TUD_DFU_RUNTIME */
+#endif /* CFG_TUD_DFU_RT */

 ESP_EVENT_DEFINE_BASE(ARDUINO_USB_EVENTS);

@ -183,9 +187,9 @@ ESPUSB::operator bool() const
 }

 bool ESPUSB::enableDFU(){
-#if CFG_TUD_DFU_RUNTIME
+#if CFG_TUD_DFU_RT
    return tinyusb_enable_interface(USB_INTERFACE_DFU, TUD_DFU_RT_DESC_LEN, load_dfu_descriptor) == ESP_OK;
-#endif /* CFG_TUD_DFU_RUNTIME */
+#endif /* CFG_TUD_DFU_RT */
    return false;
 }

@ -331,4 +335,4 @@ const char * ESPUSB::webUSBURL(void){

 ESPUSB USB;

-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */
--- a/cores/esp32/USB.h
+++ b/cores/esp32/USB.h
@ -14,7 +14,7 @@
 #pragma once

 #include "sdkconfig.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED

 #include "Arduino.h"
 #include "USBCDC.h"
@ -115,4 +115,4 @@ class ESPUSB {

 extern ESPUSB USB;

-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */
--- a/cores/esp32/USBCDC.cpp
+++ b/cores/esp32/USBCDC.cpp
@ -15,12 +15,16 @@
 #include "esp32-hal-tinyusb.h"
 #include "USB.h"
 #include "USBCDC.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED

 ESP_EVENT_DEFINE_BASE(ARDUINO_USB_CDC_EVENTS);
 esp_err_t arduino_usb_event_post(esp_event_base_t event_base, int32_t event_id, void *event_data, size_t event_data_size, TickType_t ticks_to_wait);
 esp_err_t arduino_usb_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg);

+extern "C" {
+#include "tinyusb.h"
+}
+
 #if CFG_TUD_CDC
 #define MAX_USB_CDC_DEVICES 2
 USBCDC * devices[MAX_USB_CDC_DEVICES] = {NULL, NULL};
@ -198,26 +202,22 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){

 void USBCDC::_onLineCoding(uint32_t _bit_rate, uint8_t _stop_bits, uint8_t _parity, uint8_t _data_bits){
    if(bit_rate != _bit_rate || data_bits != _data_bits || stop_bits != _stop_bits || parity != _parity){
-        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);
-        }
+        bit_rate = _bit_rate;
+        data_bits = _data_bits;
+        stop_bits = _stop_bits;
+        parity = _parity;
+        arduino_usb_cdc_event_data_t p = {0};
+        p.line_coding.bit_rate = bit_rate;
+        p.line_coding.data_bits = data_bits;
+        p.line_coding.stop_bits = stop_bits;
+        p.line_coding.parity = parity;
+        arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_LINE_CODING_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
    }
 }

 void USBCDC::_onRX(){
-    uint8_t buf[CONFIG_TINYUSB_CDC_RX_BUFSIZE+1];
-    uint32_t count = tud_cdc_n_read(itf, buf, CONFIG_TINYUSB_CDC_RX_BUFSIZE);
+    uint8_t buf[CONFIG_USB_CDC_RX_BUFSIZE+1];
+    uint32_t count = tud_cdc_n_read(itf, buf, CONFIG_USB_CDC_RX_BUFSIZE);
    for(uint32_t i=0; i<count; i++){
        if(rx_queue == NULL || !xQueueSend(rx_queue, buf+i, 0)){
            return;
@ -333,6 +333,6 @@ USBCDC::operator bool() const
 USBCDC Serial(0);
 #endif

-#endif /* CONFIG_TINYUSB_CDC_ENABLED */
+#endif /* CONFIG_USB_CDC_ENABLED */

-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */
--- a/cores/esp32/USBCDC.h
+++ b/cores/esp32/USBCDC.h
@ -17,7 +17,7 @@

 #include "Stream.h"
 #include "esp32-hal.h"
-#if CONFIG_TINYUSB_CDC_ENABLED
+#if CONFIG_USB_CDC_ENABLED

 #include "esp_event.h"

@ -130,4 +130,4 @@ protected:
 extern USBCDC Serial;
 #endif

-#endif /* CONFIG_TINYUSB_CDC_ENABLED */
+#endif /* CONFIG_USB_CDC_ENABLED */
--- a/cores/esp32/WMath.cpp
+++ b/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)
 {
@ -70,10 +69,7 @@ long map(long x, long in_min, long in_max, long out_min, long out_max) {
    const long dividend = out_max - out_min;
    const long divisor = in_max - in_min;
    const long delta = x - in_min;
-    if(divisor == 0){
-        log_e("Invalid map input range, min == max");
-        return -1; //AVR returns -1, SAM returns 0
-    }
+
    return (delta * dividend + (divisor / 2)) / divisor + out_min;
 }

--- a/cores/esp32/WString.cpp
+++ b/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;
 }

--- a/cores/esp32/WString.h
+++ b/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
--- a/cores/esp32/esp32-hal-adc.c
+++ b/cores/esp32/esp32-hal-adc.c
@ -16,15 +16,16 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_attr.h"
+#include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
+#include "soc/sens_reg.h"
+
 #include "driver/adc.h"

 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp_adc_cal.h"
-#include "soc/sens_reg.h"
-#include "soc/rtc_io_reg.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp_intr_alloc.h"
 #define DEFAULT_VREF    1100
@ -33,10 +34,6 @@ static uint16_t __analogVRef = 0;
 static uint8_t __analogVRefPin = 0;
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/ets_sys.h"
-#include "soc/sens_reg.h"
-#include "soc/rtc_io_reg.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -54,9 +51,7 @@ void __analogSetClockDiv(uint8_t 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)
@ -119,14 +114,11 @@ bool __adcAttachPin(uint8_t pin){
            WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, touch);
        }
 #endif
-    }
-#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
-    else if(pin == 25){
+    } else if(pin == 25){
        CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_XPD_DAC | RTC_IO_PDAC1_DAC_XPD_FORCE);//stop dac1
    } else if(pin == 26){
        CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_XPD_DAC | RTC_IO_PDAC2_DAC_XPD_FORCE);//stop dac2
    }
-#endif

    pinMode(pin, ANALOG);
    __analogSetPinAttenuation(pin, __analogAttenuation);
--- a/cores/esp32/esp32-hal-bt.c
+++ b/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

--- a/cores/esp32/esp32-hal-cpu.c
+++ b/cores/esp32/esp32-hal-cpu.c
@ -16,6 +16,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 #include "freertos/task.h"
+#include "freertos/xtensa_timer.h"
 #include "esp_attr.h"
 #include "esp_log.h"
 #include "soc/rtc.h"
@ -28,13 +29,9 @@
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "freertos/xtensa_timer.h"
 #include "esp32/rom/rtc.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "freertos/xtensa_timer.h"
 #include "esp32s2/rom/rtc.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/rtc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -144,14 +141,10 @@ bool removeApbChangeCallback(void * arg, apb_change_cb_t cb){
 }

 static uint32_t calculateApb(rtc_cpu_freq_config_t * conf){
-#if CONFIG_IDF_TARGET_ESP32C3
-	return APB_CLK_FREQ;
-#else
    if(conf->freq_mhz >= 80){
        return 80 * MHZ;
    }
    return (conf->source_freq_mhz * MHZ) / conf->div;
-#endif
 }

 void esp_timer_impl_update_apb_freq(uint32_t apb_ticks_per_us); //private in IDF
@ -226,12 +219,8 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
        esp_timer_impl_update_apb_freq(apb / MHZ);
    }
    //Update FreeRTOS Tick Divisor
-#if CONFIG_IDF_TARGET_ESP32C3
-
-#else
    uint32_t fcpu = (conf.freq_mhz >= 80)?(conf.freq_mhz * MHZ):(apb);
    _xt_tick_divisor = fcpu / XT_TICK_PER_SEC;
-#endif
    //Call peripheral functions after the APB change
    if(apb_change_callbacks){
        triggerApbChangeCallback(APB_AFTER_CHANGE, capb, apb);
--- a/cores/esp32/esp32-hal-dac.c
+++ b/cores/esp32/esp32-hal-dac.c
@ -13,29 +13,24 @@
 // limitations under the License.

 #include "esp32-hal.h"
-
-#if CONFIG_IDF_TARGET_ESP32
-#include "soc/rtc_io_reg.h"
-#define DAC1 25
-#define DAC2 26
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/rtc_io_reg.h"
-#define DAC1 17
-#define DAC2 18
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define NODAC
-#else
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-
-#ifndef NODAC
 #include "esp_attr.h"
+#include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/rtc_io_periph.h"
 #include "soc/sens_reg.h"
 #include "soc/sens_struct.h"
 #include "driver/dac.h"

+#if CONFIG_IDF_TARGET_ESP32
+#define DAC1 25
+#define DAC2 26
+#elif CONFIG_IDF_TARGET_ESP32S2
+#define DAC1 17
+#define DAC2 18
+#else
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+
 void ARDUINO_ISR_ATTR __dacWrite(uint8_t pin, uint8_t value)
 {
    if(pin < DAC1 || pin > DAC2){
@ -59,5 +54,3 @@ void ARDUINO_ISR_ATTR __dacWrite(uint8_t pin, uint8_t value)
 }

 extern void dacWrite(uint8_t pin, uint8_t value) __attribute__ ((weak, alias("__dacWrite")));
-
-#endif
--- a/cores/esp32/esp32-hal-gpio.c
+++ b/cores/esp32/esp32-hal-gpio.c
@ -20,25 +20,23 @@
 #include "soc/gpio_reg.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_struct.h"
-#include "driver/gpio.h"
-#include "esp_system.h"
+#include "soc/rtc_io_reg.h"

+#include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/gpio.h"
 #include "esp_intr_alloc.h"
-#include "soc/rtc_io_reg.h"
 #define GPIO_FUNC 2
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/ets_sys.h"
 #include "esp32s2/rom/gpio.h"
 #include "esp_intr_alloc.h"
 #include "soc/periph_defs.h"
-#include "soc/rtc_io_reg.h"
 #define GPIO_FUNC 1
 #else 
-#define USE_ESP_IDF_GPIO 1
+#error Target CONFIG_IDF_TARGET is not supported
 #endif
 #else // ESP32 Before IDF 4.0
 #include "rom/ets_sys.h"
@ -159,45 +157,7 @@ static InterruptHandle_t __pinInterruptHandlers[SOC_GPIO_PIN_COUNT] = {0,};

 extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
 {
-#if USE_ESP_IDF_GPIO
-	if (!GPIO_IS_VALID_GPIO(pin)) {
-		return;
-	}
-	gpio_config_t conf = {
-		    .pin_bit_mask = (1ULL<<pin),			/*!< GPIO pin: set with bit mask, each bit maps to a GPIO */
-		    .mode = GPIO_MODE_DISABLE,              /*!< GPIO mode: set input/output mode                     */
-		    .pull_up_en = GPIO_PULLUP_DISABLE,      /*!< GPIO pull-up                                         */
-		    .pull_down_en = GPIO_PULLDOWN_DISABLE,  /*!< GPIO pull-down                                       */
-		    .intr_type = GPIO_INTR_DISABLE      	/*!< GPIO interrupt type                                  */
-	};
-	if (mode < 0x20) {//io
-		conf.mode = mode & (INPUT | OUTPUT);
-		if (mode & OPEN_DRAIN) {
-			conf.mode |= GPIO_MODE_DEF_OD;
-		}
-		if (mode & PULLUP) {
-			conf.pull_up_en = GPIO_PULLUP_ENABLE;
-		}
-		if (mode & PULLDOWN) {
-			conf.pull_down_en = GPIO_PULLDOWN_ENABLE;
-		}
-	}
-	gpio_config(&conf);

-	if(mode == SPECIAL){
-#if CONFIG_IDF_TARGET_ESP32
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], (uint32_t)(((pin)==RX||(pin)==TX)?0:1));
-#elif CONFIG_IDF_TARGET_ESP32S2
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], (uint32_t)(((pin)==RX||(pin)==TX)?0:2));
-#endif
-	} else if(mode == ANALOG){
-#if !CONFIG_IDF_TARGET_ESP32C3
-		//adc_gpio_init(ADC_UNIT_1, ADC_CHANNEL_0);
-#endif
-	} else if(mode >= 0x20 && mode < ANALOG) {//function
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], mode >> 5);
-	}
-#else
    if(!digitalPinIsValid(pin)) {
        return;
    }
@ -268,7 +228,11 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
    pinFunction |= FUN_IE;//input enable but required for output as well?

    if(mode & (INPUT | OUTPUT)) {
-        pinFunction |= ((uint32_t)PIN_FUNC_GPIO << MCU_SEL_S);
+#if CONFIG_IDF_TARGET_ESP32
+        pinFunction |= ((uint32_t)2 << MCU_SEL_S);
+#elif CONFIG_IDF_TARGET_ESP32S2
+        pinFunction |= ((uint32_t)1 << MCU_SEL_S);
+#endif
    } else if(mode == SPECIAL) {
 #if CONFIG_IDF_TARGET_ESP32
        pinFunction |= ((uint32_t)(((pin)==RX||(pin)==TX)?0:1) << MCU_SEL_S);
@ -286,20 +250,10 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
    }

    GPIO.pin[pin].val = pinControl;
-#endif
 }

 extern void ARDUINO_ISR_ATTR __digitalWrite(uint8_t pin, uint8_t val)
 {
-#if USE_ESP_IDF_GPIO
-	gpio_set_level((gpio_num_t)pin, val);
-#elif CONFIG_IDF_TARGET_ESP32C3
-    if (val) {
-    	GPIO.out_w1ts.out_w1ts = (1 << pin);
-    } else {
-    	GPIO.out_w1tc.out_w1tc = (1 << pin);
-    }
-#else
    if(val) {
        if(pin < 32) {
            GPIO.out_w1ts = ((uint32_t)1 << pin);
@ -313,37 +267,18 @@ extern void ARDUINO_ISR_ATTR __digitalWrite(uint8_t pin, uint8_t val)
            GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
        }
    }
-#endif
 }

 extern int ARDUINO_ISR_ATTR __digitalRead(uint8_t pin)
 {
-#if USE_ESP_IDF_GPIO
-	return gpio_get_level((gpio_num_t)pin);
-#elif CONFIG_IDF_TARGET_ESP32C3
-	return (GPIO.in.data >> pin) & 0x1;
-#else
    if(pin < 32) {
        return (GPIO.in >> pin) & 0x1;
    } else if(pin < GPIO_PIN_COUNT) {
        return (GPIO.in1.val >> (pin - 32)) & 0x1;
    }
    return 0;
-#endif
 }

-#if USE_ESP_IDF_GPIO
-static void ARDUINO_ISR_ATTR __onPinInterrupt(void * arg) {
-	InterruptHandle_t * isr = (InterruptHandle_t*)arg;
-    if(isr->fn) {
-        if(isr->arg){
-            ((voidFuncPtrArg)isr->fn)(isr->arg);
-        } else {
-        	isr->fn();
-        }
-    }
-}
-#else
 static intr_handle_t gpio_intr_handle = NULL;

 static void ARDUINO_ISR_ATTR __onPinInterrupt()
@ -385,7 +320,6 @@ static void ARDUINO_ISR_ATTR __onPinInterrupt()
        } while(++pin<GPIO_PIN_COUNT);
    }
 }
-#endif

 extern void cleanupFunctional(void* arg);

@ -394,17 +328,8 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
    static bool interrupt_initialized = false;

    if(!interrupt_initialized) {
-#if USE_ESP_IDF_GPIO
-    	esp_err_t err = gpio_install_isr_service((int)ARDUINO_ISR_FLAG);
-    	interrupt_initialized = (err == ESP_OK) || (err == ESP_ERR_INVALID_STATE);
-#else
        interrupt_initialized = true;
        esp_intr_alloc(ETS_GPIO_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, __onPinInterrupt, NULL, &gpio_intr_handle);
-#endif
-    }
-    if(!interrupt_initialized) {
-    	log_e("GPIO ISR Service Failed To Start");
-    	return;
    }

    // if new attach without detach remove old info
@ -416,14 +341,6 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
    __pinInterruptHandlers[pin].arg = arg;
    __pinInterruptHandlers[pin].functional = functional;

-#if USE_ESP_IDF_GPIO
-    gpio_set_intr_type((gpio_num_t)pin, (gpio_int_type_t)(intr_type & 0x7));
-    if(intr_type & 0x8){
-    	gpio_wakeup_enable((gpio_num_t)pin, (gpio_int_type_t)(intr_type & 0x7));
-    }
-    gpio_isr_handler_add((gpio_num_t)pin, __onPinInterrupt, &__pinInterruptHandlers[pin]);
-    gpio_intr_enable((gpio_num_t)pin);
-#else
    esp_intr_disable(gpio_intr_handle);
 #if CONFIG_IDF_TARGET_ESP32
    if(esp_intr_get_cpu(gpio_intr_handle)) { //APP_CPU
@ -436,7 +353,6 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
 #endif
    GPIO.pin[pin].int_type = intr_type;
    esp_intr_enable(gpio_intr_handle);
-#endif
 }

 extern void __attachInterruptArg(uint8_t pin, voidFuncPtrArg userFunc, void * arg, int intr_type)
@ -450,13 +366,7 @@ extern void __attachInterrupt(uint8_t pin, voidFuncPtr userFunc, int intr_type)

 extern void __detachInterrupt(uint8_t pin)
 {
-#if USE_ESP_IDF_GPIO
-	gpio_intr_disable((gpio_num_t)pin);
-	gpio_isr_handler_remove((gpio_num_t)pin);
-	gpio_wakeup_disable((gpio_num_t)pin);
-#else
    esp_intr_disable(gpio_intr_handle);
-#endif
    if (__pinInterruptHandlers[pin].functional && __pinInterruptHandlers[pin].arg)
    {
    	cleanupFunctional(__pinInterruptHandlers[pin].arg);
@ -465,13 +375,9 @@ extern void __detachInterrupt(uint8_t pin)
    __pinInterruptHandlers[pin].arg = NULL;
    __pinInterruptHandlers[pin].functional = false;

-#if USE_ESP_IDF_GPIO
-    gpio_set_intr_type((gpio_num_t)pin, GPIO_INTR_DISABLE);
-#else
    GPIO.pin[pin].int_ena = 0;
    GPIO.pin[pin].int_type = 0;
    esp_intr_enable(gpio_intr_handle);
-#endif
 }


--- a/cores/esp32/esp32-hal-gpio.h
+++ b/cores/esp32/esp32-hal-gpio.h
@ -28,7 +28,7 @@ extern "C" {
 #include "soc/soc_caps.h"

 #if (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
-#define NUM_OUPUT_PINS  46
+#define NUM_OUPUT_PINS  45
 #define PIN_DAC1        17
 #define PIN_DAC2        18
 #else
--- a/cores/esp32/esp32-hal-i2c.c
+++ b/cores/esp32/esp32-hal-i2c.c
@ -21,19 +21,16 @@
 #include "driver/periph_ctrl.h"
 #include "soc/i2c_reg.h"
 #include "soc/i2c_struct.h"
+#include "soc/dport_reg.h"
 #include "esp_attr.h"
 #include "esp32-hal-cpu.h" // cpu clock change support 31DEC2018

 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
 #include "esp32s2/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -1798,7 +1795,7 @@ struct i2c_struct_t {
 static i2c_t * i2c_ports[2] = {NULL, NULL};

 i2c_t * i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed){
-	if(i2c_num >= SOC_I2C_NUM){
+	if(i2c_num >= 2){
 		return NULL;
 	}
 	if(!clk_speed){
@ -1819,7 +1816,7 @@ i2c_t * i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed){
 		i2c_driver_delete((i2c_port_t)i2c_num);
 	}

-    i2c_config_t conf = { };
+    i2c_config_t conf;
    conf.mode = I2C_MODE_MASTER;
    conf.scl_io_num = (gpio_num_t)scl;
    conf.sda_io_num = (gpio_num_t)sda;
--- a/cores/esp32/esp32-hal-ledc.c
+++ b/cores/esp32/esp32-hal-ledc.c
@ -17,25 +17,19 @@
 #include "freertos/task.h"
 #include "freertos/semphr.h"
 #include "esp32-hal-matrix.h"
+#include "soc/dport_reg.h"
 #include "soc/ledc_reg.h"
 #include "soc/ledc_struct.h"
-#include "driver/periph_ctrl.h"

 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
 #define LAST_CHAN (15)
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
 #include "esp32s2/rom/ets_sys.h"
 #define LAST_CHAN (7)
 #define LEDC_DIV_NUM_HSTIMER0_V LEDC_CLK_DIV_LSTIMER0_V
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#define LAST_CHAN (7)
-#define LEDC_DIV_NUM_HSTIMER0_V LEDC_CLK_DIV_LSTIMER0_V
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -117,7 +111,8 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
    static uint16_t _activeChannels = 0;
    if(!tHasStarted) {
        tHasStarted = true;
-        periph_module_enable(PERIPH_LEDC_MODULE);
+        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_LEDC_CLK_EN);
+        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_LEDC_RST);
        LEDC.conf.apb_clk_sel = 1;//LS use apb clock
        addApbChangeCallback((void*)&_activeChannels, _on_apb_change);

@ -307,7 +302,7 @@ void ledcAttachPin(uint8_t pin, uint8_t chan)
        return;
    }
    pinMode(pin, OUTPUT);
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
    pinMatrixOutAttach(pin, LEDC_LS_SIG_OUT0_IDX + chan, false, false);
 #else
    pinMatrixOutAttach(pin, ((chan/8)?LEDC_LS_SIG_OUT0_IDX:LEDC_HS_SIG_OUT0_IDX) + (chan%8), false, false);
@ -318,12 +313,3 @@ void ledcDetachPin(uint8_t pin)
 {
    pinMatrixOutDetach(pin, false, false);
 }
-
-double ledcChangeFrequency(uint8_t chan, double freq, uint8_t bit_num)
-{
-    if (chan > 15) {
-        return 0;
-    }
-    double res_freq = _ledcSetupTimerFreq(chan, freq, bit_num);
-    return res_freq;
-}
--- a/cores/esp32/esp32-hal-ledc.h
+++ b/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
--- a/cores/esp32/esp32-hal-log.c
+++ b/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
--- a/cores/esp32/esp32-hal-log.h
+++ b/cores/esp32/esp32-hal-log.h
@ -37,9 +37,6 @@ extern "C"
 #define ARDUHAL_LOG_LEVEL CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL
 #else
 #define ARDUHAL_LOG_LEVEL CORE_DEBUG_LEVEL
-#ifdef USE_ESP_IDF_LOG
-#define LOG_LOCAL_LEVEL CORE_DEBUG_LEVEL
-#endif
 #endif

 #ifndef CONFIG_ARDUHAL_LOG_COLORS
@ -75,8 +72,6 @@ extern "C"
 #define ARDUHAL_LOG_RESET_COLOR
 #endif

-
-
 const char * pathToFileName(const char * path);
 int log_printf(const char *fmt, ...);

@ -84,92 +79,55 @@ int log_printf(const char *fmt, ...);
 #define ARDUHAL_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter "[%6u][" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", (unsigned long) (esp_timer_get_time() / 1000ULL), pathToFileName(__FILE__), __LINE__, __FUNCTION__

 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_VERBOSE
-#ifndef USE_ESP_IDF_LOG
 #define log_v(format, ...) log_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)
 #define isr_log_v(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)
 #else
-#define log_v(format, ...) do {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 +151,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
 }
--- a/cores/esp32/esp32-hal-matrix.c
+++ b/cores/esp32/esp32-hal-matrix.c
@ -21,8 +21,6 @@
 #include "esp32/rom/gpio.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/gpio.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/gpio.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
--- a/cores/esp32/esp32-hal-misc.c
+++ b/cores/esp32/esp32-hal-misc.c
@ -40,10 +40,6 @@
 #include "esp32/rom/rtc.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/rtc.h"
-#include "driver/temp_sensor.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/rtc.h"
-#include "driver/temp_sensor.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -53,25 +49,12 @@

 //Undocumented!!! Get chip temperature in Farenheit
 //Source: https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_int_temp_sensor/ESP32_int_temp_sensor.ino
-#ifdef CONFIG_IDF_TARGET_ESP32
 uint8_t temprature_sens_read();

 float temperatureRead()
 {
    return (temprature_sens_read() - 32) / 1.8;
 }
-#else
-float temperatureRead()
-{
-    float result = NAN;
-    temp_sensor_config_t tsens = TSENS_CONFIG_DEFAULT();
-    temp_sensor_set_config(tsens);
-    temp_sensor_start();
-    temp_sensor_read_celsius(&result); 
-    temp_sensor_stop();
-    return result;
-}
-#endif

 void __yield()
 {
@ -177,15 +160,15 @@ void delay(uint32_t ms)

 void ARDUINO_ISR_ATTR delayMicroseconds(uint32_t us)
 {
-    uint64_t m = (uint64_t)esp_timer_get_time();
+    uint32_t m = micros();
    if(us){
-        uint64_t e = (m + us);
+        uint32_t e = (m + us);
        if(m > e){ //overflow
-            while((uint64_t)esp_timer_get_time() > e){
+            while(micros() > e){
                NOP();
            }
        }
-        while((uint64_t)esp_timer_get_time() < e){
+        while(micros() < e){
            NOP();
        }
    }
--- a/cores/esp32/esp32-hal-rmt.c
+++ b/cores/esp32/esp32-hal-rmt.c
@ -28,27 +28,15 @@
 */
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #define MAX_CHANNELS 8
-#define MAX_DATA_PER_CHANNEL 64
-#define MAX_DATA_PER_ITTERATION 62
 #elif CONFIG_IDF_TARGET_ESP32S2
 #define MAX_CHANNELS 4
-#define MAX_DATA_PER_CHANNEL 64
-#define MAX_DATA_PER_ITTERATION 62
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define MAX_CHANNELS 4
-#define MAX_DATA_PER_CHANNEL 48
-#define MAX_DATA_PER_ITTERATION 46
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
+#define MAX_DATA_PER_CHANNEL 64
+#define MAX_DATA_PER_ITTERATION 62
 #define _ABS(a) (a>0?a:-a)
 #define _LIMIT(a,b) (a>b?b:a)
-#if CONFIG_IDF_TARGET_ESP32C3
-#define _INT_TX_END(channel) (1<<(channel))
-#define _INT_RX_END(channel) (4<<(channel))
-#define _INT_ERROR(channel)  (16<<(channel))
-#define _INT_THR_EVNT(channel)  (256<<(channel))
-#else
 #define __INT_TX_END     (1)
 #define __INT_RX_END     (2)
 #define __INT_ERROR      (4)
@ -58,7 +46,6 @@
 #define _INT_RX_END(channel) (__INT_RX_END<<(channel*3))
 #define _INT_ERROR(channel)  (__INT_ERROR<<(channel*3))
 #define _INT_THR_EVNT(channel)  ((__INT_THR_EVNT)<<(channel))
-#endif

 #if CONFIG_DISABLE_HAL_LOCKS
 # define RMT_MUTEX_LOCK(channel)
@ -68,7 +55,7 @@
 # define RMT_MUTEX_UNLOCK(channel)  xSemaphoreGive(g_rmt_objlocks[channel])
 #endif /* CONFIG_DISABLE_HAL_LOCKS */

-//#define _RMT_INTERNAL_DEBUG
+#define _RMT_INTERNAL_DEBUG
 #ifdef _RMT_INTERNAL_DEBUG
 # define DEBUG_INTERRUPT_START(pin)    digitalWrite(pin, 1);
 # define DEBUG_INTERRUPT_END(pin)      digitalWrite(pin, 0);
@ -175,17 +162,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 +183,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 +200,7 @@ bool rmtSetRxThreshold(rmt_obj_t* rmt, uint32_t value)
    size_t channel = rmt->channel;

    RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf0.idle_thres = value;
-#else
    RMT.conf_ch[channel].conf0.idle_thres = value;
-#endif
    RMT_MUTEX_UNLOCK(channel);

    return true;
@ -292,7 +265,7 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
    int channel = rmt->channel;
    int allocated_size = MAX_DATA_PER_CHANNEL * rmt->buffers;

-    if (size > (allocated_size - 1)) {
+    if (size > allocated_size) {

        int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
        RMT_MUTEX_LOCK(channel);
@ -306,18 +279,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 +288,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 +304,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 
@ -382,15 +342,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;
 }

@ -429,26 +384,17 @@ 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;
@ -461,11 +407,7 @@ bool rmtEnd(rmt_obj_t* rmt) {
    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;
@ -495,11 +437,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 +445,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 +474,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 +491,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)
@ -628,47 +553,6 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
    // - 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;
@ -701,7 +585,7 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
        RMT.conf_ch[channel].conf1.mem_owner = 1;
        RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
    }
-#endif
+
    // install interrupt if at least one channel is active
    if (!intr_handle) {
        esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, _rmt_isr, NULL, &intr_handle);
@ -720,11 +604,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 +616,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 +643,6 @@ static void _initPin(int pin, int channel, bool tx_not_rx)
 {
    if (!periph_enabled) {
        periph_enabled = true;
-        periph_module_reset( PERIPH_RMT_MODULE );
        periph_module_enable( PERIPH_RMT_MODULE );
    }
    if (tx_not_rx) {
@ -785,7 +658,6 @@ static void _initPin(int pin, int channel, bool tx_not_rx)

 static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
 {
-	//DEBUG_INTERRUPT_START(4);
    int intr_val = RMT.int_st.val;
    size_t ch;
    for (ch = 0; ch < MAX_CHANNELS; ch++) {
@ -820,15 +692,9 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
                        (g_rmt_objects[ch].cb)(data_received, _rmt_get_mem_len(ch), g_rmt_objects[ch].arg);

                        // 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 +720,10 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
                xEventGroupSetBits(g_rmt_objects[ch].events, RMT_FLAG_ERROR);
            }
            // reset memory
-#if CONFIG_IDF_TARGET_ESP32C3
-            RMT.tx_conf[ch].mem_rd_rst = 1;
-            RMT.tx_conf[ch].mem_rd_rst = 0;
-            RMT.rx_conf[ch].conf1.mem_wr_rst = 1;
-            RMT.rx_conf[ch].conf1.mem_wr_rst = 0;
-#else
            RMT.conf_ch[ch].conf1.mem_rd_rst = 1;
            RMT.conf_ch[ch].conf1.mem_rd_rst = 0;
            RMT.conf_ch[ch].conf1.mem_wr_rst = 1;
            RMT.conf_ch[ch].conf1.mem_wr_rst = 0;
-#endif
        }

        if (intr_val & _INT_TX_END(ch)) {
@ -876,24 +735,15 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
        if (intr_val & _INT_THR_EVNT(ch)) {
            // clear the flag
            RMT.int_clr.val = _INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-            //RMT.int_clr.val = _INT_TX_END(ch);
-            //RMT.int_ena.val |= _INT_TX_END(ch);
-#endif

            // initial setup of continuous mode
            if (g_rmt_objects[ch].tx_state & E_SET_CONTI) {
-#if CONFIG_IDF_TARGET_ESP32C3
-                RMT.tx_conf[ch].tx_conti_mode = 1;
-#else
                RMT.conf_ch[ch].conf1.tx_conti_mode = 1;
-#endif
                g_rmt_objects[ch].intr_mode &= ~E_SET_CONTI;
            }
            _rmt_tx_mem_first(ch);
        }
    }
-    //DEBUG_INTERRUPT_END(4);
 }

 static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
@ -903,23 +753,14 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
    int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
    int i;

-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_lim[ch].limit = half_tx_nr+2;
-#else
    RMT.tx_lim_ch[ch].limit = half_tx_nr+2;
-#endif
    RMT.int_clr.val = _INT_THR_EVNT(ch);
    RMT.int_ena.val |= _INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-    //RMT.int_clr.val = _INT_TX_END(ch);
-    //RMT.int_ena.val &= ~_INT_TX_END(ch);
-#endif

    g_rmt_objects[ch].tx_state |= E_FIRST_HALF;

    if (data) {
        int remaining_size = g_rmt_objects[ch].data_size;
-        //ets_printf("RMT Tx[%d] %d\n", ch, remaining_size);
        // will the remaining data occupy the entire halfbuffer
        if (remaining_size > half_tx_nr) {
            for (i = 0; i < half_tx_nr; i++) {
@ -938,30 +779,17 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
            g_rmt_objects[ch].data_ptr = NULL;

        }
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0;
-        RMT.tx_conf[ch].tx_start = 1;
-#endif
    } else if   ((!(g_rmt_objects[ch].tx_state & E_LAST_DATA)) &&
                 (!(g_rmt_objects[ch].tx_state & E_END_TRANS))) {
-        //ets_printf("RMT Tx finishing %d!\n", ch);
        for (i = 0; i < half_tx_nr; i++) {
            RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0x000F000F;
        }
        RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0;
        g_rmt_objects[ch].tx_state |= E_LAST_DATA;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
        RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
    } else {
-        //ets_printf("RMT Tx finished %d!\n", ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
+        log_d("RMT Tx finished %d!\n", ch);
        RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
        RMT.int_ena.val &= ~_INT_TX_END(ch);
        RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
        g_rmt_objects[ch].intr_mode = E_NO_INTR;
@ -977,15 +805,10 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
    int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
    int i;
    RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_lim[ch].limit = 0;
-#else
    RMT.tx_lim_ch[ch].limit = 0;
-#endif

    if (data) {
        int remaining_size = g_rmt_objects[ch].data_size;
-        //ets_printf("RMT TxF[%d] %d\n", ch, remaining_size);

        // will the remaining data occupy the entire halfbuffer
        if (remaining_size > half_tx_nr) {
@ -996,11 +819,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 +836,23 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
            g_rmt_objects[ch].data_ptr = NULL;
        }
    } else { 
-        //ets_printf("RMT TxF finished %d!\n", ch);
        for (i = 0; i < half_tx_nr; i++) {
            RMTMEM.chan[ch].data32[i].val = 0x000F000F;
        }
        RMTMEM.chan[ch].data32[i].val = 0;

        g_rmt_objects[ch].tx_state &= ~E_FIRST_HALF;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_lim[ch].limit = 0;
-#else
        RMT.tx_lim_ch[ch].limit = 0;
-#endif
        g_rmt_objects[ch].tx_state |= E_LAST_DATA;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
        RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
    }
    DEBUG_INTERRUPT_END(2);
 }

 static int ARDUINO_ISR_ATTR _rmt_get_mem_len(uint8_t channel)
 {
-#if CONFIG_IDF_TARGET_ESP32C3
-    int block_num = RMT.rx_conf[channel].conf0.mem_size;
-    int item_block_len = block_num * 48;
-#else
    int block_num = RMT.conf_ch[channel].conf0.mem_size;
    int item_block_len = block_num * 64;
-#endif
    volatile rmt_item32_t* data = RMTMEM.chan[channel].data32;
    int idx;
    for(idx = 0; idx < item_block_len; idx++) {
--- a/cores/esp32/esp32-hal-sigmadelta.c
+++ b/cores/esp32/esp32-hal-sigmadelta.c
@ -26,8 +26,6 @@
 #include "esp32/rom/ets_sys.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
--- a/cores/esp32/esp32-hal-spi.c
+++ b/cores/esp32/esp32-hal-spi.c
@ -22,25 +22,19 @@
 #include "soc/spi_struct.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_sig_map.h"
+#include "soc/dport_reg.h"
 #include "soc/rtc.h"
-#include "driver/periph_ctrl.h"

 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/gpio.h"
 #include "esp_intr_alloc.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
 #include "esp32s2/rom/ets_sys.h"
 #include "esp32s2/rom/gpio.h"
 #include "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp32c3/rom/gpio.h"
-#include "esp_intr_alloc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -68,24 +62,11 @@ struct spi_struct_t {

 #define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:0))
 #define SPI_HSPI_SS_IDX(n)  ((n==0)?SPI3_CS0_OUT_IDX:((n==1)?SPI3_CS1_OUT_IDX:((n==2)?SPI3_CS2_OUT_IDX:SPI3_CS0_OUT_IDX)))
-#define SPI_FSPI_SS_IDX(n)  ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:FSPICS0_OUT_IDX)))
+#define SPI_FSPI_SS_IDX(n)  ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:VSPICS0_OUT_IDX)))
 #define SPI_SS_IDX(p, n)    ((p==0)?SPI_SPI_SS_IDX(n):((p==1)?SPI_SPI_SS_IDX(n):((p==2)?SPI_HSPI_SS_IDX(n):0)))

 #define SPI_INTR_SOURCE(u)  ((u==0)?ETS_SPI1_INTR_SOURCE:((u==1)?ETS_SPI2_INTR_SOURCE:((u==2)?ETS_SPI3_INTR_SOURCE:0)))

-#elif CONFIG_IDF_TARGET_ESP32C3
-// ESP32S2
-#define SPI_COUNT           (1)
-
-#define SPI_CLK_IDX(p)      FSPICLK_OUT_IDX
-#define SPI_MISO_IDX(p)     FSPIQ_OUT_IDX
-#define SPI_MOSI_IDX(p)     FSPID_IN_IDX
-
-#define SPI_SPI_SS_IDX(n)   ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:FSPICS0_OUT_IDX)))
-#define SPI_SS_IDX(p, n)    SPI_SPI_SS_IDX(n)
-
-#define SPI_INTR_SOURCE(u)  ETS_SPI2_INTR_SOURCE
-
 #else
 // ESP32
 #define SPI_COUNT           (4)
@ -128,8 +109,6 @@ static spi_t _spi_bus_array[] = {
    {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 0},
    {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 1},
    {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 2}
-#elif CONFIG_IDF_TARGET_ESP32C3
-    {(volatile spi_dev_t *)(&GPSPI2), NULL, FSPI}
 #else
    {(volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0},
    {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1},
@ -152,7 +131,7 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            sck = 14;
        } else if(spi->num == VSPI) {
@ -160,9 +139,6 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
        } else {
            sck = 6;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    pinMode(sck, OUTPUT);
@ -182,7 +158,7 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            miso = 12;
        } else if(spi->num == VSPI) {
@ -190,9 +166,6 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
        } else {
            miso = 7;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    SPI_MUTEX_LOCK();
@ -214,7 +187,7 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            mosi = 13;
        } else if(spi->num == VSPI) {
@ -222,9 +195,6 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
        } else {
            mosi = 8;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    pinMode(mosi, OUTPUT);
@ -244,7 +214,7 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            sck = 14;
        } else if(spi->num == VSPI) {
@ -252,9 +222,6 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
        } else {
            sck = 6;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    pinMatrixOutDetach(sck, false, false);
@ -274,7 +241,7 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            miso = 12;
        } else if(spi->num == VSPI) {
@ -282,9 +249,6 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
        } else {
            miso = 7;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    pinMatrixInDetach(SPI_MISO_IDX(spi->num), false, false);
@ -304,7 +268,7 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            mosi = 13;
        } else if(spi->num == VSPI) {
@ -312,9 +276,6 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
        } else {
            mosi = 8;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    pinMatrixOutDetach(mosi, false, false);
@ -338,7 +299,7 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            ss = 15;
        } else if(spi->num == VSPI) {
@ -346,9 +307,6 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
        } else {
            ss = 11;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    pinMode(ss, OUTPUT);
@ -369,7 +327,7 @@ void spiDetachSS(spi_t * spi, int8_t ss)
            log_e("HSPI Does not have default pins on ESP32S2!");
            return;
        }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
        if(spi->num == HSPI) {
            ss = 15;
        } else if(spi->num == VSPI) {
@ -377,9 +335,6 @@ void spiDetachSS(spi_t * spi, int8_t ss)
        } else {
            ss = 11;
        }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
    }
    pinMatrixOutDetach(ss, false, false);
@ -392,7 +347,7 @@ void spiEnableSSPins(spi_t * spi, uint8_t cs_mask)
        return;
    }
    SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
    spi->dev->misc.val &= ~(cs_mask & SPI_CS_MASK_ALL);
 #else
    spi->dev->pin.val &= ~(cs_mask & SPI_CS_MASK_ALL);
@ -406,7 +361,7 @@ void spiDisableSSPins(spi_t * spi, uint8_t cs_mask)
        return;
    }
    SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
    spi->dev->misc.val |= (cs_mask & SPI_CS_MASK_ALL);
 #else
    spi->dev->pin.val |= (cs_mask & SPI_CS_MASK_ALL);
@ -442,7 +397,7 @@ void spiSSSet(spi_t * spi)
        return;
    }
    SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
    spi->dev->misc.cs_keep_active = 1;
 #else
    spi->dev->pin.cs_keep_active = 1;
@ -456,7 +411,7 @@ void spiSSClear(spi_t * spi)
        return;
    }
    SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
    spi->dev->misc.cs_keep_active = 0;
 #else
    spi->dev->pin.cs_keep_active = 0;
@ -487,7 +442,7 @@ uint8_t spiGetDataMode(spi_t * spi)
    if(!spi) {
        return 0;
    }
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
    bool idleEdge = spi->dev->misc.ck_idle_edge;
 #else
    bool idleEdge = spi->dev->pin.ck_idle_edge;
@ -513,7 +468,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
    SPI_MUTEX_LOCK();
    switch (dataMode) {
    case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 0;
 #else
        spi->dev->pin.ck_idle_edge = 0;
@ -521,7 +476,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
        spi->dev->user.ck_out_edge = 1;
        break;
    case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 1;
 #else
        spi->dev->pin.ck_idle_edge = 1;
@ -529,7 +484,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
        spi->dev->user.ck_out_edge = 1;
        break;
    case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 1;
 #else
        spi->dev->pin.ck_idle_edge = 1;
@ -538,7 +493,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
        break;
    case SPI_MODE0:
    default:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 0;
 #else
        spi->dev->pin.ck_idle_edge = 0;
@ -587,11 +542,9 @@ static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb

 static void spiInitBus(spi_t * spi)
 {
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->slave.trans_done = 0;
-#endif
-    spi->dev->slave.val = 0;
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+    spi->dev->slave.slave_mode = 0;
+#if CONFIG_IDF_TARGET_ESP32S2
    spi->dev->misc.val = 0;
 #else
    spi->dev->pin.val = 0;
@ -599,15 +552,8 @@ static void spiInitBus(spi_t * spi)
    spi->dev->user.val = 0;
    spi->dev->user1.val = 0;
    spi->dev->ctrl.val = 0;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->ctrl1.val = 0;
    spi->dev->ctrl2.val = 0;
-#else
-    spi->dev->clk_gate.val = 0;
-    spi->dev->dma_conf.val = 0;
-    spi->dev->dma_conf.rx_afifo_rst = 1;
-    spi->dev->dma_conf.buf_afifo_rst = 1;
-#endif
    spi->dev->clock.val = 0;
 }

@ -616,9 +562,9 @@ void spiStopBus(spi_t * spi)
    if(!spi) {
        return;
    }
-
+    
    removeApbChangeCallback(spi, _on_apb_change);
-
+    
    SPI_MUTEX_LOCK();
    spiInitBus(spi);
    SPI_MUTEX_UNLOCK();
@ -652,7 +598,7 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
    }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
    if(spi_num == HSPI) {
        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI2_CLK_EN);
        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI2_RST);
@ -663,24 +609,14 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
    }
-#elif CONFIG_IDF_TARGET_ESP32C3
-    periph_module_reset( PERIPH_SPI2_MODULE );
-    periph_module_enable( PERIPH_SPI2_MODULE );
 #endif

    SPI_MUTEX_LOCK();
    spiInitBus(spi);
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->clk_gate.clk_en = 1;
-    spi->dev->clk_gate.mst_clk_sel = 1;
-    spi->dev->clk_gate.mst_clk_active = 1;
-    spi->dev->dma_conf.tx_seg_trans_clr_en = 1;
-    spi->dev->dma_conf.rx_seg_trans_clr_en = 1;
-    spi->dev->dma_conf.dma_seg_trans_en = 0;
-#endif
    spi->dev->user.usr_mosi = 1;
    spi->dev->user.usr_miso = 1;
    spi->dev->user.doutdin = 1;
+
    int i;
    for(i=0; i<16; i++) {
        spi->dev->data_buf[i] = 0x00000000;
@ -692,7 +628,6 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
    spiSetClockDiv(spi, clockDiv);

    addApbChangeCallback(spi, _on_apb_change);
-
    return spi;
 }

@ -707,11 +642,6 @@ void spiWaitReady(spi_t * spi)
 #if CONFIG_IDF_TARGET_ESP32S2
 #define usr_mosi_dbitlen usr_mosi_bit_len
 #define usr_miso_dbitlen usr_miso_bit_len
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define usr_mosi_dbitlen ms_data_bitlen
-#define usr_miso_dbitlen ms_data_bitlen
-#define mosi_dlen ms_dlen
-#define miso_dlen ms_dlen
 #endif

 void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
@ -725,16 +655,10 @@ void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
    }
    SPI_MUTEX_LOCK();
    spi->dev->mosi_dlen.usr_mosi_dbitlen = (len * 32) - 1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
    for(i=0; i<len; i++) {
        spi->dev->data_buf[i] = data[i];
    }
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    SPI_MUTEX_UNLOCK();
@ -755,10 +679,6 @@ void spiTransfer(spi_t * spi, uint32_t *data, uint8_t len)
    for(i=0; i<len; i++) {
        spi->dev->data_buf[i] = data[i];
    }
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    for(i=0; i<len; i++) {
@ -774,14 +694,8 @@ void spiWriteByte(spi_t * spi, uint8_t data)
    }
    SPI_MUTEX_LOCK();
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    SPI_MUTEX_UNLOCK();
@ -796,10 +710,6 @@ uint8_t spiTransferByte(spi_t * spi, uint8_t data)
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
    spi->dev->miso_dlen.usr_miso_dbitlen = 7;
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    data = spi->dev->data_buf[0] & 0xFF;
@ -827,14 +737,8 @@ void spiWriteWord(spi_t * spi, uint16_t data)
    }
    SPI_MUTEX_LOCK();
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    SPI_MUTEX_UNLOCK();
@ -852,10 +756,6 @@ uint16_t spiTransferWord(spi_t * spi, uint16_t data)
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
    spi->dev->miso_dlen.usr_miso_dbitlen = 15;
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    data = spi->dev->data_buf[0];
@ -876,14 +776,8 @@ void spiWriteLong(spi_t * spi, uint32_t data)
    }
    SPI_MUTEX_LOCK();
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    SPI_MUTEX_UNLOCK();
@ -901,10 +795,6 @@ uint32_t spiTransferLong(spi_t * spi, uint32_t data)
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
    spi->dev->miso_dlen.usr_miso_dbitlen = 31;
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    data = spi->dev->data_buf[0];
@ -944,10 +834,6 @@ static void __spiTransferBytes(spi_t * spi, const uint8_t * data, uint8_t * out,
        spi->dev->data_buf[i] = wordsBuf[i];    //copy buffer to spi fifo
    }

-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;

    while(spi->dev->cmd.usr);
@ -1012,7 +898,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
    spi->dev->clock.val = clockDiv;
    switch (dataMode) {
    case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 0;
 #else
        spi->dev->pin.ck_idle_edge = 0;
@ -1020,7 +906,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
        spi->dev->user.ck_out_edge = 1;
        break;
    case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 1;
 #else
        spi->dev->pin.ck_idle_edge = 1;
@ -1028,7 +914,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
        spi->dev->user.ck_out_edge = 1;
        break;
    case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 1;
 #else
        spi->dev->pin.ck_idle_edge = 1;
@ -1037,7 +923,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
        break;
    case SPI_MODE0:
    default:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
        spi->dev->misc.ck_idle_edge = 0;
 #else
        spi->dev->pin.ck_idle_edge = 0;
@ -1076,14 +962,8 @@ void ARDUINO_ISR_ATTR spiWriteByteNL(spi_t * spi, uint8_t data)
        return;
    }
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
 }
@ -1096,10 +976,6 @@ uint8_t spiTransferByteNL(spi_t * spi, uint8_t data)
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
    spi->dev->miso_dlen.usr_miso_dbitlen = 7;
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    data = spi->dev->data_buf[0] & 0xFF;
@ -1115,14 +991,8 @@ void ARDUINO_ISR_ATTR spiWriteShortNL(spi_t * spi, uint16_t data)
        MSB_16_SET(data, data);
    }
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
 }
@ -1138,10 +1008,6 @@ uint16_t spiTransferShortNL(spi_t * spi, uint16_t data)
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
    spi->dev->miso_dlen.usr_miso_dbitlen = 15;
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    data = spi->dev->data_buf[0] & 0xFFFF;
@ -1160,14 +1026,8 @@ void ARDUINO_ISR_ATTR spiWriteLongNL(spi_t * spi, uint32_t data)
        MSB_32_SET(data, data);
    }
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
 }
@ -1183,10 +1043,6 @@ uint32_t spiTransferLongNL(spi_t * spi, uint32_t data)
    spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
    spi->dev->miso_dlen.usr_miso_dbitlen = 31;
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    data = spi->dev->data_buf[0];
@ -1197,9 +1053,6 @@ uint32_t spiTransferLongNL(spi_t * spi, uint32_t data)
 }

 void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len){
-    if(!spi) {
-        return;
-    }
    size_t longs = len >> 2;
    if(len & 3){
        longs++;
@ -1212,16 +1065,10 @@ void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len){
        c_longs = (longs > 16)?16:longs;

        spi->dev->mosi_dlen.usr_mosi_dbitlen = (c_len*8)-1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
+        spi->dev->miso_dlen.usr_miso_dbitlen = 0;
        for (int i=0; i<c_longs; i++) {
            spi->dev->data_buf[i] = data[i];
        }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
        spi->dev->cmd.usr = 1;
        while(spi->dev->cmd.usr);

@ -1258,27 +1105,11 @@ void spiTransferBytesNL(spi_t * spi, const void * data_in, uint8_t * data_out, u
                spi->dev->data_buf[i] = 0xFFFFFFFF;
            }
        }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
        spi->dev->cmd.usr = 1;
        while(spi->dev->cmd.usr);
        if(result){
-            if(c_len & 3){
-                for (int i=0; i<(c_longs-1); i++) {
-                    result[i] = spi->dev->data_buf[i];
-                }
-                uint32_t last_data = spi->dev->data_buf[c_longs-1];
-                uint8_t * last_out8 = (uint8_t *)&result[c_longs-1];
-                uint8_t * last_data8 = (uint8_t *)&last_data;
-                for (int i=0; i<(c_len & 3); i++) {
-                    last_out8[i] = last_data8[i];
-                }
-            } else {
-                for (int i=0; i<c_longs; i++) {
-                    result[i] = spi->dev->data_buf[i];
-                }
+            for (int i=0; i<c_longs; i++) {
+                result[i] = spi->dev->data_buf[i];
            }
        }
        if(data){
@ -1317,10 +1148,6 @@ void spiTransferBitsNL(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
    spi->dev->mosi_dlen.usr_mosi_dbitlen = (bits - 1);
    spi->dev->miso_dlen.usr_miso_dbitlen = (bits - 1);
    spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
    spi->dev->cmd.usr = 1;
    while(spi->dev->cmd.usr);
    data = spi->dev->data_buf[0];
@ -1353,9 +1180,7 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32
        l_bytes = (c_len & 3);

        spi->dev->mosi_dlen.usr_mosi_dbitlen = (c_len*8)-1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
+        spi->dev->miso_dlen.usr_miso_dbitlen = 0;
        for (int i=0; i<c_longs; i++) {
            if(msb){
                if(l_bytes && i == (c_longs - 1)){
@ -1371,10 +1196,6 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32
                spi->dev->data_buf[i] = data[i];
            }
        }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
        spi->dev->cmd.usr = 1;
        while(spi->dev->cmd.usr);

@ -1397,12 +1218,7 @@ typedef union {
            uint32_t clkcnt_l:       6;                     /*it must be equal to spi_clkcnt_N.*/
            uint32_t clkcnt_h:       6;                     /*it must be floor((spi_clkcnt_N+1)/2-1).*/
            uint32_t clkcnt_n:       6;                     /*it is the divider of spi_clk. So spi_clk frequency is system/(spi_clkdiv_pre+1)/(spi_clkcnt_N+1)*/
-#if CONFIG_IDF_TARGET_ESP32C3
-            uint32_t clkdiv_pre:     4;                     /*it is pre-divider of spi_clk.*/
-            uint32_t reserved:       9;  					/*reserved*/
-#else
            uint32_t clkdiv_pre:    13;                     /*it is pre-divider of spi_clk.*/
-#endif
            uint32_t clk_equ_sysclk: 1;                     /*1: spi_clk is eqaul to system 0: spi_clk is divided from system clock.*/
    };
 } spiClk_t;
@ -1444,13 +1260,8 @@ uint32_t spiFrequencyToClockDiv(uint32_t freq)

        while(calPreVari++ <= 1) {
            calPre = (((apb_freq / (reg.clkcnt_n + 1)) / freq) - 1) + calPreVari;
-#if CONFIG_IDF_TARGET_ESP32C3
-            if(calPre > 0xF) {
-                reg.clkdiv_pre = 0xF;
-#else
            if(calPre > 0x1FFF) {
                reg.clkdiv_pre = 0x1FFF;
-#endif
            } else if(calPre <= 0) {
                reg.clkdiv_pre = 0;
            } else {
--- a/cores/esp32/esp32-hal-spi.h
+++ b/cores/esp32/esp32-hal-spi.h
@ -25,16 +25,11 @@ extern "C" {

 #define SPI_HAS_TRANSACTION

-#if CONFIG_IDF_TARGET_ESP32C3
-#define FSPI  0
-#define HSPI  1
-#else
 #define FSPI  1 //SPI bus attached to the flash (can use the same data lines but different SS)
 #define HSPI  2 //SPI bus normally mapped to pins 12 - 15, but can be matrixed to any pins
 #if CONFIG_IDF_TARGET_ESP32
 #define VSPI  3 //SPI bus normally attached to pins 5, 18, 19 and 23, but can be matrixed to any pins
 #endif
-#endif

 // This defines are not representing the real Divider of the ESP32
 // the Defines match to an AVR Arduino on 16MHz for better compatibility
--- a/cores/esp32/esp32-hal-timer.c
+++ b/cores/esp32/esp32-hal-timer.c
@ -14,12 +14,10 @@

 #include "esp32-hal-timer.h"
 #include "freertos/FreeRTOS.h"
-#ifndef CONFIG_IDF_TARGET_ESP32C3
 #include "freertos/xtensa_api.h"
-#include "soc/dport_reg.h"
-#endif
 #include "freertos/task.h"
 #include "soc/timer_group_struct.h"
+#include "soc/dport_reg.h"
 #include "esp_attr.h"
 #include "driver/periph_ctrl.h"

@ -32,10 +30,6 @@
 #include "esp32s2/rom/ets_sys.h"
 #include "esp_intr_alloc.h"
 #include "soc/periph_defs.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
-#include "soc/periph_defs.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -272,6 +266,9 @@ void timerEnd(hw_timer_t *timer){
 }

 void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
+	// EDGE DOES NOT WORK CURRENTLY
+	edge = false;
+
    static bool initialized = false;
    static intr_handle_t intr_handle = NULL;
    if(intr_handle){
@ -302,15 +299,12 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
        timer->dev->config.level_int_en = edge?0:1;//When set, an alarm will generate a level type interrupt.
        timer->dev->config.edge_int_en = edge?1:0;//When set, an alarm will generate an edge type interrupt.
        int intr_source = 0;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
        if(!edge){
-#endif
            if(timer->group){
                intr_source = ETS_TG1_T0_LEVEL_INTR_SOURCE + timer->timer;
            } else {
                intr_source = ETS_TG0_T0_LEVEL_INTR_SOURCE + timer->timer;
            }
-#ifndef CONFIG_IDF_TARGET_ESP32C3
        } else {
            if(timer->group){
                intr_source = ETS_TG1_T0_EDGE_INTR_SOURCE + timer->timer;
@ -318,7 +312,6 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
                intr_source = ETS_TG0_T0_EDGE_INTR_SOURCE + timer->timer;
            }
        }
-#endif
        if(!initialized){
            initialized = true;
            esp_intr_alloc(intr_source, (int)(ARDUINO_ISR_FLAG|ESP_INTR_FLAG_LOWMED), __timerISR, NULL, &intr_handle);
--- a/cores/esp32/esp32-hal-tinyusb.c
+++ b/cores/esp32/esp32-hal-tinyusb.c
@ -1,8 +1,7 @@

 #include "sdkconfig.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED
 #include <stdlib.h>
-#include <stdbool.h>

 #include "esp_log.h"

@ -13,14 +12,10 @@
 #include "soc/usb_reg.h"
 #include "soc/usb_wrap_reg.h"
 #include "soc/usb_wrap_struct.h"
-#include "soc/usb_periph.h"
 #include "soc/periph_defs.h"
 #include "soc/timer_group_struct.h"
 #include "soc/system_reg.h"

-#include "hal/usb_hal.h"
-#include "hal/gpio_ll.h"
-
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"

@ -29,8 +24,8 @@

 #include "esp_efuse.h"
 #include "esp_efuse_table.h"
-#include "esp_rom_gpio.h"

+#include "tinyusb.h"
 #include "esp32-hal.h"

 #include "esp32-hal-tinyusb.h"
@ -38,66 +33,6 @@
 #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;
@ -359,9 +294,9 @@ bool tud_vendor_control_complete_cb(uint8_t rhport, tusb_control_request_t const
 * Required Callbacks
 * */
 #if CFG_TUD_HID
-__attribute__ ((weak)) const uint8_t * tud_hid_descriptor_report_cb(uint8_t itf){return NULL;}
-__attribute__ ((weak)) uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen){return 0;}
-__attribute__ ((weak)) void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, const uint8_t * buffer, uint16_t bufsize){}
+__attribute__ ((weak)) const uint8_t * tud_hid_descriptor_report_cb(void){return NULL;}
+__attribute__ ((weak)) uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen){return 0;}
+__attribute__ ((weak)) void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, const uint8_t * buffer, uint16_t bufsize){}
 #endif
 #if CFG_TUD_MSC
 __attribute__ ((weak)) bool tud_msc_test_unit_ready_cb(uint8_t lun){return false;}
@ -450,8 +385,8 @@ static bool tinyusb_load_enabled_interfaces(){
    };
    memcpy(tinyusb_config_descriptor, descriptor, TUD_CONFIG_DESC_LEN);
    if ((tinyusb_loaded_interfaces_mask == (BIT(USB_INTERFACE_CDC) | BIT(USB_INTERFACE_DFU))) || (tinyusb_loaded_interfaces_mask == BIT(USB_INTERFACE_CDC))) {
-        //usb_persist_enabled = true;
-        //log_d("USB Persist enabled");
+        usb_persist_enabled = true;
+        log_d("USB Persist enabled");
    }
    log_d("Load Done: if_num: %u, descr_len: %u, if_mask: 0x%x", tinyusb_loaded_interfaces_num, tinyusb_config_descriptor_len, tinyusb_loaded_interfaces_mask);
    return true;
@ -530,9 +465,6 @@ static void IRAM_ATTR usb_persist_shutdown_handler(void)
            //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) {
@ -586,12 +518,11 @@ esp_err_t tinyusb_init(tinyusb_device_config_t *config) {

    bool usb_did_persist = (USB_WRAP.date.val == USBDC_PERSIST_ENA);

-    //if(usb_did_persist && usb_persist_enabled){
+    if(usb_did_persist && usb_persist_enabled){
        // Enable USB/IO_MUX peripheral reset, if coming from persistent reboot
        REG_CLR_BIT(RTC_CNTL_USB_CONF_REG, RTC_CNTL_IO_MUX_RESET_DISABLE);
        REG_CLR_BIT(RTC_CNTL_USB_CONF_REG, RTC_CNTL_USB_RESET_DISABLE);
-    //} else 
-    if(!usb_did_persist || !usb_persist_enabled){
+    } else {
        // Reset USB module
        periph_module_reset(PERIPH_USB_MODULE);
        periph_module_enable(PERIPH_USB_MODULE);
@ -763,4 +694,4 @@ void usb_dw_reg_dump(void)
    }
 }
 */
-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */
--- a/cores/esp32/esp32-hal-tinyusb.h
+++ b/cores/esp32/esp32-hal-tinyusb.h
@ -16,18 +16,13 @@
 #include "esp32-hal.h"

 #if CONFIG_IDF_TARGET_ESP32S2
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED

 #ifdef __cplusplus
 extern "C" {
 #endif

-#include "tusb.h"
-#include "tusb_option.h"
-#include "tusb_config.h"
-
-#define USB_ESPRESSIF_VID 0x303A
-#define USB_STRING_DESCRIPTOR_ARRAY_SIZE 10
+#include "tinyusb.h"

 typedef struct {
        uint16_t vid;
@ -51,10 +46,10 @@ typedef struct {
 #define TINYUSB_CONFIG_DEFAULT() {                                      \
        .vid = USB_ESPRESSIF_VID,                                       \
        .pid = 0x0002,                                                  \
-        .product_name = CONFIG_TINYUSB_DESC_PRODUCT_STRING,                 \
-        .manufacturer_name = CONFIG_TINYUSB_DESC_MANUFACTURER_STRING,       \
-        .serial_number = CONFIG_TINYUSB_DESC_SERIAL_STRING,                 \
-        .fw_version = CONFIG_TINYUSB_DESC_BCDDEVICE,                        \
+        .product_name = CONFIG_USB_DESC_PRODUCT_STRING,                 \
+        .manufacturer_name = CONFIG_USB_DESC_MANUFACTURER_STRING,       \
+        .serial_number = CONFIG_USB_DESC_SERIAL_STRING,                 \
+        .fw_version = CONFIG_USB_DESC_BCDDEVICE,                        \
        .usb_version = 0x0200,                                          \
        .usb_class = TUSB_CLASS_MISC,                                   \
        .usb_subclass = MISC_SUBCLASS_COMMON,                           \
@ -104,5 +99,5 @@ uint8_t tinyusb_get_free_out_endpoint(void);
 }
 #endif

-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */
 #endif /* CONFIG_IDF_TARGET_ESP32S2 */
--- a/cores/esp32/esp32-hal-touch.c
+++ b/cores/esp32/esp32-hal-touch.c
@ -13,14 +13,13 @@
 // limitations under the License.

 #include "esp32-hal-touch.h"
-#ifndef CONFIG_IDF_TARGET_ESP32C3
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_attr.h"
 #include "soc/rtc_io_reg.h"
+#include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
 #include "soc/sens_struct.h"
-#include "soc/rtc_cntl_reg.h"
 #include "driver/touch_sensor.h"

 #include "esp_system.h"
@ -226,4 +225,3 @@ void __touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t thresh
 extern uint16_t touchRead(uint8_t pin) __attribute__ ((weak, alias("__touchRead")));
 extern void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold) __attribute__ ((weak, alias("__touchAttachInterrupt")));
 extern void touchSetCycles(uint16_t measure, uint16_t sleep) __attribute__ ((weak, alias("__touchSetCycles")));
-#endif
--- a/cores/esp32/esp32-hal-uart.c
+++ b/cores/esp32/esp32-hal-uart.c
@ -23,25 +23,19 @@
 #include "soc/uart_struct.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_sig_map.h"
+#include "soc/dport_reg.h"
 #include "soc/rtc.h"
-#include "hal/uart_ll.h"
 #include "esp_intr_alloc.h"

 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/uart.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
 #include "esp32s2/rom/ets_sys.h"
 #include "esp32s2/rom/uart.h"
 #include "soc/periph_defs.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp32c3/rom/uart.h"
-#include "soc/periph_defs.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@ -51,24 +45,18 @@
 #include "esp_intr.h"
 #endif

-#if CONFIG_IDF_TARGET_ESP32
-#define UART_PORTS_NUM 3
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:(    (u==2)?DR_REG_UART2_BASE:0)))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:(         (u==2)?U2RXD_IN_IDX:0)))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:(        (u==2)?U2TXD_OUT_IDX:0)))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:((u==2)?ETS_UART2_INTR_SOURCE:0)))
-#elif CONFIG_IDF_TARGET_ESP32S2
+#if CONFIG_IDF_TARGET_ESP32S2
 #define UART_PORTS_NUM 2
 #define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:0))
 #define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:0))
 #define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:0))
 #define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:0))
 #else
-#define UART_PORTS_NUM 2
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:0))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:0))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:0))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:0))
+#define UART_PORTS_NUM 3
+#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:(    (u==2)?DR_REG_UART2_BASE:0)))
+#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:(         (u==2)?U2RXD_IN_IDX:0)))
+#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:(        (u==2)?U2TXD_OUT_IDX:0)))
+#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:((u==2)?ETS_UART2_INTR_SOURCE:0)))
 #endif

 static int s_uart_debug_nr = 0;
@ -142,10 +130,10 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
    }
 }

-static void uartEnableInterrupt(uart_t* uart, uint8_t rxfifo_full_thrhd)
+void uartEnableInterrupt(uart_t* uart)
 {
    UART_MUTEX_LOCK();
-    uart->dev->conf1.rxfifo_full_thrhd = rxfifo_full_thrhd;
+    uart->dev->conf1.rxfifo_full_thrhd = 112;
 #if CONFIG_IDF_TARGET_ESP32
    uart->dev->conf1.rx_tout_thrhd = 2;
 #else
@ -161,7 +149,7 @@ static void uartEnableInterrupt(uart_t* uart, uint8_t rxfifo_full_thrhd)
    UART_MUTEX_UNLOCK();
 }

-static void uartDisableInterrupt(uart_t* uart)
+void uartDisableInterrupt(uart_t* uart)
 {
    UART_MUTEX_LOCK();
    uart->dev->conf1.val = 0;
@ -174,7 +162,7 @@ static void uartDisableInterrupt(uart_t* uart)
    UART_MUTEX_UNLOCK();
 }

-static void uartDetachRx(uart_t* uart, uint8_t rxPin)
+void uartDetachRx(uart_t* uart, uint8_t rxPin)
 {
    if(uart == NULL) {
        return;
@ -183,7 +171,7 @@ static void uartDetachRx(uart_t* uart, uint8_t rxPin)
    uartDisableInterrupt(uart);
 }

-static void uartDetachTx(uart_t* uart, uint8_t txPin)
+void uartDetachTx(uart_t* uart, uint8_t txPin)
 {
    if(uart == NULL) {
        return;
@ -191,17 +179,17 @@ static void uartDetachTx(uart_t* uart, uint8_t txPin)
    pinMatrixOutDetach(txPin, false, false);
 }

-static void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted, uint8_t rxfifo_full_thrhd)
+void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
 {
    if(uart == NULL || rxPin >= GPIO_PIN_COUNT) {
        return;
    }
    pinMode(rxPin, INPUT);
-    uartEnableInterrupt(uart, rxfifo_full_thrhd);
+    uartEnableInterrupt(uart);
    pinMatrixInAttach(rxPin, UART_RXD_IDX(uart->num), inverted);
 }

-static void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
+void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 {
    if(uart == NULL || txPin >= GPIO_PIN_COUNT) {
        return;
@ -210,7 +198,7 @@ static void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
    pinMatrixOutAttach(txPin, UART_TXD_IDX(uart->num), inverted, false);
 }

-uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted, uint8_t rxfifo_full_thrhd)
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted)
 {
    if(uart_nr >= UART_PORTS_NUM) {
        return NULL;
@ -237,9 +225,6 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
            return NULL;
        }
    }
-#if CONFIG_IDF_TARGET_ESP32C3
-
-#else
    if(uart_nr == 1){
        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART1_CLK_EN);
        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART1_RST);
@ -252,7 +237,6 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART_CLK_EN);
        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART_RST);
    }
-#endif
    uartFlush(uart);
    uartSetBaudRate(uart, baudrate);
    UART_MUTEX_LOCK();
@ -272,7 +256,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
    UART_MUTEX_UNLOCK();

    if(rxPin != -1) {
-        uartAttachRx(uart, rxPin, inverted, rxfifo_full_thrhd);
+        uartAttachRx(uart, rxPin, inverted);
    }

    if(txPin != -1) {
@ -338,11 +322,7 @@ uint32_t uartAvailable(uart_t* uart)
    if(uart == NULL || uart->queue == NULL) {
        return 0;
    }
-#ifdef UART_READ_RX_FIFO
    return (uxQueueMessagesWaiting(uart->queue) + uart->dev->status.rxfifo_cnt) ;
-#else
-    return uxQueueMessagesWaiting(uart->queue);
-#endif
 }

 uint32_t uartAvailableForWrite(uart_t* uart)
@ -353,7 +333,6 @@ uint32_t uartAvailableForWrite(uart_t* uart)
    return 0x7f - uart->dev->status.txfifo_cnt;
 }

-#ifdef UART_READ_RX_FIFO
 void uartRxFifoToQueue(uart_t* uart)
 {
 	uint8_t c;
@ -378,7 +357,6 @@ void uartRxFifoToQueue(uart_t* uart)
 	uart->dev->int_clr.val = 0xffffffff;
    UART_MUTEX_UNLOCK();
 }
-#endif

 uint8_t uartRead(uart_t* uart)
 {
@ -386,12 +364,10 @@ uint8_t uartRead(uart_t* uart)
        return 0;
    }
    uint8_t c;
-#ifdef UART_READ_RX_FIFO
    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
    {
    	uartRxFifoToQueue(uart);
    }
-#endif
    if(xQueueReceive(uart->queue, &c, 0)) {
        return c;
    }
@ -404,12 +380,10 @@ uint8_t uartPeek(uart_t* uart)
        return 0;
    }
    uint8_t c;
-#ifdef UART_READ_RX_FIFO
    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
    {
    	uartRxFifoToQueue(uart);
    }
-#endif
    if(xQueuePeek(uart->queue, &c, 0)) {
        return c;
    }
@ -493,7 +467,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();
 }

@ -690,17 +666,15 @@ unsigned long uartBaudrateDetect(uart_t *uart, bool flg)
 */
 void uartStartDetectBaudrate(uart_t *uart) {
  if(!uart) return;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
+
  uart->dev->auto_baud.glitch_filt = 0x08;
  uart->dev->auto_baud.en = 0;
  uart->dev->auto_baud.en = 1;
-#endif
 }

 unsigned long
 uartDetectBaudrate(uart_t *uart)
 {
-#ifndef CONFIG_IDF_TARGET_ESP32C3
    static bool uartStateDetectingBaudrate = false;

    if(!uartStateDetectingBaudrate) {
@ -735,9 +709,6 @@ uartDetectBaudrate(uart_t *uart)
    }

    return default_rates[i];
-#else
-    return 0;
-#endif
 }

 /*
--- a/cores/esp32/esp32-hal-uart.h
+++ b/cores/esp32/esp32-hal-uart.h
@ -51,7 +51,7 @@ 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);
+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, uint8_t rxPin, uint8_t txPin);

 uint32_t uartAvailable(uart_t* uart);
--- a/cores/esp32/main.cpp
+++ b/cores/esp32/main.cpp
@ -6,10 +6,6 @@
 #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
@ -48,7 +44,7 @@ extern "C" void app_main()
 #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, ARDUINO_RUNNING_CORE);
 }

 #endif
--- a/docs/arduino-ide/debian_ubuntu.md
+++ b/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 && \
--- a/docs/esp32s2_pinmap.png
+++ b/docs/esp32s2_pinmap.png
--- a/libraries/AsyncUDP/src/AsyncUDP.cpp
+++ b/libraries/AsyncUDP/src/AsyncUDP.cpp
@ -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));
--- a/libraries/AsyncUDP/src/AsyncUDP.h
+++ b/libraries/AsyncUDP/src/AsyncUDP.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);
--- a/libraries/BLE/examples/BLE_Beacon_Scanner/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_Beacon_Scanner/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_EddystoneTLM_Beacon/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_EddystoneTLM_Beacon/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_EddystoneURL_Beacon/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_EddystoneURL_Beacon/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_client/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_client/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_iBeacon/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_iBeacon/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_notify/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_notify/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_scan/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_scan/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_server/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_server/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_server_multiconnect/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_server_multiconnect/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_uart/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_uart/.skip.esp32c3
--- a/libraries/BLE/examples/BLE_write/.skip.esp32c3
+++ b/libraries/BLE/examples/BLE_write/.skip.esp32c3
--- a/libraries/BLE/src/BLEAddress.cpp
+++ b/libraries/BLE/src/BLEAddress.cpp
@ -59,37 +59,14 @@ BLEAddress::BLEAddress(std::string stringAddress) {
 * @return True if the addresses are equal.
 */
 bool BLEAddress::equals(BLEAddress otherAddress) {
-	return memcmp(otherAddress.getNative(), m_address, ESP_BD_ADDR_LEN) == 0;
+	return memcmp(otherAddress.getNative(), m_address, 6) == 0;
 } // equals

-bool BLEAddress::operator==(const BLEAddress& otherAddress) const {
-	return memcmp(otherAddress.m_address, m_address, ESP_BD_ADDR_LEN) == 0;
-}
-
-bool BLEAddress::operator!=(const BLEAddress& otherAddress) const {
-  return !(*this == otherAddress);
-}
-
-bool BLEAddress::operator<(const BLEAddress& otherAddress) const {
-  return memcmp(otherAddress.m_address, m_address, ESP_BD_ADDR_LEN) < 0;
-}
-
-bool BLEAddress::operator<=(const BLEAddress& otherAddress) const {
-  return !(*this > otherAddress);
-}
-
-bool BLEAddress::operator>=(const BLEAddress& otherAddress) const {
-  return !(*this < otherAddress);
-}
-
-bool BLEAddress::operator>(const BLEAddress& otherAddress) const {
-  return memcmp(otherAddress.m_address, m_address, ESP_BD_ADDR_LEN) > 0;
-}

 /**
 * @brief Return the native representation of the address.
 * @return The native representation of the address.
- */   
+ */
 esp_bd_addr_t *BLEAddress::getNative() {
 	return &m_address;
 } // getNative
--- a/libraries/BLE/src/BLEAddress.h
+++ b/libraries/BLE/src/BLEAddress.h
@ -23,12 +23,6 @@ public:
 	BLEAddress(esp_bd_addr_t address);
 	BLEAddress(std::string stringAddress);
 	bool           equals(BLEAddress otherAddress);
-  bool           operator==(const BLEAddress& otherAddress) const;
-  bool           operator!=(const BLEAddress& otherAddress) const;
-  bool           operator<(const BLEAddress& otherAddress) const;
-  bool           operator<=(const BLEAddress& otherAddress) const;
-  bool           operator>(const BLEAddress& otherAddress) const;
-  bool           operator>=(const BLEAddress& otherAddress) const;
 	esp_bd_addr_t* getNative();
 	std::string    toString();

--- a/libraries/BLE/src/BLEAdvertisedDevice.cpp
+++ b/libraries/BLE/src/BLEAdvertisedDevice.cpp
@ -25,7 +25,6 @@ BLEAdvertisedDevice::BLEAdvertisedDevice() {
 	m_manufacturerData = "";
 	m_name             = "";
 	m_rssi             = -9999;
-	m_serviceUUIDs     = {};
 	m_serviceData      = {};
 	m_serviceDataUUIDs = {};
 	m_txPower          = 0;
@ -35,6 +34,8 @@ BLEAdvertisedDevice::BLEAdvertisedDevice() {
 	m_haveManufacturerData = false;
 	m_haveName             = false;
 	m_haveRSSI             = false;
+	m_haveServiceData      = false;
+	m_haveServiceUUID      = false;
 	m_haveTXPower          = false;

 } // BLEAdvertisedDevice
@ -106,7 +107,11 @@ BLEScan* BLEAdvertisedDevice::getScan() {
 * @return Number of service data discovered.
 */
 int BLEAdvertisedDevice::getServiceDataCount() {
-	return m_serviceData.size();
+	if (m_haveServiceData)
+		return m_serviceData.size();
+	else
+		return 0;
+
 } //getServiceDataCount

 /**
@ -114,7 +119,7 @@ int BLEAdvertisedDevice::getServiceDataCount() {
 * @return The ServiceData of the advertised device.
 */
 std::string BLEAdvertisedDevice::getServiceData() {
-	return m_serviceData.empty() ? std::string() : m_serviceData.front();
+	return m_serviceData[0];
 } //getServiceData

 /**
@ -125,20 +130,12 @@ std::string BLEAdvertisedDevice::getServiceData(int i) {
 	return m_serviceData[i];
 } //getServiceData

-/**
- * @brief Get the number of service data UUIDs.
- * @return Number of service data UUIDs discovered.
- */
-int BLEAdvertisedDevice::getServiceDataUUIDCount() {
-	return m_serviceDataUUIDs.size();
-} //getServiceDataUUIDCount
-
 /**
 * @brief Get the service data UUID.
 * @return The service data UUID.
 */
 BLEUUID BLEAdvertisedDevice::getServiceDataUUID() {
-	return m_serviceDataUUIDs.empty() ? BLEUUID() : m_serviceDataUUIDs.front();
+	return m_serviceDataUUIDs[0];
 } // getServiceDataUUID

 /**
@ -149,20 +146,12 @@ BLEUUID BLEAdvertisedDevice::getServiceDataUUID(int i) {
 	return m_serviceDataUUIDs[i];
 } // getServiceDataUUID

-/**
- * @brief Get the number of service UUIDs.
- * @return Number of service UUIDs discovered.
- */
-int BLEAdvertisedDevice::getServiceUUIDCount() {
-	return m_serviceUUIDs.size();
-} //getServiceUUIDCount
-
 /**
 * @brief Get the Service UUID.
 * @return The Service UUID of the advertised device.
 */
 BLEUUID BLEAdvertisedDevice::getServiceUUID() {
-	return m_serviceUUIDs.empty() ? BLEUUID() : m_serviceUUIDs.front();
+	return m_serviceUUIDs[0];
 } // getServiceUUID

 /**
@ -178,7 +167,7 @@ BLEUUID BLEAdvertisedDevice::getServiceUUID(int i) {
 * @return Return true if service is advertised
 */
 bool BLEAdvertisedDevice::isAdvertisingService(BLEUUID uuid){
-	for (int i = 0; i < getServiceUUIDCount(); i++) {
+	for (int i = 0; i < m_serviceUUIDs.size(); i++) {
 		if (m_serviceUUIDs[i].equals(uuid)) return true;
 	}
 	return false;
@ -235,7 +224,7 @@ bool BLEAdvertisedDevice::haveRSSI() {
 * @return True if there is a service data value present.
 */
 bool BLEAdvertisedDevice::haveServiceData() {
-	return !m_serviceData.empty();
+	return m_haveServiceData;
 } // haveServiceData


@ -244,7 +233,7 @@ bool BLEAdvertisedDevice::haveServiceData() {
 * @return True if there is a service UUID value present.
 */
 bool BLEAdvertisedDevice::haveServiceUUID() {
-	return !m_serviceUUIDs.empty();
+	return m_haveServiceUUID;
 } // haveServiceUUID


@ -497,6 +486,7 @@ void BLEAdvertisedDevice::setServiceUUID(const char* serviceUUID) {
 */
 void BLEAdvertisedDevice::setServiceUUID(BLEUUID serviceUUID) {
 	m_serviceUUIDs.push_back(serviceUUID);
+	m_haveServiceUUID = true;
 	log_d("- addServiceUUID(): serviceUUID: %s", serviceUUID.toString().c_str());
 } // setServiceUUID

@ -506,6 +496,7 @@ void BLEAdvertisedDevice::setServiceUUID(BLEUUID serviceUUID) {
 * @param [in] data ServiceData value.
 */
 void BLEAdvertisedDevice::setServiceData(std::string serviceData) {
+	m_haveServiceData = true;         // Set the flag that indicates we have service data.
 	m_serviceData.push_back(serviceData); // Save the service data that we received.
 } //setServiceData

@ -515,6 +506,7 @@ void BLEAdvertisedDevice::setServiceData(std::string serviceData) {
 * @param [in] data ServiceDataUUID value.
 */
 void BLEAdvertisedDevice::setServiceDataUUID(BLEUUID uuid) {
+	m_haveServiceData = true;         // Set the flag that indicates we have service data.
 	m_serviceDataUUIDs.push_back(uuid);
 	log_d("- addServiceDataUUID(): serviceDataUUID: %s", uuid.toString().c_str());
 } // setServiceDataUUID
@ -550,7 +542,7 @@ std::string BLEAdvertisedDevice::toString() {
 		free(pHex);
 	}
 	if (haveServiceUUID()) {
-		for (int i=0; i < getServiceUUIDCount(); i++) {
+		for (int i=0; i < m_serviceUUIDs.size(); i++) {
 		    res += ", serviceUUID: " + getServiceUUID(i).toString();
 		}
 	}
--- a/libraries/BLE/src/BLEAdvertisedDevice.h
+++ b/libraries/BLE/src/BLEAdvertisedDevice.h
@ -42,8 +42,6 @@ public:
 	BLEUUID     getServiceUUID();
 	BLEUUID     getServiceUUID(int i);
 	int         getServiceDataCount();
-	int         getServiceDataUUIDCount();
-	int         getServiceUUIDCount();
 	int8_t      getTXPower();
 	uint8_t* 	getPayload();
 	size_t		getPayloadLength();
@ -85,6 +83,8 @@ private:
 	bool m_haveManufacturerData;
 	bool m_haveName;
 	bool m_haveRSSI;
+	bool m_haveServiceData;
+	bool m_haveServiceUUID;
 	bool m_haveTXPower;


--- a/libraries/BLE/src/BLEAdvertising.cpp
+++ b/libraries/BLE/src/BLEAdvertising.cpp
@ -91,10 +91,6 @@ void BLEAdvertising::setAdvertisementType(esp_ble_adv_type_t adv_type){
 	m_advParams.adv_type = adv_type;
 } // setAdvertisementType

-void BLEAdvertising::setAdvertisementChannelMap(esp_ble_adv_channel_t channel_map) {
-	m_advParams.channel_map = channel_map;
-} // setAdvertisementChannelMap
-
 void BLEAdvertising::setMinInterval(uint16_t mininterval) {
 	m_advParams.adv_int_min = mininterval;
 } // setMinInterval
--- a/libraries/BLE/src/BLEAdvertising.h
+++ b/libraries/BLE/src/BLEAdvertising.h
@ -53,7 +53,6 @@ public:
 	void stop();
 	void setAppearance(uint16_t appearance);
 	void setAdvertisementType(esp_ble_adv_type_t adv_type);
-	void setAdvertisementChannelMap(esp_ble_adv_channel_t channel_map);
 	void setMaxInterval(uint16_t maxinterval);
 	void setMinInterval(uint16_t mininterval);
 	void setAdvertisementData(BLEAdvertisementData& advertisementData);
--- a/libraries/BLE/src/BLECharacteristic.cpp
+++ b/libraries/BLE/src/BLECharacteristic.cpp
@ -223,8 +223,7 @@ void BLECharacteristic::handleGATTServerEvent(
 				m_writeEvt = false;
 				if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
 					m_value.commit();
-					// Invoke the onWrite callback handler.
-					m_pCallbacks->onWrite(this, param);
+					m_pCallbacks->onWrite(this); // Invoke the onWrite callback handler.
 				} else {
 					m_value.cancel();
 				}
@ -312,8 +311,7 @@ void BLECharacteristic::handleGATTServerEvent(
 				} // Response needed

 				if (param->write.is_prep != true) {
-					// Invoke the onWrite callback handler.
-					m_pCallbacks->onWrite(this, param);
+					m_pCallbacks->onWrite(this); // Invoke the onWrite callback handler.
 				}
 			} // Match on handles.
 			break;
@ -385,7 +383,7 @@ void BLECharacteristic::handleGATTServerEvent(

 						// If is.long is false then this is the first (or only) request to read data, so invoke the callback
 						// Invoke the read callback.
-						m_pCallbacks->onRead(this, param);
+						m_pCallbacks->onRead(this);

 						std::string value = m_value.getValue();

@ -759,35 +757,46 @@ std::string BLECharacteristic::toString() {

 BLECharacteristicCallbacks::~BLECharacteristicCallbacks() {}

-void BLECharacteristicCallbacks::onRead(BLECharacteristic* pCharacteristic, esp_ble_gatts_cb_param_t* param) {
-	onRead(pCharacteristic);
-} // onRead

+/**
+ * @brief Callback function to support a read request.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ */
 void BLECharacteristicCallbacks::onRead(BLECharacteristic* pCharacteristic) {
-	log_d(">> onRead: default");
-	log_d("<< onRead");
+	log_d("BLECharacteristicCallbacks", ">> onRead: default");
+	log_d("BLECharacteristicCallbacks", "<< onRead");
 } // onRead


-void BLECharacteristicCallbacks::onWrite(BLECharacteristic* pCharacteristic, esp_ble_gatts_cb_param_t* param) {
-	onWrite(pCharacteristic);
-} // onWrite
-
+/**
+ * @brief Callback function to support a write request.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ */
 void BLECharacteristicCallbacks::onWrite(BLECharacteristic* pCharacteristic) {
-	log_d(">> onWrite: default");
-	log_d("<< onWrite");
+	log_d("BLECharacteristicCallbacks", ">> onWrite: default");
+	log_d("BLECharacteristicCallbacks", "<< onWrite");
 } // onWrite


+/**
+ * @brief Callback function to support a Notify request.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ */
 void BLECharacteristicCallbacks::onNotify(BLECharacteristic* pCharacteristic) {
-	log_d(">> onNotify: default");
-	log_d("<< onNotify");
+	log_d("BLECharacteristicCallbacks", ">> onNotify: default");
+	log_d("BLECharacteristicCallbacks", "<< onNotify");
 } // onNotify


+/**
+ * @brief Callback function to support a Notify/Indicate Status report.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ * @param [in] s Status of the notification/indication
+ * @param [in] code Additional code of underlying errors
+ */
 void BLECharacteristicCallbacks::onStatus(BLECharacteristic* pCharacteristic, Status s, uint32_t code) {
-	log_d(">> onStatus: default");
-	log_d("<< onStatus");
+	log_d("BLECharacteristicCallbacks", ">> onStatus: default");
+	log_d("BLECharacteristicCallbacks", "<< onStatus");
 } // onStatus


--- a/libraries/BLE/src/BLECharacteristic.h
+++ b/libraries/BLE/src/BLECharacteristic.h
@ -145,43 +145,9 @@ public:
 	}Status;

 	virtual ~BLECharacteristicCallbacks();
-
-	/**
-	 * @brief Callback function to support a read request.
-	 * @param [in] pCharacteristic The characteristic that is the source of the event.
-	 * @param [in] param The BLE GATTS param. Use param->read.
-	 */
-	virtual void onRead(BLECharacteristic* pCharacteristic, esp_ble_gatts_cb_param_t* param);
-	/**
-	 * @brief DEPRECATED! Callback function to support a read request. Called only if onRead(,) not overrided. 
-	 * @param [in] pCharacteristic The characteristic that is the source of the event.
-	 */
 	virtual void onRead(BLECharacteristic* pCharacteristic);
-
-	/**
-	 * @brief Callback function to support a write request.
-	 * @param [in] pCharacteristic The characteristic that is the source of the event.
-	 * @param [in] param The BLE GATTS param. Use param->write.
-	 */
-	virtual void onWrite(BLECharacteristic* pCharacteristic, esp_ble_gatts_cb_param_t* param);
-	/**
-	 * @brief DEPRECATED! Callback function to support a write request. Called only if onWrite(,) not overrided. 
-	 * @param [in] pCharacteristic The characteristic that is the source of the event.
-	 */
 	virtual void onWrite(BLECharacteristic* pCharacteristic);
-
-	/**
-	 * @brief Callback function to support a Notify request.
-	 * @param [in] pCharacteristic The characteristic that is the source of the event.
-	 */
 	virtual void onNotify(BLECharacteristic* pCharacteristic);
-
-	/**
-	 * @brief Callback function to support a Notify/Indicate Status report.
-	 * @param [in] pCharacteristic The characteristic that is the source of the event.
-	 * @param [in] s Status of the notification/indication
-	 * @param [in] code Additional code of underlying errors
-	 */
 	virtual void onStatus(BLECharacteristic* pCharacteristic, Status s, uint32_t code);
 };
 #endif /* CONFIG_BLUEDROID_ENABLED */
--- a/libraries/BLE/src/BLEClient.cpp
+++ b/libraries/BLE/src/BLEClient.cpp
@ -10,7 +10,6 @@
 #include <esp_bt_main.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gattc_api.h>
-#include <esp_gatt_common_api.h>// ESP32 BLE
 #include "BLEClient.h"
 #include "BLEUtils.h"
 #include "BLEService.h"
@ -61,7 +60,6 @@ BLEClient::~BLEClient() {
 	   delete myPair.second;
 	}
 	m_servicesMap.clear();
-	m_servicesMapByInstID.clear();
 } // ~BLEClient


@ -111,17 +109,7 @@ bool BLEClient::connect(BLEAddress address, esp_ble_addr_type_t type) {
 		return false;
 	}

-	uint32_t rc = m_semaphoreRegEvt.wait("connect");
-
-	if (rc != ESP_GATT_OK) {
-		// fixes ESP_GATT_NO_RESOURCES error mostly
-		log_e("esp_ble_gattc_app_register_error: rc=%d", rc);
-		BLEDevice::removePeerDevice(m_appId, true);
-		// not sure if this is needed here
-		// esp_ble_gattc_app_unregister(m_gattc_if);
-		// m_gattc_if = ESP_GATT_IF_NONE;
-		return false;
-	}
+	m_semaphoreRegEvt.wait("connect");

 	m_peerAddress = address;

@ -139,13 +127,7 @@ bool BLEClient::connect(BLEAddress address, esp_ble_addr_type_t type) {
 		return false;
 	}

-	rc = m_semaphoreOpenEvt.wait("connect");   // Wait for the connection to complete.
-	// check the status of the connection and cleanup in case of failure
-	if (rc != ESP_GATT_OK) {
-		BLEDevice::removePeerDevice(m_appId, true);
-		esp_ble_gattc_app_unregister(m_gattc_if);
-		m_gattc_if = ESP_GATT_IF_NONE;
-	}
+	uint32_t rc = m_semaphoreOpenEvt.wait("connect");   // Wait for the connection to complete.
 	log_v("<< connect(), rc=%d", rc==ESP_GATT_OK);
 	return rc == ESP_GATT_OK;
 } // connect
@ -177,11 +159,6 @@ void BLEClient::gattClientEventHandler(
 	log_d("gattClientEventHandler [esp_gatt_if: %d] ... %s",
 		gattc_if, BLEUtils::gattClientEventTypeToString(event).c_str());

-	// it is possible to receive events from other connections while waiting for registration
-	if (m_gattc_if == ESP_GATT_IF_NONE && event != ESP_GATTC_REG_EVT) {
-		return;
-	}
-
 	// Execute handler code based on the type of event received.
 	switch(event) {

@ -206,17 +183,15 @@ void BLEClient::gattClientEventHandler(
 				if (evtParam->disconnect.conn_id != getConnId()) break;
 				// If we receive a disconnect event, set the class flag that indicates that we are
 				// no longer connected.
-				bool m_wasConnected = m_isConnected;
+				if (m_isConnected && m_pClientCallbacks != nullptr) {
+					m_pClientCallbacks->onDisconnect(this);
+				}
 				m_isConnected = false;
 				esp_ble_gattc_app_unregister(m_gattc_if);
-				m_gattc_if = ESP_GATT_IF_NONE;
 				m_semaphoreOpenEvt.give(ESP_GATT_IF_NONE);
 				m_semaphoreRssiCmplEvt.give();
 				m_semaphoreSearchCmplEvt.give(1);
 				BLEDevice::removePeerDevice(m_appId, true);
-				if (m_wasConnected && m_pClientCallbacks != nullptr) {
-					m_pClientCallbacks->onDisconnect(this);
-				}
 				break;
 		} // ESP_GATTC_DISCONNECT_EVT

@ -252,8 +227,7 @@ void BLEClient::gattClientEventHandler(
 		//
 		case ESP_GATTC_REG_EVT: {
 			m_gattc_if = gattc_if;
-			// pass on the registration status result, in case of failure
-			m_semaphoreRegEvt.give(evtParam->reg.status);
+			m_semaphoreRegEvt.give();
 			break;
 		} // ESP_GATTC_REG_EVT

@ -546,39 +520,6 @@ uint16_t BLEClient::getMTU() {
 	return m_mtu;
 }

-
-/**
-	@brief Set the local and remote MTU size.
- 				Should be called once after client connects if MTU size needs to be changed.
-	@return bool indicating if MTU was successfully set locally and on remote.
-*/
-bool BLEClient::setMTU(uint16_t mtu)
-{
-	esp_err_t err = esp_ble_gatt_set_local_mtu(mtu);  //First must set local MTU value.
-	if (err == ESP_OK) 
-	{
-		err = esp_ble_gattc_send_mtu_req(m_gattc_if,m_conn_id);  //Once local is set successfully set remote size
-		if (err!=ESP_OK)
-		{
-			log_e("Error setting send MTU request MTU: %d err=%d", mtu,err);
-			return false;
-		}
-	}
-	else 
-	{
-		log_e("can't set local mtu value: %d", mtu);
-		return false;
-	}
-	log_v("<< setLocalMTU");
-
-	m_mtu = mtu; //successfully changed
-
-	return true;
-}
-
-
-
-
 /**
 * @brief Return a string representation of this client.
 * @return A string representation of this client.
--- a/libraries/BLE/src/BLEClient.h
+++ b/libraries/BLE/src/BLEClient.h
@ -57,8 +57,7 @@ public:
 	uint16_t                                   getConnId();
 	esp_gatt_if_t                              getGattcIf();
 	uint16_t								   getMTU();
-	bool 											 setMTU(uint16_t mtu);
-	
+
 uint16_t m_appId;
 private:
 	friend class BLEDevice;
--- a/libraries/BLE/src/BLERemoteCharacteristic.cpp
+++ b/libraries/BLE/src/BLERemoteCharacteristic.cpp
@ -52,7 +52,6 @@ BLERemoteCharacteristic::BLERemoteCharacteristic(
 */
 BLERemoteCharacteristic::~BLERemoteCharacteristic() {
 	removeDescriptors();   // Release resources for any descriptor information we may have allocated.
-	free(m_rawData);
 } // ~BLERemoteCharacteristic


@ -246,10 +245,6 @@ void BLERemoteCharacteristic::gattClientEventHandler(esp_gattc_cb_event_t event,
 			}
 			break;

-		case ESP_GATTC_DISCONNECT_EVT:
-			m_semaphoreWriteCharEvt.give(1);
-			break;
-			
 		default:
 			break;
 	} // End switch
@ -458,7 +453,7 @@ std::string BLERemoteCharacteristic::readValue() {
 * unregistering a notification.
 * @return N/A.
 */
-void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback, bool notifications, bool descriptorRequiresRegistration) {
+void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback, bool notifications) {
 	log_v(">> registerForNotify(): %s", toString().c_str());

 	m_notifyCallback = notifyCallback;   // Save the notification callback.
@ -479,7 +474,7 @@ void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback,
 		uint8_t val[] = {0x01, 0x00};
 		if(!notifications) val[0] = 0x02;
 		BLERemoteDescriptor* desc = getDescriptor(BLEUUID((uint16_t)0x2902));
-		if (desc != nullptr && descriptorRequiresRegistration)
+		if (desc != nullptr)
 			desc->writeValue(val, 2, true);
 	} // End Register
 	else {   // If we weren't passed a callback function, then this is an unregistration.
@ -495,7 +490,7 @@ void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback,

 		uint8_t val[] = {0x00, 0x00};
 		BLERemoteDescriptor* desc = getDescriptor((uint16_t)0x2902);
-		if (desc != nullptr && descriptorRequiresRegistration)
+		if (desc != nullptr)
 			desc->writeValue(val, 2, true);
 	} // End Unregister

--- a/libraries/BLE/src/BLERemoteCharacteristic.h
+++ b/libraries/BLE/src/BLERemoteCharacteristic.h
@ -11,7 +11,6 @@
 #if defined(CONFIG_BLUEDROID_ENABLED)

 #include <string>
-#include <functional>

 #include <esp_gattc_api.h>

@ -22,7 +21,8 @@

 class BLERemoteService;
 class BLERemoteDescriptor;
-typedef std::function<void(BLERemoteCharacteristic* pBLERemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify)> notify_callback;
+typedef void (*notify_callback)(BLERemoteCharacteristic* pBLERemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify);
+
 /**
 * @brief A model of a remote %BLE characteristic.
 */
@ -39,7 +39,6 @@ public:
 	bool        canWriteNoResponse();
 	BLERemoteDescriptor* getDescriptor(BLEUUID uuid);
 	std::map<std::string, BLERemoteDescriptor*>* getDescriptors();
-	BLERemoteService* getRemoteService();
 	uint16_t    getHandle();
 	BLEUUID     getUUID();
 	std::string readValue();
@ -47,7 +46,7 @@ public:
 	uint16_t    readUInt16();
 	uint32_t    readUInt32();
 	float       readFloat();
-	void        registerForNotify(notify_callback _callback, bool notifications = true, bool descriptorRequiresRegistration = true);
+	void        registerForNotify(notify_callback _callback, bool notifications = true);
 	void        writeValue(uint8_t* data, size_t length, bool response = false);
 	void        writeValue(std::string newValue, bool response = false);
 	void        writeValue(uint8_t newValue, bool response = false);
@ -64,6 +63,7 @@ private:
 	// Private member functions
 	void gattClientEventHandler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t* evtParam);

+	BLERemoteService* getRemoteService();
 	void              removeDescriptors();
 	void              retrieveDescriptors();

--- a/libraries/BLE/src/BLERemoteService.cpp
+++ b/libraries/BLE/src/BLERemoteService.cpp
@ -245,7 +245,6 @@ std::map<uint16_t, BLERemoteCharacteristic*>* BLERemoteService::getCharacteristi
 */
 void BLERemoteService::getCharacteristics(std::map<uint16_t, BLERemoteCharacteristic*>** pCharacteristicMap) {
 	log_v(">> getCharacteristics() for service: %s", getUUID().toString().c_str());
-	(void)pCharacteristicMap;
 	// If is possible that we have not read the characteristics associated with the service so do that
 	// now.  The request to retrieve the characteristics by calling "retrieveCharacteristics" is a blocking
 	// call and does not return until all the characteristics are available.
--- a/libraries/BluetoothSerial/examples/SerialToSerialBT/.skip.esp32c3
+++ b/libraries/BluetoothSerial/examples/SerialToSerialBT/.skip.esp32c3
--- a/libraries/BluetoothSerial/examples/SerialToSerialBTM/.skip.esp32c3
+++ b/libraries/BluetoothSerial/examples/SerialToSerialBTM/.skip.esp32c3
--- a/libraries/BluetoothSerial/examples/SerialToSerialBT_SSP_pairing/.skip.esp32c3
+++ b/libraries/BluetoothSerial/examples/SerialToSerialBT_SSP_pairing/.skip.esp32c3
--- a/libraries/BluetoothSerial/examples/SerialToSerialBT_SSP_pairing/.skip.esp32s2
+++ b/libraries/BluetoothSerial/examples/SerialToSerialBT_SSP_pairing/.skip.esp32s2
--- a/libraries/BluetoothSerial/examples/SerialToSerialBT_SSP_pairing/SerialToSerialBT_SSP_pairing.ino
+++ b/libraries/BluetoothSerial/examples/SerialToSerialBT_SSP_pairing/SerialToSerialBT_SSP_pairing.ino
@ -1,75 +0,0 @@
-//This example code is in the Public Domain (or CC0 licensed, at your option.)
-//By Richard Li - 2020
-//
-//This example creates a bridge between Serial and Classical Bluetooth (SPP with authentication)
-//and also demonstrate that SerialBT have the same functionalities of a normal Serial
-
-#include "BluetoothSerial.h"
-
-#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
-#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
-#endif
-
-BluetoothSerial SerialBT;
-boolean confirmRequestPending = true;
-
-void BTConfirmRequestCallback(uint32_t numVal)
-{
-  confirmRequestPending = true;
-  Serial.println(numVal);
-}
-
-void BTAuthCompleteCallback(boolean success)
-{
-  confirmRequestPending = false;
-  if (success)
-  {
-    Serial.println("Pairing success!!");
-  }
-  else
-  {
-    Serial.println("Pairing failed, rejected by user!!");
-  }
-}
-
-
-void setup()
-{
-  Serial.begin(115200);
-  SerialBT.enableSSP();
-  SerialBT.onConfirmRequest(BTConfirmRequestCallback);
-  SerialBT.onAuthComplete(BTAuthCompleteCallback);
-  SerialBT.begin("ESP32test"); //Bluetooth device name
-  Serial.println("The device started, now you can pair it with bluetooth!");
-}
-
-void loop()
-{
-  if (confirmRequestPending)
-  {
-    if (Serial.available())
-    {
-      int dat = Serial.read();
-      if (dat == 'Y' || dat == 'y')
-      {
-        SerialBT.confirmReply(true);
-      }
-      else
-      {
-        SerialBT.confirmReply(false);
-      }
-    }
-  }
-  else
-  {
-    if (Serial.available())
-    {
-      SerialBT.write(Serial.read());
-    }
-    if (SerialBT.available())
-    {
-      Serial.write(SerialBT.read());
-    }
-    delay(20);
-  }
-}
--- a/libraries/BluetoothSerial/examples/bt_classic_device_discovery/.skip.esp32c3
+++ b/libraries/BluetoothSerial/examples/bt_classic_device_discovery/.skip.esp32c3
--- a/libraries/BluetoothSerial/examples/bt_classic_device_discovery/.skip.esp32s2
+++ b/libraries/BluetoothSerial/examples/bt_classic_device_discovery/.skip.esp32s2
--- a/libraries/BluetoothSerial/examples/bt_classic_device_discovery/bt_classic_device_discovery.ino
+++ b/libraries/BluetoothSerial/examples/bt_classic_device_discovery/bt_classic_device_discovery.ino
@ -1,52 +0,0 @@
-#include <BluetoothSerial.h>
-
-#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
-#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
-#endif
-
-BluetoothSerial SerialBT;
-
-
-#define BT_DISCOVER_TIME	10000
-
-
-static bool btScanAsync = true;
-static bool btScanSync = true;
-
-
-void btAdvertisedDeviceFound(BTAdvertisedDevice* pDevice) {
-	Serial.printf("Found a device asynchronously: %s\n", pDevice->toString().c_str());
-}
-
-void setup() {
-  Serial.begin(115200);
-  SerialBT.begin("ESP32test"); //Bluetooth device name
-  Serial.println("The device started, now you can pair it with bluetooth!");
-
-
-  if (btScanAsync) {
-    Serial.print("Starting discoverAsync...");
-    if (SerialBT.discoverAsync(btAdvertisedDeviceFound)) {
-      Serial.println("Findings will be reported in \"btAdvertisedDeviceFound\"");
-      delay(10000);
-      Serial.print("Stopping discoverAsync... ");
-      SerialBT.discoverAsyncStop();
-      Serial.println("stopped");
-    } else {
-      Serial.println("Error on discoverAsync f.e. not workin after a \"connect\"");
-    }
-  }
-  
-  if (btScanSync) {
-    Serial.println("Starting discover...");
-    BTScanResults *pResults = SerialBT.discover(BT_DISCOVER_TIME);
-    if (pResults)
-      pResults->dump(&Serial);
-    else
-      Serial.println("Error on BT Scan, no result!");
-  }
-}
-
-void loop() {
-  delay(100);
-}
--- a/libraries/BluetoothSerial/examples/bt_remove_paired_devices/.skip.esp32c3
+++ b/libraries/BluetoothSerial/examples/bt_remove_paired_devices/.skip.esp32c3
--- a/libraries/BluetoothSerial/src/BTAddress.cpp
+++ b/libraries/BluetoothSerial/src/BTAddress.cpp
@ -1,96 +0,0 @@
-/*
- * BTAddress.cpp
- *
- *  Created on: Jul 2, 2017
- *      Author: kolban
- *  Ported  on: Feb 5, 2021
- *      Author: Thomas M. (ArcticSnowSky)
- */
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-#include "BTAddress.h"
-#include <string>
-#include <sstream>
-#include <iomanip>
-#include <string.h>
-#include <stdio.h>
-#include <malloc.h>
-#ifdef ARDUINO_ARCH_ESP32
-#include "esp32-hal-log.h"
-#endif
-
-
-/**
- * @brief Create an address from the native ESP32 representation.
- * @param [in] address The native representation.
- */
-BTAddress::BTAddress(esp_bd_addr_t address) {
-	memcpy(m_address, address, ESP_BD_ADDR_LEN);
-} // BTAddress
-
-
-/**
- * @brief Create an address from a hex string
- *
- * A hex string is of the format:
- * ```
- * 00:00:00:00:00:00
- * ```
- * which is 17 characters in length.
- *
- * @param [in] stringAddress The hex representation of the address.
- */
-BTAddress::BTAddress(std::string stringAddress) {
-	if (stringAddress.length() != 17) return;
-
-	int data[6];
-	sscanf(stringAddress.c_str(), "%x:%x:%x:%x:%x:%x", &data[0], &data[1], &data[2], &data[3], &data[4], &data[5]);
-	m_address[0] = (uint8_t) data[0];
-	m_address[1] = (uint8_t) data[1];
-	m_address[2] = (uint8_t) data[2];
-	m_address[3] = (uint8_t) data[3];
-	m_address[4] = (uint8_t) data[4];
-	m_address[5] = (uint8_t) data[5];
-} // BTAddress
-
-
-/**
- * @brief Determine if this address equals another.
- * @param [in] otherAddress The other address to compare against.
- * @return True if the addresses are equal.
- */
-bool BTAddress::equals(BTAddress otherAddress) {
-	return memcmp(otherAddress.getNative(), m_address, 6) == 0;
-} // equals
-
-
-/**
- * @brief Return the native representation of the address.
- * @return The native representation of the address.
- */
-esp_bd_addr_t *BTAddress::getNative() {
-	return &m_address;
-} // getNative
-
-
-/**
- * @brief Convert a BT address to a string.
- *
- * A string representation of an address is in the format:
- *
- * ```
- * xx:xx:xx:xx:xx:xx
- * ```
- *
- * @return The string representation of the address.
- */
-std::string BTAddress::toString() {
-	auto size = 18;
-	char *res = (char*)malloc(size);
-	snprintf(res, size, "%02x:%02x:%02x:%02x:%02x:%02x", m_address[0], m_address[1], m_address[2], m_address[3], m_address[4], m_address[5]);
-	std::string ret(res);
-	free(res);
-	return ret;
-} // toString
-#endif
--- a/libraries/BluetoothSerial/src/BTAddress.h
+++ b/libraries/BluetoothSerial/src/BTAddress.h
@ -1,36 +0,0 @@
-/*
- * BTAddress.h
- *
- *  Created on: Jul 2, 2017
- *      Author: kolban
- *  Ported  on: Feb 5, 2021
- *      Author: Thomas M. (ArcticSnowSky)
- */
-
-#ifndef COMPONENTS_CPP_UTILS_BTADDRESS_H_
-#define COMPONENTS_CPP_UTILS_BTADDRESS_H_
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-#include <esp_gap_bt_api.h> // ESP32 BT
-#include <string>
-
-
-/**
- * @brief A %BT device address.
- *
- * Every %BT device has a unique address which can be used to identify it and form connections.
- */
-class BTAddress {
-public:
-	BTAddress(esp_bd_addr_t address);
-	BTAddress(std::string stringAddress);
-	bool           equals(BTAddress otherAddress);
-	esp_bd_addr_t* getNative();
-	std::string    toString();
-
-private:
-	esp_bd_addr_t m_address;
-};
-
-#endif /* CONFIG_BT_ENABLED */
-#endif /* COMPONENTS_CPP_UTILS_BTADDRESS_H_ */
--- a/libraries/BluetoothSerial/src/BTAdvertisedDevice.h
+++ b/libraries/BluetoothSerial/src/BTAdvertisedDevice.h
@ -1,65 +0,0 @@
-/*
- * BTAdvertisedDevice.h
- *
- *  Created on: Feb 5, 2021
- *      Author: Thomas M. (ArcticSnowSky)
- */
-
-#ifndef __BTADVERTISEDDEVICE_H__
-#define __BTADVERTISEDDEVICE_H__
-
-#include "BTAddress.h"
-
-
-class BTAdvertisedDevice {
-public:
-    virtual ~BTAdvertisedDevice() = default;
-
-    virtual BTAddress   getAddress();
-    virtual uint32_t    getCOD();
-    virtual std::string getName();
-    virtual int8_t      getRSSI();
-
-
-    virtual bool        haveCOD();
-    virtual bool        haveName();
-    virtual bool        haveRSSI();
-
-    virtual std::string toString();
-};
-
-class BTAdvertisedDeviceSet : public virtual BTAdvertisedDevice {
-public:
-    BTAdvertisedDeviceSet();
-    //~BTAdvertisedDeviceSet() = default;
-    
-
-    BTAddress   getAddress();
-    uint32_t    getCOD();
-    std::string getName();
-    int8_t      getRSSI();
-
-
-    bool        haveCOD();
-    bool        haveName();
-    bool        haveRSSI();
-
-    std::string toString();
-
-    void setAddress(BTAddress address);
-    void setCOD(uint32_t cod);
-    void setName(std::string name);
-    void setRSSI(int8_t rssi);
-
-    bool m_haveCOD;
-    bool m_haveName;
-    bool m_haveRSSI;
-
-
-    BTAddress   m_address = BTAddress((uint8_t*)"\0\0\0\0\0\0");
-    uint32_t    m_cod;
-    std::string m_name;
-    int8_t      m_rssi;
-};
-
-#endif
--- a/libraries/BluetoothSerial/src/BTAdvertisedDeviceSet.cpp
+++ b/libraries/BluetoothSerial/src/BTAdvertisedDeviceSet.cpp
@ -1,78 +0,0 @@
-/*
- * BTAdvertisedDeviceSet.cpp
- *
- *  Created on: Feb 5, 2021
- *      Author: Thomas M. (ArcticSnowSky)
- */
-
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-//#include <map>
-
-#include "BTAdvertisedDevice.h"
-//#include "BTScan.h"
-
-
-BTAdvertisedDeviceSet::BTAdvertisedDeviceSet() {
-	m_cod		       = 0;
-	m_name             = "";
-	m_rssi             = 0;
-
-	m_haveCOD	       = false;
-	m_haveName         = false;
-	m_haveRSSI         = false;
-} // BTAdvertisedDeviceSet
-
-BTAddress   BTAdvertisedDeviceSet::getAddress()    { return m_address; }
-uint32_t    BTAdvertisedDeviceSet::getCOD()        { return m_cod; }
-std::string BTAdvertisedDeviceSet::getName()       { return m_name; }
-int8_t      BTAdvertisedDeviceSet::getRSSI()	    { return m_rssi; }
-
-
-bool        BTAdvertisedDeviceSet::haveCOD()   { return m_haveCOD; }
-bool        BTAdvertisedDeviceSet::haveName()  { return m_haveName; }
-bool        BTAdvertisedDeviceSet::haveRSSI()  { return m_haveRSSI; }
-
-/**
- * @brief Create a string representation of this device.
- * @return A string representation of this device.
- */
-std::string BTAdvertisedDeviceSet::toString() {
-	std::string res = "Name: " + getName() + ", Address: " + getAddress().toString();
-	if (haveCOD()) {
-		char val[6];
-		snprintf(val, sizeof(val), "%d", getCOD());
-		res += ", cod: ";
-		res += val;
-	}
-	if (haveRSSI()) {
-		char val[6];
-		snprintf(val, sizeof(val), "%d", (int8_t)getRSSI());
-		res += ", rssi: ";
-		res += val;
-	}
-	return res;
-} // toString
-
-
-void BTAdvertisedDeviceSet::setAddress(BTAddress address) {
-    m_address = address;
-}
-
-void BTAdvertisedDeviceSet::setCOD(uint32_t cod) {
-    m_cod     = cod;
-	m_haveCOD = true;
-}
-
-void BTAdvertisedDeviceSet::setName(std::string name) {
-    m_name     = name;
-	m_haveName = true;
-}
-
-void BTAdvertisedDeviceSet::setRSSI(int8_t rssi) {
-    m_rssi     = rssi;
-	m_haveRSSI = true;
-}
-
-#endif /* CONFIG_BT_ENABLED */
--- a/libraries/BluetoothSerial/src/BTScan.h
+++ b/libraries/BluetoothSerial/src/BTScan.h
@ -1,42 +0,0 @@
-/*
- * BTScan.h
- *
- *  Created on: Feb 5, 2021
- *      Author: Thomas M. (ArcticSnowSky)
- */
-
-#ifndef __BTSCAN_H__
-#define __BTSCAN_H__
-
-#include <map>
-#include <string>
-#include <Print.h>
-#include "BTAddress.h"
-#include "BTAdvertisedDevice.h"
-
-class BTAdvertisedDevice;
-class BTAdvertisedDeviceSet;
-
-
-class BTScanResults {
-public:
-	virtual ~BTScanResults() = default;
-
-    virtual void        		dump(Print *print = nullptr);
-    virtual int         		getCount();
-    virtual BTAdvertisedDevice* getDevice(uint32_t i);
-};
-
-class BTScanResultsSet : public BTScanResults {
-public:
-    void                	dump(Print *print = nullptr);
-    int                 	getCount();
-    BTAdvertisedDevice*		getDevice(uint32_t i);
-
-	bool add(BTAdvertisedDeviceSet advertisedDevice, bool unique = true);
-	void clear();
-
-    std::map<std::string, BTAdvertisedDeviceSet> m_vectorAdvertisedDevices;
-};
-
-#endif
--- a/libraries/BluetoothSerial/src/BTScanResultsSet.cpp
+++ b/libraries/BluetoothSerial/src/BTScanResultsSet.cpp
@ -1,95 +0,0 @@
-/*
- * BTScanResultsSet.cpp
- *
- *  Created on: Feb 5, 2021
- *      Author: Thomas M. (ArcticSnowSky)
- */
-
-#include "sdkconfig.h"
-#if defined(CONFIG_BT_ENABLED)
-
-
-#include <esp_err.h>
-
-#include "BTAdvertisedDevice.h"
-#include "BTScan.h"
-//#include "GeneralUtils.h"
-#include "esp32-hal-log.h"
-
-
-class BTAdvertisedDevice;
-
-/**
- * @brief Dump the scan results to the log.
- */
-void BTScanResultsSet::dump(Print *print) {
-	int cnt = getCount();
-	if (print == nullptr) {
-		log_v(">> Dump scan results : %d", cnt);
-		for (int i=0; i < cnt; i++) {
-			BTAdvertisedDevice* dev = getDevice(i);
-			if (dev)
-				log_d("- %d: %s\n", i+1, dev->toString().c_str());
-			else
-				log_d("- %d is null\n", i+1);
-		}
-		log_v("-- dump finished --");
-	} else {
-		print->printf(">> Dump scan results: %d\n", cnt);
-		for (int i=0; i < cnt; i++) {
-			BTAdvertisedDevice* dev = getDevice(i);
-			if (dev)
-				print->printf("- %d: %s\n", i+1, dev->toString().c_str());
-			else
-				print->printf("- %d is null\n", i+1);
-		}
-		print->println("-- Dump finished --");
-	}
-} // dump
-
-
-/**
- * @brief Return the count of devices found in the last scan.
- * @return The number of devices found in the last scan.
- */
-int BTScanResultsSet::getCount() {
-	return m_vectorAdvertisedDevices.size();
-} // getCount
-
-
-/**
- * @brief Return the specified device at the given index.
- * The index should be between 0 and getCount()-1.
- * @param [in] i The index of the device.
- * @return The device at the specified index.
- */
-BTAdvertisedDevice* BTScanResultsSet::getDevice(uint32_t i) {
-	if (i < 0)
-		return nullptr;
-
-	uint32_t x = 0;
-	BTAdvertisedDeviceSet* pDev = &m_vectorAdvertisedDevices.begin()->second;
-	for (auto it = m_vectorAdvertisedDevices.begin(); it != m_vectorAdvertisedDevices.end(); it++) {
-		pDev = &it->second;
-		if (x==i)	break;
-		x++;
-	}
-	return x==i ? pDev : nullptr;
-}
-
-void BTScanResultsSet::clear() {
-    //for(auto _dev : m_vectorAdvertisedDevices)
-	//	delete _dev.second;
-	m_vectorAdvertisedDevices.clear();
-}
-
-bool BTScanResultsSet::add(BTAdvertisedDeviceSet advertisedDevice, bool unique) {
-	std::string key = advertisedDevice.getAddress().toString();
-	if (!unique || m_vectorAdvertisedDevices.count(key) == 0) {
-		m_vectorAdvertisedDevices.insert(std::pair<std::string, BTAdvertisedDeviceSet>(key, advertisedDevice));
-		return true;
-	} else
-		return false;
-}
-
-#endif
--- a/libraries/BluetoothSerial/src/BluetoothSerial.cpp
+++ b/libraries/BluetoothSerial/src/BluetoothSerial.cpp
@ -42,23 +42,15 @@ const char * _spp_server_name = "ESP32SPP";

 #define RX_QUEUE_SIZE 512
 #define TX_QUEUE_SIZE 32
-#define SPP_TX_QUEUE_TIMEOUT 1000
-#define SPP_TX_DONE_TIMEOUT 1000
-#define SPP_CONGESTED_TIMEOUT 1000
-
 static uint32_t _spp_client = 0;
 static xQueueHandle _spp_rx_queue = NULL;
 static xQueueHandle _spp_tx_queue = NULL;
 static SemaphoreHandle_t _spp_tx_done = NULL;
 static TaskHandle_t _spp_task_handle = NULL;
 static EventGroupHandle_t _spp_event_group = NULL;
-static EventGroupHandle_t _bt_event_group = NULL;
 static boolean secondConnectionAttempt;
 static esp_spp_cb_t * custom_spp_callback = NULL;
 static BluetoothSerialDataCb custom_data_callback = NULL;
-static esp_bd_addr_t current_bd_addr;
-static ConfirmRequestCb confirm_request_callback = NULL;
-static AuthCompleteCb auth_complete_callback = NULL;

 #define INQ_LEN 0x10
 #define INQ_NUM_RSPS 20
@ -73,18 +65,11 @@ static int _pin_len;
 static bool _isPinSet;
 static bool _enableSSP;

-static BTScanResultsSet scanResults;
-static BTAdvertisedDeviceCb advertisedDeviceCb = nullptr;
-
 #define SPP_RUNNING     0x01
 #define SPP_CONNECTED   0x02
 #define SPP_CONGESTED   0x04
 #define SPP_DISCONNECTED 0x08

-#define BT_DISCOVERY_RUNNING    0x01
-#define BT_DISCOVERY_COMPLETED  0x02
-
-
 typedef struct {
        size_t len;
        uint8_t data[];
@ -155,7 +140,7 @@ static esp_err_t _spp_queue_packet(uint8_t *data, size_t len){
    }
    packet->len = len;
    memcpy(packet->data, data, len);
-    if (!_spp_tx_queue || xQueueSend(_spp_tx_queue, &packet, SPP_TX_QUEUE_TIMEOUT) != pdPASS) {
+    if (xQueueSend(_spp_tx_queue, &packet, portMAX_DELAY) != pdPASS) {
        log_e("SPP TX Queue Send Failed!");
        free(packet);
        return ESP_FAIL;
@ -168,25 +153,19 @@ static uint8_t _spp_tx_buffer[SPP_TX_MAX];
 static uint16_t _spp_tx_buffer_len = 0;

 static bool _spp_send_buffer(){
-    if((xEventGroupWaitBits(_spp_event_group, SPP_CONGESTED, pdFALSE, pdTRUE, SPP_CONGESTED_TIMEOUT) & SPP_CONGESTED) != 0){
-        if(!_spp_client){
-            log_v("SPP Client Gone!");
-            return false;
-        }
-        log_v("SPP Write %u", _spp_tx_buffer_len);
+    if((xEventGroupWaitBits(_spp_event_group, SPP_CONGESTED, pdFALSE, pdTRUE, portMAX_DELAY) & SPP_CONGESTED) != 0){
        esp_err_t err = esp_spp_write(_spp_client, _spp_tx_buffer_len, _spp_tx_buffer);
        if(err != ESP_OK){
            log_e("SPP Write Failed! [0x%X]", err);
            return false;
        }
        _spp_tx_buffer_len = 0;
-        if(xSemaphoreTake(_spp_tx_done, SPP_TX_DONE_TIMEOUT) != pdTRUE){
+        if(xSemaphoreTake(_spp_tx_done, portMAX_DELAY) != pdTRUE){
            log_e("SPP Ack Failed!");
            return false;
        }
        return true;
    }
-    log_e("SPP Write Congested!");
    return false;
 }

@ -212,18 +191,13 @@ static void _spp_tx_task(void * arg){
                _spp_tx_buffer_len = SPP_TX_MAX;
                data += to_send;
                len -= to_send;
-                if(!_spp_send_buffer()){
-                    len = 0;
-                }
+                _spp_send_buffer();
                while(len >= SPP_TX_MAX){
                    memcpy(_spp_tx_buffer, data, SPP_TX_MAX);
                    _spp_tx_buffer_len = SPP_TX_MAX;
                    data += SPP_TX_MAX;
                    len -= SPP_TX_MAX;
-                    if(!_spp_send_buffer()){
-                        len = 0;
-                        break;
-                    }
+                    _spp_send_buffer();
                }
                if(len){
                    memcpy(_spp_tx_buffer, data, len);
@ -262,36 +236,26 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
        break;

    case ESP_SPP_SRV_OPEN_EVT://Server connection open
-        if (param->srv_open.status == ESP_SPP_SUCCESS) {
-            log_i("ESP_SPP_SRV_OPEN_EVT: %u", _spp_client);
-            if (!_spp_client){
-                _spp_client = param->srv_open.handle;
-                _spp_tx_buffer_len = 0;
-            } else {
-                secondConnectionAttempt = true;
-                esp_spp_disconnect(param->srv_open.handle);
-            }
-            xEventGroupClearBits(_spp_event_group, SPP_DISCONNECTED);
-            xEventGroupSetBits(_spp_event_group, SPP_CONNECTED);
+        log_i("ESP_SPP_SRV_OPEN_EVT");
+        if (!_spp_client){
+            _spp_client = param->open.handle;
        } else {
-            log_e("ESP_SPP_SRV_OPEN_EVT Failed!, status:%d", param->srv_open.status);
+            secondConnectionAttempt = true;
+            esp_spp_disconnect(param->open.handle);
        }
+        xEventGroupClearBits(_spp_event_group, SPP_DISCONNECTED);
+        xEventGroupSetBits(_spp_event_group, SPP_CONNECTED);
        break;

    case ESP_SPP_CLOSE_EVT://Client connection closed
-        if ((param->close.async == false && param->close.status == ESP_SPP_SUCCESS) || param->close.async) {
-            log_i("ESP_SPP_CLOSE_EVT: %u", secondConnectionAttempt);
-            if(secondConnectionAttempt) {
-                secondConnectionAttempt = false;
-            } else {
-                _spp_client = 0;
-                xEventGroupSetBits(_spp_event_group, SPP_DISCONNECTED);
-                xEventGroupSetBits(_spp_event_group, SPP_CONGESTED);
-            }        
-            xEventGroupClearBits(_spp_event_group, SPP_CONNECTED);
+        log_i("ESP_SPP_CLOSE_EVT");
+        if(secondConnectionAttempt) {
+            secondConnectionAttempt = false;
        } else {
-            log_e("ESP_SPP_CLOSE_EVT failed!, status:%d", param->close.status);
-        }
+            _spp_client = 0;
+            xEventGroupSetBits(_spp_event_group, SPP_DISCONNECTED);
+        }        
+        xEventGroupClearBits(_spp_event_group, SPP_CONNECTED);
        break;

    case ESP_SPP_CONG_EVT://connection congestion status changed
@ -304,15 +268,11 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
        break;

    case ESP_SPP_WRITE_EVT://write operation completed
-        if (param->write.status == ESP_SPP_SUCCESS) {
-            if(param->write.cong){
-                xEventGroupClearBits(_spp_event_group, SPP_CONGESTED);
-            }
-            log_v("ESP_SPP_WRITE_EVT: %u %s", param->write.len, param->write.cong?"CONGESTED":"");
-        } else {
-            log_e("ESP_SPP_WRITE_EVT failed!, status:%d", param->write.status);
+        if(param->write.cong){
+            xEventGroupClearBits(_spp_event_group, SPP_CONGESTED);
        }
        xSemaphoreGive(_spp_tx_done);//we can try to send another packet
+        log_v("ESP_SPP_WRITE_EVT: %u %s", param->write.len, param->write.cong?"CONGESTED":"FREE");
        break;

    case ESP_SPP_DATA_IND_EVT://connection received data
@ -337,8 +297,6 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
        if (param->disc_comp.status == ESP_SPP_SUCCESS) {
            log_i("ESP_SPP_DISCOVERY_COMP_EVT: spp connect to remote");
            esp_spp_connect(ESP_SPP_SEC_AUTHENTICATE, ESP_SPP_ROLE_MASTER, param->disc_comp.scn[0], _peer_bd_addr);
-        } else {
-            log_e("ESP_SPP_DISCOVERY_COMP_EVT failed!, status:%d", param->disc_comp.status);
        }
        break;

@ -352,7 +310,6 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
        }
        xEventGroupClearBits(_spp_event_group, SPP_DISCONNECTED);
        xEventGroupSetBits(_spp_event_group, SPP_CONNECTED);
-        xEventGroupSetBits(_spp_event_group, SPP_CONGESTED);
        break;

    case ESP_SPP_START_EVT://server started
@ -376,16 +333,15 @@ void BluetoothSerial::onData(BluetoothSerialDataCb cb){
 static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
 {
    switch(event){
-        case ESP_BT_GAP_DISC_RES_EVT: {
+        case ESP_BT_GAP_DISC_RES_EVT:
            log_i("ESP_BT_GAP_DISC_RES_EVT");
 #if (ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO)
            char bda_str[18];
            log_i("Scanned device: %s", bda2str(param->disc_res.bda, bda_str, 18));
 #endif
-            BTAdvertisedDeviceSet advertisedDevice;
-            uint8_t peer_bdname_len = 0;
-            char peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
            for (int i = 0; i < param->disc_res.num_prop; i++) {
+                uint8_t peer_bdname_len;
+                char peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
                switch(param->disc_res.prop[i].type) {
                    case ESP_BT_GAP_DEV_PROP_EIR:  
                        if (get_name_from_eir((uint8_t*)param->disc_res.prop[i].val, peer_bdname, &peer_bdname_len)) {
@ -418,24 +374,10 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa

                    case ESP_BT_GAP_DEV_PROP_COD:
                        log_d("ESP_BT_GAP_DEV_PROP_COD");
-                        if (param->disc_res.prop[i].len <= sizeof(int)) {
-                            uint32_t cod = 0;
-                            memcpy(&cod, param->disc_res.prop[i].val, param->disc_res.prop[i].len);
-                            advertisedDevice.setCOD(cod);
-                        } else {
-                            log_d("Value size larger than integer");
-                        }
                        break;

                    case ESP_BT_GAP_DEV_PROP_RSSI:
                        log_d("ESP_BT_GAP_DEV_PROP_RSSI");
-                        if (param->disc_res.prop[i].len <= sizeof(int)) {
-                            uint8_t rssi = 0;
-                            memcpy(&rssi, param->disc_res.prop[i].val, param->disc_res.prop[i].len);
-                            advertisedDevice.setRSSI(rssi);
-                        } else {
-                            log_d("Value size larger than integer");
-                        }
                        break;
                        
                    default:
@ -444,46 +386,24 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
                if (_isRemoteAddressSet)
                    break;
            }
-            if (peer_bdname_len)
-                advertisedDevice.setName(peer_bdname);
-            esp_bd_addr_t addr;
-            memcpy(addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
-            advertisedDevice.setAddress(BTAddress(addr));
-            if (scanResults.add(advertisedDevice) && advertisedDeviceCb)
-                advertisedDeviceCb(&advertisedDevice);
-        }
-        break;
-
+            break;
        case ESP_BT_GAP_DISC_STATE_CHANGED_EVT:
            log_i("ESP_BT_GAP_DISC_STATE_CHANGED_EVT");
-            if (param->disc_st_chg.state == ESP_BT_GAP_DISCOVERY_STOPPED) {
-                xEventGroupClearBits(_bt_event_group, BT_DISCOVERY_RUNNING);
-                xEventGroupSetBits(_bt_event_group, BT_DISCOVERY_COMPLETED);
-            } else { // ESP_BT_GAP_DISCOVERY_STARTED
-                xEventGroupClearBits(_bt_event_group, BT_DISCOVERY_COMPLETED);
-                xEventGroupSetBits(_bt_event_group, BT_DISCOVERY_RUNNING);
-            }
            break;

        case ESP_BT_GAP_RMT_SRVCS_EVT:
-            log_i( "ESP_BT_GAP_RMT_SRVCS_EVT: status = %d, num_uuids = %d", param->rmt_srvcs.stat, param->rmt_srvcs.num_uuids);
+            log_i( "ESP_BT_GAP_RMT_SRVCS_EVT");
            break;

        case ESP_BT_GAP_RMT_SRVC_REC_EVT:
-            log_i("ESP_BT_GAP_RMT_SRVC_REC_EVT: status = %d", param->rmt_srvc_rec.stat);
+            log_i("ESP_BT_GAP_RMT_SRVC_REC_EVT");
            break;

        case ESP_BT_GAP_AUTH_CMPL_EVT:
            if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
                log_v("authentication success: %s", param->auth_cmpl.device_name);
-                if (auth_complete_callback) {
-                    auth_complete_callback(true);
-                }
            } else {
                log_e("authentication failed, status:%d", param->auth_cmpl.stat);
-                if (auth_complete_callback) {
-                    auth_complete_callback(false);
-                }
            }
            break;

@ -505,13 +425,7 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
       
        case ESP_BT_GAP_CFM_REQ_EVT:
            log_i("ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %d", param->cfm_req.num_val);
-            if (confirm_request_callback) {
-                memcpy(current_bd_addr, param->cfm_req.bda, sizeof(esp_bd_addr_t));
-                confirm_request_callback(param->cfm_req.num_val);
-            }
-            else {
-                esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
-            }
+            esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
            break;

        case ESP_BT_GAP_KEY_NOTIF_EVT:
@ -529,14 +443,6 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa

 static bool _init_bt(const char *deviceName)
 {
-    if(!_bt_event_group){
-        _bt_event_group = xEventGroupCreate();
-        if(!_bt_event_group){
-            log_e("BT Event Group Create Failed!");
-            return false;
-        }
-        xEventGroupClearBits(_bt_event_group, 0xFFFFFF);
-    }
    if(!_spp_event_group){
        _spp_event_group = xEventGroupCreate();
        if(!_spp_event_group){
@ -598,9 +504,7 @@ static bool _init_bt(const char *deviceName)
        }
    }

-    // Why only master need this?  Slave need this during pairing as well
-//    if (_isMaster && esp_bt_gap_register_callback(esp_bt_gap_cb) != ESP_OK) {
-    if (esp_bt_gap_register_callback(esp_bt_gap_cb) != ESP_OK) {
+    if (_isMaster && esp_bt_gap_register_callback(esp_bt_gap_cb) != ESP_OK) {
        log_e("gap register failed");
        return false;
    }
@ -615,9 +519,9 @@ static bool _init_bt(const char *deviceName)
        return false;
    }

-    // if (esp_bt_sleep_disable() != ESP_OK){
-    //     log_e("esp_bt_sleep_disable failed");
-    // }
+    if (esp_bt_sleep_disable() != ESP_OK){
+        log_e("esp_bt_sleep_disable failed");
+    }

    log_i("device name set");
    esp_bt_dev_set_device_name(deviceName);
@ -681,10 +585,6 @@ static bool _stop_bt()
        vSemaphoreDelete(_spp_tx_done);
        _spp_tx_done = NULL;
    }
-    if (_bt_event_group) {
-        vEventGroupDelete(_bt_event_group);
-        _bt_event_group = NULL;
-    }
    return true;
 }

@ -693,11 +593,6 @@ static bool waitForConnect(int timeout) {
    return (xEventGroupWaitBits(_spp_event_group, SPP_CONNECTED, pdFALSE, pdTRUE, xTicksToWait) & SPP_CONNECTED) != 0;
 }

-static bool waitForDiscovered(int timeout) {
-    TickType_t xTicksToWait = timeout / portTICK_PERIOD_MS;
-    return (xEventGroupWaitBits(_spp_event_group, BT_DISCOVERY_COMPLETED, pdFALSE, pdTRUE, xTicksToWait) & BT_DISCOVERY_COMPLETED) != 0;
-}
-
 /*
 * Serial Bluetooth Arduino
 *
@ -771,7 +666,7 @@ void BluetoothSerial::flush()
 {
    if (_spp_tx_queue != NULL){
        while(uxQueueMessagesWaiting(_spp_tx_queue) > 0){
-           delay(100);
+	    delay(5);
        }
    }
 }
@ -781,22 +676,6 @@ void BluetoothSerial::end()
    _stop_bt();
 }

-void BluetoothSerial::onConfirmRequest(ConfirmRequestCb cb)
-{
-    confirm_request_callback = cb;
-}
-
-void BluetoothSerial::onAuthComplete(AuthCompleteCb cb)
-{
-    auth_complete_callback = cb;
-}
-
-void BluetoothSerial::confirmReply(boolean confirm)
-{
-    esp_bt_gap_ssp_confirm_reply(current_bd_addr, confirm);  
-}
-
-
 esp_err_t BluetoothSerial::register_callback(esp_spp_cb_t * callback)
 {
    custom_spp_callback = callback;
@ -937,73 +816,6 @@ bool BluetoothSerial::isReady(bool checkMaster, int timeout) {
    return (xEventGroupWaitBits(_spp_event_group, SPP_RUNNING, pdFALSE, pdTRUE, xTicksToWait) & SPP_RUNNING) != 0;
 }

-
-/**
- * @brief           RemoteName or address are not allowed to be set during discovery
- *                  (otherwhise it might connect automatically and stop discovery)
- * @param[in]       timeoutMs can range from MIN_INQ_TIME to MAX_INQ_TIME
- * @return          in case of Error immediately Empty ScanResults.
- */
-BTScanResults* BluetoothSerial::discover(int timeoutMs) {
-    scanResults.clear();
-    if (timeoutMs < MIN_INQ_TIME || timeoutMs > MAX_INQ_TIME || strlen(_remote_name) || _isRemoteAddressSet)
-        return nullptr;
-    int timeout = timeoutMs / INQ_TIME;
-    log_i("discover::disconnect");
-    disconnect();
-    log_i("discovering");
-    // will resolve name to address first - it may take a while
-    esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
-    if (esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, timeout, 0) == ESP_OK) {
-        waitForDiscovered(timeoutMs);
-        esp_bt_gap_cancel_discovery();
-    }
-    return &scanResults;
-}
-
-/**
- * @brief           RemoteName or address are not allowed to be set during discovery
- *                  (otherwhise it might connect automatically and stop discovery)
- * @param[in]       cb called when a [b]new[/b] device has been discovered
- * @param[in]       timeoutMs can be 0 or range from MIN_INQ_TIME to MAX_INQ_TIME
- *
- * @return          Wheter start was successfull or problems with params
- */
-bool BluetoothSerial::discoverAsync(BTAdvertisedDeviceCb cb, int timeoutMs) {
-    scanResults.clear();
-    if (strlen(_remote_name) || _isRemoteAddressSet)
-        return false;
-    int timeout = timeoutMs / INQ_TIME;
-    disconnect();
-    advertisedDeviceCb = cb;
-    log_i("discovering");
-    // will resolve name to address first - it may take a while
-    esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
-    if (timeout > 0)
-        return esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, timeout, 0) == ESP_OK;
-    else return esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, ESP_BT_GAP_MAX_INQ_LEN, 0) == ESP_OK;
-}
-
-/** @brief      Stops the asynchronous discovery and clears the callback */
-void BluetoothSerial::discoverAsyncStop() {
-    esp_bt_gap_cancel_discovery();
-    advertisedDeviceCb = nullptr;
-}
-
-/** @brief      Clears scanresult entries */
-void BluetoothSerial::discoverClear() {
-    scanResults.clear();
-}
-
-/** @brief      Can be used while discovering asynchronously
- *              Will be returned also on synchronous discovery.
- *
- * @return      BTScanResults contains several information of found devices
- */
-BTScanResults* BluetoothSerial::getScanResults() {
-    return &scanResults;
-}
-
 BluetoothSerial::operator bool() const
 {
    return true;
--- a/libraries/BluetoothSerial/src/BluetoothSerial.h
+++ b/libraries/BluetoothSerial/src/BluetoothSerial.h
@ -21,15 +21,10 @@

 #include "Arduino.h"
 #include "Stream.h"
-#include <esp_gap_bt_api.h>
 #include <esp_spp_api.h>
 #include <functional>
-#include "BTScan.h"

 typedef std::function<void(const uint8_t *buffer, size_t size)> BluetoothSerialDataCb;
-typedef std::function<void(uint32_t num_val)> ConfirmRequestCb;
-typedef std::function<void(boolean success)> AuthCompleteCb;
-typedef std::function<void(BTAdvertisedDevice* pAdvertisedDevice)> BTAdvertisedDeviceCb;

 class BluetoothSerial: public Stream
 {
@ -52,10 +47,6 @@ class BluetoothSerial: public Stream
        void end(void);
        void onData(BluetoothSerialDataCb cb);
        esp_err_t register_callback(esp_spp_cb_t * callback);
-        
-        void onConfirmRequest(ConfirmRequestCb cb);
-        void onAuthComplete(AuthCompleteCb cb);
-        void confirmReply(boolean confirm);

        void enableSSP();
        bool setPin(const char *pin);
@ -66,16 +57,6 @@ class BluetoothSerial: public Stream
        bool isReady(bool checkMaster=false, int timeout=0);
        bool disconnect();
        bool unpairDevice(uint8_t remoteAddress[]);
-
-        BTScanResults* discover(int timeout=0x30*1280);
-        bool discoverAsync(BTAdvertisedDeviceCb cb, int timeout=0x30*1280);
-        void discoverAsyncStop();
-        void discoverClear();
-        BTScanResults* getScanResults();
-        
-        const int INQ_TIME = 1280;   // Inquire Time unit 1280 ms
-        const int MIN_INQ_TIME = (ESP_BT_GAP_MIN_INQ_LEN * INQ_TIME);
-        const int MAX_INQ_TIME = (ESP_BT_GAP_MAX_INQ_LEN * INQ_TIME);
        
        operator bool() const;
    private:
--- a/libraries/EEPROM/src/EEPROM.cpp
+++ b/libraries/EEPROM/src/EEPROM.cpp
@ -382,9 +382,6 @@ size_t EEPROMClass::readString (int address, char* value, size_t maxLen)
  if (address + len > _size)
    return 0;

-  if (len > maxLen)
-    return 0; //Maybe return part of the string instead?
-
  memcpy((uint8_t*) value, _data + address, len);
  value[len] = 0;
  return len;
@ -403,7 +400,7 @@ String EEPROMClass::readString (int address)
  if (address + len > _size)
    return String();

-  char value[len+1];
+  char value[len];
  memcpy((uint8_t*) value, _data + address, len);
  value[len] = 0;
  return String(value);
--- a/libraries/ESP32/examples/AnalogOut/ledcWrite_RGB/ledcWrite_RGB.ino
+++ b/libraries/ESP32/examples/AnalogOut/ledcWrite_RGB/ledcWrite_RGB.ino
@ -9,9 +9,9 @@
 */
 
 // Set up the rgb led names
-uint8_t ledR = 2;
-uint8_t ledG = 4;
-uint8_t ledB = 5; 
+uint8_t ledR = A4;
+uint8_t ledG = A5;
+uint8_t ledB = A18; 

 uint8_t ledArray[3] = {1, 2, 3}; // three led channels

--- a/libraries/ESP32/examples/Camera/CameraWebServer/.skip.esp32c3
+++ b/libraries/ESP32/examples/Camera/CameraWebServer/.skip.esp32c3
--- a/libraries/ESP32/examples/DeepSleep/ExternalWakeUp/.skip.esp32c3
+++ b/libraries/ESP32/examples/DeepSleep/ExternalWakeUp/.skip.esp32c3
--- a/libraries/ESP32/examples/DeepSleep/TouchWakeUp/.skip.esp32c3
+++ b/libraries/ESP32/examples/DeepSleep/TouchWakeUp/.skip.esp32c3
--- a/libraries/ESP32/examples/HallSensor/.skip.esp32c3
+++ b/libraries/ESP32/examples/HallSensor/.skip.esp32c3
--- a/libraries/ESP32/examples/I2S/HiFreq_ADC/.skip.esp32c3
+++ b/libraries/ESP32/examples/I2S/HiFreq_ADC/.skip.esp32c3
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
me-no-dev	7d3f49940f	Update esptool for Big Sur	2020-12-07 10:17:52 +02:00
me-no-dev	9bc8420e2f	Update boards.txt	2020-12-01 18:00:24 +02:00
lbernstone	c1b06cc120	Fix possible race condition in uart attach (#4569 )	2020-12-01 16:36:44 +02:00
Sweety	93c6226177	Separate Provisioning library from WiFi library to avoid unnecessary compilation while using WiFi library (#4550 )	2020-11-19 00:13:14 +02:00
Me No Dev	b5651491e5	Ignore mklittlefs	2020-11-18 19:11:42 +02:00
me-no-dev	a25ccb2ef7	Fix Wire.begin causing divide by zero Fixes: https://github.com/espressif/arduino-esp32/issues/4530	2020-11-17 02:30:12 +02:00
me-no-dev	5b5b61c018	rework persist reboot	2020-11-17 02:04:56 +02:00
me-no-dev	cbafe67ee1	Fix PSRAM on S2	2020-11-17 01:13:23 +02:00
Me No Dev	e0f8b845fb	Merge branch 'master' into idf-release/v4.2	2020-11-15 21:47:59 +02:00
Me No Dev	1eb2c6d3dc	Merge pull request #4542 from lbernstone/adc_vref Fix deprecated vref function	2020-11-15 21:31:36 +02:00
Me No Dev	564733137a	Merge pull request #4541 from lbernstone/SD_MMC_v4.2 Updated SD_MMC init to match changes upstream	2020-11-15 21:31:12 +02:00
Larry Bernstone	e5555c72e5	Fix deprecated vref function	2020-11-15 12:16:02 -07:00
Me No Dev	104d28bd9c	Merge pull request #4540 from loick111/feature/custom_variants_dir_idf4.2 Allow custom variants directory	2020-11-15 21:10:52 +02:00
Larry Bernstone	934553d290	Updated SD_MMC init to match changes upstream	2020-11-15 12:00:55 -07:00
Loick MAHIEUX	f7fe024744	Allow custom variants directory	2020-11-15 19:56:05 +01:00
me-no-dev	29e3b640a8	Update IDF to 494a124d9	2020-11-15 12:25:38 +02:00
Me No Dev	91025f8515	Merge branch 'master' into idf-release/v4.2	2020-11-15 12:04:09 +02:00
Sweety	a2e0e865dd	Provisioning Fixes (#4522 )	2020-11-12 14:31:59 +02:00
Me No Dev	9debb9fc76	Merge branch 'master' into idf-release/v4.2	2020-11-10 20:52:25 +02:00
lorol	5d62ba56f6	Idf release/v4.2 - corrections of LITTLEFS and tools (#4515 ) * Update package_esp32_index.template.json Fix of wrong file type * Update LITTLEFS.cpp Suppress warnings fix.	2020-11-10 10:19:34 +02:00
Limor "Ladyada" Fried	2d0e772674	add 2 variants (#4514 ) * add variants * add boards	2020-11-10 10:18:42 +02:00
Me No Dev	2063a606e9	Merge branch 'master' into idf-release/v4.2	2020-11-09 17:08:38 +02:00
Me No Dev	ca6405658a	Merge branch 'master' into idf-release/v4.2	2020-11-06 22:28:28 +02:00
me-no-dev	70bd58b00b	Update Arduino.h	2020-11-06 22:07:24 +02:00
me-no-dev	f1cbd3b74b	Create esp_arduino_version.h	2020-11-06 22:02:40 +02:00
me-no-dev	e55d657e9f	Try to free some memory	2020-11-06 15:45:10 +02:00
Me No Dev	ef5c73f1ed	Merge branch 'master' into idf-release/v4.2	2020-11-06 14:17:30 +02:00
Me No Dev	591c43880a	RE: Change check for BT_ENABLE to really be a check for BLUEDROID_ENABLED (#4497 ) * Change check for CONFIG_BT_ENABLE to really be a check for CONFIG_BLUEDROID_ENABLED Which is really what should have been tested. This allows use of the Arduino layer with the newer Nimble stack for those that don't want to use Bluedroid. In support of https://github.com/meshtastic/Meshtastic-device/issues/266 * Change check for CONFIG_BT_ENABLE to really be a check for CONFIG_BLUEDROID_ENABLED Which is really what should have been tested. This allows use of the Arduino layer with the newer Nimble stack for those that don't want to use Bluedroid. In support of https://github.com/meshtastic/Meshtastic-device/issues/266 * wifi prov changes * merge fixes Co-authored-by: geeksville <kevinh@geeksville.com>	2020-11-06 14:00:06 +02:00
Me No Dev	8767419289	Merge branch 'master' into idf-release/v4.2	2020-11-06 13:27:35 +02:00
me-no-dev	78783c5183	fix psram init	2020-11-06 12:20:20 +02:00
me-no-dev	1bb7abe271	Make setHostname return true	2020-11-05 20:37:07 +02:00
me-no-dev	ec5ec746d9	skip bt tests for esp32s2	2020-11-04 04:08:22 +02:00
Me No Dev	a4aaec6a23	Merge branch 'master' into idf-release/v4.2	2020-11-04 02:31:29 +02:00
me-no-dev	976aca4781	more fixes	2020-11-04 02:31:08 +02:00
me-no-dev	72c25f2fdb	Update WiFiProv.ino	2020-11-04 02:21:38 +02:00
me-no-dev	a07f3c16a5	Add missing config	2020-11-04 02:16:30 +02:00
me-no-dev	37af4c9d2f	more fixes	2020-11-04 01:53:38 +02:00
me-no-dev	5e3189f2f1	fix some merge errors	2020-11-04 01:33:52 +02:00
lorol	b76c95206c	Adding LITTLEFS after esp_littlefs (IDF) is built-in (#4483 ) Tools idea: https://github.com/lorol/arduino-esp32fs-plugin	2020-11-04 01:20:58 +02:00
me-no-dev	8ae5be5659	Add esp-rainmaker support for ESP32	2020-11-04 01:19:31 +02:00
me-no-dev	6ffe081fd2	Update IDF master to 357a27760	2020-11-04 01:19:29 +02:00
me-no-dev	2d0b8c7e81	Update IDF and Camera	2020-11-04 01:19:07 +02:00
me-no-dev	9a37a020d2	Fix Arduino PIN counts	2020-11-04 01:19:05 +02:00
bobobo1618	cf93d473fb	Make esp32-hal-tinyusb.h conditional on tinyusb (#4155 )	2020-11-04 01:19:05 +02:00
me-no-dev	659e9a51dd	Update IDF and Tools	2020-11-04 01:19:01 +02:00
me-no-dev	8900e8fca9	Update .gitignore	2020-11-04 01:18:31 +02:00
me-no-dev	064aa692f9	Update platform.txt	2020-11-04 01:18:31 +02:00
me-no-dev	57c96aa4e3	Add camera support first automated cmake build	2020-11-04 01:18:31 +02:00
me-no-dev	f8b72db3c6	Try with speed optimization as opposed to debug. Coremark 240 -> 430	2020-11-04 01:18:28 +02:00
tobozo	100001389b	Added ESP32-Wrover-Kit with distinct build.board (#4118 ) * Added ESP32-Wrover-Kit with distinct build.board * Fixed broken values * Update boards.txt Co-authored-by: Me No Dev <me-no-dev@users.noreply.github.com>	2020-11-04 01:18:27 +02:00
microDev	8c85642b04	Add board microS2 (#4314 )	2020-11-04 01:16:22 +02:00
copercini	bae722f1c1	Makes ethernet get an IP when connected (#4234 )	2020-11-04 01:16:22 +02:00
Mike Dunston	fa852c955f	Update WiFiMulti.cpp (#4099 ) Fix for https://github.com/espressif/arduino-esp32/issues/3914 by syncing with https://github.com/espressif/arduino-esp32/blob/esp32s2/libraries/WiFi/src/WiFiSTA.cpp#L161	2020-11-04 01:16:22 +02:00
me-no-dev	1ded874ce1	Update USB.cpp	2020-11-04 01:16:22 +02:00
me-no-dev	470cbedd8a	Update boards.txt	2020-11-04 01:16:22 +02:00
me-no-dev	7f2bf4e401	Update platform.txt	2020-11-04 01:16:22 +02:00
me-no-dev	ad07421931	Update install-platformio-esp32.sh	2020-11-04 01:16:22 +02:00
Me No Dev	537384da7d	Update platform.txt Provided by @ESP32DE	2020-11-04 01:16:22 +02:00
me-no-dev	394c32ddfc	Update IDF, tools and toolchains	2020-11-04 01:16:17 +02:00
me-no-dev	86c87aaeee	Some fixes	2020-11-04 01:15:33 +02:00
me-no-dev	0ac788f666	Add option to select the core used for Arduino and it's events	2020-11-04 01:15:32 +02:00
Me No Dev	e25ef9e6d0	Update CMakeLists.txt	2020-11-04 01:15:32 +02:00
me-no-dev	9e2b2bff70	Update HardwareSerial.h	2020-11-04 01:14:42 +02:00
Unexpected Maker	17581ec74d	Added UM FeatherS2 and UM ProS2 boards to boards.txt (#4188 ) * Added UM FeatherS2 and UM ProS2 boards to boards.txt Updated the name of TinyPICO to UM TinyPICO in boards.txt * Added VID/PID/Product names for TinyPICO, ProS2 & FeatherS2 Setup variant folders for each board * Removed unneeded stuff from FeatherS2 & ProS2 menu options * Added Serial CDC output default for FeatherS2 and ProS2 * Removed unneeded stuff from FeatherS2 & ProS2 menu options * Rebase from upstream and fixed Serial Output settings for FeatherS2 and ProS2 Co-authored-by: Seon Rozenblum <seonr@3sprockets.com>	2020-11-04 01:14:41 +02:00
me-no-dev	31ab456a3a	Update CMakeLists.txt	2020-11-04 01:11:29 +02:00
me-no-dev	681b1214cf	Improve CDC Logging support	2020-11-04 01:11:29 +02:00
me-no-dev	d777949bf5	Create USB_NOT.h	2020-11-04 01:11:28 +02:00
me-no-dev	1a7a928b64	Add option USB CDC to be used for Serial (starting USB early)	2020-11-04 01:11:28 +02:00
me-no-dev	4967f19513	Add support for custom VID/PID and Board name to show in ArduinoIDE ports list	2020-11-04 01:11:28 +02:00
me-no-dev	2a94977f60	Update tinyusb	2020-11-04 01:11:28 +02:00
me-no-dev	e325872f4e	Update USB.cpp	2020-11-04 01:11:28 +02:00
me-no-dev	e687951c0f	Some CDC and BTSerial compatibility fixes	2020-11-04 01:11:28 +02:00
me-no-dev	8cc9e955dc	Add debug output to CDC	2020-11-04 01:11:28 +02:00
me-no-dev	29e3d0e75f	Handle persistent reboot better in CDC	2020-11-04 01:11:28 +02:00
me-no-dev	7f54a357a4	Change driver attach api and remove DFU from CDC	2020-11-04 01:11:28 +02:00
me-no-dev	c9ae74f012	Update TinyUSB	2020-11-04 01:11:27 +02:00
me-no-dev	c6c3be12b9	Update USBCDC.cpp	2020-11-04 01:11:27 +02:00
me-no-dev	e9f1b5e838	Update libtinyusb.a	2020-11-04 01:11:27 +02:00
me-no-dev	ec7a51b263	Fix compilation issues	2020-11-04 01:11:27 +02:00
me-no-dev	6cd0d7c3db	Fix DTR/RTS state for ESP32S2 native USB	2020-11-04 01:11:27 +02:00
me-no-dev	1879a5c93d	Update CMakeLists.txt	2020-11-04 01:11:27 +02:00
me-no-dev	1b67e41c82	Add files to cmakelists and disconnect CDC if unplugged	2020-11-04 01:11:27 +02:00
me-no-dev	f43352b752	Add TinyUSB HAL and CDC	2020-11-04 01:10:37 +02:00
me-no-dev	47b34df897	Update IDF Libs	2020-11-04 01:10:37 +02:00
me-no-dev	7611f483ae	Update TinyUSB Lib	2020-11-04 01:10:35 +02:00
Me No Dev	1e48761177	Fix GPIO Interrupts	2020-11-04 01:10:35 +02:00
Mike Dunston	06125d22e1	Fixing static IP configuration so it doesn't get overwritten by DHCP as part of WiFi.begin(). (#4103 ) Fixing DHCP client stop if WiFi.config() is called before WiFi.begin() (as done in WiFiClientStaticIP.ino)	2020-11-04 01:10:35 +02:00
me-no-dev	cf713a88c8	Update libtinyusb.a	2020-11-04 01:10:35 +02:00
me-no-dev	e094e19f17	Add missing DFU driver	2020-11-04 01:10:35 +02:00
me-no-dev	0df54ea169	Try custom device descriptors	2020-11-04 01:10:34 +02:00
me-no-dev	93c97aac1c	again	2020-11-04 01:10:34 +02:00
me-no-dev	232ab09694	change endpoints	2020-11-04 01:10:33 +02:00
me-no-dev	146878768c	TinyUSB adjust	2020-11-04 01:10:32 +02:00
me-no-dev	1f53f28481	Update pins_arduino.h	2020-11-04 01:10:32 +02:00
me-no-dev	5a2580db7e	Fix swapped USB pins issue	2020-11-04 01:10:32 +02:00
me-no-dev	298a6f8910	Update CMakeLists.txt	2020-11-04 01:10:31 +02:00
me-no-dev	eda687069a	what happened to no-stub?	2020-11-04 01:09:00 +02:00
me-no-dev	9612ac89b7	how about now?	2020-11-04 01:09:00 +02:00
me-no-dev	c32a9be28b	what if functions are in the core?	2020-11-04 01:08:59 +02:00
me-no-dev	832edd2c63	try to fix linking errors	2020-11-04 01:08:58 +02:00
me-no-dev	908ee03db4	hopefully all is here now	2020-11-04 01:08:57 +02:00
me-no-dev	76637cbd5b	Once again	2020-11-04 01:08:56 +02:00
me-no-dev	f2e1016ea5	Update TinyUSB	2020-11-04 01:08:55 +02:00
me-no-dev	8ac2a69553	Add support for no-stub usb s2 flashing	2020-11-04 01:08:54 +02:00
me-no-dev	5dbcf201b8	Pull latest IDF and enable TinyUSB	2020-11-04 01:07:49 +02:00
me-no-dev	604abf0a96	Disable modem sleep by default on S2 for now.	2020-11-04 01:07:47 +02:00
me-no-dev	dc707a3121	add psram to malloc only if interrupts are not in IRAM	2020-11-04 01:07:21 +02:00
me-no-dev	b499befa9b	fix psram always init	2020-11-04 01:07:21 +02:00
me-no-dev	895fba0ded	fix issue with rtc wdt	2020-11-04 01:07:20 +02:00
me-no-dev	67e7706728	update idf libs, disable WDT on S2, use malloc for PSRAM	2020-11-04 01:07:19 +02:00
me-no-dev	99b5be0037	Disable IRAM ISRs and functions by default	2020-11-04 01:07:18 +02:00
me-no-dev	3397208d12	Update esp32-hal-gpio.c	2020-11-04 01:06:45 +02:00
me-no-dev	131c87b127	Update main.cpp	2020-11-04 01:06:45 +02:00
me-no-dev	87c9a8a8fa	some i2c fixes	2020-11-04 01:06:44 +02:00
me-no-dev	90e77cdaaf	Update WPS.ino	2020-11-04 01:06:44 +02:00
me-no-dev	59264b0254	Update WiFiProv.ino	2020-11-04 01:06:44 +02:00
me-no-dev	d1e7aefed7	Update WiFiBlueToothSwitch.ino	2020-11-04 01:06:08 +02:00
me-no-dev	ae27682601	Update WiFiClientEvents.ino	2020-11-04 01:06:08 +02:00
me-no-dev	dd64404823	more example fixes	2020-11-04 01:06:08 +02:00
me-no-dev	146c493b30	fix wrong bootloader path in pio scripts	2020-11-04 01:06:08 +02:00
me-no-dev	1f204676e6	fix some examples	2020-11-04 01:06:08 +02:00
me-no-dev	ecc96060da	fix WiFi	2020-11-04 01:04:59 +02:00
me-no-dev	a761281d8c	Fix PSRAM support	2020-11-04 00:57:18 +02:00
me-no-dev	5abe013f78	Update esp32-hal-uart.c	2020-11-04 00:57:18 +02:00
me-no-dev	92aa3b5e14	Update esp32-hal-uart.c	2020-11-04 00:57:18 +02:00
me-no-dev	61132a7172	Fix Serial	2020-11-04 00:57:18 +02:00
me-no-dev	4b9f70236f	Update HardwareSerial.cpp	2020-11-04 00:56:45 +02:00
me-no-dev	ce64a26ce3	Add I2C IDF Wrapper	2020-11-04 00:56:45 +02:00
me-no-dev	77015e05be	fix compile errors for esp32	2020-11-04 00:56:45 +02:00
me-no-dev	0c5f0f8bf8	fix peripherals	2020-11-04 00:56:45 +02:00
me-no-dev	3f89e22174	Update on-push.sh	2020-11-04 00:56:45 +02:00
me-no-dev	986b2a2699	Update install-platformio-esp32.sh	2020-11-04 00:56:45 +02:00
me-no-dev	55eca6830d	fix py script	2020-11-04 00:56:45 +02:00
me-no-dev	39c1de2e6d	new try at pio	2020-11-04 00:56:45 +02:00
me-no-dev	703ce7ed14	does not work	2020-11-04 00:56:44 +02:00
me-no-dev	df0c8aedda	how about now?	2020-11-04 00:56:44 +02:00
me-no-dev	40665eaf3a	try outputing the map	2020-11-04 00:56:44 +02:00
me-no-dev	bac6aece9e	Update on-push.sh	2020-11-04 00:56:44 +02:00
me-no-dev	f6d705f577	Update platformio-build-esp32.py	2020-11-04 00:56:44 +02:00
me-no-dev	d2bf40c0b3	Update platformio-build-esp32.py	2020-11-04 00:56:44 +02:00
me-no-dev	4aefc0ea3b	try pio again	2020-11-04 00:56:44 +02:00
me-no-dev	bcadf08fa6	Update on-push.sh	2020-11-04 00:55:56 +02:00
me-no-dev	92772e2aba	Update on-push.sh	2020-11-04 00:55:56 +02:00
me-no-dev	edee32ac07	Update WiFiTelnetToSerial.ino	2020-11-04 00:55:56 +02:00
me-no-dev	cd9f890400	skip more examples	2020-11-04 00:55:56 +02:00
me-no-dev	66b3e68bc4	Update esp32-hal-i2c.c	2020-11-04 00:55:56 +02:00
me-no-dev	d64a825b0a	Update SD_Update.ino	2020-11-04 00:55:56 +02:00
me-no-dev	2fcb386dcf	Create .skip.esp32s2	2020-11-04 00:55:56 +02:00
me-no-dev	fbac930d7c	skip some examples	2020-11-04 00:55:56 +02:00
me-no-dev	d349cdc08f	Update SPI_Multiple_Buses.ino	2020-11-04 00:55:55 +02:00
me-no-dev	a0b8025ad8	Update TouchRead.ino	2020-11-04 00:55:55 +02:00
me-no-dev	5784081147	disable BT Serial examples for S2	2020-11-04 00:55:55 +02:00
me-no-dev	d3c5f26fa4	Update ResetReason.ino	2020-11-04 00:55:55 +02:00
me-no-dev	bcae3a4def	Update on-push.sh	2020-11-04 00:55:55 +02:00
me-no-dev	7e06b32ce3	try s2 ci	2020-11-04 00:55:55 +02:00
me-no-dev	2326f91bc9	fix provision compilation	2020-11-04 00:55:55 +02:00
me-no-dev	c070e7152b	fix cmake check	2020-11-04 00:54:09 +02:00
me-no-dev	3735cfe548	Update app_httpd.cpp	2020-11-04 00:54:09 +02:00
me-no-dev	d9c7b589a0	some compile fixes	2020-11-04 00:54:09 +02:00
me-no-dev	5570003949	Update CameraWebServer.ino	2020-11-04 00:52:50 +02:00
me-no-dev	96b9e89015	Update esp32-hal-gpio.c	2020-11-04 00:52:50 +02:00
me-no-dev	c6b03a3f94	Add S2 variant	2020-11-04 00:52:50 +02:00
me-no-dev	0a262244e6	Initial Commit	2020-11-04 00:52:28 +02:00
me-no-dev	ebe0d9a6cb	Add fixes	2020-11-04 00:29:15 +02:00
me-no-dev	970fef63c0	Pass ethernet events to the main handler	2020-11-04 00:28:42 +02:00
me-no-dev	f14a85311f	get smart config to work as well	2020-11-04 00:28:41 +02:00
me-no-dev	92db9730e0	make ETH work	2020-11-04 00:28:41 +02:00
me-no-dev	ee535efb5c	Update package_esp32_index.template.json	2020-11-04 00:28:41 +02:00
me-no-dev	96679576d0	Update CMakeLists.txt	2020-11-04 00:28:41 +02:00
me-no-dev	1bf59ac227	Initial IDF-4.0 port SmartConfig and ETH need some work to adapt to the new API	2020-11-04 00:28:05 +02:00