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

.github/scripts/check-cmakelists.sh

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

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

@@ -48,22 +48,16 @@ else
 	export ARDUINO_USR_PATH="$HOME/Arduino"
 fi
 
-# Updated as of Nov 3rd 2020
-ARDUINO_IDE_URL="https://github.com/espressif/arduino-esp32/releases/download/1.0.4/arduino-nightly-"
-
-# Currently not working
-#ARDUINO_IDE_URL="https://www.arduino.cc/download.php?f=/arduino-nightly-"
-
 if [ ! -d "$ARDUINO_IDE_PATH" ]; then
 	echo "Installing Arduino IDE on $OS_NAME ..."
-	echo "Downloading '$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
+	echo "Downloading 'arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
 	if [ "$OS_IS_LINUX" == "1" ]; then
-		wget -O "arduino.$ARCHIVE_FORMAT" "$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		wget -O "arduino.$ARCHIVE_FORMAT" "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
 		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
 		tar xf "arduino.$ARCHIVE_FORMAT" > /dev/null
 		mv arduino-nightly "$ARDUINO_IDE_PATH"
 	else
-		curl -o "arduino.$ARCHIVE_FORMAT" -L "$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		curl -o "arduino.$ARCHIVE_FORMAT" -L "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
 		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
 		unzip "arduino.$ARCHIVE_FORMAT" > /dev/null
 		if [ "$OS_IS_MACOS" == "1" ]; then
@@ -116,10 +110,9 @@ function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
 		$win_opts $xtra_opts "$sketch"
 }
 
-function count_sketches() # count_sketches <examples-path> <target-mcu>
+function count_sketches() # count_sketches <examples-path>
 {
 	local examples="$1"
-	local target="$2"
     rm -rf sketches.txt
 	if [ ! -d "$examples" ]; then
 		touch sketches.txt
@@ -134,7 +127,7 @@ function count_sketches() # count_sketches <examples-path> <target-mcu>
         if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
             continue
         fi;
-        if [[ -f "$sketchdir/.skip.$target" ]]; then
+        if [[ -f "$sketchdir/.test.skip" ]]; then
             continue
         fi
         echo $sketch >> sketches.txt
@@ -143,25 +136,24 @@ function count_sketches() # count_sketches <examples-path> <target-mcu>
     return $sketchnum
 }
 
-function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <chunk> <total-chunks> [extra-options]
+function build_sketches() # build_sketches <fqbn> <examples-path> <chunk> <total-chunks> [extra-options]
 {
     local fqbn=$1
-	local target="$2"
-    local examples=$3
-    local chunk_idex=$4
-    local chunks_num=$5
-    local xtra_opts=$6
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
+    local xtra_opts=$5
 
-    if [ "$#" -lt 3 ]; then
+    if [ "$#" -lt 2 ]; then
 		echo "ERROR: Illegal number of parameters"
-		echo "USAGE: build_sketches <fqbn> <target-mcu <examples-path> [<chunk> <total-chunks>] [extra-options]"
+		echo "USAGE: build_sketches <fqbn> <examples-path> [<chunk> <total-chunks>] [extra-options]"
 		return 1
 	fi
 
-    if [ "$#" -lt 5 ]; then
+    if [ "$#" -lt 4 ]; then
 		chunk_idex="0"
 		chunks_num="1"
-		xtra_opts=$4
+		xtra_opts=$3
 	fi
 
 	if [ "$chunks_num" -le 0 ]; then
@@ -210,7 +202,7 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
         local sketchdirname=$(basename $sketchdir)
         local sketchname=$(basename $sketch)
         if [ "${sketchdirname}.ino" != "$sketchname" ] \
-        || [ -f "$sketchdir/.skip.$target" ]; then
+        || [ -f "$sketchdir/.test.skip" ]; then
             continue
         fi
         sketchnum=$(($sketchnum + 1))

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

@@ -1,7 +1,6 @@
 #!/bin/bash
 
 export PLATFORMIO_ESP32_PATH="$HOME/.platformio/packages/framework-arduinoespressif32"
-PLATFORMIO_ESP32_URL="https://github.com/platformio/platform-espressif32.git#feature/idf-v4.0"
 
 echo "Installing Python Wheel ..."
 pip install wheel > /dev/null 2>&1
@@ -10,36 +9,40 @@ echo "Installing PlatformIO ..."
 pip install -U https://github.com/platformio/platformio/archive/develop.zip > /dev/null 2>&1
 
 echo "Installing Platform ESP32 ..."
-python -m platformio platform install $PLATFORMIO_ESP32_URL > /dev/null 2>&1
+python -m platformio platform install https://github.com/platformio/platform-espressif32.git#feature/stage > /dev/null 2>&1
 
 echo "Replacing the framework version ..."
-python -c "import json; import os; fp=open(os.path.expanduser('~/.platformio/platforms/espressif32/platform.json'), 'r+'); data=json.load(fp); data['packages']['framework-arduinoespressif32']['version'] = '*'; del data['packages']['framework-arduinoespressif32']['owner']; fp.seek(0); fp.truncate(); json.dump(data, fp); fp.close()"
+if [[ "$OSTYPE" == "darwin"* ]]; then
+	sed 's/https:\/\/github\.com\/espressif\/arduino-esp32\.git/*/' "$HOME/.platformio/platforms/espressif32/platform.json" > "platform.json"
+	mv -f "platform.json" "$HOME/.platformio/platforms/espressif32/platform.json"
+else
+	sed -i 's/https:\/\/github\.com\/espressif\/arduino-esp32\.git/*/' "$HOME/.platformio/platforms/espressif32/platform.json"
+fi
 
 if [ "$GITHUB_REPOSITORY" == "espressif/arduino-esp32" ];  then
 	echo "Linking Core..."
 	ln -s $GITHUB_WORKSPACE "$PLATFORMIO_ESP32_PATH"
 else
 	echo "Cloning Core Repository ..."
-	git clone --recursive https://github.com/espressif/arduino-esp32.git "$PLATFORMIO_ESP32_PATH" > /dev/null 2>&1
+	git clone https://github.com/espressif/arduino-esp32.git "$PLATFORMIO_ESP32_PATH" > /dev/null 2>&1
 fi
 
 echo "PlatformIO for ESP32 has been installed"
 echo ""
 
-function build_pio_sketch(){ # build_pio_sketch <board> <options> <path-to-ino>
-    if [ "$#" -lt 3 ]; then
+function build_pio_sketch(){ # build_pio_sketch <board> <path-to-ino>
+    if [ "$#" -lt 2 ]; then
         echo "ERROR: Illegal number of parameters"
-        echo "USAGE: build_pio_sketch <board> <options> <path-to-ino>"
+        echo "USAGE: build_pio_sketch <board> <path-to-ino>"
         return 1
     fi
 
     local board="$1"
-    local options="$2"
-    local sketch="$3"
+    local sketch="$2"
     local sketch_dir=$(dirname "$sketch")
     echo ""
     echo "Compiling '"$(basename "$sketch")"' ..."
-    python -m platformio ci --board "$board" "$sketch_dir" --project-option="$options"
+    python -m platformio ci --board "$board" "$sketch_dir" --project-option="board_build.partitions = huge_app.csv"
 }
 
 function count_sketches() # count_sketches <examples-path>
@@ -68,21 +71,20 @@ function count_sketches() # count_sketches <examples-path>
     return $sketchnum
 }
 
-function build_pio_sketches() # build_pio_sketches <board> <options> <examples-path> <chunk> <total-chunks>
+function build_pio_sketches() # build_pio_sketches <board> <examples-path> <chunk> <total-chunks>
 {
-    if [ "$#" -lt 3 ]; then
+    if [ "$#" -lt 2 ]; then
         echo "ERROR: Illegal number of parameters"
-        echo "USAGE: build_pio_sketches <board> <options> <examples-path> [<chunk> <total-chunks>]"
+        echo "USAGE: build_pio_sketches <board> <examples-path> [<chunk> <total-chunks>]"
         return 1
     fi
 
     local board=$1
-    local options="$2"
-    local examples=$3
-    local chunk_idex=$4
-    local chunks_num=$5
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
 
-    if [ "$#" -lt 5 ]; then
+    if [ "$#" -lt 4 ]; then
         chunk_idex="0"
         chunks_num="1"
     fi
@@ -141,7 +143,7 @@ function build_pio_sketches() # build_pio_sketches <board> <options> <examples-p
         || [ "$sketchnum" -gt "$end_index" ]; then
             continue
         fi
-        build_pio_sketch "$board" "$options" "$sketch"
+        build_pio_sketch "$board" "$sketch"
         local result=$?
         if [ $result -ne 0 ]; then
             return $result

.github/scripts/on-push.sh

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

.gitignore

@@ -1,5 +1,4 @@
 tools/xtensa-esp32-elf
-tools/xtensa-esp32s2-elf
 tools/dist
 tools/esptool
 tools/esptool.exe
@@ -13,6 +12,3 @@ tools/mkspiffs/mkspiffs.exe
 .vs/
 __vm/
 *.vcxproj*
-.vscode/
-platform.sloeber.txt
-boards.sloeber.txt

CMakeLists.txt

@@ -15,7 +15,6 @@ set(CORE_SRCS
   cores/esp32/esp32-hal-spi.c
   cores/esp32/esp32-hal-time.c
   cores/esp32/esp32-hal-timer.c
-  cores/esp32/esp32-hal-tinyusb.c
   cores/esp32/esp32-hal-touch.c
   cores/esp32/esp32-hal-uart.c
   cores/esp32/esp32-hal-rmt.c
@@ -32,8 +31,6 @@ set(CORE_SRCS
   cores/esp32/stdlib_noniso.c
   cores/esp32/Stream.cpp
   cores/esp32/StreamString.cpp
-  cores/esp32/USB.cpp
-  cores/esp32/USBCDC.cpp
   cores/esp32/wiring_pulse.c
   cores/esp32/wiring_shift.c
   cores/esp32/WMath.cpp
@@ -52,7 +49,6 @@ set(LIBRARY_SRCS
   libraries/FS/src/vfs_api.cpp
   libraries/HTTPClient/src/HTTPClient.cpp
   libraries/HTTPUpdate/src/HTTPUpdate.cpp
-  libraries/LITTLEFS/src/LITTLEFS.cpp
   libraries/NetBIOS/src/NetBIOS.cpp
   libraries/Preferences/src/Preferences.cpp
   libraries/SD_MMC/src/SD_MMC.cpp
@@ -75,7 +71,6 @@ set(LIBRARY_SRCS
   libraries/WiFi/src/WiFi.cpp
   libraries/WiFi/src/WiFiGeneric.cpp
   libraries/WiFi/src/WiFiMulti.cpp
-  libraries/WiFi/src/WiFiProv.cpp
   libraries/WiFi/src/WiFiScan.cpp
   libraries/WiFi/src/WiFiServer.cpp
   libraries/WiFi/src/WiFiSTA.cpp
@@ -115,8 +110,9 @@ set(BLE_SRCS
   libraries/BLE/src/GeneralUtils.cpp
   )
 
+set(COMPONENT_SRCS ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 
-set(includedirs
+set(COMPONENT_ADD_INCLUDEDIRS
   variants/esp32/
   cores/esp32/
   libraries/ArduinoOTA/src
@@ -131,7 +127,6 @@ set(includedirs
   libraries/FS/src
   libraries/HTTPClient/src
   libraries/HTTPUpdate/src
-  libraries/LITTLEFS/src
   libraries/NetBIOS/src
   libraries/Preferences/src
   libraries/SD_MMC/src
@@ -147,16 +142,9 @@ set(includedirs
   libraries/Wire/src
   )
 
-set(srcs ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
-set(priv_includes cores/esp32/libb64)
-set(requires spi_flash mbedtls mdns esp_adc_cal)
-set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt tinyusb main)
+set(COMPONENT_PRIV_INCLUDEDIRS cores/esp32/libb64)
 
-idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})
+set(COMPONENT_REQUIRES spi_flash mbedtls mdns esp_adc_cal)
+set(COMPONENT_PRIV_REQUIRES fatfs nvs_flash app_update spiffs bootloader_support openssl bt)
 
-if(IDF_TARGET STREQUAL "esp32")
-target_compile_options(${COMPONENT_TARGET} PUBLIC -DARDUINO=10812 -DARDUINO_ESP32_DEV -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32_DEV" -DARDUINO_VARIANT="esp32" -DESP32)
-endif()
-if(IDF_TARGET STREQUAL "esp32s2")
-target_compile_options(${COMPONENT_TARGET} PUBLIC -DARDUINO=10812 -DARDUINO_ESP32S2_DEV -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32S2_DEV" -DARDUINO_VARIANT="esp32s2" -DESP32)
-endif()
+register_component()

Kconfig.projbuild

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

cores/esp32/Arduino.h

@@ -115,10 +115,10 @@ typedef bool boolean;
 typedef uint8_t byte;
 typedef unsigned int word;
 
-#ifdef __cplusplus
 void setup(void);
 void loop(void);
 
+#ifdef __cplusplus
 long random(long, long);
 #endif
 void randomSeed(unsigned long);

cores/esp32/Esp.cpp

@@ -35,8 +35,6 @@ extern "C" {
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/spi_flash.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/spi_flash.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -133,36 +131,24 @@ uint32_t EspClass::getMaxAllocHeap(void)
 
 uint32_t EspClass::getPsramSize(void)
 {
-	if(psramFound()){
-	    multi_heap_info_t info;
-	    heap_caps_get_info(&info, MALLOC_CAP_SPIRAM);
-	    return info.total_free_bytes + info.total_allocated_bytes;
-	}
-	return 0;
+    multi_heap_info_t info;
+    heap_caps_get_info(&info, MALLOC_CAP_SPIRAM);
+    return info.total_free_bytes + info.total_allocated_bytes;
 }
 
 uint32_t EspClass::getFreePsram(void)
 {
-	if(psramFound()){
-	    return heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
-	}
-	return 0;
+    return heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
 }
 
 uint32_t EspClass::getMinFreePsram(void)
 {
-	if(psramFound()){
-	    return heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM);
-	}
-	return 0;
+    return heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM);
 }
 
 uint32_t EspClass::getMaxAllocPsram(void)
 {
-	if(psramFound()){
-	    return heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM);
-	}
-	return 0;
+    return heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM);
 }
 
 static uint32_t sketchSize(sketchSize_t response) {

cores/esp32/Esp.h

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

cores/esp32/FunctionalInterrupt.cpp

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

cores/esp32/HardwareSerial.cpp

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

cores/esp32/HardwareSerial.h

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

cores/esp32/MD5Builder.h

@@ -26,8 +26,6 @@
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/md5_hash.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/md5_hash.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif

cores/esp32/USB.cpp

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

cores/esp32/USB.h

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

cores/esp32/USBCDC.cpp

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

cores/esp32/USBCDC.h

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

cores/esp32/esp32-hal-adc.c

@@ -21,19 +21,13 @@
 #include "soc/sens_reg.h"
 
 #include "driver/adc.h"
+#include "esp_adc_cal.h"
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp_adc_cal.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp_intr_alloc.h"
-#define DEFAULT_VREF    1100
-static esp_adc_cal_characteristics_t *__analogCharacteristics[2] = {NULL, NULL};
-static uint16_t __analogVRef = 0;
-static uint8_t __analogVRefPin = 0;
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -42,9 +36,23 @@ static uint8_t __analogVRefPin = 0;
 #include "esp_intr.h"
 #endif
 
+#define DEFAULT_VREF    1100
+static esp_adc_cal_characteristics_t *__analogCharacteristics[2] = {NULL, NULL};
 static uint8_t __analogAttenuation = 3;//11db
 static uint8_t __analogWidth = 3;//12 bits
 static uint8_t __analogClockDiv = 1;
+static uint16_t __analogVRef = 0;
+static uint8_t __analogVRefPin = 0;
+
+void __analogSetWidth(uint8_t bits){
+    if(bits < 9){
+        bits = 9;
+    } else if(bits > 12){
+        bits = 12;
+    }
+    __analogWidth = bits - 9;
+    adc1_config_width(__analogWidth);
+}
 
 void __analogSetClockDiv(uint8_t clockDiv){
     if(!clockDiv){
@@ -59,18 +67,6 @@ void __analogSetAttenuation(adc_attenuation_t attenuation)
     __analogAttenuation = attenuation & 3;
 }
 
-#if CONFIG_IDF_TARGET_ESP32
-void __analogSetWidth(uint8_t bits){
-    if(bits < 9){
-        bits = 9;
-    } else if(bits > 12){
-        bits = 12;
-    }
-    __analogWidth = bits - 9;
-    adc1_config_width(__analogWidth);
-}
-#endif
-
 void __analogInit(){
     static bool initialized = false;
     if(initialized){
@@ -78,9 +74,7 @@ void __analogInit(){
     }
     initialized = true;
     __analogSetClockDiv(__analogClockDiv);
-#if CONFIG_IDF_TARGET_ESP32
     __analogSetWidth(__analogWidth + 9);//in bits
-#endif
 }
 
 void __analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation)
@@ -105,7 +99,6 @@ bool __adcAttachPin(uint8_t pin){
     }
     int8_t pad = digitalPinToTouchChannel(pin);
     if(pad >= 0){
-#if CONFIG_IDF_TARGET_ESP32
         uint32_t touch = READ_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG);
         if(touch & (1 << pad)){
             touch &= ~((1 << (pad + SENS_TOUCH_PAD_OUTEN2_S))
@@ -113,7 +106,6 @@ bool __adcAttachPin(uint8_t pin){
                     | (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)));
             WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, touch);
         }
-#endif
     } else if(pin == 25){
         CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_XPD_DAC | RTC_IO_PDAC1_DAC_XPD_FORCE);//stop dac1
     } else if(pin == 26){
@@ -130,9 +122,7 @@ void __analogReadResolution(uint8_t bits)
     if(!bits || bits > 16){
         return;
     }
-#if CONFIG_IDF_TARGET_ESP32
     __analogSetWidth(bits);         // hadware from 9 to 12
-#endif
 }
 
 uint16_t __analogRead(uint8_t pin)
@@ -163,13 +153,19 @@ uint16_t __analogRead(uint8_t pin)
     return value;
 }
 
+void __analogSetVRefPin(uint8_t pin){
+    if(pin <25 || pin > 27){
+        pin = 0;
+    }
+    __analogVRefPin = pin;
+}
+
 uint32_t __analogReadMilliVolts(uint8_t pin){
     int8_t channel = digitalPinToAnalogChannel(pin);
     if(channel < 0){
         log_e("Pin %u is not ADC pin!", pin);
         return 0;
     }
-#if CONFIG_IDF_TARGET_ESP32
     if(!__analogVRef){
         if (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_TP) == ESP_OK) {
             log_d("eFuse Two Point: Supported");
@@ -214,27 +210,6 @@ uint32_t __analogReadMilliVolts(uint8_t pin){
         }
     }
     return esp_adc_cal_raw_to_voltage(adc_reading, __analogCharacteristics[unit - 1]);
-#else
-    uint16_t adc_reading = __analogRead(pin);
-    uint16_t max_reading = 8191;
-    uint16_t max_mv = 1100;
-    switch(__analogAttenuation){
-        case 3: max_mv = 3900; break;
-        case 2: max_mv = 2200; break;
-        case 1: max_mv = 1500; break;
-        default: break;
-    }
-    return (adc_reading * max_mv) / max_reading;
-#endif
-}
-
-#if CONFIG_IDF_TARGET_ESP32
-
-void __analogSetVRefPin(uint8_t pin){
-    if(pin <25 || pin > 27){
-        pin = 0;
-    }
-    __analogVRefPin = pin;
 }
 
 int __hallRead()    //hall sensor without LNA
@@ -260,20 +235,16 @@ int __hallRead()    //hall sensor without LNA
     CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_HALL_PHASE_FORCE);
     return (Sens_Vp1 - Sens_Vp0) - (Sens_Vn1 - Sens_Vn0);
 }
-#endif
 
 extern uint16_t analogRead(uint8_t pin) __attribute__ ((weak, alias("__analogRead")));
-extern uint32_t analogReadMilliVolts(uint8_t pin) __attribute__ ((weak, alias("__analogReadMilliVolts")));
 extern void analogReadResolution(uint8_t bits) __attribute__ ((weak, alias("__analogReadResolution")));
+extern void analogSetWidth(uint8_t bits) __attribute__ ((weak, alias("__analogSetWidth")));
 extern void analogSetClockDiv(uint8_t clockDiv) __attribute__ ((weak, alias("__analogSetClockDiv")));
 extern void analogSetAttenuation(adc_attenuation_t attenuation) __attribute__ ((weak, alias("__analogSetAttenuation")));
 extern void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation) __attribute__ ((weak, alias("__analogSetPinAttenuation")));
+extern int hallRead() __attribute__ ((weak, alias("__hallRead")));
 
 extern bool adcAttachPin(uint8_t pin) __attribute__ ((weak, alias("__adcAttachPin")));
 
-#if CONFIG_IDF_TARGET_ESP32
 extern void analogSetVRefPin(uint8_t pin) __attribute__ ((weak, alias("__analogSetVRefPin")));
-extern void analogSetWidth(uint8_t bits) __attribute__ ((weak, alias("__analogSetWidth")));
-extern int hallRead() __attribute__ ((weak, alias("__hallRead")));
-#endif
-
+extern uint32_t analogReadMilliVolts(uint8_t pin) __attribute__ ((weak, alias("__analogReadMilliVolts")));

cores/esp32/esp32-hal-adc.h

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

cores/esp32/esp32-hal-cpu.c

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

cores/esp32/esp32-hal-dac.c

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

cores/esp32/esp32-hal-gpio.c

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

cores/esp32/esp32-hal-gpio.h

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

cores/esp32/esp32-hal-i2c.c

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

cores/esp32/esp32-hal-ledc.c

@@ -25,11 +25,6 @@
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/ets_sys.h"
-#define LAST_CHAN (15)
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#define LAST_CHAN (7)
-#define LEDC_DIV_NUM_HSTIMER0_V LEDC_CLK_DIV_LSTIMER0_V
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -124,13 +119,9 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
     LEDC_TIMER(group, timer).conf.clock_divider = div_num;//18 bit (10.8) This register is used to configure parameter for divider in timer the least significant eight bits represent the decimal part.
     LEDC_TIMER(group, timer).conf.duty_resolution = bit_num;//5 bit This register controls the range of the counter in timer. the counter range is [0 2**bit_num] the max bit width for counter is 20.
     LEDC_TIMER(group, timer).conf.tick_sel = apb_clk;//apb clock
-#if CONFIG_IDF_TARGET_ESP32
     if(group) {
-#endif
         LEDC_TIMER(group, timer).conf.low_speed_update = 1;//This bit is only useful for low speed timer channels, reserved for high speed timers
-#if CONFIG_IDF_TARGET_ESP32
     }
-#endif
     LEDC_TIMER(group, timer).conf.pause = 0;
     LEDC_TIMER(group, timer).conf.rst = 1;//This bit is used to reset timer the counter will be 0 after reset.
     LEDC_TIMER(group, timer).conf.rst = 0;
@@ -195,21 +186,17 @@ static void _ledcSetupChannel(uint8_t chan, uint8_t idle_level)
     LEDC_CHAN(group, channel).duty.duty = 0;
     LEDC_CHAN(group, channel).conf0.sig_out_en = 0;//This is the output enable control bit for channel
     LEDC_CHAN(group, channel).conf1.duty_start = 0;//When duty_num duty_cycle and duty_scale has been configured. these register won't take effect until set duty_start. this bit is automatically cleared by hardware.
-#if CONFIG_IDF_TARGET_ESP32
     if(group) {
-#endif
         LEDC_CHAN(group, channel).conf0.low_speed_update = 1;
-#if CONFIG_IDF_TARGET_ESP32
     } else {
         LEDC_CHAN(group, channel).conf0.clk_en = 0;
     }
-#endif
     LEDC_MUTEX_UNLOCK();
 }
 
 double ledcSetup(uint8_t chan, double freq, uint8_t bit_num)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return 0;
     }
     double res_freq = _ledcSetupTimerFreq(chan, freq, bit_num);
@@ -219,7 +206,7 @@ double ledcSetup(uint8_t chan, double freq, uint8_t bit_num)
 
 void ledcWrite(uint8_t chan, uint32_t duty)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return;
     }
     uint8_t group=(chan/8), channel=(chan%8);
@@ -228,34 +215,26 @@ void ledcWrite(uint8_t chan, uint32_t duty)
     if(duty) {
         LEDC_CHAN(group, channel).conf0.sig_out_en = 1;//This is the output enable control bit for channel
         LEDC_CHAN(group, channel).conf1.duty_start = 1;//When duty_num duty_cycle and duty_scale has been configured. these register won't take effect until set duty_start. this bit is automatically cleared by hardware.
-#if CONFIG_IDF_TARGET_ESP32
         if(group) {
-#endif
             LEDC_CHAN(group, channel).conf0.low_speed_update = 1;
-#if CONFIG_IDF_TARGET_ESP32
         } else {
             LEDC_CHAN(group, channel).conf0.clk_en = 1;
         }
-#endif
     } else {
         LEDC_CHAN(group, channel).conf0.sig_out_en = 0;//This is the output enable control bit for channel
         LEDC_CHAN(group, channel).conf1.duty_start = 0;//When duty_num duty_cycle and duty_scale has been configured. these register won't take effect until set duty_start. this bit is automatically cleared by hardware.
-#if CONFIG_IDF_TARGET_ESP32
         if(group) {
-#endif
             LEDC_CHAN(group, channel).conf0.low_speed_update = 1;
-#if CONFIG_IDF_TARGET_ESP32
         } else {
             LEDC_CHAN(group, channel).conf0.clk_en = 0;
         }
-#endif
     }
     LEDC_MUTEX_UNLOCK();
 }
 
 uint32_t ledcRead(uint8_t chan)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return 0;
     }
     return LEDC.channel_group[chan/8].channel[chan%8].duty.duty >> 4;
@@ -271,7 +250,7 @@ double ledcReadFreq(uint8_t chan)
 
 double ledcWriteTone(uint8_t chan, double freq)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return 0;
     }
     if(!freq) {
@@ -298,15 +277,11 @@ double ledcWriteNote(uint8_t chan, note_t note, uint8_t octave){
 
 void ledcAttachPin(uint8_t pin, uint8_t chan)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return;
     }
     pinMode(pin, OUTPUT);
-#if CONFIG_IDF_TARGET_ESP32S2
-    pinMatrixOutAttach(pin, LEDC_LS_SIG_OUT0_IDX + chan, false, false);
-#else
     pinMatrixOutAttach(pin, ((chan/8)?LEDC_LS_SIG_OUT0_IDX:LEDC_HS_SIG_OUT0_IDX) + (chan%8), false, false);
-#endif
 }
 
 void ledcDetachPin(uint8_t pin)

cores/esp32/esp32-hal-log.h

@@ -20,7 +20,6 @@ extern "C"
 #endif
 
 #include "sdkconfig.h"
-#include "esp_timer.h"
 
 #define ARDUHAL_LOG_LEVEL_NONE       (0)
 #define ARDUHAL_LOG_LEVEL_ERROR      (1)
@@ -76,7 +75,7 @@ const char * pathToFileName(const char * path);
 int log_printf(const char *fmt, ...);
 
 #define ARDUHAL_SHORT_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter format ARDUHAL_LOG_RESET_COLOR "\r\n"
-#define ARDUHAL_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter "[%6u][" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", (unsigned long) (esp_timer_get_time() / 1000ULL), pathToFileName(__FILE__), __LINE__, __FUNCTION__
+#define ARDUHAL_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter "[" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", pathToFileName(__FILE__), __LINE__, __FUNCTION__
 
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_VERBOSE
 #define log_v(format, ...) log_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)

cores/esp32/esp32-hal-matrix.c

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

cores/esp32/esp32-hal-misc.c

@@ -38,8 +38,6 @@
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/rtc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/rtc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -143,12 +141,12 @@ BaseType_t xTaskCreateUniversal( TaskFunction_t pxTaskCode,
 #endif
 }
 
-unsigned long ARDUINO_ISR_ATTR micros()
+unsigned long IRAM_ATTR micros()
 {
     return (unsigned long) (esp_timer_get_time());
 }
 
-unsigned long ARDUINO_ISR_ATTR millis()
+unsigned long IRAM_ATTR millis()
 {
     return (unsigned long) (esp_timer_get_time() / 1000ULL);
 }
@@ -158,7 +156,7 @@ void delay(uint32_t ms)
     vTaskDelay(ms / portTICK_PERIOD_MS);
 }
 
-void ARDUINO_ISR_ATTR delayMicroseconds(uint32_t us)
+void IRAM_ATTR delayMicroseconds(uint32_t us)
 {
     uint32_t m = micros();
     if(us){
@@ -210,7 +208,7 @@ void initArduino()
 #ifdef F_CPU
     setCpuFrequencyMhz(F_CPU/1000000);
 #endif
-#if CONFIG_SPIRAM_SUPPORT || CONFIG_SPIRAM
+#if CONFIG_SPIRAM_SUPPORT
     psramInit();
 #endif
     esp_log_level_set("*", CONFIG_LOG_DEFAULT_LEVEL);
@@ -239,7 +237,7 @@ void initArduino()
 }
 
 //used by hal log
-const char * ARDUINO_ISR_ATTR pathToFileName(const char * path)
+const char * IRAM_ATTR pathToFileName(const char * path)
 {
     size_t i = 0;
     size_t pos = 0;

cores/esp32/esp32-hal-psram.c

@@ -14,7 +14,7 @@
 
 #include "esp32-hal.h"
 
-#if CONFIG_SPIRAM_SUPPORT || CONFIG_SPIRAM
+#if CONFIG_SPIRAM_SUPPORT
 #include "soc/efuse_reg.h"
 #include "esp_heap_caps.h"
 
@@ -22,9 +22,6 @@
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/spiram.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/spiram.h"
-#include "esp32s2/rom/cache.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -43,7 +40,6 @@ bool psramInit(){
     if (spiramFailed) {
         return false;
     }
-#if CONFIG_IDF_TARGET_ESP32
     uint32_t chip_ver = REG_GET_FIELD(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_VER_PKG);
     uint32_t pkg_ver = chip_ver & 0x7;
     if (pkg_ver == EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5 || pkg_ver == EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2) {
@@ -52,21 +48,13 @@ bool psramInit(){
         return false;
     }
     esp_spiram_init_cache();
-#elif CONFIG_IDF_TARGET_ESP32S2
-    extern void esp_config_data_cache_mode(void);
-    esp_config_data_cache_mode();
-    Cache_Enable_DCache(0);
-#endif
     if (esp_spiram_init() != ESP_OK) {
         spiramFailed = true;
         log_w("PSRAM init failed!");
-#if CONFIG_IDF_TARGET_ESP32
         pinMatrixOutDetach(16, false, false);
         pinMatrixOutDetach(17, false, false);
-#endif
         return false;
     }
-    esp_spiram_init_cache();
     if (!esp_spiram_test()) {
         spiramFailed = true;
         log_e("PSRAM test failed!");
@@ -77,34 +65,31 @@ bool psramInit(){
         log_e("PSRAM could not be added to the heap!");
         return false;
     }
-#if CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL && !CONFIG_ARDUINO_ISR_IRAM
-        heap_caps_malloc_extmem_enable(CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL);
-#endif
 #endif
     spiramDetected = true;
     log_d("PSRAM enabled");
     return true;
 }
 
-bool ARDUINO_ISR_ATTR psramFound(){
+bool IRAM_ATTR psramFound(){
     return spiramDetected;
 }
 
-void ARDUINO_ISR_ATTR *ps_malloc(size_t size){
+void IRAM_ATTR *ps_malloc(size_t size){
     if(!spiramDetected){
         return NULL;
     }
     return heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
 }
 
-void ARDUINO_ISR_ATTR *ps_calloc(size_t n, size_t size){
+void IRAM_ATTR *ps_calloc(size_t n, size_t size){
     if(!spiramDetected){
         return NULL;
     }
     return heap_caps_calloc(n, size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
 }
 
-void ARDUINO_ISR_ATTR *ps_realloc(void *ptr, size_t size){
+void IRAM_ATTR *ps_realloc(void *ptr, size_t size){
     if(!spiramDetected){
         return NULL;
     }
@@ -117,19 +102,19 @@ bool psramInit(){
     return false;
 }
 
-bool ARDUINO_ISR_ATTR psramFound(){
+bool IRAM_ATTR psramFound(){
     return false;
 }
 
-void ARDUINO_ISR_ATTR *ps_malloc(size_t size){
+void IRAM_ATTR *ps_malloc(size_t size){
     return NULL;
 }
 
-void ARDUINO_ISR_ATTR *ps_calloc(size_t n, size_t size){
+void IRAM_ATTR *ps_calloc(size_t n, size_t size){
     return NULL;
 }
 
-void ARDUINO_ISR_ATTR *ps_realloc(void *ptr, size_t size){
+void IRAM_ATTR *ps_realloc(void *ptr, size_t size){
     return NULL;
 }
 

cores/esp32/esp32-hal-psram.h

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

cores/esp32/esp32-hal-rmt.c

@@ -19,20 +19,18 @@
 #include "esp32-hal.h"
 #include "esp8266-compat.h"
 #include "soc/gpio_reg.h"
-#include "soc/rmt_struct.h"
+#include "soc/gpio_reg.h"
+
+#include "esp32-hal-rmt.h"
 #include "driver/periph_ctrl.h"
+
+#include "soc/rmt_struct.h"
 #include "esp_intr_alloc.h"
 
 /**
  * Internal macros
  */
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #define MAX_CHANNELS 8
-#elif CONFIG_IDF_TARGET_ESP32S2
-#define MAX_CHANNELS 4
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
 #define MAX_DATA_PER_CHANNEL 64
 #define MAX_DATA_PER_ITTERATION 62
 #define _ABS(a) (a>0?a:-a)
@@ -102,10 +100,7 @@ struct rmt_obj_s
  * Internal variables for channel descriptors
  */
 static xSemaphoreHandle g_rmt_objlocks[MAX_CHANNELS] = {
-    NULL, NULL, NULL, NULL, 
-#if CONFIG_IDF_TARGET_ESP32
-    NULL, NULL, NULL, NULL
-#endif
+    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
 };
 
 static rmt_obj_t g_rmt_objects[MAX_CHANNELS] = {
@@ -113,12 +108,10 @@ static rmt_obj_t g_rmt_objects[MAX_CHANNELS] = {
     { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
     { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
     { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-#if CONFIG_IDF_TARGET_ESP32
     { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
     { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
     { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
     { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-#endif
 };
 
 /**
@@ -137,17 +130,17 @@ static void _initPin(int pin, int channel, bool tx_not_rx);
 
 static bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous);
 
-static void ARDUINO_ISR_ATTR _rmt_isr(void* arg);
+static void IRAM_ATTR _rmt_isr(void* arg);
 
 static rmt_obj_t* _rmtAllocate(int pin, int from, int size);
 
 static void _initPin(int pin, int channel, bool tx_not_rx);
 
-static int ARDUINO_ISR_ATTR _rmt_get_mem_len(uint8_t channel);
+static int IRAM_ATTR _rmt_get_mem_len(uint8_t channel);
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch);
+static void IRAM_ATTR _rmt_tx_mem_first(uint8_t ch);
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch);
+static void IRAM_ATTR _rmt_tx_mem_second(uint8_t ch);
 
 
 /**
@@ -270,7 +263,7 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         RMT_MUTEX_LOCK(channel);
         // setup interrupt handler if not yet installed for half and full tx
         if (!intr_handle) {
-            esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, _rmt_isr, NULL, &intr_handle);
+            esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ESP_INTR_FLAG_IRAM, _rmt_isr, NULL, &intr_handle);
         }
 
         rmt->data_size = size - MAX_DATA_PER_ITTERATION;
@@ -539,17 +532,12 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
     RMT.conf_ch[channel].conf0.mem_size = buffers;
     RMT.conf_ch[channel].conf0.carrier_en = 0;
     RMT.conf_ch[channel].conf0.carrier_out_lv = 0;
-#if CONFIG_IDF_TARGET_ESP32
     RMT.conf_ch[channel].conf0.mem_pd = 0;
-#endif
+
     RMT.conf_ch[channel].conf0.idle_thres = 0x80;
     RMT.conf_ch[channel].conf1.rx_en = 0;
     RMT.conf_ch[channel].conf1.tx_conti_mode = 0;
-#if CONFIG_IDF_TARGET_ESP32
     RMT.conf_ch[channel].conf1.ref_cnt_rst = 0;
-#else
-    RMT.conf_ch[channel].conf1.chk_rx_carrier_en = 0;
-#endif
     RMT.conf_ch[channel].conf1.rx_filter_en = 0;
     RMT.conf_ch[channel].conf1.rx_filter_thres = 0;
     RMT.conf_ch[channel].conf1.idle_out_lv = 0;     // signal level for idle
@@ -569,7 +557,7 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
 
     // install interrupt if at least one channel is active
     if (!intr_handle) {
-        esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, _rmt_isr, NULL, &intr_handle);
+        esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ESP_INTR_FLAG_IRAM, _rmt_isr, NULL, &intr_handle);
     }
     RMT_MUTEX_UNLOCK(channel);
 
@@ -637,7 +625,7 @@ static void _initPin(int pin, int channel, bool tx_not_rx)
 }
 
 
-static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
+static void IRAM_ATTR _rmt_isr(void* arg)
 {
     int intr_val = RMT.int_st.val;
     size_t ch;
@@ -727,7 +715,7 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
     }
 }
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
+static void IRAM_ATTR _rmt_tx_mem_second(uint8_t ch)
 {
     DEBUG_INTERRUPT_START(4)
     uint32_t* data = g_rmt_objects[ch].data_ptr;
@@ -779,7 +767,7 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
     DEBUG_INTERRUPT_END(4);
 }
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
+static void IRAM_ATTR _rmt_tx_mem_first(uint8_t ch)
 {
     DEBUG_INTERRUPT_START(2);
     uint32_t* data = g_rmt_objects[ch].data_ptr;
@@ -830,7 +818,7 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
     DEBUG_INTERRUPT_END(2);
 }
 
-static int ARDUINO_ISR_ATTR _rmt_get_mem_len(uint8_t channel)
+static int IRAM_ATTR _rmt_get_mem_len(uint8_t channel)
 {
     int block_num = RMT.conf_ch[channel].conf0.mem_size;
     int item_block_len = block_num * 64;

cores/esp32/esp32-hal-sigmadelta.c

@@ -24,8 +24,6 @@
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -81,9 +79,6 @@ uint32_t sigmaDeltaSetup(uint8_t channel, uint32_t freq) //chan 0-7 freq 1220-31
         prescale = 0xFF;
     }
     SD_MUTEX_LOCK();
-#ifndef CONFIG_IDF_TARGET_ESP32
-    SIGMADELTA.misc.function_clk_en = 1;
-#endif
     SIGMADELTA.channel[channel].prescale = prescale;
     SIGMADELTA.cg.clk_en = 0;
     SIGMADELTA.cg.clk_en = 1;

cores/esp32/esp32-hal-spi.c

@@ -31,10 +31,6 @@
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/gpio.h"
 #include "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/gpio.h"
-#include "esp_intr_alloc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -44,6 +40,18 @@
 #include "esp_intr.h"
 #endif
 
+#define SPI_CLK_IDX(p)  ((p==0)?SPICLK_OUT_IDX:((p==1)?SPICLK_OUT_IDX:((p==2)?HSPICLK_OUT_IDX:((p==3)?VSPICLK_OUT_IDX:0))))
+#define SPI_MISO_IDX(p) ((p==0)?SPIQ_OUT_IDX:((p==1)?SPIQ_OUT_IDX:((p==2)?HSPIQ_OUT_IDX:((p==3)?VSPIQ_OUT_IDX:0))))
+#define SPI_MOSI_IDX(p) ((p==0)?SPID_IN_IDX:((p==1)?SPID_IN_IDX:((p==2)?HSPID_IN_IDX:((p==3)?VSPID_IN_IDX:0))))
+
+#define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:((n==2)?SPICS2_OUT_IDX:SPICS0_OUT_IDX)))
+#define SPI_HSPI_SS_IDX(n)   ((n==0)?HSPICS0_OUT_IDX:((n==1)?HSPICS1_OUT_IDX:((n==2)?HSPICS2_OUT_IDX:HSPICS0_OUT_IDX)))
+#define SPI_VSPI_SS_IDX(n)   ((n==0)?VSPICS0_OUT_IDX:((n==1)?VSPICS1_OUT_IDX:((n==2)?VSPICS2_OUT_IDX:VSPICS0_OUT_IDX)))
+#define SPI_SS_IDX(p, n)   ((p==0)?SPI_SPI_SS_IDX(n):((p==1)?SPI_SPI_SS_IDX(n):((p==2)?SPI_HSPI_SS_IDX(n):((p==3)?SPI_VSPI_SS_IDX(n):0))))
+
+#define SPI_INUM(u)        (2)
+#define SPI_INTR_SOURCE(u) ((u==0)?ETS_SPI0_INTR_SOURCE:((u==1)?ETS_SPI1_INTR_SOURCE:((u==2)?ETS_SPI2_INTR_SOURCE:((p==3)?ETS_SPI3_INTR_SOURCE:0))))
+
 struct spi_struct_t {
     spi_dev_t * dev;
 #if !CONFIG_DISABLE_HAL_LOCKS
@@ -52,69 +60,25 @@ struct spi_struct_t {
     uint8_t num;
 };
 
-#if CONFIG_IDF_TARGET_ESP32S2
-// ESP32S2
-#define SPI_COUNT           (3)
-
-#define SPI_CLK_IDX(p)      ((p==0)?SPICLK_OUT_MUX_IDX:((p==1)?FSPICLK_OUT_MUX_IDX:((p==2)?SPI3_CLK_OUT_MUX_IDX:0)))
-#define SPI_MISO_IDX(p)     ((p==0)?SPIQ_OUT_IDX:((p==1)?FSPIQ_OUT_IDX:((p==2)?SPI3_Q_OUT_IDX:0)))
-#define SPI_MOSI_IDX(p)     ((p==0)?SPID_IN_IDX:((p==1)?FSPID_IN_IDX:((p==2)?SPI3_D_IN_IDX:0)))
-
-#define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:0))
-#define SPI_HSPI_SS_IDX(n)  ((n==0)?SPI3_CS0_OUT_IDX:((n==1)?SPI3_CS1_OUT_IDX:((n==2)?SPI3_CS2_OUT_IDX:SPI3_CS0_OUT_IDX)))
-#define SPI_FSPI_SS_IDX(n)  ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:VSPICS0_OUT_IDX)))
-#define SPI_SS_IDX(p, n)    ((p==0)?SPI_SPI_SS_IDX(n):((p==1)?SPI_SPI_SS_IDX(n):((p==2)?SPI_HSPI_SS_IDX(n):0)))
-
-#define SPI_INTR_SOURCE(u)  ((u==0)?ETS_SPI1_INTR_SOURCE:((u==1)?ETS_SPI2_INTR_SOURCE:((u==2)?ETS_SPI3_INTR_SOURCE:0)))
-
-#else
-// ESP32
-#define SPI_COUNT           (4)
-
-#define SPI_CLK_IDX(p)      ((p==0)?SPICLK_OUT_IDX:((p==1)?SPICLK_OUT_IDX:((p==2)?HSPICLK_OUT_IDX:((p==3)?VSPICLK_OUT_IDX:0))))
-#define SPI_MISO_IDX(p)     ((p==0)?SPIQ_OUT_IDX:((p==1)?SPIQ_OUT_IDX:((p==2)?HSPIQ_OUT_IDX:((p==3)?VSPIQ_OUT_IDX:0))))
-#define SPI_MOSI_IDX(p)     ((p==0)?SPID_IN_IDX:((p==1)?SPID_IN_IDX:((p==2)?HSPID_IN_IDX:((p==3)?VSPID_IN_IDX:0))))
-
-#define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:((n==2)?SPICS2_OUT_IDX:SPICS0_OUT_IDX)))
-#define SPI_HSPI_SS_IDX(n)  ((n==0)?HSPICS0_OUT_IDX:((n==1)?HSPICS1_OUT_IDX:((n==2)?HSPICS2_OUT_IDX:HSPICS0_OUT_IDX)))
-#define SPI_VSPI_SS_IDX(n)  ((n==0)?VSPICS0_OUT_IDX:((n==1)?VSPICS1_OUT_IDX:((n==2)?VSPICS2_OUT_IDX:VSPICS0_OUT_IDX)))
-#define SPI_SS_IDX(p, n)    ((p==0)?SPI_SPI_SS_IDX(n):((p==1)?SPI_SPI_SS_IDX(n):((p==2)?SPI_HSPI_SS_IDX(n):((p==3)?SPI_VSPI_SS_IDX(n):0))))
-
-#define SPI_INTR_SOURCE(u)  ((u==0)?ETS_SPI0_INTR_SOURCE:((u==1)?ETS_SPI1_INTR_SOURCE:((u==2)?ETS_SPI2_INTR_SOURCE:((p==3)?ETS_SPI3_INTR_SOURCE:0))))
-
-#endif
-
 #if CONFIG_DISABLE_HAL_LOCKS
 #define SPI_MUTEX_LOCK()
 #define SPI_MUTEX_UNLOCK()
 
-static spi_t _spi_bus_array[] = {
-#if CONFIG_IDF_TARGET_ESP32S2
-    {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 0},
-    {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 1},
-    {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 2}
-#else
+static spi_t _spi_bus_array[4] = {
     {(volatile spi_dev_t *)(DR_REG_SPI0_BASE), 0},
     {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 1},
     {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 2},
     {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 3}
-#endif
 };
 #else
 #define SPI_MUTEX_LOCK()    do {} while (xSemaphoreTake(spi->lock, portMAX_DELAY) != pdPASS)
 #define SPI_MUTEX_UNLOCK()  xSemaphoreGive(spi->lock)
 
-static spi_t _spi_bus_array[] = {
-#if CONFIG_IDF_TARGET_ESP32S2
-    {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 0},
-    {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 1},
-    {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 2}
-#else
+static spi_t _spi_bus_array[4] = {
     {(volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0},
     {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1},
     {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 2},
     {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 3}
-#endif
 };
 #endif
 
@@ -124,14 +88,6 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
         return;
     }
     if(sck < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            sck = 36;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -139,7 +95,6 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#endif
     }
     pinMode(sck, OUTPUT);
     pinMatrixOutAttach(sck, SPI_CLK_IDX(spi->num), false, false);
@@ -151,14 +106,6 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
         return;
     }
     if(miso < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            miso = 37;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -166,7 +113,6 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#endif
     }
     SPI_MUTEX_LOCK();
     pinMode(miso, INPUT);
@@ -180,14 +126,6 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
         return;
     }
     if(mosi < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            mosi = 35;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -195,7 +133,6 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#endif
     }
     pinMode(mosi, OUTPUT);
     pinMatrixOutAttach(mosi, SPI_MOSI_IDX(spi->num), false, false);
@@ -207,14 +144,6 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
         return;
     }
     if(sck < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            sck = 36;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -222,7 +151,6 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#endif
     }
     pinMatrixOutDetach(sck, false, false);
     pinMode(sck, INPUT);
@@ -234,14 +162,6 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
         return;
     }
     if(miso < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            miso = 37;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -249,7 +169,6 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#endif
     }
     pinMatrixInDetach(SPI_MISO_IDX(spi->num), false, false);
     pinMode(miso, INPUT);
@@ -261,14 +180,6 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
         return;
     }
     if(mosi < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            mosi = 35;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -276,7 +187,6 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#endif
     }
     pinMatrixOutDetach(mosi, false, false);
     pinMode(mosi, INPUT);
@@ -292,14 +202,6 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
     }
     if(ss < 0) {
         cs_num = 0;
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            ss = 34;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -307,7 +209,6 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
         } else {
             ss = 11;
         }
-#endif
     }
     pinMode(ss, OUTPUT);
     pinMatrixOutAttach(ss, SPI_SS_IDX(spi->num, cs_num), false, false);
@@ -320,14 +221,6 @@ void spiDetachSS(spi_t * spi, int8_t ss)
         return;
     }
     if(ss < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            ss = 34;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -335,7 +228,6 @@ void spiDetachSS(spi_t * spi, int8_t ss)
         } else {
             ss = 11;
         }
-#endif
     }
     pinMatrixOutDetach(ss, false, false);
     pinMode(ss, INPUT);
@@ -347,11 +239,7 @@ void spiEnableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.val &= ~(cs_mask & SPI_CS_MASK_ALL);
-#else
     spi->dev->pin.val &= ~(cs_mask & SPI_CS_MASK_ALL);
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -361,11 +249,7 @@ void spiDisableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.val |= (cs_mask & SPI_CS_MASK_ALL);
-#else
     spi->dev->pin.val |= (cs_mask & SPI_CS_MASK_ALL);
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -397,11 +281,7 @@ void spiSSSet(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.cs_keep_active = 1;
-#else
     spi->dev->pin.cs_keep_active = 1;
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -411,11 +291,7 @@ void spiSSClear(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.cs_keep_active = 0;
-#else
     spi->dev->pin.cs_keep_active = 0;
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -442,11 +318,7 @@ uint8_t spiGetDataMode(spi_t * spi)
     if(!spi) {
         return 0;
     }
-#if CONFIG_IDF_TARGET_ESP32S2
-    bool idleEdge = spi->dev->misc.ck_idle_edge;
-#else
     bool idleEdge = spi->dev->pin.ck_idle_edge;
-#endif
     bool outEdge = spi->dev->user.ck_out_edge;
     if(idleEdge) {
         if(outEdge) {
@@ -468,36 +340,20 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
     SPI_MUTEX_LOCK();
     switch (dataMode) {
     case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
         spi->dev->pin.ck_idle_edge = 0;
-#endif
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
         spi->dev->pin.ck_idle_edge = 1;
-#endif
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
         spi->dev->pin.ck_idle_edge = 1;
-#endif
         spi->dev->user.ck_out_edge = 0;
         break;
     case SPI_MODE0:
     default:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
         spi->dev->pin.ck_idle_edge = 0;
-#endif
         spi->dev->user.ck_out_edge = 0;
         break;
     }
@@ -540,39 +396,28 @@ static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb
     }
 }
 
-static void spiInitBus(spi_t * spi)
+void spiStopBus(spi_t * spi)
 {
+    if(!spi) {
+        return;
+    }
+    SPI_MUTEX_LOCK();
     spi->dev->slave.trans_done = 0;
     spi->dev->slave.slave_mode = 0;
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.val = 0;
-#else
     spi->dev->pin.val = 0;
-#endif
     spi->dev->user.val = 0;
     spi->dev->user1.val = 0;
     spi->dev->ctrl.val = 0;
     spi->dev->ctrl1.val = 0;
     spi->dev->ctrl2.val = 0;
     spi->dev->clock.val = 0;
-}
-
-void spiStopBus(spi_t * spi)
-{
-    if(!spi) {
-        return;
-    }
-    
-    removeApbChangeCallback(spi, _on_apb_change);
-    
-    SPI_MUTEX_LOCK();
-    spiInitBus(spi);
     SPI_MUTEX_UNLOCK();
+    removeApbChangeCallback(spi, _on_apb_change);
 }
 
 spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder)
 {
-    if(spi_num >= SPI_COUNT){
+    if(spi_num > 3){
         return NULL;
     }
 
@@ -587,18 +432,6 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
     }
 #endif
 
-#if CONFIG_IDF_TARGET_ESP32S2
-    if(spi_num == FSPI) {
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI2_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI2_RST);
-    } else if(spi_num == HSPI) {
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI3_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI3_RST);
-    } else {
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
-    }
-#else
     if(spi_num == HSPI) {
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI2_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI2_RST);
@@ -609,10 +442,13 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
     }
-#endif
+
+    spiStopBus(spi);
+    spiSetDataMode(spi, dataMode);
+    spiSetBitOrder(spi, bitOrder);
+    spiSetClockDiv(spi, clockDiv);
 
     SPI_MUTEX_LOCK();
-    spiInitBus(spi);
     spi->dev->user.usr_mosi = 1;
     spi->dev->user.usr_miso = 1;
     spi->dev->user.doutdin = 1;
@@ -623,10 +459,6 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
     }
     SPI_MUTEX_UNLOCK();
 
-    spiSetDataMode(spi, dataMode);
-    spiSetBitOrder(spi, bitOrder);
-    spiSetClockDiv(spi, clockDiv);
-
     addApbChangeCallback(spi, _on_apb_change);
     return spi;
 }
@@ -639,11 +471,6 @@ void spiWaitReady(spi_t * spi)
     while(spi->dev->cmd.usr);
 }
 
-#if CONFIG_IDF_TARGET_ESP32S2
-#define usr_mosi_dbitlen usr_mosi_bit_len
-#define usr_miso_dbitlen usr_miso_bit_len
-#endif
-
 void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
 {
     if(!spi) {
@@ -897,39 +724,23 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
     SPI_MUTEX_LOCK();
     spi->dev->clock.val = clockDiv;
     switch (dataMode) {
-    case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
-        spi->dev->pin.ck_idle_edge = 0;
-#endif
-        spi->dev->user.ck_out_edge = 1;
-        break;
-    case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
-        spi->dev->pin.ck_idle_edge = 1;
-#endif
-        spi->dev->user.ck_out_edge = 1;
-        break;
-    case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
-        spi->dev->pin.ck_idle_edge = 1;
-#endif
-        spi->dev->user.ck_out_edge = 0;
-        break;
-    case SPI_MODE0:
-    default:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
-        spi->dev->pin.ck_idle_edge = 0;
-#endif
-        spi->dev->user.ck_out_edge = 0;
-        break;
+        case SPI_MODE1:
+            spi->dev->pin.ck_idle_edge = 0;
+            spi->dev->user.ck_out_edge = 1;
+            break;
+        case SPI_MODE2:
+            spi->dev->pin.ck_idle_edge = 1;
+            spi->dev->user.ck_out_edge = 1;
+            break;
+        case SPI_MODE3:
+            spi->dev->pin.ck_idle_edge = 1;
+            spi->dev->user.ck_out_edge = 0;
+            break;
+        case SPI_MODE0:
+        default:
+            spi->dev->pin.ck_idle_edge = 0;
+            spi->dev->user.ck_out_edge = 0;
+            break;
     }
     if (SPI_MSBFIRST == bitOrder) {
         spi->dev->ctrl.wr_bit_order = 0;
@@ -956,7 +767,7 @@ void spiEndTransaction(spi_t * spi)
     SPI_MUTEX_UNLOCK();
 }
 
-void ARDUINO_ISR_ATTR spiWriteByteNL(spi_t * spi, uint8_t data)
+void IRAM_ATTR spiWriteByteNL(spi_t * spi, uint8_t data)
 {
     if(!spi) {
         return;
@@ -982,7 +793,7 @@ uint8_t spiTransferByteNL(spi_t * spi, uint8_t data)
     return data;
 }
 
-void ARDUINO_ISR_ATTR spiWriteShortNL(spi_t * spi, uint16_t data)
+void IRAM_ATTR spiWriteShortNL(spi_t * spi, uint16_t data)
 {
     if(!spi) {
         return;
@@ -1017,7 +828,7 @@ uint16_t spiTransferShortNL(spi_t * spi, uint16_t data)
     return data;
 }
 
-void ARDUINO_ISR_ATTR spiWriteLongNL(spi_t * spi, uint32_t data)
+void IRAM_ATTR spiWriteLongNL(spi_t * spi, uint32_t data)
 {
     if(!spi) {
         return;
@@ -1165,7 +976,7 @@ void spiTransferBitsNL(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
     }
 }
 
-void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32_t len){
+void IRAM_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32_t len){
     size_t longs = len >> 2;
     if(len & 3){
         longs++;

cores/esp32/esp32-hal-spi.h

@@ -19,7 +19,6 @@
 extern "C" {
 #endif
 
-#include "sdkconfig.h"
 #include <stdint.h>
 #include <stdbool.h>
 
@@ -27,9 +26,7 @@ extern "C" {
 
 #define FSPI  1 //SPI bus attached to the flash (can use the same data lines but different SS)
 #define HSPI  2 //SPI bus normally mapped to pins 12 - 15, but can be matrixed to any pins
-#if CONFIG_IDF_TARGET_ESP32
 #define VSPI  3 //SPI bus normally attached to pins 5, 18, 19 and 23, but can be matrixed to any pins
-#endif
 
 // This defines are not representing the real Divider of the ESP32
 // the Defines match to an AVR Arduino on 16MHz for better compatibility

cores/esp32/esp32-hal-time.c

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

cores/esp32/esp32-hal-timer.c

@@ -19,17 +19,12 @@
 #include "soc/timer_group_struct.h"
 #include "soc/dport_reg.h"
 #include "esp_attr.h"
-#include "driver/periph_ctrl.h"
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/ets_sys.h"
 #include "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
-#include "soc/periph_defs.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -83,18 +78,11 @@ static hw_timer_t hw_timer[4] = {
 typedef void (*voidFuncPtr)(void);
 static voidFuncPtr __timerInterruptHandlers[4] = {0,0,0,0};
 
-void ARDUINO_ISR_ATTR __timerISR(void * arg){
-#if CONFIG_IDF_TARGET_ESP32
+void IRAM_ATTR __timerISR(void * arg){
     uint32_t s0 = TIMERG0.int_st_timers.val;
     uint32_t s1 = TIMERG1.int_st_timers.val;
     TIMERG0.int_clr_timers.val = s0;
     TIMERG1.int_clr_timers.val = s1;
-#else
-    uint32_t s0 = TIMERG0.int_st.val;
-    uint32_t s1 = TIMERG1.int_st.val;
-    TIMERG0.int_clr.val = s0;
-    TIMERG1.int_clr.val = s1;
-#endif
     uint8_t status = (s1 & 3) << 2 | (s0 & 3);
     uint8_t i = 4;
     //restart the timers that should autoreload
@@ -226,29 +214,15 @@ hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
     }
     hw_timer_t * timer = &hw_timer[num];
     if(timer->group) {
-    	periph_module_enable(PERIPH_TIMG1_MODULE);
+        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_TIMERGROUP1_CLK_EN);
+        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_TIMERGROUP1_RST);
+        TIMERG1.int_ena.val &= ~BIT(timer->timer);
     } else {
-    	periph_module_enable(PERIPH_TIMG0_MODULE);
+        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_TIMERGROUP_CLK_EN);
+        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_TIMERGROUP_RST);
+        TIMERG0.int_ena.val &= ~BIT(timer->timer);
     }
     timer->dev->config.enable = 0;
-    if(timer->group) {
-        TIMERG1.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG1.int_clr.val = BIT(timer->timer);
-#endif
-    } else {
-        TIMERG0.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG0.int_clr.val = BIT(timer->timer);
-#endif
-    }
-#ifdef TIMER_GROUP_SUPPORTS_XTAL_CLOCK
-    timer->dev->config.use_xtal = 0;
-#endif
     timerSetDivider(timer, divider);
     timerSetCountUp(timer, countUp);
     timerSetAutoReload(timer, false);
@@ -266,9 +240,6 @@ 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){
@@ -280,18 +251,8 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
         timer->dev->config.alarm_en = 0;
         if(timer->num & 2){
             TIMERG1.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG1.int_clr.val = BIT(timer->timer);
-#endif
         } else {
             TIMERG0.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG0.int_clr.val = BIT(timer->timer);
-#endif
         }
         __timerInterruptHandlers[timer->num] = NULL;
     } else {
@@ -314,7 +275,7 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
         }
         if(!initialized){
             initialized = true;
-            esp_intr_alloc(intr_source, (int)(ARDUINO_ISR_FLAG|ESP_INTR_FLAG_LOWMED), __timerISR, NULL, &intr_handle);
+            esp_intr_alloc(intr_source, (int)(ESP_INTR_FLAG_IRAM|ESP_INTR_FLAG_LOWMED|ESP_INTR_FLAG_EDGE), __timerISR, NULL, &intr_handle);
         } else {
             intr_matrix_set(esp_intr_get_cpu(intr_handle), intr_source, esp_intr_get_intno(intr_handle));
         }

cores/esp32/esp32-hal-tinyusb.c

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

cores/esp32/esp32-hal-tinyusb.h

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

cores/esp32/esp32-hal-touch.c

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

cores/esp32/esp32-hal-uart.c

@@ -32,10 +32,6 @@
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/uart.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/uart.h"
-#include "soc/periph_defs.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -45,19 +41,10 @@
 #include "esp_intr.h"
 #endif
 
-#if CONFIG_IDF_TARGET_ESP32S2
-#define UART_PORTS_NUM 2
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:0))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:0))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:0))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:0))
-#else
-#define UART_PORTS_NUM 3
 #define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:(    (u==2)?DR_REG_UART2_BASE:0)))
 #define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:(         (u==2)?U2RXD_IN_IDX:0)))
 #define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:(        (u==2)?U2TXD_OUT_IDX:0)))
 #define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:((u==2)?ETS_UART2_INTR_SOURCE:0)))
-#endif
 
 static int s_uart_debug_nr = 0;
 
@@ -75,35 +62,31 @@ struct uart_struct_t {
 #define UART_MUTEX_LOCK()
 #define UART_MUTEX_UNLOCK()
 
-static uart_t _uart_bus_array[] = {
-    {&UART0, 0, NULL, NULL},
-    {&UART1, 1, NULL, NULL},
-#if CONFIG_IDF_TARGET_ESP32
-    {&UART2, 2, NULL, NULL}
-#endif
+static uart_t _uart_bus_array[3] = {
+    {(volatile uart_dev_t *)(DR_REG_UART_BASE), 0, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART1_BASE), 1, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART2_BASE), 2, NULL, NULL}
 };
 #else
 #define UART_MUTEX_LOCK()    do {} while (xSemaphoreTake(uart->lock, portMAX_DELAY) != pdPASS)
 #define UART_MUTEX_UNLOCK()  xSemaphoreGive(uart->lock)
 
-static uart_t _uart_bus_array[] = {
-    {&UART0, NULL, 0, NULL, NULL},
-    {&UART1, NULL, 1, NULL, NULL},
-#if CONFIG_IDF_TARGET_ESP32
-    {&UART2, NULL, 2, NULL, NULL}
-#endif
+static uart_t _uart_bus_array[3] = {
+    {(volatile uart_dev_t *)(DR_REG_UART_BASE), NULL, 0, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART1_BASE), NULL, 1, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART2_BASE), NULL, 2, NULL, NULL}
 };
 #endif
 
 static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb);
 
-static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
+static void IRAM_ATTR _uart_isr(void *arg)
 {
     uint8_t i, c;
     BaseType_t xHigherPriorityTaskWoken;
     uart_t* uart;
 
-    for(i=0;i<UART_PORTS_NUM;i++){
+    for(i=0;i<3;i++){
         uart = &_uart_bus_array[i];
         if(uart->intr_handle == NULL){
             continue;
@@ -111,15 +94,9 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
         uart->dev->int_clr.rxfifo_full = 1;
         uart->dev->int_clr.frm_err = 1;
         uart->dev->int_clr.rxfifo_tout = 1;
-#if CONFIG_IDF_TARGET_ESP32
         while(uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
             c = uart->dev->fifo.rw_byte;
-#else
-        uint32_t fifo_reg = UART_FIFO_AHB_REG(i);
-        while(uart->dev->status.rxfifo_cnt) {
-        	c = ESP_REG(fifo_reg);
-#endif
-            if(uart->queue != NULL)  {
+            if(uart->queue != NULL && !xQueueIsQueueFullFromISR(uart->queue)) {
                 xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
             }
         }
@@ -134,18 +111,14 @@ void uartEnableInterrupt(uart_t* uart)
 {
     UART_MUTEX_LOCK();
     uart->dev->conf1.rxfifo_full_thrhd = 112;
-#if CONFIG_IDF_TARGET_ESP32
     uart->dev->conf1.rx_tout_thrhd = 2;
-#else
-    uart->dev->mem_conf.rx_tout_thrhd = 2;
-#endif
     uart->dev->conf1.rx_tout_en = 1;
     uart->dev->int_ena.rxfifo_full = 1;
     uart->dev->int_ena.frm_err = 1;
     uart->dev->int_ena.rxfifo_tout = 1;
     uart->dev->int_clr.val = 0xffffffff;
 
-    esp_intr_alloc(UART_INTR_SOURCE(uart->num), (int)ARDUINO_ISR_FLAG, _uart_isr, NULL, &uart->intr_handle);
+    esp_intr_alloc(UART_INTR_SOURCE(uart->num), (int)ESP_INTR_FLAG_IRAM, _uart_isr, NULL, &uart->intr_handle);
     UART_MUTEX_UNLOCK();
 }
 
@@ -181,7 +154,7 @@ void uartDetachTx(uart_t* uart)
 
 void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
 {
-    if(uart == NULL || rxPin >= GPIO_PIN_COUNT) {
+    if(uart == NULL || rxPin > 39) {
         return;
     }
     pinMode(rxPin, INPUT);
@@ -191,7 +164,7 @@ void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
 
 void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 {
-    if(uart == NULL || txPin >= GPIO_PIN_COUNT) {
+    if(uart == NULL || txPin > 39) {
         return;
     }
     pinMode(txPin, OUTPUT);
@@ -200,7 +173,7 @@ void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 
 uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted)
 {
-    if(uart_nr >= UART_PORTS_NUM) {
+    if(uart_nr > 2) {
         return NULL;
     }
 
@@ -228,11 +201,9 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     if(uart_nr == 1){
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART1_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART1_RST);
-#if CONFIG_IDF_TARGET_ESP32
     } else if(uart_nr == 2){
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART2_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART2_RST);
-#endif
     } else {
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART_RST);
@@ -248,11 +219,6 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
         uart->dev->conf0.stop_bit_num = ONE_STOP_BITS_CONF;
         uart->dev->rs485_conf.dl1_en = 1;
     }
-
-    // tx_idle_num : idle interval after tx FIFO is empty(unit: the time it takes to send one bit under current baudrate)
-    // Setting it to 0 prevents line idle time/delays when sending messages with small intervals
-    uart->dev->idle_conf.tx_idle_num = 0;  //
-
     UART_MUTEX_UNLOCK();
 
     if(rxPin != -1) {
@@ -310,7 +276,7 @@ uint32_t uartAvailable(uart_t* uart)
     if(uart == NULL || uart->queue == NULL) {
         return 0;
     }
-    return (uxQueueMessagesWaiting(uart->queue) + uart->dev->status.rxfifo_cnt) ;
+    return uxQueueMessagesWaiting(uart->queue);
 }
 
 uint32_t uartAvailableForWrite(uart_t* uart)
@@ -321,41 +287,12 @@ uint32_t uartAvailableForWrite(uart_t* uart)
     return 0x7f - uart->dev->status.txfifo_cnt;
 }
 
-void uartRxFifoToQueue(uart_t* uart)
-{
-	uint8_t c;
-    UART_MUTEX_LOCK();
-	//disable interrupts
-	uart->dev->int_ena.val = 0;
-	uart->dev->int_clr.val = 0xffffffff;
-#if CONFIG_IDF_TARGET_ESP32
-	while (uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
-		c = uart->dev->fifo.rw_byte;
-#else
-	uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-	while (uart->dev->status.rxfifo_cnt) {
-		c = ESP_REG(fifo_reg);
-#endif
-		xQueueSend(uart->queue, &c, 0);
-	}
-	//enable interrupts
-	uart->dev->int_ena.rxfifo_full = 1;
-	uart->dev->int_ena.frm_err = 1;
-	uart->dev->int_ena.rxfifo_tout = 1;
-	uart->dev->int_clr.val = 0xffffffff;
-    UART_MUTEX_UNLOCK();
-}
-
 uint8_t uartRead(uart_t* uart)
 {
     if(uart == NULL || uart->queue == NULL) {
         return 0;
     }
     uint8_t c;
-    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
-    {
-    	uartRxFifoToQueue(uart);
-    }
     if(xQueueReceive(uart->queue, &c, 0)) {
         return c;
     }
@@ -368,10 +305,6 @@ uint8_t uartPeek(uart_t* uart)
         return 0;
     }
     uint8_t c;
-    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
-    {
-    	uartRxFifoToQueue(uart);
-    }
     if(xQueuePeek(uart->queue, &c, 0)) {
         return c;
     }
@@ -385,11 +318,7 @@ void uartWrite(uart_t* uart, uint8_t c)
     }
     UART_MUTEX_LOCK();
     while(uart->dev->status.txfifo_cnt == 0x7F);
-#if CONFIG_IDF_TARGET_ESP32
     uart->dev->fifo.rw_byte = c;
-#else
-    ESP_REG(UART_FIFO_AHB_REG(uart->num)) = c;
-#endif
     UART_MUTEX_UNLOCK();
 }
 
@@ -399,16 +328,9 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
         return;
     }
     UART_MUTEX_LOCK();
-#ifndef CONFIG_IDF_TARGET_ESP32
-    uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-#endif
     while(len) {
         while(uart->dev->status.txfifo_cnt == 0x7F);
-#if CONFIG_IDF_TARGET_ESP32
         uart->dev->fifo.rw_byte = *data++;
-#else
-        ESP_REG(fifo_reg) = *data++;
-#endif
         len--;
     }
     UART_MUTEX_UNLOCK();
@@ -426,7 +348,6 @@ void uartFlushTxOnly(uart_t* uart, bool txOnly)
     }
 
     UART_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32
     while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
     
     if( !txOnly ){
@@ -440,11 +361,6 @@ void uartFlushTxOnly(uart_t* uart, bool txOnly)
 
         xQueueReset(uart->queue);
     }
-#else
-    while(uart->dev->status.txfifo_cnt);
-    uart->dev->conf0.txfifo_rst = 1;
-    uart->dev->conf0.txfifo_rst = 0;
-#endif
     
     UART_MUTEX_UNLOCK();
 }
@@ -472,14 +388,8 @@ static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old
         // read RX fifo
         uint8_t c;
    //     BaseType_t xHigherPriorityTaskWoken;
-#if CONFIG_IDF_TARGET_ESP32
         while(uart->dev->status.rxfifo_cnt != 0 || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
             c = uart->dev->fifo.rw_byte;
-#else
-        uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-        while(uart->dev->status.rxfifo_cnt != 0) {
-            c = ESP_REG(fifo_reg);
-#endif
             if(uart->queue != NULL ) {
                 xQueueSend(uart->queue, &c, 1); //&xHigherPriorityTaskWoken);
             }
@@ -487,11 +397,7 @@ static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old
         UART_MUTEX_UNLOCK();
  
         // wait TX empty
-#if CONFIG_IDF_TARGET_ESP32
         while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
-#else
-        while(uart->dev->status.txfifo_cnt);
-#endif
     } else {
         //todo:
         // set baudrate
@@ -524,35 +430,23 @@ uint32_t uartGetBaudRate(uart_t* uart)
     return ((getApbFrequency()<<4)/clk_div);
 }
 
-static void ARDUINO_ISR_ATTR uart0_write_char(char c)
+static void IRAM_ATTR uart0_write_char(char c)
 {
-#if CONFIG_IDF_TARGET_ESP32
     while(((ESP_REG(0x01C+DR_REG_UART_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
     ESP_REG(DR_REG_UART_BASE) = c;
-#else
-    while(UART0.status.txfifo_cnt == 0x7F);
-    WRITE_PERI_REG(UART_FIFO_AHB_REG(0), c);
-#endif
 }
 
-static void ARDUINO_ISR_ATTR uart1_write_char(char c)
+static void IRAM_ATTR uart1_write_char(char c)
 {
-#if CONFIG_IDF_TARGET_ESP32
     while(((ESP_REG(0x01C+DR_REG_UART1_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
     ESP_REG(DR_REG_UART1_BASE) = c;
-#else
-    while(UART1.status.txfifo_cnt == 0x7F);
-    WRITE_PERI_REG(UART_FIFO_AHB_REG(1), c);
-#endif
 }
 
-#if CONFIG_IDF_TARGET_ESP32
-static void ARDUINO_ISR_ATTR uart2_write_char(char c)
+static void IRAM_ATTR uart2_write_char(char c)
 {
     while(((ESP_REG(0x01C+DR_REG_UART2_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
     ESP_REG(DR_REG_UART2_BASE) = c;
 }
-#endif
 
 void uart_install_putc()
 {
@@ -563,11 +457,9 @@ void uart_install_putc()
     case 1:
         ets_install_putc1((void (*)(char)) &uart1_write_char);
         break;
-#if CONFIG_IDF_TARGET_ESP32
     case 2:
         ets_install_putc1((void (*)(char)) &uart2_write_char);
         break;
-#endif
     default:
         ets_install_putc1(NULL);
         break;
@@ -576,7 +468,7 @@ void uart_install_putc()
 
 void uartSetDebug(uart_t* uart)
 {
-    if(uart == NULL || uart->num >= UART_PORTS_NUM) {
+    if(uart == NULL || uart->num > 2) {
         s_uart_debug_nr = -1;
         //ets_install_putc1(NULL);
         //return;
@@ -595,6 +487,9 @@ int uartGetDebug()
 
 int log_printf(const char *format, ...)
 {
+    if(s_uart_debug_nr < 0){
+        return 0;
+    }
     static char loc_buf[64];
     char * temp = loc_buf;
     int len;
@@ -612,7 +507,7 @@ int log_printf(const char *format, ...)
     }
     vsnprintf(temp, len+1, format, arg);
 #if !CONFIG_DISABLE_HAL_LOCKS
-    if(s_uart_debug_nr != -1 && _uart_bus_array[s_uart_debug_nr].lock){
+    if(_uart_bus_array[s_uart_debug_nr].lock){
         xSemaphoreTake(_uart_bus_array[s_uart_debug_nr].lock, portMAX_DELAY);
         ets_printf("%s", temp);
         xSemaphoreGive(_uart_bus_array[s_uart_debug_nr].lock);
@@ -703,9 +598,5 @@ uartDetectBaudrate(uart_t *uart)
  * Returns the status of the RX state machine, if the value is non-zero the state machine is active.
  */
 bool uartRxActive(uart_t* uart) {
-#if CONFIG_IDF_TARGET_ESP32
     return uart->dev->status.st_urx_out != 0;
-#else
-    return 0;
-#endif
 }

cores/esp32/esp32-hal.h

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

cores/esp32/esp8266-compat.h

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

cores/esp32/main.cpp

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

libraries/AsyncUDP/src/AsyncUDP.h

@@ -7,7 +7,7 @@
 #include <functional>
 extern "C" {
 #include "lwip/ip_addr.h"
-#include "esp_netif.h"
+#include <tcpip_adapter.h>
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
 }

libraries/BLE/src/BLEAdvertisedDevice.h

@@ -12,6 +12,7 @@
 #include <esp_gattc_api.h>
 
 #include <map>
+#include <vector>
 
 #include "BLEAddress.h"
 #include "BLEScan.h"

libraries/BLE/src/BLEAdvertising.h

@@ -12,7 +12,7 @@
 #include <esp_gap_ble_api.h>
 #include "BLEUUID.h"
 #include <vector>
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 /**
  * @brief Advertisement data set by the programmer to be published by the %BLE server.

libraries/BLE/src/BLECharacteristic.h

@@ -16,7 +16,7 @@
 #include <esp_gap_ble_api.h>
 #include "BLEDescriptor.h"
 #include "BLEValue.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLEService;
 class BLEDescriptor;

libraries/BLE/src/BLEDescriptor.h

@@ -13,7 +13,7 @@
 #include "BLEUUID.h"
 #include "BLECharacteristic.h"
 #include <esp_gatts_api.h>
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLEService;
 class BLECharacteristic;

libraries/BLE/src/BLERemoteCharacteristic.h

@@ -17,7 +17,7 @@
 #include "BLERemoteService.h"
 #include "BLERemoteDescriptor.h"
 #include "BLEUUID.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLERemoteService;
 class BLERemoteDescriptor;

libraries/BLE/src/BLERemoteDescriptor.h

@@ -15,7 +15,7 @@
 
 #include "BLERemoteCharacteristic.h"
 #include "BLEUUID.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLERemoteCharacteristic;
 /**

libraries/BLE/src/BLERemoteService.h

@@ -15,7 +15,7 @@
 #include "BLEClient.h"
 #include "BLERemoteCharacteristic.h"
 #include "BLEUUID.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLEClient;
 class BLERemoteCharacteristic;

libraries/BLE/src/BLEScan.h

@@ -15,7 +15,7 @@
 #include <string>
 #include "BLEAdvertisedDevice.h"
 #include "BLEClient.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLEAdvertisedDevice;
 class BLEAdvertisedDeviceCallbacks;

libraries/BLE/src/BLEServer.cpp

@@ -202,19 +202,13 @@ void BLEServer::handleGATTServerEvent(esp_gatts_cb_event_t event, esp_gatt_if_t
 		// If we receive a disconnect event then invoke the callback for disconnects (if one is present).
 		// we also want to start advertising again.
 		case ESP_GATTS_DISCONNECT_EVT: {
+			m_connectedCount--;                          // Decrement the number of connected devices count.
 			if (m_pServerCallbacks != nullptr) {         // If we have callbacks, call now.
 				m_pServerCallbacks->onDisconnect(this);
 			}
-            if(m_connId == ESP_GATT_IF_NONE) {
-                return;
-            }
-
-            // only decrement if connection is found in map and removed
-            // sometimes this event triggers w/o a valid connection
-			if(removePeerDevice(param->disconnect.conn_id, false)) {
-                m_connectedCount--;                          // Decrement the number of connected devices count.
-            }
-            break;
+			startAdvertising(); //- do this with some delay from the loop()
+			removePeerDevice(param->disconnect.conn_id, false);
+			break;
 		} // ESP_GATTS_DISCONNECT_EVT
 
 
@@ -401,8 +395,8 @@ void BLEServer::addPeerDevice(void* peer, bool _client, uint16_t conn_id) {
 	m_connectedServersMap.insert(std::pair<uint16_t, conn_status_t>(conn_id, status));	
 }
 
-bool BLEServer::removePeerDevice(uint16_t conn_id, bool _client) {
-	return m_connectedServersMap.erase(conn_id) > 0;
+void BLEServer::removePeerDevice(uint16_t conn_id, bool _client) {
+	m_connectedServersMap.erase(conn_id);
 }
 /* multi connect support */
 

libraries/BLE/src/BLEServer.h

@@ -20,7 +20,7 @@
 #include "BLECharacteristic.h"
 #include "BLEService.h"
 #include "BLESecurity.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 #include "BLEAddress.h"
 
 class BLEServerCallbacks;
@@ -79,7 +79,7 @@ public:
 	/* multi connection support */
 	std::map<uint16_t, conn_status_t> getPeerDevices(bool client);
 	void addPeerDevice(void* peer, bool is_client, uint16_t conn_id);
-	bool removePeerDevice(uint16_t conn_id, bool client);
+	void removePeerDevice(uint16_t conn_id, bool client);
 	BLEServer* getServerByConnId(uint16_t conn_id);
 	void updatePeerMTU(uint16_t connId, uint16_t mtu);
 	uint16_t getPeerMTU(uint16_t conn_id);

libraries/BLE/src/BLEService.h

@@ -15,7 +15,7 @@
 #include "BLECharacteristic.h"
 #include "BLEServer.h"
 #include "BLEUUID.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLEServer;
 

libraries/BLE/src/FreeRTOS.cpp

@@ -10,7 +10,7 @@
 #include <string>
 #include <sstream>
 #include <iomanip>
-#include "RTOS.h"
+#include "FreeRTOS.h"
 #include "sdkconfig.h"
 #include "esp32-hal-log.h"
 

libraries/BLE/src/FreeRTOS.h

@@ -0,0 +1,77 @@
+/*
+ * FreeRTOS.h
+ *
+ *  Created on: Feb 24, 2017
+ *      Author: kolban
+ */
+
+#ifndef MAIN_FREERTOS_H_
+#define MAIN_FREERTOS_H_
+#include <stdint.h>
+#include <string>
+#include <pthread.h>
+
+#include <freertos/FreeRTOS.h>   // Include the base FreeRTOS definitions.
+#include <freertos/task.h>       // Include the task definitions.
+#include <freertos/semphr.h>     // Include the semaphore definitions.
+#include <freertos/ringbuf.h>    // Include the ringbuffer definitions.
+
+
+/**
+ * @brief Interface to %FreeRTOS functions.
+ */
+class FreeRTOS {
+public:
+	static void sleep(uint32_t ms);
+	static void startTask(void task(void*), std::string taskName, void* param = nullptr, uint32_t stackSize = 2048);
+	static void deleteTask(TaskHandle_t pTask = nullptr);
+
+	static uint32_t getTimeSinceStart();
+
+	class Semaphore {
+	public:
+		Semaphore(std::string owner = "<Unknown>");
+		~Semaphore();
+		void        give();
+		void        give(uint32_t value);
+		void        giveFromISR();
+		void        setName(std::string name);
+		bool        take(std::string owner = "<Unknown>");
+		bool        take(uint32_t timeoutMs, std::string owner = "<Unknown>");
+		std::string toString();
+		uint32_t	wait(std::string owner = "<Unknown>");
+		bool		timedWait(std::string owner = "<Unknown>", uint32_t timeoutMs = portMAX_DELAY);
+		uint32_t	value(){ return m_value; };
+
+	private:
+		SemaphoreHandle_t m_semaphore;
+		pthread_mutex_t   m_pthread_mutex;
+		std::string       m_name;
+		std::string       m_owner;
+		uint32_t          m_value;
+		bool              m_usePthreads;
+
+	};
+};
+
+
+/**
+ * @brief Ringbuffer.
+ */
+class Ringbuffer {
+public:
+#ifdef ESP_IDF_VERSION_MAJOR
+  Ringbuffer(size_t length, RingbufferType_t type = RINGBUF_TYPE_NOSPLIT);
+#else
+  Ringbuffer(size_t length, ringbuf_type_t type = RINGBUF_TYPE_NOSPLIT);
+#endif
+	~Ringbuffer();
+
+	void*    receive(size_t* size, TickType_t wait = portMAX_DELAY);
+	void     returnItem(void* item);
+	bool     send(void* data, size_t length, TickType_t wait = portMAX_DELAY);
+private:
+	RingbufHandle_t m_handle;
+};
+
+#endif /* MAIN_FREERTOS_H_ */

libraries/BLE/src/GeneralUtils.cpp

@@ -12,7 +12,7 @@
 #include <string>
 #include <sstream>
 #include <iomanip>
-#include "RTOS.h"
+#include "FreeRTOS.h"
 #include <esp_err.h>
 #include <nvs.h>
 #include <esp_wifi.h>

libraries/BLE/src/RTOS.h

@@ -1,81 +0,0 @@
-/*
- * FreeRTOS.h
- *
- *  Created on: Feb 24, 2017
- *      Author: kolban
- */
-
-#ifdef __cplusplus
-#ifndef MAIN_FREERTOS_H_
-#define MAIN_FREERTOS_H_
-#include <stdint.h>
-#include <string>
-#include <pthread.h>
-
-#include <freertos/FreeRTOS.h>   // Include the base FreeRTOS definitions.
-#include <freertos/task.h>       // Include the task definitions.
-#include <freertos/semphr.h>     // Include the semaphore definitions.
-#include <freertos/ringbuf.h>    // Include the ringbuffer definitions.
-
-
-/**
- * @brief Interface to %FreeRTOS functions.
- */
-class FreeRTOS {
-public:
-	static void sleep(uint32_t ms);
-	static void startTask(void task(void*), std::string taskName, void* param = nullptr, uint32_t stackSize = 2048);
-	static void deleteTask(TaskHandle_t pTask = nullptr);
-
-	static uint32_t getTimeSinceStart();
-
-	class Semaphore {
-	public:
-		Semaphore(std::string owner = "<Unknown>");
-		~Semaphore();
-		void        give();
-		void        give(uint32_t value);
-		void        giveFromISR();
-		void        setName(std::string name);
-		bool        take(std::string owner = "<Unknown>");
-		bool        take(uint32_t timeoutMs, std::string owner = "<Unknown>");
-		std::string toString();
-		uint32_t	wait(std::string owner = "<Unknown>");
-		bool		timedWait(std::string owner = "<Unknown>", uint32_t timeoutMs = portMAX_DELAY);
-		uint32_t	value(){ return m_value; };
-
-	private:
-		SemaphoreHandle_t m_semaphore;
-		pthread_mutex_t   m_pthread_mutex;
-		std::string       m_name;
-		std::string       m_owner;
-		uint32_t          m_value;
-		bool              m_usePthreads;
-
-	};
-};
-
-
-/**
- * @brief Ringbuffer.
- */
-class Ringbuffer {
-public:
-#ifdef ESP_IDF_VERSION_MAJOR
-  Ringbuffer(size_t length, RingbufferType_t type = RINGBUF_TYPE_NOSPLIT);
-#else
-  Ringbuffer(size_t length, ringbuf_type_t type = RINGBUF_TYPE_NOSPLIT);
-#endif
-	~Ringbuffer();
-
-	void*    receive(size_t* size, TickType_t wait = portMAX_DELAY);
-	void     returnItem(void* item);
-	bool     send(void* data, size_t length, TickType_t wait = portMAX_DELAY);
-private:
-	RingbufHandle_t m_handle;
-};
-
-#endif /* MAIN_FREERTOS_H_ */
-#else
-#include "freertos/FreeRTOS.h"
-#endif

libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino

@@ -26,4 +26,4 @@ void loop() {
     Serial.write(SerialBT.read());
   }
   delay(20);
-}
+}

libraries/BluetoothSerial/src/BluetoothSerial.cpp

@@ -477,7 +477,7 @@ static bool _init_bt(const char *deviceName)
     }
 
     if(!_spp_task_handle){
-        xTaskCreatePinnedToCore(_spp_tx_task, "spp_tx", 4096, NULL, 10, &_spp_task_handle, 0);
+        xTaskCreatePinnedToCore(_spp_tx_task, "spp_tx", 4096, NULL, 2, &_spp_task_handle, 0);
         if(!_spp_task_handle){
             log_e("Network Event Task Start Failed!");
             return false;
@@ -815,9 +815,4 @@ bool BluetoothSerial::isReady(bool checkMaster, int timeout) {
     TickType_t xTicksToWait = timeout / portTICK_PERIOD_MS;
     return (xEventGroupWaitBits(_spp_event_group, SPP_RUNNING, pdFALSE, pdTRUE, xTicksToWait) & SPP_RUNNING) != 0;
 }
-
-BluetoothSerial::operator bool() const
-{
-    return true;
-}
 #endif

libraries/BluetoothSerial/src/BluetoothSerial.h

@@ -34,9 +34,6 @@ class BluetoothSerial: public Stream
         ~BluetoothSerial(void);
 
         bool begin(String localName=String(), bool isMaster=false);
-        bool begin(unsigned long baud){//compatibility
-            return begin();
-        }
         int available(void);
         int peek(void);
         bool hasClient(void);
@@ -57,8 +54,7 @@ class BluetoothSerial: public Stream
         bool isReady(bool checkMaster=false, int timeout=0);
         bool disconnect();
         bool unpairDevice(uint8_t remoteAddress[]);
-        
-        operator bool() const;
+
     private:
         String local_name;
 

libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino

@@ -1,5 +1,3 @@
-//Disable Example for now
-#if 0
 #include "esp_camera.h"
 #include <WiFi.h>
 
@@ -13,9 +11,7 @@
 #define CAMERA_MODEL_WROVER_KIT // Has PSRAM
 //#define CAMERA_MODEL_ESP_EYE // Has PSRAM
 //#define CAMERA_MODEL_M5STACK_PSRAM // Has PSRAM
-//#define CAMERA_MODEL_M5STACK_V2_PSRAM // M5Camera version B Has PSRAM
-//#define CAMERA_MODEL_M5STACK_WIDE // Has PSRAM
-//#define CAMERA_MODEL_M5STACK_ESP32CAM // No PSRAM
+//#define CAMERA_MODEL_M5STACK_WIDE	// Has PSRAM
 //#define CAMERA_MODEL_AI_THINKER // Has PSRAM
 //#define CAMERA_MODEL_TTGO_T_JOURNAL // No PSRAM
 
@@ -87,7 +83,7 @@ void setup() {
   // drop down frame size for higher initial frame rate
   s->set_framesize(s, FRAMESIZE_QVGA);
 
-#if defined(CAMERA_MODEL_M5STACK_WIDE) || defined(CAMERA_MODEL_M5STACK_ESP32CAM)
+#if defined(CAMERA_MODEL_M5STACK_WIDE)
   s->set_vflip(s, 1);
   s->set_hmirror(s, 1);
 #endif
@@ -112,7 +108,3 @@ void loop() {
   // put your main code here, to run repeatedly:
   delay(10000);
 }
-#else
-void setup(){}
-void loop(){}
-#endif

libraries/ESP32/examples/Camera/CameraWebServer/app_httpd.cpp

@@ -11,7 +11,6 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#if 0
 #include "esp_http_server.h"
 #include "esp_timer.h"
 #include "esp_camera.h"
@@ -404,9 +403,6 @@ static esp_err_t stream_handler(httpd_req_t *req){
                 }
             }
         }
-        if(res == ESP_OK){
-            res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
-        }
         if(res == ESP_OK){
             size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
             res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
@@ -414,6 +410,9 @@ static esp_err_t stream_handler(httpd_req_t *req){
         if(res == ESP_OK){
             res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
         }
+        if(res == ESP_OK){
+            res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
+        }
         if(fb){
             esp_camera_fb_return(fb);
             fb = NULL;
@@ -661,4 +660,3 @@ void startCameraServer(){
         httpd_register_uri_handler(stream_httpd, &stream_uri);
     }
 }
-#endif

libraries/ESP32/examples/Camera/CameraWebServer/camera_pins.h

@@ -56,25 +56,6 @@
 #define HREF_GPIO_NUM     26
 #define PCLK_GPIO_NUM     21
 
-#elif defined(CAMERA_MODEL_M5STACK_V2_PSRAM)
-#define PWDN_GPIO_NUM     -1
-#define RESET_GPIO_NUM    15
-#define XCLK_GPIO_NUM     27
-#define SIOD_GPIO_NUM     22
-#define SIOC_GPIO_NUM     23
-
-#define Y9_GPIO_NUM       19
-#define Y8_GPIO_NUM       36
-#define Y7_GPIO_NUM       18
-#define Y6_GPIO_NUM       39
-#define Y5_GPIO_NUM        5
-#define Y4_GPIO_NUM       34
-#define Y3_GPIO_NUM       35
-#define Y2_GPIO_NUM       32
-#define VSYNC_GPIO_NUM    25
-#define HREF_GPIO_NUM     26
-#define PCLK_GPIO_NUM     21
-
 #elif defined(CAMERA_MODEL_M5STACK_WIDE)
 #define PWDN_GPIO_NUM     -1
 #define RESET_GPIO_NUM    15
@@ -94,25 +75,6 @@
 #define HREF_GPIO_NUM     26
 #define PCLK_GPIO_NUM     21
 
-#elif defined(CAMERA_MODEL_M5STACK_ESP32CAM)
-#define PWDN_GPIO_NUM     -1
-#define RESET_GPIO_NUM    15
-#define XCLK_GPIO_NUM     27
-#define SIOD_GPIO_NUM     25
-#define SIOC_GPIO_NUM     23
-
-#define Y9_GPIO_NUM       19
-#define Y8_GPIO_NUM       36
-#define Y7_GPIO_NUM       18
-#define Y6_GPIO_NUM       39
-#define Y5_GPIO_NUM        5
-#define Y4_GPIO_NUM       34
-#define Y3_GPIO_NUM       35
-#define Y2_GPIO_NUM       17
-#define VSYNC_GPIO_NUM    22
-#define HREF_GPIO_NUM     26
-#define PCLK_GPIO_NUM     21
-
 #elif defined(CAMERA_MODEL_AI_THINKER)
 #define PWDN_GPIO_NUM     32
 #define RESET_GPIO_NUM    -1

libraries/ESP32/examples/GPIO/FunctionalInterrupt/FunctionalInterrupt.ino

@@ -15,7 +15,7 @@ public:
 		detachInterrupt(PIN);
 	}
 
-	void ARDUINO_ISR_ATTR isr() {
+	void IRAM_ATTR isr() {
 		numberKeyPresses += 1;
 		pressed = true;
 	}

libraries/ESP32/examples/GPIO/GPIOInterrupt/GPIOInterrupt.ino

@@ -9,13 +9,13 @@ struct Button {
 Button button1 = {23, 0, false};
 Button button2 = {18, 0, false};
 
-void ARDUINO_ISR_ATTR isr(void* arg) {
+void IRAM_ATTR isr(void* arg) {
     Button* s = static_cast<Button*>(arg);
     s->numberKeyPresses += 1;
     s->pressed = true;
 }
 
-void ARDUINO_ISR_ATTR isr() {
+void IRAM_ATTR isr() {
     button2.numberKeyPresses += 1;
     button2.pressed = true;
 }

libraries/ESP32/examples/HallSensor/HallSensor.ino

@@ -1,6 +1,7 @@
 //Simple sketch to access the internal hall effect detector on the esp32.
 //values can be quite low. 
 //Brian Degger / @sctv  
+
 int val = 0;
 void setup() {
   Serial.begin(9600);

libraries/ESP32/examples/ResetReason/ResetReason.ino

@@ -15,8 +15,6 @@
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/rtc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/rtc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif

libraries/ESP32/examples/Timer/RepeatTimer/RepeatTimer.ino

@@ -18,7 +18,7 @@ portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
 volatile uint32_t isrCounter = 0;
 volatile uint32_t lastIsrAt = 0;
 
-void ARDUINO_ISR_ATTR onTimer(){
+void IRAM_ATTR onTimer(){
   // Increment the counter and set the time of ISR
   portENTER_CRITICAL_ISR(&timerMux);
   isrCounter++;

libraries/ESP32/examples/Timer/WatchdogTimer/WatchdogTimer.ino

@@ -4,7 +4,7 @@ const int button = 0;         //gpio to use to trigger delay
 const int wdtTimeout = 3000;  //time in ms to trigger the watchdog
 hw_timer_t *timer = NULL;
 
-void ARDUINO_ISR_ATTR resetModule() {
+void IRAM_ATTR resetModule() {
   ets_printf("reboot\n");
   esp_restart();
 }

libraries/ESP32/examples/Touch/TouchRead/TouchRead.ino

@@ -10,6 +10,6 @@ void setup()
 
 void loop()
 {
-  Serial.println(touchRead(T1));  // get value using T0
+  Serial.println(touchRead(T0));  // get value using T0
   delay(1000);
 }

libraries/ESPmDNS/src/ESPmDNS.cpp

@@ -51,9 +51,9 @@ License (MIT license):
 #define STR(tok) tok
 #endif
 
-// static void _on_sys_event(arduino_event_t *event){
-//     mdns_handle_system_event(NULL, event);
-// }
+static void _on_sys_event(system_event_t *event){
+    mdns_handle_system_event(NULL, event);
+}
 
 MDNSResponder::MDNSResponder() :results(NULL) {}
 MDNSResponder::~MDNSResponder() {
@@ -65,7 +65,7 @@ bool MDNSResponder::begin(const char* hostName){
         log_e("Failed starting MDNS");
         return false;
     }
-    //WiFi.onEvent(_on_sys_event);
+    WiFi.onEvent(_on_sys_event);
     _hostname = hostName;
 	_hostname.toLowerCase();
     if(mdns_hostname_set(hostName)) {
@@ -171,7 +171,7 @@ bool MDNSResponder::addServiceTxt(char *name, char *proto, char *key, char *valu
 }
 
 IPAddress MDNSResponder::queryHost(char *host, uint32_t timeout){
-    esp_ip4_addr_t addr;
+    struct ip4_addr addr;
     addr.addr = 0;
 
     esp_err_t err = mdns_query_a(host, timeout,  &addr);

libraries/FS/src/vfs_api.cpp

@@ -184,11 +184,6 @@ bool VFSImpl::rmdir(const char *path)
         return false;
     }
 
-    if (strcmp(_mountpoint, "/spiffs") == 0) {
-        log_e("rmdir is unnecessary in SPIFFS");
-        return false;
-    }
-
     VFSFileImpl f(this, path, "r");
     if(!f || !f.isDirectory()) {
         if(f) {
@@ -205,7 +200,7 @@ bool VFSImpl::rmdir(const char *path)
         return false;
     }
     sprintf(temp,"%s%s", _mountpoint, path);
-    auto rc = ::rmdir(temp);
+    auto rc = unlink(temp);
     free(temp);
     return rc == 0;
 }

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/.gitignore

@@ -1,4 +0,0 @@
-.pio
-.vscode
-mklittlefs.exe
-mklittlefs

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/README.md

@@ -1,68 +0,0 @@
-# How to run on PlatformIO IDE
-
-- Download and extract to this project root a **mklittlefs** executable for your OS [from a zipped binary here](https://github.com/earlephilhower/mklittlefs/releases) 
-- Open **LITTLEFS_PlatformIO** folder
-- Run PlatformIO project task: **Upload Filesystem Image** 
-- Run PlatformIO project task: **Upload and Monitor**
-- You will see a Serial output like:
-```
---- Miniterm on COM5  115200,8,N,1 ---
---- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
-ets Jun  8 2016 00:22:57
-
-rst:0x1 (POWERON_RESET),boot:0x13 (Snfigsip: 0, SPIWP:0xee
-clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
-mode:DIO, clock div:2
-load:0x3fff0018,len:4
-load:0x3fff001c,len:1044
-load:0x40078000,len:10044
-load:0x40080400,len:5872
-entry 0x400806ac
-Listing directory: /
-  FILE: /file1.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
-  DIR : /testfolder  LAST WRITE: 2020-10-06 15:10:33
-Creating Dir: /mydir
-Dir created
-Writing file: /mydir/hello2.txt
-- file written
-Listing directory: /
-  FILE: /file1.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
-  DIR : /mydir  LAST WRITE: 1970-01-01 00:00:00
-Listing directory: /mydir
-  FILE: /mydir/hello2.txt  SIZE: 6  LAST WRITE: 1970-01-01 00:00:00
-  DIR : /testfolder  LAST WRITE: 2020-10-06 15:10:33
-Listing directory: /testfolder
-  FILE: /testfolder/test2.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
-Deleting file: /mydir/hello2.txt
-- file deleted
-Removing Dir: /mydir
-Dir removed
-Listing directory: /
-  FILE: /file1.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
-  DIR : /testfolder  LAST WRITE: 2020-10-06 15:10:33
-Listing directory: /testfolder
-  FILE: /testfolder/test2.txt  SIZE: 3  LAST WRITE: 2020-10-06 15:10:33
-Writing file: /hello.txt
-- file written
-Appending to file: /hello.txt
-- message appended
-Reading file: /hello.txt
-- read from file:
-Hello World!
-Renaming file /hello.txt to /foo.txt
-- file renamed
-Reading file: /foo.txt
-- read from file:
-Hello World!
-Deleting file: /foo.txt
-- file deleted
-Testing file I/O with /test.txt
-- writing................................................................
- - 1048576 bytes written in 12006 ms
-- reading................................................................
-- 1048576 bytes read in 547 ms
-Deleting file: /test.txt
-- file deleted
-Test complete
-```
-- If you have a module with more than 4MB flash, you can uncomment **partitions_custom.csv** in **platformio.ini** and modify the csv file accordingly

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/data/file1.txt

@@ -1 +0,0 @@
-aaa

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/data/testfolder/test2.txt

@@ -1 +0,0 @@
-bbb

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/littlefsbuilder.py

@@ -1,2 +0,0 @@
-Import("env")
-env.Replace( MKSPIFFSTOOL=env.get("PROJECT_DIR") + '/mklittlefs' )

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/partitions_custom.csv

@@ -1,6 +0,0 @@
-# Name,   Type, SubType,  Offset,   Size,  Flags
-ota_0,     app, ota_0,   0x10000,  0x1A0000,
-ota_1,     app, ota_1,          ,  0x1A0000,
-otadata,  data, ota,    0x350000,  0x2000,
-nvs,      data, nvs,            ,  0x6000,
-data,     data, spiffs,         ,  0xA8000,

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/platformio.ini

@@ -1,35 +0,0 @@
-; PlatformIO Project Configuration File
-;
-;   Build options: build flags, source filter
-;   Upload options: custom upload port, speed and extra flags
-;   Library options: dependencies, extra library storages
-;   Advanced options: extra scripting
-;
-; Please visit documentation for the other options and examples
-; https://docs.platformio.org/page/projectconf.html
-
-[platformio]
-default_envs = esp32
-
-[env]
-framework = arduino
-
-[env:esp32]
-platform = espressif32
-;platform = https://github.com/platformio/platform-espressif32.git
-;board_build.mcu = esp32
-platform_packages = framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git
-
-build_flags = 
-	${env.build_flags} 
-	-D=${PIOENV} 
-	;-D CONFIG_LITTLEFS_FOR_IDF_3_2
-
-lib_deps = https://github.com/lorol/LITTLEFS.git
-
-board = esp32dev
-;board_build.partitions = partitions_custom.csv
-monitor_filters = esp32_exception_decoder
-monitor_speed = 115200
-
-extra_scripts = ./littlefsbuilder.py

libraries/LITTLEFS/examples/LITTLEFS_PlatformIO/src/main.cpp

@@ -1,282 +0,0 @@
-#include <Arduino.h>
-#include "FS.h"
-#include <LITTLEFS.h>
-#include <time.h>
-
-/* You only need to format LITTLEFS the first time you run a
-   test or else use the LITTLEFS plugin to create a partition
-   https://github.com/lorol/arduino-esp32littlefs-plugin */
-   
-#define FORMAT_LITTLEFS_IF_FAILED true
-
-void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
-    Serial.printf("Listing directory: %s\r\n", dirname);
-
-    File root = fs.open(dirname);
-    if(!root){
-        Serial.println("- failed to open directory");
-        return;
-    }
-    if(!root.isDirectory()){
-        Serial.println(" - not a directory");
-        return;
-    }
-
-    File file = root.openNextFile();
-    while(file){
-        if(file.isDirectory()){
-            Serial.print("  DIR : ");
-
-            Serial.print(file.name());
-            time_t t= file.getLastWrite();
-            struct tm * tmstruct = localtime(&t);
-            Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct->tm_year)+1900,( tmstruct->tm_mon)+1, tmstruct->tm_mday,tmstruct->tm_hour , tmstruct->tm_min, tmstruct->tm_sec);
-
-            if(levels){
-                listDir(fs, file.name(), levels -1);
-            }
-        } else {
-            Serial.print("  FILE: ");
-            Serial.print(file.name());
-            Serial.print("  SIZE: ");
-
-            Serial.print(file.size());
-            time_t t= file.getLastWrite();
-            struct tm * tmstruct = localtime(&t);
-            Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct->tm_year)+1900,( tmstruct->tm_mon)+1, tmstruct->tm_mday,tmstruct->tm_hour , tmstruct->tm_min, tmstruct->tm_sec);
-        }
-        file = root.openNextFile();
-    }
-}
-
-void createDir(fs::FS &fs, const char * path){
-    Serial.printf("Creating Dir: %s\n", path);
-    if(fs.mkdir(path)){
-        Serial.println("Dir created");
-    } else {
-        Serial.println("mkdir failed");
-    }
-}
-
-void removeDir(fs::FS &fs, const char * path){
-    Serial.printf("Removing Dir: %s\n", path);
-    if(fs.rmdir(path)){
-        Serial.println("Dir removed");
-    } else {
-        Serial.println("rmdir failed");
-    }
-}
-
-void readFile(fs::FS &fs, const char * path){
-    Serial.printf("Reading file: %s\r\n", path);
-
-    File file = fs.open(path);
-    if(!file || file.isDirectory()){
-        Serial.println("- failed to open file for reading");
-        return;
-    }
-
-    Serial.println("- read from file:");
-    while(file.available()){
-        Serial.write(file.read());
-    }
-    file.close();
-}
-
-void writeFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Writing file: %s\r\n", path);
-
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("- failed to open file for writing");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("- file written");
-    } else {
-        Serial.println("- write failed");
-    }
-    file.close();
-}
-
-void appendFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Appending to file: %s\r\n", path);
-
-    File file = fs.open(path, FILE_APPEND);
-    if(!file){
-        Serial.println("- failed to open file for appending");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("- message appended");
-    } else {
-        Serial.println("- append failed");
-    }
-    file.close();
-}
-
-void renameFile(fs::FS &fs, const char * path1, const char * path2){
-    Serial.printf("Renaming file %s to %s\r\n", path1, path2);
-    if (fs.rename(path1, path2)) {
-        Serial.println("- file renamed");
-    } else {
-        Serial.println("- rename failed");
-    }
-}
-
-void deleteFile(fs::FS &fs, const char * path){
-    Serial.printf("Deleting file: %s\r\n", path);
-    if(fs.remove(path)){
-        Serial.println("- file deleted");
-    } else {
-        Serial.println("- delete failed");
-    }
-}
-
-// SPIFFS-like write and delete file
-
-// See: https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/src/LittleFS.cpp#L60
-void writeFile2(fs::FS &fs, const char * path, const char * message){
-    if(!fs.exists(path)){
-		if (strchr(path, '/')) {
-            Serial.printf("Create missing folders of: %s\r\n", path);
-			char *pathStr = strdup(path);
-			if (pathStr) {
-				char *ptr = strchr(pathStr, '/');
-				while (ptr) {
-					*ptr = 0;
-					fs.mkdir(pathStr);
-					*ptr = '/';
-					ptr = strchr(ptr+1, '/');
-				}
-			}
-			free(pathStr);
-		}
-    }
-
-    Serial.printf("Writing file to: %s\r\n", path);
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("- failed to open file for writing");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("- file written");
-    } else {
-        Serial.println("- write failed");
-    }
-    file.close();
-}
-
-// See:  https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/src/LittleFS.h#L149
-void deleteFile2(fs::FS &fs, const char * path){
-    Serial.printf("Deleting file and empty folders on path: %s\r\n", path);
-
-    if(fs.remove(path)){
-        Serial.println("- file deleted");
-    } else {
-        Serial.println("- delete failed");
-    }
-
-    char *pathStr = strdup(path);
-    if (pathStr) {
-        char *ptr = strrchr(pathStr, '/');
-        if (ptr) {
-            Serial.printf("Removing all empty folders on path: %s\r\n", path);
-        }
-        while (ptr) {
-            *ptr = 0;
-            fs.rmdir(pathStr);
-            ptr = strrchr(pathStr, '/');
-        }
-        free(pathStr);
-    }
-}
-
-void testFileIO(fs::FS &fs, const char * path){
-    Serial.printf("Testing file I/O with %s\r\n", path);
-
-    static uint8_t buf[512];
-    size_t len = 0;
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("- failed to open file for writing");
-        return;
-    }
-
-    size_t i;
-    Serial.print("- writing" );
-    uint32_t start = millis();
-    for(i=0; i<2048; i++){
-        if ((i & 0x001F) == 0x001F){
-          Serial.print(".");
-        }
-        file.write(buf, 512);
-    }
-    Serial.println("");
-    uint32_t end = millis() - start;
-    Serial.printf(" - %u bytes written in %u ms\r\n", 2048 * 512, end);
-    file.close();
-
-    file = fs.open(path);
-    start = millis();
-    end = start;
-    i = 0;
-    if(file && !file.isDirectory()){
-        len = file.size();
-        size_t flen = len;
-        start = millis();
-        Serial.print("- reading" );
-        while(len){
-            size_t toRead = len;
-            if(toRead > 512){
-                toRead = 512;
-            }
-            file.read(buf, toRead);
-            if ((i++ & 0x001F) == 0x001F){
-              Serial.print(".");
-            }
-            len -= toRead;
-        }
-        Serial.println("");
-        end = millis() - start;
-        Serial.printf("- %u bytes read in %u ms\r\n", flen, end);
-        file.close();
-    } else {
-        Serial.println("- failed to open file for reading");
-    }
-}
-
-void setup(){
-    Serial.begin(115200);
-    if(!LITTLEFS.begin(FORMAT_LITTLEFS_IF_FAILED)){
-        Serial.println("LITTLEFS Mount Failed");
-        return;
-    }
-    
-    listDir(LITTLEFS, "/", 0);
-	createDir(LITTLEFS, "/mydir");
-	writeFile(LITTLEFS, "/mydir/hello2.txt", "Hello2");
-  //writeFile(LITTLEFS, "/mydir/newdir2/newdir3/hello3.txt", "Hello3");
-    writeFile2(LITTLEFS, "/mydir/newdir2/newdir3/hello3.txt", "Hello3");
-	listDir(LITTLEFS, "/", 3);
-	deleteFile(LITTLEFS, "/mydir/hello2.txt");
-  //deleteFile(LITTLEFS, "/mydir/newdir2/newdir3/hello3.txt");
-    deleteFile2(LITTLEFS, "/mydir/newdir2/newdir3/hello3.txt");
-	removeDir(LITTLEFS, "/mydir");
-	listDir(LITTLEFS, "/", 3);
-    writeFile(LITTLEFS, "/hello.txt", "Hello ");
-    appendFile(LITTLEFS, "/hello.txt", "World!\r\n");
-    readFile(LITTLEFS, "/hello.txt");
-    renameFile(LITTLEFS, "/hello.txt", "/foo.txt");
-    readFile(LITTLEFS, "/foo.txt");
-    deleteFile(LITTLEFS, "/foo.txt");
-    testFileIO(LITTLEFS, "/test.txt");
-    deleteFile(LITTLEFS, "/test.txt");
-	
-    Serial.println( "Test complete" );
-}
-
-void loop(){
-
-}

libraries/LITTLEFS/examples/LITTLEFS_test/LITTLEFS_test.ino

@@ -1,272 +0,0 @@
-#include <Arduino.h>
-#include "FS.h"
-#include <LITTLEFS.h>
-
-/* You only need to format LITTLEFS the first time you run a
-   test or else use the LITTLEFS plugin to create a partition
-   https://github.com/lorol/arduino-esp32littlefs-plugin */
-   
-#define FORMAT_LITTLEFS_IF_FAILED true
-
-void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
-    Serial.printf("Listing directory: %s\r\n", dirname);
-
-    File root = fs.open(dirname);
-    if(!root){
-        Serial.println("- failed to open directory");
-        return;
-    }
-    if(!root.isDirectory()){
-        Serial.println(" - not a directory");
-        return;
-    }
-
-    File file = root.openNextFile();
-    while(file){
-        if(file.isDirectory()){
-            Serial.print("  DIR : ");
-            Serial.println(file.name());
-            if(levels){
-                listDir(fs, file.name(), levels -1);
-            }
-        } else {
-            Serial.print("  FILE: ");
-            Serial.print(file.name());
-            Serial.print("\tSIZE: ");
-            Serial.println(file.size());
-        }
-        file = root.openNextFile();
-    }
-}
-
-void createDir(fs::FS &fs, const char * path){
-    Serial.printf("Creating Dir: %s\n", path);
-    if(fs.mkdir(path)){
-        Serial.println("Dir created");
-    } else {
-        Serial.println("mkdir failed");
-    }
-}
-
-void removeDir(fs::FS &fs, const char * path){
-    Serial.printf("Removing Dir: %s\n", path);
-    if(fs.rmdir(path)){
-        Serial.println("Dir removed");
-    } else {
-        Serial.println("rmdir failed");
-    }
-}
-
-void readFile(fs::FS &fs, const char * path){
-    Serial.printf("Reading file: %s\r\n", path);
-
-    File file = fs.open(path);
-    if(!file || file.isDirectory()){
-        Serial.println("- failed to open file for reading");
-        return;
-    }
-
-    Serial.println("- read from file:");
-    while(file.available()){
-        Serial.write(file.read());
-    }
-    file.close();
-}
-
-void writeFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Writing file: %s\r\n", path);
-
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("- failed to open file for writing");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("- file written");
-    } else {
-        Serial.println("- write failed");
-    }
-    file.close();
-}
-
-void appendFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Appending to file: %s\r\n", path);
-
-    File file = fs.open(path, FILE_APPEND);
-    if(!file){
-        Serial.println("- failed to open file for appending");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("- message appended");
-    } else {
-        Serial.println("- append failed");
-    }
-    file.close();
-}
-
-void renameFile(fs::FS &fs, const char * path1, const char * path2){
-    Serial.printf("Renaming file %s to %s\r\n", path1, path2);
-    if (fs.rename(path1, path2)) {
-        Serial.println("- file renamed");
-    } else {
-        Serial.println("- rename failed");
-    }
-}
-
-void deleteFile(fs::FS &fs, const char * path){
-    Serial.printf("Deleting file: %s\r\n", path);
-    if(fs.remove(path)){
-        Serial.println("- file deleted");
-    } else {
-        Serial.println("- delete failed");
-    }
-}
-
-// SPIFFS-like write and delete file
-
-// See: https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/src/LittleFS.cpp#L60
-void writeFile2(fs::FS &fs, const char * path, const char * message){
-    if(!fs.exists(path)){
-		if (strchr(path, '/')) {
-            Serial.printf("Create missing folders of: %s\r\n", path);
-			char *pathStr = strdup(path);
-			if (pathStr) {
-				char *ptr = strchr(pathStr, '/');
-				while (ptr) {
-					*ptr = 0;
-					fs.mkdir(pathStr);
-					*ptr = '/';
-					ptr = strchr(ptr+1, '/');
-				}
-			}
-			free(pathStr);
-		}
-    }
-
-    Serial.printf("Writing file to: %s\r\n", path);
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("- failed to open file for writing");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("- file written");
-    } else {
-        Serial.println("- write failed");
-    }
-    file.close();
-}
-
-// See:  https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/src/LittleFS.h#L149
-void deleteFile2(fs::FS &fs, const char * path){
-    Serial.printf("Deleting file and empty folders on path: %s\r\n", path);
-
-    if(fs.remove(path)){
-        Serial.println("- file deleted");
-    } else {
-        Serial.println("- delete failed");
-    }
-
-    char *pathStr = strdup(path);
-    if (pathStr) {
-        char *ptr = strrchr(pathStr, '/');
-        if (ptr) {
-            Serial.printf("Removing all empty folders on path: %s\r\n", path);
-        }
-        while (ptr) {
-            *ptr = 0;
-            fs.rmdir(pathStr);
-            ptr = strrchr(pathStr, '/');
-        }
-        free(pathStr);
-    }
-}
-
-void testFileIO(fs::FS &fs, const char * path){
-    Serial.printf("Testing file I/O with %s\r\n", path);
-
-    static uint8_t buf[512];
-    size_t len = 0;
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("- failed to open file for writing");
-        return;
-    }
-
-    size_t i;
-    Serial.print("- writing" );
-    uint32_t start = millis();
-    for(i=0; i<2048; i++){
-        if ((i & 0x001F) == 0x001F){
-          Serial.print(".");
-        }
-        file.write(buf, 512);
-    }
-    Serial.println("");
-    uint32_t end = millis() - start;
-    Serial.printf(" - %u bytes written in %u ms\r\n", 2048 * 512, end);
-    file.close();
-
-    file = fs.open(path);
-    start = millis();
-    end = start;
-    i = 0;
-    if(file && !file.isDirectory()){
-        len = file.size();
-        size_t flen = len;
-        start = millis();
-        Serial.print("- reading" );
-        while(len){
-            size_t toRead = len;
-            if(toRead > 512){
-                toRead = 512;
-            }
-            file.read(buf, toRead);
-            if ((i++ & 0x001F) == 0x001F){
-              Serial.print(".");
-            }
-            len -= toRead;
-        }
-        Serial.println("");
-        end = millis() - start;
-        Serial.printf("- %u bytes read in %u ms\r\n", flen, end);
-        file.close();
-    } else {
-        Serial.println("- failed to open file for reading");
-    }
-}
-
-void setup(){
-    Serial.begin(115200);
-    if(!LITTLEFS.begin(FORMAT_LITTLEFS_IF_FAILED)){
-        Serial.println("LITTLEFS Mount Failed");
-        return;
-    }
-    Serial.println( "SPIFFS-like write file to new path and delete it w/folders" );
-    writeFile2(LITTLEFS, "/new1/new2/new3/hello3.txt", "Hello3");
-    listDir(LITTLEFS, "/", 3);
-    deleteFile2(LITTLEFS, "/new1/new2/new3/hello3.txt");
-    
-    listDir(LITTLEFS, "/", 3);
-	createDir(LITTLEFS, "/mydir");
-	writeFile(LITTLEFS, "/mydir/hello2.txt", "Hello2");
-	listDir(LITTLEFS, "/", 1);
-	deleteFile(LITTLEFS, "/mydir/hello2.txt");
-	removeDir(LITTLEFS, "/mydir");
-	listDir(LITTLEFS, "/", 1);
-    writeFile(LITTLEFS, "/hello.txt", "Hello ");
-    appendFile(LITTLEFS, "/hello.txt", "World!\r\n");
-    readFile(LITTLEFS, "/hello.txt");
-    renameFile(LITTLEFS, "/hello.txt", "/foo.txt");
-    readFile(LITTLEFS, "/foo.txt");
-    deleteFile(LITTLEFS, "/foo.txt");
-    testFileIO(LITTLEFS, "/test.txt");
-    deleteFile(LITTLEFS, "/test.txt");
-	
-    Serial.println( "Test complete" );
-}
-
-void loop(){
-
-}