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

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -24,7 +24,7 @@ https://github.com/me-no-dev/EspExceptionDecoder
 
 ### Hardware:
 Board:							?ESP32 Dev Module? ?node32? ?ttgo_lora?
-Core Installation version:			?1.0.0? ?1.0.1-rc4? ?1.0.1? ?1.0.1-git?
+Core Installation version:			?1.0.0? ?1.0.1-rc4? ?1.0.1? ?1.0.1-git? ?1.0.2? ?1.0.3?
 IDE name:						?Arduino IDE? ?Platform.io? ?IDF component?
 Flash Frequency:					?40Mhz?
 PSRAM enabled:                                    ?no? ?yes?

.github/scripts/check-cmakelists.sh

@@ -8,10 +8,10 @@
 
 set -e
 
-cd "`dirname $0`/.."  # cd to arduino-esp32 root
+# pull all submodules
+git submodule update --init --recursive
 
 # find all source files in repo
-#REPO_SRCS=`find cores/esp32/ libraries/ -name 'examples' -prune -o -name 'main.cpp' -prune -o -name '*.c' -print -o -name '*.cpp' -print | sort`
 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

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

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+export ARDUINO_ESP32_PATH="$ARDUINO_USR_PATH/hardware/espressif/esp32"
+if [ ! -d "$ARDUINO_ESP32_PATH" ]; then
+	echo "Installing ESP32 Arduino Core ..."
+	script_init_path="$PWD"
+	mkdir -p "$ARDUINO_USR_PATH/hardware/espressif"
+	cd "$ARDUINO_USR_PATH/hardware/espressif"
+
+	echo "Installing Python Serial ..."
+	pip install pyserial > /dev/null
+
+	if [ "$OS_IS_WINDOWS" == "1" ]; then
+		echo "Installing Python Requests ..."
+		pip install requests > /dev/null
+	fi
+
+	if [ "$GITHUB_REPOSITORY" == "espressif/arduino-esp32" ];  then
+		echo "Linking Core..."
+		ln -s $GITHUB_WORKSPACE esp32
+	else
+		echo "Cloning Core Repository..."
+		git clone https://github.com/espressif/arduino-esp32.git esp32 > /dev/null 2>&1
+	fi
+
+	#echo "Updating Submodules ..."
+	cd esp32
+	#git submodule update --init --recursive > /dev/null 2>&1
+
+	echo "Installing Platform Tools ..."
+	cd tools && python get.py
+	cd $script_init_path
+
+	echo "ESP32 Arduino has been installed in '$ARDUINO_ESP32_PATH'"
+	echo ""
+fi

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

@@ -0,0 +1,220 @@
+#!/bin/bash
+
+#OSTYPE: 'linux-gnu', ARCH: 'x86_64' => linux64
+#OSTYPE: 'msys', ARCH: 'x86_64' => win32
+#OSTYPE: 'darwin18', ARCH: 'i386' => macos
+
+OSBITS=`arch`
+if [[ "$OSTYPE" == "linux"* ]]; then
+	export OS_IS_LINUX="1"
+	ARCHIVE_FORMAT="tar.xz"
+	if [[ "$OSBITS" == "i686" ]]; then
+		OS_NAME="linux32"
+	elif [[ "$OSBITS" == "x86_64" ]]; then
+		OS_NAME="linux64"
+	elif [[ "$OSBITS" == "armv7l" || "$OSBITS" == "aarch64" ]]; then
+		OS_NAME="linuxarm"
+	else
+		OS_NAME="$OSTYPE-$OSBITS"
+		echo "Unknown OS '$OS_NAME'"
+		exit 1
+	fi
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+	export OS_IS_MACOS="1"
+	ARCHIVE_FORMAT="zip"
+	OS_NAME="macosx"
+elif [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "win32" ]]; then
+	export OS_IS_WINDOWS="1"
+	ARCHIVE_FORMAT="zip"
+	OS_NAME="windows"
+else
+	OS_NAME="$OSTYPE-$OSBITS"
+	echo "Unknown OS '$OS_NAME'"
+	exit 1
+fi
+export OS_NAME
+
+ARDUINO_BUILD_DIR="$HOME/.arduino/build.tmp"
+ARDUINO_CACHE_DIR="$HOME/.arduino/cache.tmp"
+
+if [ "$OS_IS_MACOS" == "1" ]; then
+	export ARDUINO_IDE_PATH="/Applications/Arduino.app/Contents/Java"
+	export ARDUINO_USR_PATH="$HOME/Documents/Arduino"
+elif [ "$OS_IS_WINDOWS" == "1" ]; then
+	export ARDUINO_IDE_PATH="$HOME/arduino_ide"
+	export ARDUINO_USR_PATH="$HOME/Documents/Arduino"
+else
+	export ARDUINO_IDE_PATH="$HOME/arduino_ide"
+	export ARDUINO_USR_PATH="$HOME/Arduino"
+fi
+
+if [ ! -d "$ARDUINO_IDE_PATH" ]; then
+	echo "Installing Arduino IDE on $OS_NAME ..."
+	echo "Downloading 'arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
+	if [ "$OS_IS_LINUX" == "1" ]; then
+		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 "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
+			mv "Arduino.app" "/Applications/Arduino.app"
+		else
+			mv arduino-nightly "$ARDUINO_IDE_PATH"
+		fi
+	fi
+	rm -rf "arduino.$ARCHIVE_FORMAT"
+
+	mkdir -p "$ARDUINO_USR_PATH/libraries"
+	mkdir -p "$ARDUINO_USR_PATH/hardware"
+
+	echo "Arduino IDE Installed in '$ARDUINO_IDE_PATH'"
+	echo ""
+fi
+
+function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
+    if [ "$#" -lt 2 ]; then
+		echo "ERROR: Illegal number of parameters"
+		echo "USAGE: build_sketch <fqbn> <path-to-ino> [extra-options]"
+		return 1
+	fi
+
+	local fqbn="$1"
+	local sketch="$2"
+	local xtra_opts="$3"
+	local win_opts=""
+	if [ "$OS_IS_WINDOWS" == "1" ]; then
+		local ctags_version=`ls "$ARDUINO_IDE_PATH/tools-builder/ctags/"`
+		local preprocessor_version=`ls "$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/"`
+		win_opts="-prefs=runtime.tools.ctags.path=$ARDUINO_IDE_PATH/tools-builder/ctags/$ctags_version -prefs=runtime.tools.arduino-preprocessor.path=$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/$preprocessor_version"
+	fi
+
+	echo ""
+	echo "Compiling '"$(basename "$sketch")"' ..."
+	mkdir -p "$ARDUINO_BUILD_DIR"
+	mkdir -p "$ARDUINO_CACHE_DIR"
+	$ARDUINO_IDE_PATH/arduino-builder -compile -logger=human -core-api-version=10810 \
+		-fqbn=$fqbn \
+		-warnings="all" \
+		-tools "$ARDUINO_IDE_PATH/tools-builder" \
+		-tools "$ARDUINO_IDE_PATH/tools" \
+		-built-in-libraries "$ARDUINO_IDE_PATH/libraries" \
+		-hardware "$ARDUINO_IDE_PATH/hardware" \
+		-hardware "$ARDUINO_USR_PATH/hardware" \
+		-libraries "$ARDUINO_USR_PATH/libraries" \
+		-build-cache "$ARDUINO_CACHE_DIR" \
+		-build-path "$ARDUINO_BUILD_DIR" \
+		$win_opts $xtra_opts "$sketch"
+}
+
+function count_sketches() # count_sketches <examples-path>
+{
+	local examples="$1"
+    rm -rf sketches.txt
+	if [ ! -d "$examples" ]; then
+		touch sketches.txt
+		return 0
+	fi
+    local sketches=$(find $examples -name *.ino)
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
+            continue
+        fi;
+        if [[ -f "$sketchdir/.test.skip" ]]; then
+            continue
+        fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
+    done
+    return $sketchnum
+}
+
+function build_sketches() # build_sketches <fqbn> <examples-path> <chunk> <total-chunks> [extra-options]
+{
+    local fqbn=$1
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
+    local xtra_opts=$5
+
+    if [ "$#" -lt 2 ]; then
+		echo "ERROR: Illegal number of parameters"
+		echo "USAGE: build_sketches <fqbn> <examples-path> [<chunk> <total-chunks>] [extra-options]"
+		return 1
+	fi
+
+    if [ "$#" -lt 4 ]; then
+		chunk_idex="0"
+		chunks_num="1"
+		xtra_opts=$3
+	fi
+
+	if [ "$chunks_num" -le 0 ]; then
+		echo "ERROR: Chunks count must be positive number"
+		return 1
+	fi
+	if [ "$chunk_idex" -ge "$chunks_num" ]; then
+		echo "ERROR: Chunk index must be less than chunks count"
+		return 1
+	fi
+
+	set +e
+    count_sketches "$examples"
+    local sketchcount=$?
+	set -e
+    local sketches=$(cat sketches.txt)
+    rm -rf sketches.txt
+
+    local chunk_size=$(( $sketchcount / $chunks_num ))
+    local all_chunks=$(( $chunks_num * $chunk_size ))
+    if [ "$all_chunks" -lt "$sketchcount" ]; then
+    	chunk_size=$(( $chunk_size + 1 ))
+    fi
+
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+    	echo "Skipping job"
+    	return 0
+    fi
+
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+    	end_index=$sketchcount
+    fi
+
+    local start_num=$(( $start_index + 1 ))
+    echo "Found $sketchcount Sketches";
+    echo "Chunk Count : $chunks_num"
+    echo "Chunk Size  : $chunk_size"
+    echo "Start Sketch: $start_num"
+    echo "End Sketch  : $end_index"
+
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [ "${sketchdirname}.ino" != "$sketchname" ] \
+        || [ -f "$sketchdir/.test.skip" ]; then
+            continue
+        fi
+        sketchnum=$(($sketchnum + 1))
+        if [ "$sketchnum" -le "$start_index" ] \
+        || [ "$sketchnum" -gt "$end_index" ]; then
+        	continue
+        fi
+        build_sketch "$fqbn" "$sketch" "$xtra_opts"
+        local result=$?
+        if [ $result -ne 0 ]; then
+            return $result
+        fi
+    done
+    return 0
+}

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

@@ -0,0 +1,153 @@
+#!/bin/bash
+
+export PLATFORMIO_ESP32_PATH="$HOME/.platformio/packages/framework-arduinoespressif32"
+
+echo "Installing Python Wheel ..."
+pip install wheel > /dev/null 2>&1
+
+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 https://github.com/platformio/platform-espressif32.git#feature/stage > /dev/null 2>&1
+
+echo "Replacing the framework version ..."
+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 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> <path-to-ino>
+    if [ "$#" -lt 2 ]; then
+        echo "ERROR: Illegal number of parameters"
+        echo "USAGE: build_pio_sketch <board> <path-to-ino>"
+        return 1
+    fi
+
+    local board="$1"
+    local sketch="$2"
+    local sketch_dir=$(dirname "$sketch")
+    echo ""
+    echo "Compiling '"$(basename "$sketch")"' ..."
+    python -m platformio ci --board "$board" "$sketch_dir" --project-option="board_build.partitions = huge_app.csv"
+}
+
+function count_sketches() # count_sketches <examples-path>
+{
+    local examples="$1"
+    rm -rf sketches.txt
+    if [ ! -d "$examples" ]; then
+        touch sketches.txt
+        return 0
+    fi
+    local sketches=$(find $examples -name *.ino)
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
+            continue
+        fi;
+        if [[ -f "$sketchdir/.test.skip" ]]; then
+            continue
+        fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
+    done
+    return $sketchnum
+}
+
+function build_pio_sketches() # build_pio_sketches <board> <examples-path> <chunk> <total-chunks>
+{
+    if [ "$#" -lt 2 ]; then
+        echo "ERROR: Illegal number of parameters"
+        echo "USAGE: build_pio_sketches <board> <examples-path> [<chunk> <total-chunks>]"
+        return 1
+    fi
+
+    local board=$1
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
+
+    if [ "$#" -lt 4 ]; then
+        chunk_idex="0"
+        chunks_num="1"
+    fi
+
+    if [ "$chunks_num" -le 0 ]; then
+        echo "ERROR: Chunks count must be positive number"
+        return 1
+    fi
+    if [ "$chunk_idex" -ge "$chunks_num" ]; then
+        echo "ERROR: Chunk index must be less than chunks count"
+        return 1
+    fi
+
+    set +e
+    count_sketches "$examples"
+    local sketchcount=$?
+    set -e
+    local sketches=$(cat sketches.txt)
+    rm -rf sketches.txt
+
+    local chunk_size=$(( $sketchcount / $chunks_num ))
+    local all_chunks=$(( $chunks_num * $chunk_size ))
+    if [ "$all_chunks" -lt "$sketchcount" ]; then
+        chunk_size=$(( $chunk_size + 1 ))
+    fi
+
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+        echo "Skipping job"
+        return 0
+    fi
+
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+        end_index=$sketchcount
+    fi
+
+    local start_num=$(( $start_index + 1 ))
+    echo "Found $sketchcount Sketches";
+    echo "Chunk Count : $chunks_num"
+    echo "Chunk Size  : $chunk_size"
+    echo "Start Sketch: $start_num"
+    echo "End Sketch  : $end_index"
+
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [ "${sketchdirname}.ino" != "$sketchname" ] \
+        || [ -f "$sketchdir/.test.skip" ]; then
+            continue
+        fi
+        sketchnum=$(($sketchnum + 1))
+        if [ "$sketchnum" -le "$start_index" ] \
+        || [ "$sketchnum" -gt "$end_index" ]; then
+            continue
+        fi
+        build_pio_sketch "$board" "$sketch"
+        local result=$?
+        if [ $result -ne 0 ]; then
+            return $result
+        fi
+    done
+    return 0
+}

.github/scripts/merge_packages.py

@@ -36,7 +36,11 @@ def pkgVersionNormalized(versionString):
     verParts = re.split('\.|-rc', verStr, flags=re.IGNORECASE)
     
     if len(verParts) == 3:
-        verStr = str(versionString) + '-rc' + str(sys.maxint)
+        if (sys.version_info > (3, 0)): # Python 3
+            verStr = str(versionString) + '-rc' + str(sys.maxsize)
+        else: # Python 2
+            verStr = str(versionString) + '-rc' + str(sys.maxint)
+        
     elif len(verParts) != 4:
         print("pkgVersionNormalized WARNING: unexpected version format: {0})".format(verStr), file=sys.stderr)
         

.github/scripts/on-pages.sh

@@ -0,0 +1,131 @@
+#/bin/bash
+set -e
+
+function get_file_size(){
+    local file="$1"
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        eval `stat -s "$file"`
+        local res="$?"
+        echo "$st_size"
+        return $res
+    else
+        stat --printf="%s" "$file"
+        return $?
+    fi
+}
+
+#git_remove_from_pages <file>
+function git_remove_from_pages(){
+    local path=$1
+    local info=`curl -s -k -H "Authorization: token $GITHUB_TOKEN" -H "Accept: application/vnd.github.v3.object+json" -X GET "https://api.github.com/repos/$GITHUB_REPOSITORY/contents/$path?ref=gh-pages"`
+    local type=`echo "$info" | jq -r '.type'`
+    if [ ! $type == "file" ]; then
+        if [ ! $type == "null" ]; then
+            echo "Wrong type '$type'"
+        else
+            echo "File is not on Pages"
+        fi
+        return 0
+    fi
+    local sha=`echo "$info" | jq -r '.sha'`
+    local message="Deleting "$(basename $path)
+    local json="{\"branch\":\"gh-pages\",\"message\":\"$message\",\"sha\":\"$sha\"}"
+    echo "$json" | curl -s -k -H "Authorization: token $GITHUB_TOKEN" -H "Accept: application/vnd.github.v3.raw+json" -X DELETE --data @- "https://api.github.com/repos/$GITHUB_REPOSITORY/contents/$path"
+}
+
+function git_upload_to_pages(){
+    local path=$1
+    local src=$2
+
+    if [ ! -f "$src" ]; then
+        >&2 echo "Input is not a file! Aborting..."
+        return 1
+    fi
+
+    local info=`curl -s -k -H "Authorization: token $GITHUB_TOKEN" -H "Accept: application/vnd.github.v3.object+json" -X GET "https://api.github.com/repos/$GITHUB_REPOSITORY/contents/$path?ref=gh-pages"`
+    local type=`echo "$info" | jq -r '.type'`
+    local message=$(basename $path)
+    local sha=""
+    local content=""
+
+    if [ $type == "file" ]; then
+        sha=`echo "$info" | jq -r '.sha'`
+        sha=",\"sha\":\"$sha\""
+        message="Updating $message"
+    elif [ ! $type == "null" ]; then
+        >&2 echo "Wrong type '$type'"
+        return 1
+    else
+        message="Creating $message"
+    fi
+
+    content=`base64 -i "$src"`
+    data="{\"branch\":\"gh-pages\",\"message\":\"$message\",\"content\":\"$content\"$sha}"
+
+    echo "$data" | curl -s -k -H "Authorization: token $GITHUB_TOKEN" -H "Accept: application/vnd.github.v3.raw+json" -X PUT --data @- "https://api.github.com/repos/$GITHUB_REPOSITORY/contents/$path"
+}
+
+function git_safe_upload_to_pages(){
+    local path=$1
+    local file="$2"
+    local name=$(basename "$file")
+    local size=`get_file_size "$file"`
+    local upload_res=`git_upload_to_pages "$path" "$file"`
+    if [ $? -ne 0 ]; then 
+        >&2 echo "ERROR: Failed to upload '$name' ($?)"
+        return 1
+    fi
+    up_size=`echo "$upload_res" | jq -r '.content.size'`
+    if [ $up_size -ne $size ]; then
+        >&2 echo "ERROR: Uploaded size does not match! $up_size != $size"
+        #git_delete_asset
+        return 1
+    fi
+    echo "$upload_res" | jq -r '.content.download_url'
+    return $?
+}
+
+EVENT_JSON=`cat $GITHUB_EVENT_PATH`
+
+pages_added=`echo "$EVENT_JSON" | jq -r '.commits[].added[]'`
+pages_modified=`echo "$EVENT_JSON" | jq -r '.commits[].modified[]'`
+pages_removed=`echo "$EVENT_JSON" | jq -r '.commits[].removed[]'`
+
+for page in $pages_added; do
+    if [[ $page != "README.md" && $page != "docs/"* ]]; then
+        continue
+    fi
+    echo "Adding '$page' to pages ..."
+    if [[ $page == "README.md" ]]; then
+        git_safe_upload_to_pages "index.md" "README.md"
+    else
+        git_safe_upload_to_pages "$page" "$page"
+    fi
+done
+
+for page in $pages_modified; do
+    if [[ $page != "README.md" && $page != "docs/"* ]]; then
+        continue
+    fi
+    echo "Modifying '$page' ..."
+    if [[ $page == "README.md" ]]; then
+        git_safe_upload_to_pages "index.md" "README.md"
+    else
+        git_safe_upload_to_pages "$page" "$page"
+    fi
+done
+
+for page in $pages_removed; do
+    if [[ $page != "README.md" && $page != "docs/"* ]]; then
+        continue
+    fi
+    echo "Removing '$page' from pages ..."
+    if [[ $page == "README.md" ]]; then
+        git_remove_from_pages "README.md" > /dev/null
+    else
+        git_remove_from_pages "$page" > /dev/null
+    fi
+done
+
+echo
+echo "DONE!"

.github/scripts/on-push.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+set -e
+
+if [ ! -z "$TRAVIS_TAG" ]; then
+	echo "Skipping Test: Tagged build"
+	exit 0
+fi
+
+if [ ! -z "$GITHUB_WORKSPACE" ]; then
+	export TRAVIS_BUILD_DIR="$GITHUB_WORKSPACE"
+	export TRAVIS_REPO_SLUG="$GITHUB_REPOSITORY"
+elif [ ! -z "$TRAVIS_BUILD_DIR" ]; then
+	export GITHUB_WORKSPACE="$TRAVIS_BUILD_DIR"
+	export GITHUB_REPOSITORY="$TRAVIS_REPO_SLUG"
+else
+	export GITHUB_WORKSPACE="$PWD"
+	export GITHUB_REPOSITORY="espressif/arduino-esp32"
+fi
+
+CHUNK_INDEX=$1
+CHUNKS_CNT=$2
+BUILD_PIO=0
+if [ "$#" -lt 2 ] || [ "$CHUNKS_CNT" -le 0 ]; then
+	CHUNK_INDEX=0
+	CHUNKS_CNT=1
+elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ]; then
+	CHUNK_INDEX=$CHUNKS_CNT
+elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then
+	BUILD_PIO=1
+fi
+
+#echo "Updating submodules ..."
+#git -C "$GITHUB_WORKSPACE" submodule update --init --recursive > /dev/null 2>&1
+
+if [ "$BUILD_PIO" -eq 0 ]; then
+	# ArduinoIDE Test
+	FQBN="espressif:esp32:esp32:PSRAM=enabled,PartitionScheme=huge_app"
+	source ./.github/scripts/install-arduino-ide.sh
+	source ./.github/scripts/install-arduino-core-esp32.sh
+	if [ "$OS_IS_WINDOWS" == "1" ]; then
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	elif [ "$OS_IS_MACOS" == "1" ]; then
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	else
+		# CMake Test
+		if [ "$CHUNK_INDEX" -eq 0 ]; then
+			bash "$ARDUINO_ESP32_PATH/.github/scripts/check-cmakelists.sh"
+		fi
+		build_sketches "$FQBN" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
+	fi
+else
+	# PlatformIO Test
+	source ./.github/scripts/install-platformio-esp32.sh
+	BOARD="esp32dev"
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	#build_pio_sketches esp32dev "$PLATFORMIO_ESP32_PATH/libraries"
+fi

.github/scripts/on-release.sh

@@ -0,0 +1,380 @@
+#!/bin/bash
+
+if [ ! $GITHUB_EVENT_NAME == "release" ]; then
+    echo "Wrong event '$GITHUB_EVENT_NAME'!"
+    exit 1
+fi
+
+EVENT_JSON=`cat $GITHUB_EVENT_PATH`
+
+action=`echo $EVENT_JSON | jq -r '.action'`
+if [ ! $action == "published" ]; then
+    echo "Wrong action '$action'. Exiting now..."
+    exit 0
+fi
+
+draft=`echo $EVENT_JSON | jq -r '.release.draft'`
+if [ $draft == "true" ]; then
+    echo "It's a draft release. Exiting now..."
+    exit 0
+fi
+
+RELEASE_PRE=`echo $EVENT_JSON | jq -r '.release.prerelease'`
+RELEASE_TAG=`echo $EVENT_JSON | jq -r '.release.tag_name'`
+RELEASE_BRANCH=`echo $EVENT_JSON | jq -r '.release.target_commitish'`
+RELEASE_ID=`echo $EVENT_JSON | jq -r '.release.id'`
+RELEASE_BODY=`echo $EVENT_JSON | jq -r '.release.body'`
+
+OUTPUT_DIR="$GITHUB_WORKSPACE/build"
+PACKAGE_NAME="esp32-$RELEASE_TAG"
+PACKAGE_JSON_MERGE="$GITHUB_WORKSPACE/.github/scripts/merge_packages.py"
+PACKAGE_JSON_TEMPLATE="$GITHUB_WORKSPACE/package/package_esp32_index.template.json"
+PACKAGE_JSON_DEV="package_esp32_dev_index.json"
+PACKAGE_JSON_REL="package_esp32_index.json"
+
+echo "Event: $GITHUB_EVENT_NAME, Repo: $GITHUB_REPOSITORY, Path: $GITHUB_WORKSPACE, Ref: $GITHUB_REF"
+echo "Action: $action, Branch: $RELEASE_BRANCH, ID: $RELEASE_ID" 
+echo "Tag: $RELEASE_TAG, Draft: $draft, Pre-Release: $RELEASE_PRE"
+
+function get_file_size(){
+    local file="$1"
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        eval `stat -s "$file"`
+        local res="$?"
+        echo "$st_size"
+        return $res
+    else
+        stat --printf="%s" "$file"
+        return $?
+    fi
+}
+
+function git_upload_asset(){
+    local name=$(basename "$1")
+    # local mime=$(file -b --mime-type "$1")
+    curl -k -X POST -sH "Authorization: token $GITHUB_TOKEN" -H "Content-Type: application/octet-stream" --data-binary @"$1" "https://uploads.github.com/repos/$GITHUB_REPOSITORY/releases/$RELEASE_ID/assets?name=$name"
+}
+
+function git_safe_upload_asset(){
+    local file="$1"
+    local name=$(basename "$file")
+    local size=`get_file_size "$file"`
+    local upload_res=`git_upload_asset "$file"`
+    if [ $? -ne 0 ]; then 
+        >&2 echo "ERROR: Failed to upload '$name' ($?)"
+        return 1
+    fi
+    up_size=`echo "$upload_res" | jq -r '.size'`
+    if [ $up_size -ne $size ]; then
+        >&2 echo "ERROR: Uploaded size does not match! $up_size != $size"
+        #git_delete_asset
+        return 1
+    fi
+    echo "$upload_res" | jq -r '.browser_download_url'
+    return $?
+}
+
+function git_upload_to_pages(){
+    local path=$1
+    local src=$2
+
+    if [ ! -f "$src" ]; then
+        >&2 echo "Input is not a file! Aborting..."
+        return 1
+    fi
+
+    local info=`curl -s -k -H "Authorization: token $GITHUB_TOKEN" -H "Accept: application/vnd.github.v3.object+json" -X GET "https://api.github.com/repos/$GITHUB_REPOSITORY/contents/$path?ref=gh-pages"`
+    local type=`echo "$info" | jq -r '.type'`
+    local message=$(basename $path)
+    local sha=""
+    local content=""
+
+    if [ $type == "file" ]; then
+        sha=`echo "$info" | jq -r '.sha'`
+        sha=",\"sha\":\"$sha\""
+        message="Updating $message"
+    elif [ ! $type == "null" ]; then
+        >&2 echo "Wrong type '$type'"
+        return 1
+    else
+        message="Creating $message"
+    fi
+
+    content=`base64 -i "$src"`
+    data="{\"branch\":\"gh-pages\",\"message\":\"$message\",\"content\":\"$content\"$sha}"
+
+    echo "$data" | curl -s -k -H "Authorization: token $GITHUB_TOKEN" -H "Accept: application/vnd.github.v3.raw+json" -X PUT --data @- "https://api.github.com/repos/$GITHUB_REPOSITORY/contents/$path"
+}
+
+function git_safe_upload_to_pages(){
+    local path=$1
+    local file="$2"
+    local name=$(basename "$file")
+    local size=`get_file_size "$file"`
+    local upload_res=`git_upload_to_pages "$path" "$file"`
+    if [ $? -ne 0 ]; then 
+        >&2 echo "ERROR: Failed to upload '$name' ($?)"
+        return 1
+    fi
+    up_size=`echo "$upload_res" | jq -r '.content.size'`
+    if [ $up_size -ne $size ]; then
+        >&2 echo "ERROR: Uploaded size does not match! $up_size != $size"
+        #git_delete_asset
+        return 1
+    fi
+    echo "$upload_res" | jq -r '.content.download_url'
+    return $?
+}
+
+function merge_package_json(){
+    local jsonLink=$1
+    local jsonOut=$2
+    local old_json=$OUTPUT_DIR/oldJson.json
+    local merged_json=$OUTPUT_DIR/mergedJson.json
+    
+    echo "Downloading previous JSON $jsonLink ..."
+    curl -L -o "$old_json" "https://github.com/$GITHUB_REPOSITORY/releases/download/$jsonLink?access_token=$GITHUB_TOKEN" 2>/dev/null
+    if [ $? -ne 0 ]; then echo "ERROR: Download Failed! $?"; exit 1; fi
+
+    echo "Creating new JSON ..."
+    set +e
+    stdbuf -oL python "$PACKAGE_JSON_MERGE" "$jsonOut" "$old_json" > "$merged_json"
+    set -e
+    
+    set -v
+    if [ ! -s $merged_json ]; then
+        rm -f "$merged_json"
+        echo "Nothing to merge"
+    else
+        rm -f "$jsonOut"
+        mv "$merged_json" "$jsonOut"
+        echo "JSON data successfully merged"
+    fi
+    rm -f "$old_json"
+    set +v
+}
+
+set -e
+
+##
+## PACKAGE ZIP
+##
+
+mkdir -p "$OUTPUT_DIR"
+PKG_DIR="$OUTPUT_DIR/$PACKAGE_NAME"
+PACKAGE_ZIP="$PACKAGE_NAME.zip"
+
+echo "Updating submodules ..."
+git -C "$GITHUB_WORKSPACE" submodule update --init --recursive > /dev/null 2>&1
+
+mkdir -p "$PKG_DIR/tools"
+
+# Copy all core files to the package folder
+echo "Copying files for packaging ..."
+cp -f  "$GITHUB_WORKSPACE/boards.txt"              "$PKG_DIR/"
+cp -f  "$GITHUB_WORKSPACE/programmers.txt"         "$PKG_DIR/"
+cp -Rf "$GITHUB_WORKSPACE/cores"                   "$PKG_DIR/"
+cp -Rf "$GITHUB_WORKSPACE/libraries"               "$PKG_DIR/"
+cp -Rf "$GITHUB_WORKSPACE/variants"                "$PKG_DIR/"
+cp -f  "$GITHUB_WORKSPACE/tools/espota.exe"        "$PKG_DIR/tools/"
+cp -f  "$GITHUB_WORKSPACE/tools/espota.py"         "$PKG_DIR/tools/"
+cp -f  "$GITHUB_WORKSPACE/tools/esptool.py"        "$PKG_DIR/tools/"
+cp -f  "$GITHUB_WORKSPACE/tools/gen_esp32part.py"  "$PKG_DIR/tools/"
+cp -f  "$GITHUB_WORKSPACE/tools/gen_esp32part.exe" "$PKG_DIR/tools/"
+cp -Rf "$GITHUB_WORKSPACE/tools/partitions"        "$PKG_DIR/tools/"
+cp -Rf "$GITHUB_WORKSPACE/tools/sdk"               "$PKG_DIR/tools/"
+
+# Remove unnecessary files in the package folder
+echo "Cleaning up folders ..."
+find "$PKG_DIR" -name '*.DS_Store' -exec rm -f {} \;
+find "$PKG_DIR" -name '*.git*' -type f -delete
+
+# Replace tools locations in platform.txt
+echo "Generating platform.txt..."
+cat "$GITHUB_WORKSPACE/platform.txt" | \
+sed "s/version=.*/version=$ver$extent/g" | \
+sed 's/runtime.tools.xtensa-esp32-elf-gcc.path={runtime.platform.path}\/tools\/xtensa-esp32-elf//g' | \
+sed 's/tools.esptool_py.path={runtime.platform.path}\/tools\/esptool/tools.esptool_py.path=\{runtime.tools.esptool_py.path\}/g' \
+ > "$PKG_DIR/platform.txt"
+
+# Add header with version information
+echo "Generating core_version.h ..."
+ver_define=`echo $RELEASE_TAG | tr "[:lower:].\055" "[:upper:]_"`
+ver_hex=`git -C "$GITHUB_WORKSPACE" rev-parse --short=8 HEAD 2>/dev/null`
+echo \#define ARDUINO_ESP32_GIT_VER 0x$ver_hex > "$PKG_DIR/cores/esp32/core_version.h"
+echo \#define ARDUINO_ESP32_GIT_DESC `git -C "$GITHUB_WORKSPACE" describe --tags 2>/dev/null` >> "$PKG_DIR/cores/esp32/core_version.h"
+echo \#define ARDUINO_ESP32_RELEASE_$ver_define >> "$PKG_DIR/cores/esp32/core_version.h"
+echo \#define ARDUINO_ESP32_RELEASE \"$ver_define\" >> "$PKG_DIR/cores/esp32/core_version.h"
+
+# Compress package folder
+echo "Creating ZIP ..."
+pushd "$OUTPUT_DIR" >/dev/null
+zip -qr "$PACKAGE_ZIP" "$PACKAGE_NAME"
+if [ $? -ne 0 ]; then echo "ERROR: Failed to create $PACKAGE_ZIP ($?)"; exit 1; fi
+
+# Calculate SHA-256
+echo "Calculating SHA sum ..."
+PACKAGE_PATH="$OUTPUT_DIR/$PACKAGE_ZIP"
+PACKAGE_SHA=`shasum -a 256 "$PACKAGE_ZIP" | cut -f 1 -d ' '`
+PACKAGE_SIZE=`get_file_size "$PACKAGE_ZIP"`
+popd >/dev/null
+rm -rf "$PKG_DIR"
+echo "'$PACKAGE_ZIP' Created! Size: $PACKAGE_SIZE, SHA-256: $PACKAGE_SHA"
+echo
+
+# Upload package to release page
+echo "Uploading package to release page ..."
+PACKAGE_URL=`git_safe_upload_asset "$PACKAGE_PATH"`
+echo "Package Uploaded"
+echo "Download URL: $PACKAGE_URL"
+echo
+
+##
+## PACKAGE JSON
+##
+
+# Construct JQ argument with package data
+jq_arg=".packages[0].platforms[0].version = \"$RELEASE_TAG\" | \
+    .packages[0].platforms[0].url = \"$PACKAGE_URL\" |\
+    .packages[0].platforms[0].archiveFileName = \"$PACKAGE_ZIP\" |\
+    .packages[0].platforms[0].size = \"$PACKAGE_SIZE\" |\
+    .packages[0].platforms[0].checksum = \"SHA-256:$PACKAGE_SHA\""
+
+# Generate package JSONs
+echo "Genarating $PACKAGE_JSON_DEV ..."
+cat "$PACKAGE_JSON_TEMPLATE" | jq "$jq_arg" > "$OUTPUT_DIR/$PACKAGE_JSON_DEV"
+if [ "$RELEASE_PRE" == "false" ]; then
+    echo "Genarating $PACKAGE_JSON_REL ..."
+    cat "$PACKAGE_JSON_TEMPLATE" | jq "$jq_arg" > "$OUTPUT_DIR/$PACKAGE_JSON_REL"
+fi
+
+# Figure out the last release or pre-release
+echo "Getting previous releases ..."
+releasesJson=`curl -sH "Authorization: token $GITHUB_TOKEN" "https://api.github.com/repos/$GITHUB_REPOSITORY/releases" 2>/dev/null`
+if [ $? -ne 0 ]; then echo "ERROR: Get Releases Failed! ($?)"; exit 1; fi
+
+set +e
+prev_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false and .prerelease == false)) | sort_by(.created_at | - fromdateiso8601) | .[0].tag_name')
+prev_any_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false)) | sort_by(.created_at | - fromdateiso8601)  | .[0].tag_name')
+shopt -s nocasematch
+if [ "$prev_any_release" == "$RELEASE_TAG" ]; then
+    prev_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false and .prerelease == false)) | sort_by(.created_at | - fromdateiso8601) | .[1].tag_name')
+    prev_any_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false)) | sort_by(.created_at | - fromdateiso8601)  | .[1].tag_name')
+fi
+COMMITS_SINCE_RELEASE="$prev_any_release"
+shopt -u nocasematch
+set -e
+
+# Merge package JSONs with previous releases
+if [ ! -z "$prev_any_release" ] && [ "$prev_any_release" != "null" ]; then
+    echo "Merging with JSON from $prev_any_release ..."
+    merge_package_json "$prev_any_release/$PACKAGE_JSON_DEV" "$OUTPUT_DIR/$PACKAGE_JSON_DEV"
+fi
+
+if [ "$RELEASE_PRE" == "false" ]; then
+    COMMITS_SINCE_RELEASE="$prev_release"
+    if [ ! -z "$prev_release" ] && [ "$prev_release" != "null" ]; then
+        echo "Merging with JSON from $prev_release ..."
+        merge_package_json "$prev_release/$PACKAGE_JSON_REL" "$OUTPUT_DIR/$PACKAGE_JSON_REL"
+    fi
+fi
+
+echo "Previous Release: $prev_release"
+echo "Previous (any)release: $prev_any_release"
+echo
+
+# Upload package JSONs
+echo "Uploading $PACKAGE_JSON_DEV ..."
+echo "Download URL: "`git_safe_upload_asset "$OUTPUT_DIR/$PACKAGE_JSON_DEV"`
+echo "Pages URL: "`git_safe_upload_to_pages "$PACKAGE_JSON_DEV" "$OUTPUT_DIR/$PACKAGE_JSON_DEV"`
+echo
+if [ "$RELEASE_PRE" == "false" ]; then
+    echo "Uploading $PACKAGE_JSON_REL ..."
+    echo "Download URL: "`git_safe_upload_asset "$OUTPUT_DIR/$PACKAGE_JSON_REL"`
+    echo "Pages URL: "`git_safe_upload_to_pages "$PACKAGE_JSON_REL" "$OUTPUT_DIR/$PACKAGE_JSON_REL"`
+    echo
+fi
+
+##
+## RELEASE NOTES
+##
+
+# Create release notes
+echo "Preparing release notes ..."
+releaseNotes=""
+
+# Process annotated tags
+relNotesRaw=`git -C "$GITHUB_WORKSPACE" show -s --format=%b $RELEASE_TAG`
+readarray -t msgArray <<<"$relNotesRaw"
+arrLen=${#msgArray[@]}
+if [ $arrLen > 3 ] && [ "${msgArray[0]:0:3}" == "tag" ]; then 
+    ind=3
+    while [ $ind -lt $arrLen ]; do
+        if [ $ind -eq 3 ]; then
+            releaseNotes="#### ${msgArray[ind]}"
+            releaseNotes+=$'\r\n'
+        else
+            oneLine="$(echo -e "${msgArray[ind]}" | sed -e 's/^[[:space:]]*//')"
+            if [ ${#oneLine} -gt 0 ]; then
+                if [ "${oneLine:0:2}" == "* " ]; then oneLine=$(echo ${oneLine/\*/-}); fi
+                if [ "${oneLine:0:2}" != "- " ]; then releaseNotes+="- "; fi        
+                releaseNotes+="$oneLine"
+                releaseNotes+=$'\r\n'
+            fi
+        fi
+        let ind=$ind+1
+    done
+fi
+
+# Append Commit Messages
+if [ ! -z "$COMMITS_SINCE_RELEASE" ] && [ "$COMMITS_SINCE_RELEASE" != "null" ]; then
+    echo "Getting commits since $COMMITS_SINCE_RELEASE ..."
+    commitFile=$OUTPUT_DIR/commits.txt
+    git -C "$GITHUB_WORKSPACE" log --oneline $COMMITS_SINCE_RELEASE.. > "$OUTPUT_DIR/commits.txt"
+    releaseNotes+=$'\r\n##### Commits\r\n'
+    IFS=$'\n'
+    for next in `cat $commitFile`
+    do
+        IFS=' ' read -r commitId commitMsg <<< "$next"
+        commitLine="- [$commitId](https://github.com/$GITHUB_REPOSITORY/commit/$commitId) $commitMsg"
+        releaseNotes+="$commitLine"
+        releaseNotes+=$'\r\n'
+    done
+    rm -f $commitFile
+fi
+
+# Prepend the original release body
+if [ "${RELEASE_BODY: -1}" == $'\r' ]; then         
+    RELEASE_BODY="${RELEASE_BODY:0:-1}"
+else 
+    RELEASE_BODY="$RELEASE_BODY"
+fi
+RELEASE_BODY+=$'\r\n'
+releaseNotes="$RELEASE_BODY$releaseNotes"
+
+# Update release page
+echo "Updating release notes ..."
+releaseNotes=$(printf '%s' "$releaseNotes" | python -c 'import json,sys; print(json.dumps(sys.stdin.read()))')
+releaseNotes=${releaseNotes:1:-1}
+curlData="{\"body\": \"$releaseNotes\"}"
+releaseData=`curl --data "$curlData" "https://api.github.com/repos/$GITHUB_REPOSITORY/releases/$RELEASE_ID?access_token=$GITHUB_TOKEN" 2>/dev/null`
+if [ $? -ne 0 ]; then echo "ERROR: Updating Release Failed: $?"; exit 1; fi
+echo "Release notes successfully updated"
+echo
+
+##
+## SUBMODULE VERSIONS
+##
+
+# Upload submodules versions
+echo "Generating submodules.txt ..."
+git -C "$GITHUB_WORKSPACE" submodule status > "$OUTPUT_DIR/submodules.txt"
+echo "Uploading submodules.txt ..."
+echo "Download URL: "`git_safe_upload_asset "$OUTPUT_DIR/submodules.txt"`
+echo ""
+set +e
+
+##
+## DONE
+##
+echo "DONE!"

.github/stale.yml

@@ -0,0 +1,64 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+# Number of days of inactivity before an Issue or Pull Request becomes stale
+daysUntilStale: 60
+
+# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
+# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
+daysUntilClose: 14
+
+# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
+onlyLabels: []
+
+# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
+exemptLabels:
+  - pinned
+  - security
+  - "to be implemented"
+  - "for reference"
+  - "move to PR"
+  - "enhancement"
+
+# Set to true to ignore issues in a project (defaults to false)
+exemptProjects: false
+
+# Set to true to ignore issues in a milestone (defaults to false)
+exemptMilestones: false
+
+# Set to true to ignore issues with an assignee (defaults to false)
+exemptAssignees: false
+
+# Label to use when marking as stale
+staleLabel: stale
+
+# Comment to post when marking as stale. Set to `false` to disable
+markComment: >
+  [STALE_SET] This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed in 14 days if no further activity occurs. Thank you
+  for your contributions.
+
+# Comment to post when removing the stale label.
+unmarkComment: >
+  [STALE_CLR] This issue has been removed from the stale queue. Please ensure activity to keep it openin the future.
+
+# Comment to post when closing a stale Issue or Pull Request.
+closeComment: >
+  [STALE_DEL] This stale issue has been automatically closed. Thank you for your contributions.
+
+# Limit the number of actions per hour, from 1-30. Default is 30
+limitPerRun: 30
+
+# Limit to only `issues` or `pulls`
+only: issues
+
+# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls':
+# pulls:
+#   daysUntilStale: 30
+#   markComment: >
+#     This pull request has been automatically marked as stale because it has not had
+#     recent activity. It will be closed if no further activity occurs. Thank you
+#     for your contributions.
+
+# issues:
+#   exemptLabels:
+#     - confirmed

.github/workflows/gh-pages.yml

@@ -0,0 +1,21 @@
+name: GitHub Pages CI
+
+on:
+  push:
+    branches:
+    - master
+    paths:
+    - 'README.md'
+    - 'docs/**'
+
+jobs:
+
+  build-pages:
+    name: Build GitHub Pages
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Copy Files
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: bash ./.github/scripts/on-pages.sh

.github/workflows/push.yml

@@ -0,0 +1,58 @@
+name: ESP32 Arduino CI
+
+on:
+  push:
+    branches:
+    - master
+    - release/*
+  pull_request:
+
+jobs:
+  
+  # Ubuntu
+  build-arduino-linux:
+    name: Arduino ${{ matrix.chunk }} on ubuntu-latest
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        chunk: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+    
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/setup-python@v1
+      with:
+        python-version: '3.x'
+    - name: Build Sketches
+      run: bash ./.github/scripts/on-push.sh ${{ matrix.chunk }} 15
+
+  # Windows and MacOS
+  build-arduino-win-mac:
+    name: Arduino on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest, macOS-latest]
+    
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/setup-python@v1
+      with:
+        python-version: '3.x'
+    - name: Build Sketches
+      run: bash ./.github/scripts/on-push.sh
+
+  # PlatformIO on Windows, Ubuntu and Mac
+  build-platformio:
+    name: PlatformIO on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+    
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/setup-python@v1
+      with:
+        python-version: '3.x'
+    - name: Build Sketches
+      run: bash ./.github/scripts/on-push.sh 1 1 #equal and non-zero to trigger PIO

.github/workflows/release.yml

@@ -0,0 +1,20 @@
+name: ESP32 Arduino Release
+
+on:
+  release:
+    types: published
+
+jobs:
+  build:
+    name: Publish Release
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@master
+    - uses: actions/setup-python@v1
+      with:
+        python-version: '3.x'
+    - name: Build Release
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: bash ./.github/scripts/on-release.sh

.gitignore

@@ -5,3 +5,10 @@ tools/esptool.exe
 tools/mkspiffs/mkspiffs
 tools/mkspiffs/mkspiffs.exe
 .DS_Store
+ 
+#Ignore files built by Visual Studio/Visual Micro
+[Dd]ebug*/
+[Rr]elease*/
+.vs/
+__vm/
+*.vcxproj*

.gitmodules

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

.travis.yml

@@ -1,8 +1,6 @@
 sudo: false
 
 language: python
-python:
-  - "2.7"
 
 os:
   - linux
@@ -10,22 +8,40 @@ os:
 git:
   depth: false
 
-env:
-    global:
-        - secure: "l/4Dt+KQ/mACtGAHDUsPr66fUte840PZoQ4xpPikqWZI0uARu4l+Ym7+sHinnT6fBqrj8AJeBYGz4nFa8NK4LutZn9mSD40w+sxl0wSV4oHV8rzKe3Cd8+sMG3+o33yWoikMNjSvqa73Q0rm+SgrlInNdZbuAyixL+a2alaWSnGPm4F2xwUGj+S33TOy5P/Xp77CYtCV5S8vzyk/eEdNhoF0GYePJVdfuzCOUjXMyT5OWxORkzzQ7Hnn/Ka/RDfV8Si4HgujLQBrK5q6iPnNBFqBSqilYBepSMn4opnOBpIm0SCgePz7XQEFC83buA7GUcnCnfg38bf+dCwHaODf1d1PmqVRYt2QmfinexXtM4afAtL0iBUDtvrfnXHzwW9w82VeZhpbJSVh9DUQvB0IlsZeCz9J9PUBAi3N+SMX+9l+BomYwRUlPuKY+Ef2JKk9q6mxtUkky5R0daAlVxEhpVdQks1rT+T+NMoDMemxQ3SKEiqAHh6EgHecruszffmZ71uLX9MpERpew0qN+UFiafws+jkTjx+3yF9yut0Hf9sMbeAYzzkGzRqJTUEBJ6B29Cql8M0yRXCNN/8wuuTHhG8esstozga4ZQoIVrq7mEAgup376PTcNfr1+imbbWVQ7lJdYIuDe6OS5V3OX6np11vgK/DbhfyzvQv9Z1zAGnM="
-        - REMOTE_URL=https://github.com/$TRAVIS_REPO_SLUG/releases/download/$TRAVIS_TAG
-    
-script:
-  - bash $TRAVIS_BUILD_DIR/tools/build.sh
+before_install:
+  - git submodule update --init --recursive
 
-deploy:
-  provider: script
-  skip_cleanup: true
-  script: bash $TRAVIS_BUILD_DIR/tools/deploy.sh -t$TRAVIS_TAG -a$ESP32_GITHUB_TOKEN -s$TRAVIS_REPO_SLUG -drelease
+stages:
+  - build
+  - deploy
 
-  on:
-    tags: true
+jobs:
+  include:
 
+    - name: "Build Arduino 0"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 0 10
+
+    - name: "Build Arduino 1"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 1 10
+
+    - name: "Build Arduino 2"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 2 10
+
+    - name: "Build Arduino 3"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 3 10
+
+    - name: "Build PlatformIO"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 1 1
 
 notifications:
   email:

CMakeLists.txt

@@ -78,66 +78,6 @@ set(LIBRARY_SRCS
   libraries/Wire/src/Wire.cpp
   )
 
-set(AZURE_SRCS
-  libraries/AzureIoT/src/az_iot/azureiotcerts.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/agenttime.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/dns_async.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/freertos/lock.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/freertos/threadapi.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/freertos/tickcounter.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/lwip/sntp_lwip.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/socket_async.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/src/platform_openssl_compact.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/src/tlsio_openssl_compact.c
-  libraries/AzureIoT/src/az_iot/c-utility/pal/tlsio_options.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/base64.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/buffer.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/connection_string_parser.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/consolelogger.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/constbuffer.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/constmap.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/crt_abstractions.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/doublylinkedlist.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/gballoc.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/gb_stdio.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/gb_time.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/hmac.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/hmacsha256.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/httpapiex.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/httpapiexsas.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/httpheaders.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/http_proxy_io.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/map.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/optionhandler.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/sastoken.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/sha1.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/sha224.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/sha384-512.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/singlylinkedlist.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/strings.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/string_tokenizer.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/urlencode.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/usha.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/vector.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/xio.c
-  libraries/AzureIoT/src/az_iot/c-utility/src/xlogging.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/blob.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client_authorization.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client_ll.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client_retry_control.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_message.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothubtransport.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothubtransportmqtt.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/iothubtransport_mqtt_common.c
-  libraries/AzureIoT/src/az_iot/iothub_client/src/version.c
-  libraries/AzureIoT/src/az_iot/umqtt/src/mqtt_client.c
-  libraries/AzureIoT/src/az_iot/umqtt/src/mqtt_codec.c
-  libraries/AzureIoT/src/az_iot/umqtt/src/mqtt_message.c
-  libraries/AzureIoT/src/AzureIotHub.cpp
-  libraries/AzureIoT/src/Esp32MQTTClient.cpp
-  )
-
 set(BLE_SRCS
   libraries/BLE/src/BLE2902.cpp
   libraries/BLE/src/BLE2904.cpp
@@ -170,14 +110,13 @@ set(BLE_SRCS
   libraries/BLE/src/GeneralUtils.cpp
   )
 
-set(COMPONENT_SRCS ${CORE_SRCS} ${LIBRARY_SRCS} ${AZURE_SRCS} ${BLE_SRCS})
+set(COMPONENT_SRCS ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 
 set(COMPONENT_ADD_INCLUDEDIRS
   variants/esp32/
   cores/esp32/
   libraries/ArduinoOTA/src
   libraries/AsyncUDP/src
-  libraries/AzureIoT/src
   libraries/BLE/src
   libraries/BluetoothSerial/src
   libraries/DNSServer/src
@@ -205,7 +144,7 @@ set(COMPONENT_ADD_INCLUDEDIRS
 
 set(COMPONENT_PRIV_INCLUDEDIRS cores/esp32/libb64)
 
-set(COMPONENT_REQUIRES spi_flash mbedtls mdns ethernet)
+set(COMPONENT_REQUIRES spi_flash mbedtls mdns esp_adc_cal)
 set(COMPONENT_PRIV_REQUIRES fatfs nvs_flash app_update spiffs bootloader_support openssl bt)
 
 register_component()

Kconfig.projbuild

@@ -232,6 +232,12 @@ config ARDUINO_SELECTIVE_ESPmDNS
     select ARDUINO_SELECTIVE_WiFi
     default y
 
+config ARDUINO_SELECTIVE_FFat
+    bool "Enable FFat"
+    depends on ARDUINO_SELECTIVE_COMPILATION
+    select ARDUINO_SELECTIVE_FS
+    default y
+
 config ARDUINO_SELECTIVE_FS
     bool "Enable FS"
     depends on ARDUINO_SELECTIVE_COMPILATION

README.md

@@ -1,4 +1,5 @@
-# Arduino core for ESP32 WiFi chip    [![Build Status](https://travis-ci.org/espressif/arduino-esp32.svg?branch=master)](https://travis-ci.org/espressif/arduino-esp32)
+# Arduino core for the ESP32
+[![Build Status](https://travis-ci.org/espressif/arduino-esp32.svg?branch=master)](https://travis-ci.org/espressif/arduino-esp32) ![](https://github.com/espressif/arduino-esp32/workflows/ESP32%20Arduino%20CI/badge.svg)
 
 ### Need help or have a question? Join the chat at [![https://gitter.im/espressif/arduino-esp32](https://badges.gitter.im/espressif/arduino-esp32.svg)](https://gitter.im/espressif/arduino-esp32?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
@@ -9,17 +10,12 @@
 - [Issue/Bug report template](#issuebug-report-template)
 - [ESP32Dev Board PINMAP](#esp32dev-board-pinmap)
 
-## Development Status
+### Development Status
 [Latest stable release ![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32.svg?style=plastic) ![Release Date](https://img.shields.io/github/release-date/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) ![Downloads](https://img.shields.io/github/downloads/espressif/arduino-esp32/latest/total.svg?style=plastic)
 
 [Latest development release ![Development Version](https://img.shields.io/github/release/espressif/arduino-esp32/all.svg?style=plastic) ![Development Date](https://img.shields.io/github/release-date-pre/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) ![Downloads](https://img.shields.io/github/downloads-pre/espressif/arduino-esp32/latest/total.svg?style=plastic)
 
-Most of the framework is implemented. Most noticable is the missing analogWrite. While analogWrite is on it's way, there are a few other options that you can use:
-- 16 channels [LEDC](cores/esp32/esp32-hal-ledc.h) which is PWM
-- 8 channels [SigmaDelta](cores/esp32/esp32-hal-sigmadelta.h) which uses SigmaDelta modulation
-- 2 channels [DAC](cores/esp32/esp32-hal-dac.h) which gives real analog output
-
-## Installation Instructions
+### Installation Instructions
 - Using Arduino IDE Boards Manager (preferred)
   + [Instructions for Boards Manager](docs/arduino-ide/boards_manager.md)
 - Using Arduino IDE with the development repository
@@ -33,20 +29,19 @@ Most of the framework is implemented. Most noticable is the missing analogWrite.
 - [Using as ESP-IDF component](docs/esp-idf_component.md)
 - [Using OTAWebUpdater](docs/OTAWebUpdate/OTAWebUpdate.md)
 
-#### Decoding exceptions
+### Decoding exceptions
 
 You can use [EspExceptionDecoder](https://github.com/me-no-dev/EspExceptionDecoder) to get meaningful call trace.
 
-#### Issue/Bug report template
+### Issue/Bug report template
 Before reporting an issue, make sure you've searched for similar one that was already created. Also make sure to go through all the issues labelled as [for reference](https://github.com/espressif/arduino-esp32/issues?utf8=%E2%9C%93&q=is%3Aissue%20label%3A%22for%20reference%22%20).
 
-Finally, if you're sure no one else had the issue, follow the [ISSUE_TEMPLATE](docs/ISSUE_TEMPLATE.md) while reporting any issue.
+Finally, if you are sure no one else had the issue, follow the [ISSUE_TEMPLATE](docs/ISSUE_TEMPLATE.md) while reporting any issue.
 
-
-## ESP32Dev Board PINMAP
+### ESP32Dev Board PINMAP
 
 ![Pin Functions](docs/esp32_pinmap.png)
 
-## Hint
+### Tip
 
 Sometimes to program ESP32 via serial you must keep GPIO0 LOW during the programming process

appveyor.yml

@@ -1,19 +0,0 @@
-build: off
-environment:
-
-  matrix:
-    - PLATFORMIO_CI_SRC: "libraries/WiFi/examples/WiFiClient"
-    - PLATFORMIO_CI_SRC: "libraries/WiFi/examples/WiFiClientBasic"
-    - PLATFORMIO_CI_SRC: "libraries/WiFi/examples/WiFiClientEvents"
-    - PLATFORMIO_CI_SRC: "libraries/WiFi/examples/WiFiIPv6"
-    - PLATFORMIO_CI_SRC: "libraries/WiFi/examples/WiFiScan"
-    - PLATFORMIO_CI_SRC: "libraries/WiFi/examples/WiFiSmartConfig"
-
-install:
-  - cmd: git submodule update --init --recursive
-  - cmd: SET PATH=%PATH%;C:\Python27\Scripts
-  - cmd: pip install -U https://github.com/platformio/platformio/archive/develop.zip
-  - cmd: platformio platform install https://github.com/platformio/platform-espressif32.git#feature/stage
-
-test_script:
-  - cmd: platformio ci -b esp32dev -b nano32 -b node32s

cores/esp32/Arduino.h

@@ -118,7 +118,9 @@ typedef unsigned int word;
 void setup(void);
 void loop(void);
 
+#ifdef __cplusplus
 long random(long, long);
+#endif
 void randomSeed(unsigned long);
 long map(long, long, long, long, long);
 

cores/esp32/Client.h

@@ -28,8 +28,6 @@ class Client: public Stream
 public:
     virtual int connect(IPAddress ip, uint16_t port) =0;
     virtual int connect(const char *host, uint16_t port) =0;
-    virtual int connect(IPAddress ip, uint16_t port, int timeout) =0;
-    virtual int connect(const char *host, uint16_t port, int timeout) =0;
     virtual size_t write(uint8_t) =0;
     virtual size_t write(const uint8_t *buf, size_t size) =0;
     virtual int available() = 0;

cores/esp32/Esp.cpp

@@ -19,7 +19,6 @@
 
 #include "Arduino.h"
 #include "Esp.h"
-#include "rom/spi_flash.h"
 #include "esp_sleep.h"
 #include "esp_spi_flash.h"
 #include <memory>
@@ -32,6 +31,17 @@ extern "C" {
 }
 #include <MD5Builder.h>
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/spi_flash.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/spi_flash.h"
+#endif
+
 /**
  * User-defined Literals
  *  usage:
@@ -92,13 +102,6 @@ void EspClass::deepSleep(uint32_t time_us)
     esp_deep_sleep(time_us);
 }
 
-uint32_t EspClass::getCycleCount()
-{
-    uint32_t ccount;
-    __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));
-    return ccount;
-}
-
 void EspClass::restart(void)
 {
     esp_restart();

cores/esp32/Esp.h

@@ -75,8 +75,8 @@ public:
     uint32_t getMaxAllocPsram();
 
     uint8_t getChipRevision();
-    uint8_t getCpuFreqMHz(){ return CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ; }
-    uint32_t getCycleCount();
+    uint32_t getCpuFreqMHz(){ return getCpuFrequencyMhz(); }
+    inline uint32_t getCycleCount() __attribute__((always_inline));
     const char * getSdkVersion();
 
     void deepSleep(uint32_t time_us);
@@ -101,6 +101,13 @@ public:
 
 };
 
+uint32_t IRAM_ATTR EspClass::getCycleCount()
+{
+    uint32_t ccount;
+    __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));
+    return ccount;
+}
+
 extern EspClass ESP;
 
 #endif //ESP_H

cores/esp32/HardwareSerial.cpp

@@ -55,6 +55,7 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
     _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
 
     if(!baud) {
+        uartStartDetectBaudrate(_uart);
         time_t startMillis = millis();
         unsigned long detectedBaudRate = 0;
         while(millis() - startMillis < timeout_ms && !(detectedBaudRate = uartDetectBaudrate(_uart))) {
@@ -130,11 +131,34 @@ int HardwareSerial::read(void)
     return -1;
 }
 
-void HardwareSerial::flush()
+// read characters into buffer
+// terminates if size characters have been read, or no further are pending
+// returns the number of characters placed in the buffer
+// the buffer is NOT null terminated.
+size_t HardwareSerial::read(uint8_t *buffer, size_t size)
+{
+    size_t avail = available();
+    if (size < avail) {
+        avail = size;
+    }
+    size_t count = 0;
+    while(count < avail) {
+        *buffer++ = uartRead(_uart);
+        count++;
+    }
+    return count;
+}
+
+void HardwareSerial::flush(void)
 {
     uartFlush(_uart);
 }
 
+void HardwareSerial::flush(bool txOnly)
+{
+    uartFlushTxOnly(_uart, txOnly);
+}
+
 size_t HardwareSerial::write(uint8_t c)
 {
     uartWrite(_uart, c);

cores/esp32/HardwareSerial.h

@@ -62,10 +62,19 @@ public:
     int availableForWrite(void);
     int peek(void);
     int read(void);
+    size_t read(uint8_t *buffer, size_t size);
+    inline size_t read(char * buffer, size_t size)
+    {
+        return read((uint8_t*) buffer, size);
+    }
     void flush(void);
+    void flush( bool txOnly);
     size_t write(uint8_t);
     size_t write(const uint8_t *buffer, size_t 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));
@@ -97,10 +106,12 @@ protected:
     uart_t* _uart;
 };
 
+extern void serialEventRun(void) __attribute__((weak));
+
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
 extern HardwareSerial Serial;
 extern HardwareSerial Serial1;
 extern HardwareSerial Serial2;
 #endif
 
-#endif
+#endif // HardwareSerial_h

cores/esp32/MD5Builder.h

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

cores/esp32/Print.cpp

@@ -52,19 +52,24 @@ size_t Print::printf(const char *format, ...)
     va_list copy;
     va_start(arg, format);
     va_copy(copy, arg);
-    size_t len = vsnprintf(NULL, 0, format, arg);
+    int len = vsnprintf(temp, sizeof(loc_buf), format, copy);
     va_end(copy);
+    if(len < 0) {
+        va_end(arg);
+        return 0;
+    };
     if(len >= sizeof(loc_buf)){
-        temp = new char[len+1];
+        temp = (char*) malloc(len+1);
         if(temp == NULL) {
+            va_end(arg);
             return 0;
         }
+        len = vsnprintf(temp, len+1, format, arg);
     }
-    len = vsnprintf(temp, len+1, format, arg);
-    write((uint8_t*)temp, len);
     va_end(arg);
-    if(len >= sizeof(loc_buf)){
-        delete[] temp;
+    len = write((uint8_t*)temp, len);
+    if(temp != loc_buf){
+        free(temp);
     }
     return len;
 }
@@ -154,8 +159,10 @@ size_t Print::print(struct tm * timeinfo, const char * format)
     }
     char buf[64];
     size_t written = strftime(buf, 64, f, timeinfo);
-    print(buf);
-    return written;
+    if(written == 0){
+        return written;
+    }
+    return print(buf);
 }
 
 size_t Print::println(void)

cores/esp32/WMath.cpp

@@ -65,9 +65,12 @@ long random(long howsmall, long howbig)
     return random(diff) + howsmall;
 }
 
-long map(long x, long in_min, long in_max, long out_min, long out_max)
-{
-    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+long map(long x, long in_min, long in_max, long out_min, long out_max) {
+    long divisor = (in_max - in_min);
+    if(divisor == 0){
+        return -1; //AVR returns -1, SAM returns 0
+    }
+    return (x - in_min) * (out_max - out_min) / divisor + out_min;
 }
 
 unsigned int makeWord(unsigned int w)

cores/esp32/WString.cpp

@@ -31,7 +31,7 @@
 
 String::String(const char *cstr) {
     init();
-    if(cstr)
+    if (cstr)
         copy(cstr, strlen(cstr));
 }
 
@@ -136,7 +136,7 @@ inline void String::init(void) {
 }
 
 void String::invalidate(void) {
-    if(!sso() && wbuffer())
+    if(!isSSO() && wbuffer())
         free(wbuffer());
     init();
 }
@@ -154,17 +154,21 @@ unsigned char String::reserve(unsigned int size) {
 
 unsigned char String::changeBuffer(unsigned int maxStrLen) {
     // Can we use SSO here to avoid allocation?
-    if (maxStrLen < sizeof(sso_buf)) {
-        if (sso() || !buffer()) {
+    if (maxStrLen < sizeof(sso.buff) - 1) {
+        if (isSSO() || !buffer()) {
             // Already using SSO, nothing to do
+	    uint16_t oldLen = len();
             setSSO(true);
+	    setLen(oldLen);
             return 1;
-        } else { // if bufptr && !sso()
-            // Using bufptr, need to shrink into sso_buff
-            char temp[sizeof(sso_buf)];
+        } else { // if bufptr && !isSSO()
+            // Using bufptr, need to shrink into sso.buff
+            char temp[sizeof(sso.buff)];
             memcpy(temp, buffer(), maxStrLen);
             free(wbuffer());
+            uint16_t oldLen = len();
             setSSO(true);
+	    setLen(oldLen);
             memcpy(wbuffer(), temp, maxStrLen);
             return 1;
         }
@@ -176,12 +180,12 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
         return false;
     }
     uint16_t oldLen = len();
-    char *newbuffer = (char *) realloc(sso() ? nullptr : wbuffer(), newSize);
-    if(newbuffer) {
+    char *newbuffer = (char *) realloc(isSSO() ? nullptr : wbuffer(), newSize);
+    if (newbuffer) {
         size_t oldSize = capacity() + 1; // include NULL.
-        if (sso()) {
+        if (isSSO()) {
             // Copy the SSO buffer into allocated space
-            memcpy(newbuffer, sso_buf, sizeof(sso_buf));
+            memmove(newbuffer, sso.buff, sizeof(sso.buff));
         }
         if (newSize > oldSize)
         {
@@ -206,7 +210,7 @@ String & String::copy(const char *cstr, unsigned int length) {
         return *this;
     }
     setLen(length);
-    strcpy(wbuffer(), cstr);
+    memmove(wbuffer(), cstr, length + 1);
     return *this;
 }
 
@@ -216,7 +220,7 @@ String & String::copy(const __FlashStringHelper *pstr, unsigned int length) {
         return *this;
     }
     setLen(length);
-    strcpy_P(wbuffer(), (PGM_P)pstr);
+    memcpy_P(wbuffer(), (PGM_P)pstr, length + 1); // We know wbuffer() cannot ever be in PROGMEM, so memcpy safe here
     return *this;
 }
 
@@ -224,20 +228,20 @@ String & String::copy(const __FlashStringHelper *pstr, unsigned int length) {
 void String::move(String &rhs) {
     if(buffer()) {
         if(capacity() >= rhs.len()) {
-            strcpy(wbuffer(), rhs.buffer());
+            memmove(wbuffer(), rhs.buffer(), rhs.length() + 1);
             setLen(rhs.len());
 	    rhs.invalidate();
             return;
         } else {
-            if (!sso()) {
+            if (!isSSO()) {
                 free(wbuffer());
                 setBuffer(nullptr);
             }
         }
     }
-    if (rhs.sso()) {
+    if (rhs.isSSO()) {
         setSSO(true);
-        memmove(sso_buf, rhs.sso_buf, sizeof(sso_buf));
+        memmove(sso.buff, rhs.sso.buff, sizeof(sso.buff));
     } else {
         setSSO(false);
         setBuffer(rhs.wbuffer());
@@ -309,7 +313,7 @@ unsigned char String::concat(const String &s) {
             return 1;
         if (!reserve(newlen))
             return 0;
-        memcpy(wbuffer() + len(), buffer(), len());
+        memmove(wbuffer() + len(), buffer(), len());
         setLen(newlen);
         wbuffer()[len()] = 0;
         return 1;
@@ -326,7 +330,12 @@ unsigned char String::concat(const char *cstr, unsigned int length) {
         return 1;
     if(!reserve(newlen))
         return 0;
-    strcpy(wbuffer() + len(), cstr);
+    if (cstr >= wbuffer() && cstr < wbuffer() + len())
+        // compatible with SSO in ram #6155 (case "x += x.c_str()")
+        memmove(wbuffer() + len(), cstr, length + 1);
+    else
+        // compatible with source in flash #6367
+        memcpy_P(wbuffer() + len(), cstr, length + 1);
     setLen(newlen);
     return 1;
 }
@@ -392,7 +401,7 @@ unsigned char String::concat(const __FlashStringHelper * str) {
     if (length == 0) return 1;
     unsigned int newlen = len() + length;
     if (!reserve(newlen)) return 0;
-    strcpy_P(wbuffer() + len(), (PGM_P)str);
+    memcpy_P(wbuffer() + len(), (PGM_P)str, length + 1);
     setLen(newlen);
     return 1;
 }

cores/esp32/WString.h

@@ -27,6 +27,7 @@
 #include <string.h>
 #include <ctype.h>
 #include <pgmspace.h>
+#include <stdint.h>
 
 // An inherited class for holding the result of a concatenation.  These
 // result objects are assumed to be writable by subsequent concatenations.
@@ -35,7 +36,8 @@ class StringSumHelper;
 // an abstract class used as a means to proide a unique pointer type
 // but really has no body
 class __FlashStringHelper;
-#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
+#define FPSTR(pstr_pointer) (reinterpret_cast<const __FlashStringHelper *>(pstr_pointer))
+#define F(string_literal) (FPSTR(PSTR(string_literal)))
 
 // The string class
 class String {
@@ -81,6 +83,12 @@ class String {
                 return 0;
             }
         }
+        inline void clear(void) {
+            setLen(0);
+        }
+        inline bool isEmpty(void) const {
+            return length() == 0;
+        }
 
         // creates a copy of the assigned value.  if the value is null or
         // invalid, or if the memory allocation fails, the string will be
@@ -97,7 +105,7 @@ class String {
 
         // returns true on success, false on failure (in which case, the string
         // is left unchanged).  if the argument is null or invalid, the
-        // concatenation is considered unsucessful.
+        // concatenation is considered unsuccessful.
         unsigned char concat(const String &str);
         unsigned char concat(const char *cstr);
         unsigned char concat(char c);
@@ -195,10 +203,22 @@ class String {
         unsigned char equalsIgnoreCase(const String &s) const;
         unsigned char equalsConstantTime(const String &s) const;
         unsigned char startsWith(const String &prefix) const;
+        unsigned char startsWith(const char *prefix) const {
+            return this->startsWith(String(prefix));
+        }
+        unsigned char startsWith(const __FlashStringHelper *prefix) const {
+            return this->startsWith(String(prefix));
+        }
         unsigned char startsWith(const String &prefix, unsigned int offset) const;
         unsigned char endsWith(const String &suffix) const;
+        unsigned char endsWith(const char *suffix) const {
+            return this->endsWith(String(suffix));
+        }
+        unsigned char endsWith(const __FlashStringHelper * suffix) const {
+            return this->endsWith(String(suffix));
+        }
 
-        // character acccess
+        // character access
         char charAt(unsigned int index) const;
         void setCharAt(unsigned int index, char c);
         char operator [](unsigned int index) const;
@@ -230,7 +250,22 @@ class String {
 
         // modification
         void replace(char find, char replace);
-        void replace(const String& find, const String& replace);
+        void replace(const String &find, const String &replace);
+        void replace(const char *find, const String &replace) {
+            this->replace(String(find), replace);
+        }
+        void replace(const __FlashStringHelper *find, const String &replace) {
+            this->replace(String(find), replace);
+        }
+        void replace(const char *find, const char *replace) {
+            this->replace(String(find), String(replace));
+        }
+        void replace(const __FlashStringHelper *find, const char *replace) {
+            this->replace(String(find), String(replace));
+        }
+        void replace(const __FlashStringHelper *find, const __FlashStringHelper *replace) {
+            this->replace(String(find), String(replace));
+        }
         void remove(unsigned int index);
         void remove(unsigned int index, unsigned int count);
         void toLowerCase(void);
@@ -249,27 +284,29 @@ class String {
             uint16_t cap;
             uint16_t len;
         };
-
-        // SSO is handled by checking the last byte of sso_buff.
-        // When not in SSO mode, that byte is set to 0xff, while when in SSO mode it is always 0x00 (so it can serve as the string terminator as well as a flag)
-        // This allows strings up up to 12 (11 + \0 termination) without any extra space.
-        enum { SSOSIZE = sizeof(struct _ptr) + 4 }; // Characters to allocate space for SSO, must be 12 or more
-        enum { CAPACITY_MAX = 65535 }; // If size of capacity changed, be sure to update this enum
+        // This allows strings up up to 11 (10 + \0 termination) without any extra space.
+        enum { SSOSIZE = sizeof(struct _ptr) + 4 - 1 }; // Characters to allocate space for SSO, must be 12 or more
+        struct _sso {
+            char     buff[SSOSIZE];
+            unsigned char len   : 7; // Ensure only one byte is allocated by GCC for the bitfields
+            unsigned char isSSO : 1;
+        } __attribute__((packed)); // Ensure that GCC doesn't expand the flag byte to a 32-bit word for alignment issues
+        enum { CAPACITY_MAX = 65535 }; // If typeof(cap) changed from uint16_t, be sure to update this enum to the max value storable in the type
         union {
             struct _ptr ptr;
-            char sso_buf[SSOSIZE];
+            struct _sso sso;
         };
         // Accessor functions
-        inline bool sso() const { return sso_buf[SSOSIZE - 1] == 0; }
-        inline unsigned int len() const { return sso() ? strlen(sso_buf) : ptr.len; }
-        inline unsigned int capacity() const { return sso() ? SSOSIZE - 1 : ptr.cap; }
-        inline void setSSO(bool sso) { sso_buf[SSOSIZE - 1] = sso ? 0x00 : 0xff; }
-        inline void setLen(int len) { if (!sso()) ptr.len = len; }
-        inline void setCapacity(int cap) { if (!sso()) ptr.cap = cap; }
-	inline void setBuffer(char *buff) { if (!sso()) ptr.buff = buff; }
+        inline bool isSSO() const { return sso.isSSO; }
+        inline unsigned int len() const { return isSSO() ? sso.len : ptr.len; }
+        inline unsigned int capacity() const { return isSSO() ? (unsigned int)SSOSIZE - 1 : ptr.cap; } // Size of max string not including terminal NUL
+        inline void setSSO(bool set) { sso.isSSO = set; }
+        inline void setLen(int len) { if (isSSO()) sso.len = len; else ptr.len = len; }
+        inline void setCapacity(int cap) { if (!isSSO()) ptr.cap = cap; }
+	inline void setBuffer(char *buff) { if (!isSSO()) ptr.buff = buff; }
         // Buffer accessor functions
-        inline const char *buffer() const { return (const char *)(sso() ? sso_buf : ptr.buff); }
-        inline char *wbuffer() const { return sso() ? const_cast<char *>(sso_buf) : ptr.buff; } // Writable version of buffer
+        inline const char *buffer() const { return (const char *)(isSSO() ? sso.buff : ptr.buff); }
+        inline char *wbuffer() const { return isSSO() ? const_cast<char *>(sso.buff) : ptr.buff; } // Writable version of buffer
 
     protected:
         void init(void);

cores/esp32/base64.cpp

@@ -31,11 +31,11 @@ extern "C" {
 
 /**
  * convert input data to base64
- * @param data uint8_t *
+ * @param data const uint8_t *
  * @param length size_t
  * @return String
  */
-String base64::encode(uint8_t * data, size_t length)
+String base64::encode(const uint8_t * data, size_t length)
 {
     size_t size = base64_encode_expected_len(length) + 1;
     char * buffer = (char *) malloc(size);
@@ -54,10 +54,10 @@ String base64::encode(uint8_t * data, size_t length)
 
 /**
  * convert input data to base64
- * @param text String
+ * @param text const String&
  * @return String
  */
-String base64::encode(String text)
+String base64::encode(const String& text)
 {
     return base64::encode((uint8_t *) text.c_str(), text.length());
 }

cores/esp32/base64.h

@@ -4,8 +4,8 @@
 class base64
 {
 public:
-    static String encode(uint8_t * data, size_t length);
-    static String encode(String text);
+    static String encode(const uint8_t * data, size_t length);
+    static String encode(const String& text);
 private:
 };
 

cores/esp32/esp32-hal-adc.c

@@ -15,21 +15,34 @@
 #include "esp32-hal-adc.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "rom/ets_sys.h"
 #include "esp_attr.h"
-#include "esp_intr.h"
 #include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
 
+#include "driver/adc.h"
+#include "esp_adc_cal.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"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/ets_sys.h"
+#include "esp_intr.h"
+#endif
+
+#define 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 __analogCycles = 8;
-static uint8_t __analogSamples = 0;//1 sample
 static uint8_t __analogClockDiv = 1;
-
-// Width of returned answer ()
-static uint8_t __analogReturnedWidth = 12;
+static uint16_t __analogVRef = 0;
+static uint8_t __analogVRefPin = 0;
 
 void __analogSetWidth(uint8_t bits){
     if(bits < 9){
@@ -37,81 +50,31 @@ void __analogSetWidth(uint8_t bits){
     } else if(bits > 12){
         bits = 12;
     }
-    __analogReturnedWidth = bits;
     __analogWidth = bits - 9;
-    SET_PERI_REG_BITS(SENS_SAR_START_FORCE_REG, SENS_SAR1_BIT_WIDTH, __analogWidth, SENS_SAR1_BIT_WIDTH_S);
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_SAMPLE_BIT, __analogWidth, SENS_SAR1_SAMPLE_BIT_S);
-
-    SET_PERI_REG_BITS(SENS_SAR_START_FORCE_REG, SENS_SAR2_BIT_WIDTH, __analogWidth, SENS_SAR2_BIT_WIDTH_S);
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_SAMPLE_BIT, __analogWidth, SENS_SAR2_SAMPLE_BIT_S);
-}
-
-void __analogSetCycles(uint8_t cycles){
-    __analogCycles = cycles;
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_SAMPLE_CYCLE, __analogCycles, SENS_SAR1_SAMPLE_CYCLE_S);
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_SAMPLE_CYCLE, __analogCycles, SENS_SAR2_SAMPLE_CYCLE_S);
-}
-
-void __analogSetSamples(uint8_t samples){
-    if(!samples){
-        return;
-    }
-    __analogSamples = samples - 1;
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_SAMPLE_NUM, __analogSamples, SENS_SAR1_SAMPLE_NUM_S);
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_SAMPLE_NUM, __analogSamples, SENS_SAR2_SAMPLE_NUM_S);
+    adc1_config_width(__analogWidth);
 }
 
 void __analogSetClockDiv(uint8_t clockDiv){
     if(!clockDiv){
-        return;
+        clockDiv = 1;
     }
     __analogClockDiv = clockDiv;
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL_REG, SENS_SAR1_CLK_DIV, __analogClockDiv, SENS_SAR1_CLK_DIV_S);
-    SET_PERI_REG_BITS(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_CLK_DIV, __analogClockDiv, SENS_SAR2_CLK_DIV_S);
+    adc_set_clk_div(__analogClockDiv);
 }
 
 void __analogSetAttenuation(adc_attenuation_t attenuation)
 {
     __analogAttenuation = attenuation & 3;
-    uint32_t att_data = 0;
-    int i = 10;
-    while(i--){
-        att_data |= __analogAttenuation << (i * 2);
-    }
-    WRITE_PERI_REG(SENS_SAR_ATTEN1_REG, att_data & 0xFFFF);//ADC1 has 8 channels
-    WRITE_PERI_REG(SENS_SAR_ATTEN2_REG, att_data);
 }
 
-void IRAM_ATTR __analogInit(){
+void __analogInit(){
     static bool initialized = false;
     if(initialized){
         return;
     }
-
-    __analogSetAttenuation(__analogAttenuation);
-    __analogSetCycles(__analogCycles);
-    __analogSetSamples(__analogSamples + 1);//in samples
+    initialized = true;
     __analogSetClockDiv(__analogClockDiv);
     __analogSetWidth(__analogWidth + 9);//in bits
-
-    SET_PERI_REG_MASK(SENS_SAR_READ_CTRL_REG, SENS_SAR1_DATA_INV);
-    SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
-
-    SET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_START_FORCE_M); //SAR ADC1 controller (in RTC) is started by SW
-    SET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_SAR1_EN_PAD_FORCE_M); //SAR ADC1 pad enable bitmap is controlled by SW
-    SET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_START_FORCE_M); //SAR ADC2 controller (in RTC) is started by SW
-    SET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_SAR2_EN_PAD_FORCE_M); //SAR ADC2 pad enable bitmap is controlled by SW
-
-    CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_WAIT2_REG, SENS_FORCE_XPD_SAR_M); //force XPD_SAR=0, use XPD_FSM
-    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT2_REG, SENS_FORCE_XPD_AMP, 0x2, SENS_FORCE_XPD_AMP_S); //force XPD_AMP=0
-
-    CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_CTRL_REG, 0xfff << SENS_AMP_RST_FB_FSM_S);  //clear FSM
-    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT1_REG, SENS_SAR_AMP_WAIT1, 0x1, SENS_SAR_AMP_WAIT1_S);
-    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT1_REG, SENS_SAR_AMP_WAIT2, 0x1, SENS_SAR_AMP_WAIT2_S);
-    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT2_REG, SENS_SAR_AMP_WAIT3, 0x1, SENS_SAR_AMP_WAIT3_S);
-    while (GET_PERI_REG_BITS2(SENS_SAR_SLAVE_ADDR1_REG, 0x7, SENS_MEAS_STATUS_S) != 0); //wait det_fsm==
-
-    initialized = true;
 }
 
 void __analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation)
@@ -120,21 +83,20 @@ void __analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation)
     if(channel < 0 || attenuation > 3){
         return ;
     }
-    __analogInit();
-    if(channel > 7){
-        SET_PERI_REG_BITS(SENS_SAR_ATTEN2_REG, 3, attenuation, ((channel - 10) * 2));
+    if(channel > 9){
+        adc2_config_channel_atten(channel - 10, attenuation);
     } else {
-        SET_PERI_REG_BITS(SENS_SAR_ATTEN1_REG, 3, attenuation, (channel * 2));
+        adc1_config_channel_atten(channel, attenuation);
     }
+    __analogInit();
 }
 
-bool IRAM_ATTR __adcAttachPin(uint8_t pin){
-
+bool __adcAttachPin(uint8_t pin){
     int8_t channel = digitalPinToAnalogChannel(pin);
     if(channel < 0){
-        return false;//not adc pin
+        log_e("Pin %u is not ADC pin!", pin);
+        return false;
     }
-
     int8_t pad = digitalPinToTouchChannel(pin);
     if(pad >= 0){
         uint32_t touch = READ_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG);
@@ -151,86 +113,103 @@ bool IRAM_ATTR __adcAttachPin(uint8_t pin){
     }
 
     pinMode(pin, ANALOG);
-
-    __analogInit();
+    __analogSetPinAttenuation(pin, __analogAttenuation);
     return true;
 }
 
-bool IRAM_ATTR __adcStart(uint8_t pin){
-
-    int8_t channel = digitalPinToAnalogChannel(pin);
-    if(channel < 0){
-        return false;//not adc pin
-    }
-
-    if(channel > 9){
-        channel -= 10;
-        CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_START_SAR_M);
-        SET_PERI_REG_BITS(SENS_SAR_MEAS_START2_REG, SENS_SAR2_EN_PAD, (1 << channel), SENS_SAR2_EN_PAD_S);
-        SET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_START_SAR_M);
-    } else {
-        CLEAR_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_START_SAR_M);
-        SET_PERI_REG_BITS(SENS_SAR_MEAS_START1_REG, SENS_SAR1_EN_PAD, (1 << channel), SENS_SAR1_EN_PAD_S);
-        SET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_START_SAR_M);
-    }
-    return true;
-}
-
-bool IRAM_ATTR __adcBusy(uint8_t pin){
-
-    int8_t channel = digitalPinToAnalogChannel(pin);
-    if(channel < 0){
-        return false;//not adc pin
-    }
-
-    if(channel > 7){
-        return (GET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_DONE_SAR) == 0);
-    }
-    return (GET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_DONE_SAR) == 0);
-}
-
-uint16_t IRAM_ATTR __adcEnd(uint8_t pin)
-{
-
-    uint16_t value = 0;
-    int8_t channel = digitalPinToAnalogChannel(pin);
-    if(channel < 0){
-        return 0;//not adc pin
-    }
-    if(channel > 7){
-        while (GET_PERI_REG_MASK(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_DONE_SAR) == 0); //wait for conversion
-        value = GET_PERI_REG_BITS2(SENS_SAR_MEAS_START2_REG, SENS_MEAS2_DATA_SAR, SENS_MEAS2_DATA_SAR_S);
-    } else {
-        while (GET_PERI_REG_MASK(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_DONE_SAR) == 0); //wait for conversion
-        value = GET_PERI_REG_BITS2(SENS_SAR_MEAS_START1_REG, SENS_MEAS1_DATA_SAR, SENS_MEAS1_DATA_SAR_S);
-    }
-
-    // Shift result if necessary
-    uint8_t from = __analogWidth + 9;
-    if (from == __analogReturnedWidth) {
-        return value;
-    }
-    if (from > __analogReturnedWidth) {
-        return value >> (from - __analogReturnedWidth);
-    }
-    return value << (__analogReturnedWidth - from);
-}
-
-uint16_t IRAM_ATTR __analogRead(uint8_t pin)
-{
-    if(!__adcAttachPin(pin) || !__adcStart(pin)){
-        return 0;
-    }
-    return __adcEnd(pin);
-}
-
 void __analogReadResolution(uint8_t bits)
 {
     if(!bits || bits > 16){
         return;
     }
     __analogSetWidth(bits);         // hadware from 9 to 12
-    __analogReturnedWidth = bits;   // software from 1 to 16
+}
+
+uint16_t __analogRead(uint8_t pin)
+{
+    int8_t channel = digitalPinToAnalogChannel(pin);
+    int value = 0;
+    esp_err_t r = ESP_OK;
+    if(channel < 0){
+        log_e("Pin %u is not ADC pin!", pin);
+        return value;
+    }
+    __adcAttachPin(pin);
+    if(channel > 9){
+        channel -= 10;
+        r = adc2_get_raw( channel, __analogWidth, &value);
+        if ( r == ESP_OK ) {
+            return value;
+        } else if ( r == ESP_ERR_INVALID_STATE ) {
+            log_e("GPIO%u: %s: ADC2 not initialized yet.", pin, esp_err_to_name(r));
+        } else if ( r == ESP_ERR_TIMEOUT ) {
+            log_e("GPIO%u: %s: ADC2 is in use by Wi-Fi.", pin, esp_err_to_name(r));
+        } else {
+            log_e("GPIO%u: %s", pin, esp_err_to_name(r));
+        }
+    } else {
+        return adc1_get_raw(channel);
+    }
+    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(!__analogVRef){
+        if (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_TP) == ESP_OK) {
+            log_d("eFuse Two Point: Supported");
+            __analogVRef = DEFAULT_VREF;
+        }
+        if (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_VREF) == ESP_OK) {
+            log_d("eFuse Vref: Supported");
+            __analogVRef = DEFAULT_VREF;
+        }
+        if(!__analogVRef){
+            __analogVRef = DEFAULT_VREF;
+            if(__analogVRefPin){
+                esp_adc_cal_characteristics_t chars;
+                if(adc2_vref_to_gpio(__analogVRefPin) == ESP_OK){
+                    __analogVRef = __analogRead(__analogVRefPin);
+                    esp_adc_cal_characterize(1, __analogAttenuation, __analogWidth, DEFAULT_VREF, &chars);
+                    __analogVRef = esp_adc_cal_raw_to_voltage(__analogVRef, &chars);
+                    log_d("Vref to GPIO%u: %u", __analogVRefPin, __analogVRef);
+                }
+            }
+        }
+    }
+    uint8_t unit = 1;
+    if(channel > 9){
+        unit = 2;
+    }
+    uint16_t adc_reading = __analogRead(pin);
+    if(__analogCharacteristics[unit - 1] == NULL){
+        __analogCharacteristics[unit - 1] = calloc(1, sizeof(esp_adc_cal_characteristics_t));
+        if(__analogCharacteristics[unit - 1] == NULL){
+            return 0;
+        }
+        esp_adc_cal_value_t val_type = esp_adc_cal_characterize(unit, __analogAttenuation, __analogWidth, __analogVRef, __analogCharacteristics[unit - 1]);
+        if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) {
+            log_i("ADC%u: Characterized using Two Point Value: %u\n", unit, __analogCharacteristics[unit - 1]->vref);
+        } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
+            log_i("ADC%u: Characterized using eFuse Vref: %u\n", unit, __analogCharacteristics[unit - 1]->vref);
+        } else if(__analogVRef != DEFAULT_VREF){
+            log_i("ADC%u: Characterized using Vref to GPIO%u: %u\n", unit, __analogVRefPin, __analogCharacteristics[unit - 1]->vref);
+        } else {
+            log_i("ADC%u: Characterized using Default Vref: %u\n", unit, __analogCharacteristics[unit - 1]->vref);
+        }
+    }
+    return esp_adc_cal_raw_to_voltage(adc_reading, __analogCharacteristics[unit - 1]);
 }
 
 int __hallRead()    //hall sensor without LNA
@@ -260,14 +239,12 @@ int __hallRead()    //hall sensor without LNA
 extern uint16_t analogRead(uint8_t pin) __attribute__ ((weak, alias("__analogRead")));
 extern void analogReadResolution(uint8_t bits) __attribute__ ((weak, alias("__analogReadResolution")));
 extern void analogSetWidth(uint8_t bits) __attribute__ ((weak, alias("__analogSetWidth")));
-extern void analogSetCycles(uint8_t cycles) __attribute__ ((weak, alias("__analogSetCycles")));
-extern void analogSetSamples(uint8_t samples) __attribute__ ((weak, alias("__analogSetSamples")));
 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")));
-extern bool adcStart(uint8_t pin) __attribute__ ((weak, alias("__adcStart")));
-extern bool adcBusy(uint8_t pin) __attribute__ ((weak, alias("__adcBusy")));
-extern uint16_t adcEnd(uint8_t pin) __attribute__ ((weak, alias("__adcEnd")));
+
+extern void analogSetVRefPin(uint8_t pin) __attribute__ ((weak, alias("__analogSetVRefPin")));
+extern uint32_t analogReadMilliVolts(uint8_t pin) __attribute__ ((weak, alias("__analogReadMilliVolts")));

cores/esp32/esp32-hal-adc.h

@@ -54,24 +54,6 @@ void analogReadResolution(uint8_t bits);
  * */
 void analogSetWidth(uint8_t bits);
 
-/*
- * Set number of cycles per sample
- * Default is 8 and seems to do well
- * Range is 1 - 255
- * */
-void analogSetCycles(uint8_t cycles);
-
-/*
- * Set number of samples in the range.
- * Default is 1
- * Range is 1 - 255
- * This setting splits the range into
- * "samples" pieces, which could look
- * like the sensitivity has been multiplied
- * that many times
- * */
-void analogSetSamples(uint8_t samples);
-
 /*
  * Set the divider for the ADC clock.
  * Default is 1
@@ -97,34 +79,20 @@ void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation);
  * */
 int hallRead();
 
-/*
- * Non-Blocking API (almost)
- *
- * Note: ADC conversion can run only for single pin at a time.
- *       That means that if you want to run ADC on two pins on the same bus,
- *       you need to run them one after another. Probably the best use would be
- *       to start conversion on both buses in parallel.
- * */
-
 /*
  * Attach pin to ADC (will also clear any other analog mode that could be on)
  * */
 bool adcAttachPin(uint8_t pin);
 
 /*
- * Start ADC conversion on attached pin's bus
+ * Set pin to use for ADC calibration if the esp is not already calibrated (25, 26 or 27)
  * */
-bool adcStart(uint8_t pin);
+void analogSetVRefPin(uint8_t pin);
 
 /*
- * Check if conversion on the pin's ADC bus is currently running
+ * Get MilliVolts value for pin
  * */
-bool adcBusy(uint8_t pin);
-
-/*
- * Get the result of the conversion (will wait if it have not finished)
- * */
-uint16_t adcEnd(uint8_t pin);
+uint32_t analogReadMilliVolts(uint8_t pin);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-bt.c

@@ -65,6 +65,14 @@ bool btStop(){
         while(esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_ENABLED);
     }
     if(esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_INITED){
+        if (esp_bt_controller_deinit()) {
+			log_e("BT deint failed");
+			return false;
+		}
+		vTaskDelay(1);
+		if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_IDLE) {			
+			return false;		
+		}
         return true;
     }
     log_e("BT Stop failed");

cores/esp32/esp32-hal-cpu.c

@@ -21,12 +21,24 @@
 #include "esp_log.h"
 #include "soc/rtc.h"
 #include "soc/rtc_cntl_reg.h"
-#include "rom/rtc.h"
 #include "soc/apb_ctrl_reg.h"
+#include "soc/efuse_reg.h"
 #include "esp32-hal.h"
 #include "esp32-hal-cpu.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/rtc.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/rtc.h"
+#endif
+
 typedef struct apb_change_cb_s {
+        struct apb_change_cb_s * prev;
         struct apb_change_cb_s * next;
         void * arg;
         apb_change_cb_t cb;
@@ -52,9 +64,19 @@ static void triggerApbChangeCallback(apb_change_ev_t ev_type, uint32_t old_apb,
     initApbChangeCallback();
     xSemaphoreTake(apb_change_lock, portMAX_DELAY);
     apb_change_t * r = apb_change_callbacks;
-    while(r != NULL){
-        r->cb(r->arg, ev_type, old_apb, new_apb);
-        r=r->next;
+    if( r != NULL ){
+        if(ev_type == APB_BEFORE_CHANGE )
+            while(r != NULL){
+                r->cb(r->arg, ev_type, old_apb, new_apb);
+                r=r->next;
+            }
+        else { // run backwards through chain
+            while(r->next != NULL) r = r->next; // find first added
+            while( r != NULL){
+                r->cb(r->arg, ev_type, old_apb, new_apb);
+                r=r->prev;
+            }
+        }
     }
     xSemaphoreGive(apb_change_lock);
 }
@@ -67,6 +89,7 @@ bool addApbChangeCallback(void * arg, apb_change_cb_t cb){
         return false;
     }
     c->next = NULL;
+    c->prev = NULL;
     c->arg = arg;
     c->cb = cb;
     xSemaphoreTake(apb_change_lock, portMAX_DELAY);
@@ -74,18 +97,20 @@ bool addApbChangeCallback(void * arg, apb_change_cb_t cb){
         apb_change_callbacks = c;
     } else {
         apb_change_t * r = apb_change_callbacks;
-        if(r->cb != cb || r->arg != arg){
-            while(r->next){
-                r = r->next;
-                if(r->cb == cb && r->arg == arg){
-                    free(c);
-                    goto unlock_and_exit;
-                }
-            }
-            r->next = c;
+        // look for duplicate callbacks
+        while( (r != NULL ) && !((r->cb == cb) && ( r->arg == arg))) r = r->next;
+        if (r) {
+            log_e("duplicate func=%08X arg=%08X",c->cb,c->arg);
+            free(c);
+            xSemaphoreGive(apb_change_lock);
+            return false;
+        }
+        else {
+            c->next = apb_change_callbacks;
+            apb_change_callbacks-> prev = c;
+            apb_change_callbacks = c;
         }
     }
-unlock_and_exit:
     xSemaphoreGive(apb_change_lock);
     return true;
 }
@@ -94,24 +119,21 @@ bool removeApbChangeCallback(void * arg, apb_change_cb_t cb){
     initApbChangeCallback();
     xSemaphoreTake(apb_change_lock, portMAX_DELAY);
     apb_change_t * r = apb_change_callbacks;
-    if(r == NULL){
+    // look for matching callback
+    while( (r != NULL ) && !((r->cb == cb) && ( r->arg == arg))) r = r->next;
+    if ( r == NULL ) {
+        log_e("not found func=%08X arg=%08X",cb,arg);
         xSemaphoreGive(apb_change_lock);
         return false;
-    }
-    if(r->cb == cb && r->arg == arg){
-        apb_change_callbacks = r->next;
+        }
+    else {
+        // patch links
+        if(r->prev) r->prev->next = r->next;
+        else { // this is first link
+           apb_change_callbacks = r->next;
+        }
+        if(r->next) r->next->prev = r->prev;
         free(r);
-    } else {
-        while(r->next && (r->next->cb != cb || r->next->arg != arg)){
-            r = r->next;
-        }
-        if(r->next == NULL || r->next->cb != cb || r->next->arg != arg){
-            xSemaphoreGive(apb_change_lock);
-            return false;
-        }
-        apb_change_t * c = r->next;
-        r->next = c->next;
-        free(c);
     }
     xSemaphoreGive(apb_change_lock);
     return true;
@@ -150,6 +172,15 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
         }
         return false;
     }
+    //check if cpu supports the frequency
+    if(cpu_freq_mhz == 240){
+        //Check if ESP32 is rated for a CPU frequency of 160MHz only
+        if (REG_GET_BIT(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_CPU_FREQ_RATED) &&
+            REG_GET_BIT(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_CPU_FREQ_LOW)) {
+            log_e("Can not switch to 240 MHz! Chip CPU frequency rated for 160MHz.");
+            cpu_freq_mhz = 160;
+        }
+    }
     //Get current CPU clock configuration
     rtc_clk_cpu_freq_get_config(&cconf);
     //return if frequency has not changed
@@ -176,7 +207,7 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
         //Update REF_TICK (uncomment if REF_TICK is different than 1MHz)
         //if(conf.freq_mhz < 80){
         //    ESP_REG(APB_CTRL_XTAL_TICK_CONF_REG) = conf.freq_mhz / (REF_CLK_FREQ / MHZ) - 1;
-        //}
+        // }
         //Update APB Freq REG
         rtc_clk_apb_freq_update(apb);
         //Update esp_timer divisor

cores/esp32/esp32-hal-dac.c

@@ -15,13 +15,24 @@
 #include "esp32-hal-dac.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "rom/ets_sys.h"
 #include "esp_attr.h"
-#include "esp_intr.h"
 #include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/ets_sys.h"
+#include "esp_intr_alloc.h"
+#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 IRAM_ATTR __dacWrite(uint8_t pin, uint8_t value)
 {
     if(pin < 25 || pin > 26){

cores/esp32/esp32-hal-gpio.c

@@ -15,15 +15,27 @@
 #include "esp32-hal-gpio.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "rom/ets_sys.h"
 #include "esp_attr.h"
-#include "esp_intr.h"
-#include "rom/gpio.h"
 #include "soc/gpio_reg.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_struct.h"
 #include "soc/rtc_io_reg.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/ets_sys.h"
+#include "esp32/rom/gpio.h"
+#include "esp_intr_alloc.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/ets_sys.h"
+#include "rom/gpio.h"
+#include "esp_intr.h"
+#endif
+
 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};
 
 const DRAM_ATTR esp32_gpioMux_t esp32_gpioMux[GPIO_PIN_COUNT]={
@@ -59,8 +71,8 @@ const DRAM_ATTR esp32_gpioMux_t esp32_gpioMux[GPIO_PIN_COUNT]={
     {0, -1, -1, -1},
     {0, -1, -1, -1},
     {0, -1, -1, -1},
-    {0x1c, 9, 4, 9},
-    {0x20, 8, 5, 8},
+    {0x1c, 9, 4, 8},
+    {0x20, 8, 5, 9},
     {0x14, 4, 6, -1},
     {0x18, 5, 7, -1},
     {0x04, 0, 0, -1},

cores/esp32/esp32-hal-i2c.c

@@ -18,13 +18,25 @@
 #include "freertos/task.h"
 #include "freertos/semphr.h"
 #include "freertos/event_groups.h"
-#include "rom/ets_sys.h"
 #include "driver/periph_ctrl.h"
 #include "soc/i2c_reg.h"
 #include "soc/i2c_struct.h"
 #include "soc/dport_reg.h"
 #include "esp_attr.h"
 #include "esp32-hal-cpu.h" // cpu clock change support 31DEC2018
+
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/ets_sys.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/ets_sys.h"
+#endif
+
+
 //#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))
@@ -1270,7 +1282,7 @@ i2c_err_t i2cProcQueue(i2c_t * i2c, uint32_t *readCount, uint16_t timeOutMillis)
 
     i2c->dev->ctr.trans_start=1; // go for it
 
-#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
+#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
     portTickType tBefore=xTaskGetTickCount();
 #endif
     
@@ -1278,7 +1290,7 @@ i2c_err_t i2cProcQueue(i2c_t * i2c, uint32_t *readCount, uint16_t timeOutMillis)
     
     uint32_t eBits = xEventGroupWaitBits(i2c->i2c_event,EVENT_DONE,pdFALSE,pdTRUE,ticksTimeOut);
 
-#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
+#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
     portTickType tAfter=xTaskGetTickCount();
 #endif
 

cores/esp32/esp32-hal-ledc.c

@@ -16,19 +16,29 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
-#include "rom/ets_sys.h"
 #include "esp32-hal-matrix.h"
 #include "soc/dport_reg.h"
 #include "soc/ledc_reg.h"
 #include "soc/ledc_struct.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/ets_sys.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/ets_sys.h"
+#endif
+
 #if CONFIG_DISABLE_HAL_LOCKS
 #define LEDC_MUTEX_LOCK()
 #define LEDC_MUTEX_UNLOCK()
 #else
 #define LEDC_MUTEX_LOCK()    do {} while (xSemaphoreTake(_ledc_sys_lock, portMAX_DELAY) != pdPASS)
 #define LEDC_MUTEX_UNLOCK()  xSemaphoreGive(_ledc_sys_lock)
-xSemaphoreHandle _ledc_sys_lock;
+xSemaphoreHandle _ledc_sys_lock = NULL;
 #endif
 
 /*
@@ -55,27 +65,35 @@ xSemaphoreHandle _ledc_sys_lock;
 
 static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb){
     if(ev_type == APB_AFTER_CHANGE && old_apb != new_apb){
-        uint32_t iarg = (uint32_t)arg;
-        uint8_t chan = iarg;
-        uint8_t group=(chan/8), timer=((chan/2)%4);
+        uint16_t iarg = *(uint16_t*)arg;
+        uint8_t chan = 0;
         old_apb /= 1000000;
         new_apb /= 1000000;
-        if(LEDC_TIMER(group, timer).conf.tick_sel){
-            LEDC_MUTEX_LOCK();
-            uint32_t old_div = LEDC_TIMER(group, timer).conf.clock_divider;
-            uint32_t div_num = (new_apb * old_div) / old_apb;
-            if(div_num > LEDC_DIV_NUM_HSTIMER0_V){
-                new_apb = REF_CLK_FREQ / 1000000;
-                div_num = (new_apb * old_div) / old_apb;
-                if(div_num > LEDC_DIV_NUM_HSTIMER0_V) {
-                    div_num = LEDC_DIV_NUM_HSTIMER0_V;//lowest clock possible
+        while(iarg){ // run though all active channels, adjusting timing configurations
+            if(iarg & 1) {// this channel is active
+                uint8_t group=(chan/8), timer=((chan/2)%4);
+                if(LEDC_TIMER(group, timer).conf.tick_sel){
+                    LEDC_MUTEX_LOCK();
+                    uint32_t old_div = LEDC_TIMER(group, timer).conf.clock_divider;
+                    uint32_t div_num = (new_apb * old_div) / old_apb;
+                    if(div_num > LEDC_DIV_NUM_HSTIMER0_V){
+                        div_num = ((REF_CLK_FREQ /1000000) * old_div) / old_apb;
+                        if(div_num > LEDC_DIV_NUM_HSTIMER0_V) {
+                            div_num = LEDC_DIV_NUM_HSTIMER0_V;//lowest clock possible
+                        }
+                        LEDC_TIMER(group, timer).conf.tick_sel = 0;
+                    } else if(div_num < 256) {
+                        div_num = 256;//highest clock possible
+                    }
+                    LEDC_TIMER(group, timer).conf.clock_divider = div_num;
+                    LEDC_MUTEX_UNLOCK();
+                }
+                else {
+                    log_d("using REF_CLK chan=%d",chan);
                 }
-                LEDC_TIMER(group, timer).conf.tick_sel = 0;
-            } else if(div_num < 256) {
-                div_num = 256;//highest clock possible
             }
-            LEDC_TIMER(group, timer).conf.clock_divider = div_num;
-            LEDC_MUTEX_UNLOCK();
+            iarg = iarg >> 1;
+            chan++;
         }
     }
 }
@@ -85,11 +103,14 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
 {
     uint8_t group=(chan/8), timer=((chan/2)%4);
     static bool tHasStarted = false;
+    static uint16_t _activeChannels = 0;
     if(!tHasStarted) {
         tHasStarted = true;
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_LEDC_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_LEDC_RST);
         LEDC.conf.apb_clk_sel = 1;//LS use apb clock
+        addApbChangeCallback((void*)&_activeChannels, _on_apb_change);
+
 #if !CONFIG_DISABLE_HAL_LOCKS
         _ledc_sys_lock = xSemaphoreCreateMutex();
 #endif
@@ -105,8 +126,7 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
     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;
     LEDC_MUTEX_UNLOCK();
-    uint32_t iarg = chan;
-    addApbChangeCallback((void*)iarg, _on_apb_change);
+    _activeChannels |= (1 << chan); // mark as active for APB callback
 }
 
 //max div_num 0x3FFFF (262143)

cores/esp32/esp32-hal-matrix.c

@@ -14,7 +14,17 @@
 
 #include "esp32-hal-matrix.h"
 #include "esp_attr.h"
+
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/gpio.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
 #include "rom/gpio.h"
+#endif
 
 #define MATRIX_DETACH_OUT_SIG 0x100
 #define MATRIX_DETACH_IN_LOW_PIN 0x30

cores/esp32/esp32-hal-misc.c

@@ -31,10 +31,20 @@
 #include "soc/rtc.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/apb_ctrl_reg.h"
-#include "rom/rtc.h"
 #include "esp_task_wdt.h"
 #include "esp32-hal.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/rtc.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/rtc.h"
+#endif
+
 //Undocumented!!! Get chip temperature in Farenheit
 //Source: https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_int_temp_sensor/ESP32_int_temp_sensor.ino
 uint8_t temprature_sens_read();
@@ -44,11 +54,13 @@ float temperatureRead()
     return (temprature_sens_read() - 32) / 1.8;
 }
 
-void yield()
+void __yield()
 {
     vPortYield();
 }
 
+void yield() __attribute__ ((weak, alias("__yield")));
+
 #if CONFIG_AUTOSTART_ARDUINO
 
 extern TaskHandle_t loopTaskHandle;

cores/esp32/esp32-hal-psram.c

@@ -1,11 +1,34 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include "esp32-hal.h"
 
 #if CONFIG_SPIRAM_SUPPORT
-#include "esp_spiram.h"
 #include "soc/efuse_reg.h"
 #include "esp_heap_caps.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/spiram.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "esp_spiram.h"
+#endif
+
 static volatile bool spiramDetected = false;
 static volatile bool spiramFailed = false;
 

cores/esp32/esp32-hal-rmt.c

@@ -128,7 +128,7 @@ static xSemaphoreHandle g_rmt_block_lock = NULL;
  */
 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);
+static bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous);
 
 static void IRAM_ATTR _rmt_isr(void* arg);
 
@@ -234,6 +234,20 @@ bool rmtDeinit(rmt_obj_t *rmt)
     return true;
 }
 
+bool rmtLoop(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
+{
+    if (!rmt) {
+        return false;
+    }
+
+    int allocated_size = MAX_DATA_PER_CHANNEL * rmt->buffers;
+
+    if (size > allocated_size) {
+        return false;
+    }
+    return _rmtSendOnce(rmt, data, size, true);
+}
+
 bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
 {
     if (!rmt) {
@@ -282,10 +296,10 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         RMT_MUTEX_UNLOCK(channel);
 
         // start the transation
-        return _rmtSendOnce(rmt, data, MAX_DATA_PER_ITTERATION);
+        return _rmtSendOnce(rmt, data, MAX_DATA_PER_ITTERATION, false);
     } else {
         // use one-go mode if data fits one buffer 
-        return _rmtSendOnce(rmt, data, size);
+        return _rmtSendOnce(rmt, data, size, false);
     }
 }
 
@@ -483,7 +497,7 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
             break;
         }
     }
-    if (i == MAX_CHANNELS || i+j >= MAX_CHANNELS || j != buffers)  {
+    if (i == MAX_CHANNELS || i+j > MAX_CHANNELS || j != buffers)  {
         xSemaphoreGive(g_rmt_block_lock);
         return NULL;
     }
@@ -553,7 +567,7 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
 /**
  * Private methods definitions
  */
-bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
+bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous)
 {
     if (!rmt) {
         return false;
@@ -571,6 +585,7 @@ bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
     }
 
     RMT_MUTEX_LOCK(channel);
+    RMT.conf_ch[channel].conf1.tx_conti_mode = continuous;
     RMT.conf_ch[channel].conf1.mem_rd_rst = 1;
     RMT.conf_ch[channel].conf1.tx_start = 1;
     RMT_MUTEX_UNLOCK(channel);

cores/esp32/esp32-hal-rmt.h

@@ -73,6 +73,12 @@ float rmtSetTick(rmt_obj_t* rmt, float tick);
 */
 bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size);
 
+/**
+*    Loop data up to the reserved memsize continuously
+*
+*/
+bool rmtLoop(rmt_obj_t* rmt, rmt_data_t* data, size_t size);
+
 /**
 *    Initiates async receive, event flag indicates data received
 *

cores/esp32/esp32-hal-sigmadelta.c

@@ -16,11 +16,21 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
-#include "rom/ets_sys.h"
 #include "esp32-hal-matrix.h"
 #include "soc/gpio_sd_reg.h"
 #include "soc/gpio_sd_struct.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/ets_sys.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/ets_sys.h"
+#endif
+
 
 #if CONFIG_DISABLE_HAL_LOCKS
 #define SD_MUTEX_LOCK()

cores/esp32/esp32-hal-spi.c

@@ -17,10 +17,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
-#include "rom/ets_sys.h"
 #include "esp_attr.h"
-#include "esp_intr.h"
-#include "rom/gpio.h"
 #include "soc/spi_reg.h"
 #include "soc/spi_struct.h"
 #include "soc/io_mux_reg.h"
@@ -28,6 +25,21 @@
 #include "soc/dport_reg.h"
 #include "soc/rtc.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/ets_sys.h"
+#include "esp32/rom/gpio.h"
+#include "esp_intr_alloc.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/ets_sys.h"
+#include "rom/gpio.h"
+#include "esp_intr.h"
+#endif
+
 #define SPI_CLK_IDX(p)  ((p==0)?SPICLK_OUT_IDX:((p==1)?SPICLK_OUT_IDX:((p==2)?HSPICLK_OUT_IDX:((p==3)?VSPICLK_OUT_IDX:0))))
 #define SPI_MISO_IDX(p) ((p==0)?SPIQ_OUT_IDX:((p==1)?SPIQ_OUT_IDX:((p==2)?HSPIQ_OUT_IDX:((p==3)?VSPIQ_OUT_IDX:0))))
 #define SPI_MOSI_IDX(p) ((p==0)?SPID_IN_IDX:((p==1)?SPID_IN_IDX:((p==2)?HSPID_IN_IDX:((p==3)?VSPID_IN_IDX:0))))
@@ -421,14 +433,14 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
 #endif
 
     if(spi_num == HSPI) {
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI_RST);
+        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 == VSPI) {
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI_CLK_EN_2);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI_RST_2);
+        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_SPI_CLK_EN_1);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI_RST_1);
+        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);
     }
 
     spiStopBus(spi);
@@ -459,7 +471,7 @@ void spiWaitReady(spi_t * spi)
     while(spi->dev->cmd.usr);
 }
 
-void spiWrite(spi_t * spi, uint32_t *data, uint8_t len)
+void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
 {
     if(!spi) {
         return;
@@ -532,17 +544,7 @@ uint8_t spiTransferByte(spi_t * spi, uint8_t data)
     return data;
 }
 
-uint32_t __spiTranslate24(uint32_t data)
-{
-    union {
-        uint32_t l;
-        uint8_t b[4];
-    } out;
-    out.l = data;
-    return out.b[2] | (out.b[1] << 8) | (out.b[0] << 16);
-}
-
-uint32_t __spiTranslate32(uint32_t data)
+static uint32_t __spiTranslate32(uint32_t data)
 {
     union {
         uint32_t l;
@@ -630,7 +632,7 @@ uint32_t spiTransferLong(spi_t * spi, uint32_t data)
     return data;
 }
 
-void __spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t bytes)
+static void __spiTransferBytes(spi_t * spi, const uint8_t * data, uint8_t * out, uint32_t bytes)
 {
     if(!spi) {
         return;
@@ -671,7 +673,7 @@ void __spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t byt
     }
 }
 
-void spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t size)
+void spiTransferBytes(spi_t * spi, const uint8_t * data, uint8_t * out, uint32_t size)
 {
     if(!spi) {
         return;
@@ -861,7 +863,7 @@ uint32_t spiTransferLongNL(spi_t * spi, uint32_t data)
     return data;
 }
 
-void spiWriteNL(spi_t * spi, const void * data_in, size_t len){
+void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len){
     size_t longs = len >> 2;
     if(len & 3){
         longs++;
@@ -887,7 +889,7 @@ void spiWriteNL(spi_t * spi, const void * data_in, size_t len){
     }
 }
 
-void spiTransferBytesNL(spi_t * spi, const void * data_in, uint8_t * data_out, size_t len){
+void spiTransferBytesNL(spi_t * spi, const void * data_in, uint8_t * data_out, uint32_t len){
     if(!spi) {
         return;
     }
@@ -974,7 +976,7 @@ void spiTransferBitsNL(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
     }
 }
 
-void IRAM_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, size_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

@@ -96,7 +96,7 @@ void spiSetClockDiv(spi_t * spi, uint32_t clockDiv);
 void spiSetDataMode(spi_t * spi, uint8_t dataMode);
 void spiSetBitOrder(spi_t * spi, uint8_t bitOrder);
 
-void spiWrite(spi_t * spi, uint32_t *data, uint8_t len);
+void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len);
 void spiWriteByte(spi_t * spi, uint8_t data);
 void spiWriteWord(spi_t * spi, uint16_t data);
 void spiWriteLong(spi_t * spi, uint32_t data);
@@ -105,7 +105,7 @@ void spiTransfer(spi_t * spi, uint32_t *out, uint8_t len);
 uint8_t spiTransferByte(spi_t * spi, uint8_t data);
 uint16_t spiTransferWord(spi_t * spi, uint16_t data);
 uint32_t spiTransferLong(spi_t * spi, uint32_t data);
-void spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t size);
+void spiTransferBytes(spi_t * spi, const uint8_t * data, uint8_t * out, uint32_t size);
 void spiTransferBits(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits);
 
 /*
@@ -115,11 +115,11 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
 void spiSimpleTransaction(spi_t * spi);
 void spiEndTransaction(spi_t * spi);
 
-void spiWriteNL(spi_t * spi, const void * data, uint32_t len);
+void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len);
 void spiWriteByteNL(spi_t * spi, uint8_t data);
 void spiWriteShortNL(spi_t * spi, uint16_t data);
 void spiWriteLongNL(spi_t * spi, uint32_t data);
-void spiWritePixelsNL(spi_t * spi, const void * data, uint32_t len);
+void spiWritePixelsNL(spi_t * spi, const void * data_in, uint32_t len);
 
 #define spiTransferNL(spi, data, len) spiTransferBytesNL(spi, data, data, len)
 uint8_t spiTransferByteNL(spi_t * spi, uint8_t data);

cores/esp32/esp32-hal-time.c

@@ -14,6 +14,7 @@
 
 #include "esp32-hal.h"
 #include "lwip/apps/sntp.h"
+#include "tcpip_adapter.h"
 
 static void setTimeZone(long offset, int daylight)
 {
@@ -45,6 +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
     if(sntp_enabled()){
         sntp_stop();
     }
@@ -62,6 +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
     if(sntp_enabled()){
         sntp_stop();
     }

cores/esp32/esp32-hal-timer.c

@@ -16,11 +16,22 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/xtensa_api.h"
 #include "freertos/task.h"
-#include "rom/ets_sys.h"
 #include "soc/timer_group_struct.h"
 #include "soc/dport_reg.h"
 #include "esp_attr.h"
+
+#include "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
 
 #define HWTIMER_LOCK()      portENTER_CRITICAL(timer->lock)
 #define HWTIMER_UNLOCK()    portEXIT_CRITICAL(timer->lock)
@@ -165,6 +176,7 @@ void timerStop(hw_timer_t *timer){
 
 void timerRestart(hw_timer_t *timer){
     timer->dev->config.enable = 0;
+    timer->dev->reload = 1;
     timer->dev->config.enable = 1;
 }
 

cores/esp32/esp32-hal-touch.c

@@ -15,13 +15,24 @@
 #include "esp32-hal-touch.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "rom/ets_sys.h"
 #include "esp_attr.h"
-#include "esp_intr.h"
 #include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
 
+#include "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
+
 static uint16_t __touchSleepCycles = 0x1000;
 static uint16_t __touchMeasureCycles = 0x1000;
 

cores/esp32/esp32-hal-uart.c

@@ -18,10 +18,7 @@
 #include "freertos/task.h"
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
-#include "rom/ets_sys.h"
 #include "esp_attr.h"
-#include "esp_intr.h"
-#include "rom/uart.h"
 #include "soc/uart_reg.h"
 #include "soc/uart_struct.h"
 #include "soc/io_mux_reg.h"
@@ -30,6 +27,20 @@
 #include "soc/rtc.h"
 #include "esp_intr_alloc.h"
 
+#include "esp_system.h"
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/ets_sys.h"
+#include "esp32/rom/uart.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/ets_sys.h"
+#include "rom/uart.h"
+#include "esp_intr.h"
+#endif
+
 #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)))
@@ -217,7 +228,6 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     if(txPin != -1) {
         uartAttachTx(uart, txPin, inverted);
     }
-
     addApbChangeCallback(uart, uart_on_apb_change);
     return uart;
 }
@@ -253,7 +263,7 @@ size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
         vQueueDelete(uart->queue);
         uart->queue = xQueueCreate(new_size, sizeof(uint8_t));
         if(uart->queue == NULL) {
-            return NULL;
+            return 0;
         }
     }
     UART_MUTEX_UNLOCK();
@@ -327,6 +337,11 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
 }
 
 void uartFlush(uart_t* uart)
+{
+    uartFlushTxOnly(uart,false);
+}
+
+void uartFlushTxOnly(uart_t* uart, bool txOnly)
 {
     if(uart == NULL) {
         return;
@@ -334,15 +349,19 @@ void uartFlush(uart_t* uart)
 
     UART_MUTEX_LOCK();
     while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
+    
+    if( !txOnly ){
+        //Due to hardware issue, we can not use fifo_rst to reset uart fifo.
+        //See description about UART_TXFIFO_RST and UART_RXFIFO_RST in <<esp32_technical_reference_manual>> v2.6 or later.
 
-    //Due to hardware issue, we can not use fifo_rst to reset uart fifo.
-    //See description about UART_TXFIFO_RST and UART_RXFIFO_RST in <<esp32_technical_reference_manual>> v2.6 or later.
+        // we read the data out and make `fifo_len == 0 && rd_addr == wr_addr`.
+        while(uart->dev->status.rxfifo_cnt != 0 || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
+            READ_PERI_REG(UART_FIFO_REG(uart->num));
+        }
 
-    // we read the data out and make `fifo_len == 0 && rd_addr == wr_addr`.
-    while(uart->dev->status.rxfifo_cnt != 0 || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
-        READ_PERI_REG(UART_FIFO_REG(uart->num));
+        xQueueReset(uart->queue);
     }
-
+    
     UART_MUTEX_UNLOCK();
 }
 
@@ -368,18 +387,21 @@ static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old
         uart->dev->int_clr.val = 0xffffffff;
         // read RX fifo
         uint8_t c;
-        BaseType_t xHigherPriorityTaskWoken;
+   //     BaseType_t xHigherPriorityTaskWoken;
         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;
-            if(uart->queue != NULL && !xQueueIsQueueFullFromISR(uart->queue)) {
-                xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
+            if(uart->queue != NULL ) {
+                xQueueSend(uart->queue, &c, 1); //&xHigherPriorityTaskWoken);
             }
         }
+        UART_MUTEX_UNLOCK();
+ 
         // wait TX empty
         while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
     } else {
         //todo:
         // set baudrate
+        UART_MUTEX_LOCK();
         uint32_t clk_div = (uart->dev->clk_div.div_int << 4) | (uart->dev->clk_div.div_frag & 0x0F);
         uint32_t baud_rate = ((old_apb<<4)/clk_div);
         clk_div = ((new_apb<<4)/baud_rate);
@@ -399,7 +421,12 @@ uint32_t uartGetBaudRate(uart_t* uart)
     if(uart == NULL) {
         return 0;
     }
+
     uint32_t clk_div = (uart->dev->clk_div.div_int << 4) | (uart->dev->clk_div.div_frag & 0x0F);
+    if(!clk_div) {
+        return 0;
+    }
+
     return ((getApbFrequency()<<4)/clk_div);
 }
 
@@ -520,6 +547,14 @@ unsigned long uartBaudrateDetect(uart_t *uart, bool flg)
  * detected calling uartBadrateDetect(). The raw baudrate is computed using the UART_CLK_FREQ. The raw baudrate is 
  * rounded to the closed real baudrate.
 */
+void uartStartDetectBaudrate(uart_t *uart) {
+  if(!uart) return;
+
+  uart->dev->auto_baud.glitch_filt = 0x08;
+  uart->dev->auto_baud.en = 0;
+  uart->dev->auto_baud.en = 1;
+}
+
 unsigned long
 uartDetectBaudrate(uart_t *uart)
 {

cores/esp32/esp32-hal-uart.h

@@ -63,6 +63,7 @@ void uartWrite(uart_t* uart, uint8_t c);
 void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len);
 
 void uartFlush(uart_t* uart);
+void uartFlushTxOnly(uart_t* uart, bool txOnly );
 
 void uartSetBaudRate(uart_t* uart, uint32_t baud_rate);
 uint32_t uartGetBaudRate(uart_t* uart);
@@ -72,6 +73,7 @@ size_t uartResizeRxBuffer(uart_t* uart, size_t new_size);
 void uartSetDebug(uart_t* uart);
 int uartGetDebug();
 
+void uartStartDetectBaudrate(uart_t *uart);
 unsigned long uartDetectBaudrate(uart_t *uart);
 
 bool uartRxActive(uart_t* uart);

cores/esp32/esp32-hal.h

@@ -34,6 +34,7 @@ extern "C" {
 #include <math.h>
 #include "sdkconfig.h"
 #include "esp_system.h"
+#include "esp_sleep.h"
 
 #ifndef F_CPU
 #define F_CPU (CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ * 1000000U)

cores/esp32/main.cpp

@@ -17,6 +17,7 @@ void loopTask(void *pvParameters)
             esp_task_wdt_reset();
         }
         loop();
+        if (serialEventRun) serialEventRun();
     }
 }
 

cores/esp32/pgmspace.h

@@ -32,7 +32,6 @@ typedef unsigned long prog_uint32_t;
 #define PROGMEM
 #define PGM_P         const char *
 #define PGM_VOID_P    const void *
-#define FPSTR(p)      ((const char *)(p))
 #define PSTR(s)       (s)
 #define _SFR_BYTE(n)  (n)
 

docs/arduino-ide/boards_manager.md

@@ -1,13 +1,12 @@
-Installation instructions using Arduino IDE Boards Manager
-==========================================================
+## Installation instructions using Arduino IDE Boards Manager
+### ==========================================================
 
-Starting with 1.6.4, Arduino allows installation of third-party platform packages using Boards Manager. We have packages available for Windows, Mac OS, and Linux (32 and 64 bit).
+- Stable release link: `https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json`
+- Development release link: `https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json`
+
+Starting with 1.6.4, Arduino allows installation of third-party platform packages using Boards Manager. We have packages available for Windows, Mac OS, and Linux (32, 64 bit and ARM).
 
 - Install the current upstream Arduino IDE at the 1.8 level or later. The current version is at the [Arduino website](http://www.arduino.cc/en/main/software).
 - Start Arduino and open Preferences window.
-- Enter ```https://dl.espressif.com/dl/package_esp32_index.json``` into *Additional Board Manager URLs* field. You can add multiple URLs, separating them with commas.
+- Enter one of the release links above into *Additional Board Manager URLs* field. You can add multiple URLs, separating them with commas.
 - Open Boards Manager from Tools > Board menu and install *esp32* platform (and don't forget to select your ESP32 board from Tools > Board menu after installation).
-
-Stable release link: `https://dl.espressif.com/dl/package_esp32_index.json`
-
-Development release link: `https://dl.espressif.com/dl/package_esp32_dev_index.json`

docs/esp-idf_component.md

@@ -1,6 +1,10 @@
 To use as a component of ESP-IDF
 =================================================
 
+## esp32-arduino-lib-builder
+
+For a simplified method, see [lib-builder](lib_builder.md)
+
 ## Installation
 
 - Download and install [esp-idf](https://github.com/espressif/esp-idf)

docs/lib_builder.md

@@ -0,0 +1,14 @@
+## Using esp32-arduino-lib-builder to compile custom libraries
+
+Espressif has provided a [tool](https://github.com/espressif/esp32-arduino-lib-builder) to simplify building your own compiled libraries for use in Arduino IDE (or your favorite IDE).
+To use it to generate custom libraries, follow these steps:
+1. `git clone https://github.com/espressif/esp32-arduino-lib-builder`
+2. `cd esp32-arduino-lib-builder`
+3. `./tools/update-components.sh`
+4. `./tools/install-esp-idf.sh` (if you already have an $IDF_PATH defined, it will use your local copy of the repository)
+5. `make menuconfig` or directly edit sdkconfig.
+6. `./build.sh`
+
+The script automates the process of building [arduino as an ESP-IDF component](https://github.com/espressif/arduino-esp32/blob/master/docs/esp-idf_component.md).
+Once it is complete, you can cherry pick the needed libraries from `out/tools/sdk/lib`, or run `tools/copy-to-arduino.sh` to copy the entire built system.
+`tools/config.sh` contains a number of variables that control the process, particularly the $IDF_BRANCH variable.  You can adjust this to try building against newer versions, but there are absolutely no guarantees that any components will work or even successfully compile against a newer IDF.

docs/platformio.md

@@ -1,11 +1,11 @@
 Installation instructions for using PlatformIO
 =================================================
 
-- [What is PlatformIO?](http://docs.platformio.org/en/latest/what-is-platformio.html?utm_source=github&utm_medium=arduino-esp32)
-- [PlatformIO IDE](http://platformio.org/platformio-ide?utm_source=github&utm_medium=arduino-esp32)
-- [PlatformIO Core](http://docs.platformio.org/en/latest/core.html?utm_source=github&utm_medium=arduino-esp32) (command line tool)
-- [Advanced usage](http://docs.platformio.org/en/latest/platforms/espressif32.html?utm_source=github&utm_medium=arduino-esp32) -
+- [What is PlatformIO?](https://docs.platformio.org/en/latest/what-is-platformio.html?utm_source=github&utm_medium=arduino-esp32)
+- [PlatformIO IDE](https://platformio.org/platformio-ide?utm_source=github&utm_medium=arduino-esp32)
+- [PlatformIO Core](https://docs.platformio.org/en/latest/core.html?utm_source=github&utm_medium=arduino-esp32) (command line tool)
+- [Advanced usage](https://docs.platformio.org/en/latest/platforms/espressif32.html?utm_source=github&utm_medium=arduino-esp32) -
   custom settings, uploading to SPIFFS, Over-the-Air (OTA), staging version
-- [Integration with Cloud and Standalone IDEs](http://docs.platformio.org/en/latest/ide.html?utm_source=github&utm_medium=arduino-esp32) -
+- [Integration with Cloud and Standalone IDEs](https://docs.platformio.org/en/latest/ide.html?utm_source=github&utm_medium=arduino-esp32) -
   Cloud9, Codeanywhere, Eclipse Che (Codenvy), Atom, CLion, Eclipse, Emacs, NetBeans, Qt Creator, Sublime Text, VIM, Visual Studio, and VSCode
-- [Project Examples](http://docs.platformio.org/en/latest/platforms/espressif32.html?utm_source=github&utm_medium=arduino-esp32#examples)
+- [Project Examples](https://docs.platformio.org/en/latest/platforms/espressif32.html?utm_source=github&utm_medium=arduino-esp32#examples)

libraries/ArduinoOTA/src/ArduinoOTA.cpp

@@ -127,9 +127,7 @@ void ArduinoOTAClass::begin() {
     }
     _initialized = true;
     _state = OTA_IDLE;
-#ifdef OTA_DEBUG
-    OTA_DEBUG.printf("OTA server at: %s.local:%u\n", _hostname.c_str(), _port);
-#endif
+    log_i("OTA server at: %s.local:%u", _hostname.c_str(), _port);
 }
 
 int ArduinoOTAClass::parseInt(){
@@ -173,6 +171,7 @@ void ArduinoOTAClass::_onRx(){
         _md5 = readStringUntil('\n');
         _md5.trim();
         if(_md5.length() != 32){
+            log_e("bad md5 length");
             return;
         }
 
@@ -198,6 +197,7 @@ void ArduinoOTAClass::_onRx(){
     } else if (_state == OTA_WAITAUTH) {
         int cmd = parseInt();
         if (cmd != U_AUTH) {
+            log_e("%d was expected. got %d instead", U_AUTH, cmd);
             _state = OTA_IDLE;
             return;
         }
@@ -205,6 +205,7 @@ void ArduinoOTAClass::_onRx(){
         String cnonce = readStringUntil(' ');
         String response = readStringUntil('\n');
         if (cnonce.length() != 32 || response.length() != 32) {
+            log_e("auth param fail");
             _state = OTA_IDLE;
             return;
         }
@@ -225,6 +226,7 @@ void ArduinoOTAClass::_onRx(){
         } else {
             _udp_ota.beginPacket(_udp_ota.remoteIP(), _udp_ota.remotePort());
             _udp_ota.print("Authentication Failed");
+            log_w("Authentication Failed");
             _udp_ota.endPacket();
             if (_error_callback) _error_callback(OTA_AUTH_ERROR);
             _state = OTA_IDLE;
@@ -234,9 +236,9 @@ void ArduinoOTAClass::_onRx(){
 
 void ArduinoOTAClass::_runUpdate() {
     if (!Update.begin(_size, _cmd)) {
-#ifdef OTA_DEBUG
-        Update.printError(OTA_DEBUG);
-#endif
+
+        log_e("Begin ERROR: %s", Update.errorString());
+
         if (_error_callback) {
             _error_callback(OTA_BEGIN_ERROR);
         }
@@ -272,21 +274,15 @@ void ArduinoOTAClass::_runUpdate() {
         }
         if (!waited){
             if(written && tried++ < 3){
-#ifdef OTA_DEBUG
-                OTA_DEBUG.printf("Try[%u]: %u\n", tried, written);
-#endif
+                log_i("Try[%u]: %u", tried, written);
                 if(!client.printf("%u", written)){
-#ifdef OTA_DEBUG
-                    OTA_DEBUG.printf("failed to respond\n");
-#endif
+                    log_e("failed to respond");
                     _state = OTA_IDLE;
                     break;
                 }
                 continue;
             }
-#ifdef OTA_DEBUG
-            OTA_DEBUG.printf("Receive Failed\n");
-#endif
+            log_e("Receive Failed");
             if (_error_callback) {
                 _error_callback(OTA_RECEIVE_ERROR);
             }
@@ -295,9 +291,7 @@ void ArduinoOTAClass::_runUpdate() {
             return;
         }
         if(!available){
-#ifdef OTA_DEBUG
-            OTA_DEBUG.printf("No Data: %u\n", waited);
-#endif
+            log_e("No Data: %u", waited);
             _state = OTA_IDLE;
             break;
         }
@@ -317,18 +311,14 @@ void ArduinoOTAClass::_runUpdate() {
                 log_w("didn't write enough! %u != %u", written, r);
             }
             if(!client.printf("%u", written)){
-#ifdef OTA_DEBUG
-                OTA_DEBUG.printf("failed to respond\n");
-#endif
+                log_w("failed to respond");
             }
             total += written;
             if(_progress_callback) {
                 _progress_callback(total, _size);
             }
         } else {
-#ifdef OTA_DEBUG
-            Update.printError(OTA_DEBUG);
-#endif
+            log_e("Write ERROR: %s", Update.errorString());
         }
     }
 
@@ -351,10 +341,7 @@ void ArduinoOTAClass::_runUpdate() {
         Update.printError(client);
         client.stop();
         delay(10);
-#ifdef OTA_DEBUG
-        OTA_DEBUG.print("Update ERROR: ");
-        Update.printError(OTA_DEBUG);
-#endif
+        log_e("Update ERROR: %s", Update.errorString());
         _state = OTA_IDLE;
     }
 }
@@ -366,9 +353,7 @@ void ArduinoOTAClass::end() {
         MDNS.end();
     }
     _state = OTA_IDLE;
-#ifdef OTA_DEBUG
-    OTA_DEBUG.println("OTA server stopped.");
-#endif
+    log_i("OTA server stopped.");
 }
 
 void ArduinoOTAClass::handle() {
@@ -395,4 +380,4 @@ void ArduinoOTAClass::setTimeout(int timeoutInMillis) {
 
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_ARDUINOOTA)
 ArduinoOTAClass ArduinoOTA;
-#endif
+#endif

libraries/AsyncUDP/library.json

@@ -1,17 +0,0 @@
-{
-  "name":"AsyncUDP",
-  "description":"Asynchronous UDP Library for ESP32",
-  "keywords":"async,udp,server,client,multicast,broadcast",
-  "authors":
-  {
-    "name": "Hristo Gochkov",
-    "maintainer": true
-  },
-  "repository":
-  {
-    "type": "git",
-    "url": "https://github.com/me-no-dev/ESPAsyncUDP.git"
-  },
-  "frameworks": "arduino",
-  "platforms":"espressif"
-}

libraries/AsyncUDP/src/AsyncUDP.cpp

@@ -682,8 +682,9 @@ void AsyncUDP::_recv(udp_pcb *upcb, pbuf *pb, const ip_addr_t *addr, uint16_t po
         if(_handler) {
             AsyncUDPPacket packet(this, this_pb, addr, port, netif);
             _handler(packet);
+        } else {
+            pbuf_free(this_pb);
         }
-        pbuf_free(this_pb);
     }
 }
 

libraries/BLE/examples/BLE_client/BLE_client.ino

@@ -87,6 +87,7 @@ bool connectToServer() {
       pRemoteCharacteristic->registerForNotify(notifyCallback);
 
     connected = true;
+    return true;
 }
 /**
  * Scan for BLE servers and find the first one that advertises the service we are looking for.
@@ -153,7 +154,7 @@ void loop() {
     // Set the characteristic's value to be the array of bytes that is actually a string.
     pRemoteCharacteristic->writeValue(newValue.c_str(), newValue.length());
   }else if(doScan){
-    BLEDevice::getScan()->start(0);  // this is just eample to start scan after disconnect, most likely there is better way to do it in arduino
+    BLEDevice::getScan()->start(0);  // this is just example to start scan after disconnect, most likely there is better way to do it in arduino
   }
   
   delay(1000); // Delay a second between loops.

libraries/BLE/examples/BLE_iBeacon/BLE_iBeacon.ino

@@ -65,6 +65,7 @@ void setBeacon() {
   
   pAdvertising->setAdvertisementData(oAdvertisementData);
   pAdvertising->setScanResponseData(oScanResponseData);
+  pAdvertising->setAdvertisementType(ADV_TYPE_NONCONN_IND);
 
 }
 

libraries/BLE/src/BLEAddress.cpp

@@ -13,6 +13,7 @@
 #include <iomanip>
 #include <string.h>
 #include <stdio.h>
+#include <malloc.h>
 #ifdef ARDUINO_ARCH_ESP32
 #include "esp32-hal-log.h"
 #endif
@@ -83,13 +84,11 @@ esp_bd_addr_t *BLEAddress::getNative() {
  * @return The string representation of the address.
  */
 std::string BLEAddress::toString() {
-	std::stringstream stream;
-	stream << std::setfill('0') << std::setw(2) << std::hex << (int) ((uint8_t*) (m_address))[0] << ':';
-	stream << std::setfill('0') << std::setw(2) << std::hex << (int) ((uint8_t*) (m_address))[1] << ':';
-	stream << std::setfill('0') << std::setw(2) << std::hex << (int) ((uint8_t*) (m_address))[2] << ':';
-	stream << std::setfill('0') << std::setw(2) << std::hex << (int) ((uint8_t*) (m_address))[3] << ':';
-	stream << std::setfill('0') << std::setw(2) << std::hex << (int) ((uint8_t*) (m_address))[4] << ':';
-	stream << std::setfill('0') << std::setw(2) << std::hex << (int) ((uint8_t*) (m_address))[5];
-	return stream.str();
+	auto size = 18;
+	char *res = (char*)malloc(size);
+	snprintf(res, size, "%02x:%02x:%02x:%02x:%02x:%02x", m_address[0], m_address[1], m_address[2], m_address[3], m_address[4], m_address[5]);
+	std::string ret(res);
+	free(res);
+	return ret;
 } // toString
 #endif

libraries/BLE/src/BLEAdvertisedDevice.cpp

@@ -25,7 +25,8 @@ BLEAdvertisedDevice::BLEAdvertisedDevice() {
 	m_manufacturerData = "";
 	m_name             = "";
 	m_rssi             = -9999;
-	m_serviceData      = "";
+	m_serviceData      = {};
+	m_serviceDataUUIDs = {};
 	m_txPower          = 0;
 	m_pScan            = nullptr;
 
@@ -101,33 +102,66 @@ BLEScan* BLEAdvertisedDevice::getScan() {
 	return m_pScan;
 } // getScan
 
+/**
+ * @brief Get the number of service data.
+ * @return Number of service data discovered.
+ */
+int BLEAdvertisedDevice::getServiceDataCount() {
+	if (m_haveServiceData)
+		return m_serviceData.size();
+	else
+		return 0;
+
+} //getServiceDataCount
 
 /**
  * @brief Get the service data.
  * @return The ServiceData of the advertised device.
  */
 std::string BLEAdvertisedDevice::getServiceData() {
-	return m_serviceData;
+	return m_serviceData[0];
 } //getServiceData
 
+/**
+ * @brief Get the service data.
+ * @return The ServiceData of the advertised device.
+ */
+std::string BLEAdvertisedDevice::getServiceData(int i) {
+	return m_serviceData[i];
+} //getServiceData
 
 /**
  * @brief Get the service data UUID.
  * @return The service data UUID.
  */
 BLEUUID BLEAdvertisedDevice::getServiceDataUUID() {
-	return m_serviceDataUUID;
+	return m_serviceDataUUIDs[0];
 } // getServiceDataUUID
 
+/**
+ * @brief Get the service data UUID.
+ * @return The service data UUID.
+ */
+BLEUUID BLEAdvertisedDevice::getServiceDataUUID(int i) {
+	return m_serviceDataUUIDs[i];
+} // getServiceDataUUID
 
 /**
  * @brief Get the Service UUID.
  * @return The Service UUID of the advertised device.
  */
-BLEUUID BLEAdvertisedDevice::getServiceUUID() {  //TODO Remove it eventually, is no longer useful
+BLEUUID BLEAdvertisedDevice::getServiceUUID() {
 	return m_serviceUUIDs[0];
 } // getServiceUUID
 
+/**
+ * @brief Get the Service UUID.
+ * @return The Service UUID of the advertised device.
+ */
+BLEUUID BLEAdvertisedDevice::getServiceUUID(int i) {
+	return m_serviceUUIDs[i];
+} // getServiceUUID
+
 /**
  * @brief Check advertised serviced for existence required UUID
  * @return Return true if service is advertised
@@ -454,7 +488,7 @@ void BLEAdvertisedDevice::setServiceUUID(BLEUUID serviceUUID) {
  */
 void BLEAdvertisedDevice::setServiceData(std::string serviceData) {
 	m_haveServiceData = true;         // Set the flag that indicates we have service data.
-	m_serviceData     = serviceData;  // Save the service data that we received.
+	m_serviceData.push_back(serviceData); // Save the service data that we received.
 } //setServiceData
 
 
@@ -464,7 +498,8 @@ void BLEAdvertisedDevice::setServiceData(std::string serviceData) {
  */
 void BLEAdvertisedDevice::setServiceDataUUID(BLEUUID uuid) {
 	m_haveServiceData = true;         // Set the flag that indicates we have service data.
-	m_serviceDataUUID = uuid;
+	m_serviceDataUUIDs.push_back(uuid);
+	log_d("- addServiceDataUUID(): serviceDataUUID: %s", uuid.toString().c_str());
 } // setServiceDataUUID
 
 
@@ -484,23 +519,31 @@ void BLEAdvertisedDevice::setTXPower(int8_t txPower) {
  * @return A string representation of this device.
  */
 std::string BLEAdvertisedDevice::toString() {
-	std::stringstream ss;
-	ss << "Name: " << getName() << ", Address: " << getAddress().toString();
+	std::string res = "Name: " + getName() + ", Address: " + getAddress().toString();
 	if (haveAppearance()) {
-		ss << ", appearance: " << getAppearance();
+		char val[6];
+		snprintf(val, sizeof(val), "%d", getAppearance());
+		res += ", appearance: ";
+		res += val;
 	}
 	if (haveManufacturerData()) {
 		char *pHex = BLEUtils::buildHexData(nullptr, (uint8_t*)getManufacturerData().data(), getManufacturerData().length());
-		ss << ", manufacturer data: " << pHex;
+		res += ", manufacturer data: ";
+		res += pHex;
 		free(pHex);
 	}
 	if (haveServiceUUID()) {
-		ss << ", serviceUUID: " << getServiceUUID().toString();
+		for (int i=0; i < m_serviceUUIDs.size(); i++) {
+		    res += ", serviceUUID: " + getServiceUUID(i).toString();
+		}
 	}
 	if (haveTXPower()) {
-		ss << ", txPower: " << (int)getTXPower();
+		char val[6];
+		snprintf(val, sizeof(val), "%d", getTXPower());
+		res += ", txPower: ";
+		res += val;
 	}
-	return ss.str();
+	return res;
 } // toString
 
 uint8_t* BLEAdvertisedDevice::getPayload() {

libraries/BLE/src/BLEAdvertisedDevice.h

@@ -12,6 +12,7 @@
 #include <esp_gattc_api.h>
 
 #include <map>
+#include <vector>
 
 #include "BLEAddress.h"
 #include "BLEScan.h"
@@ -36,8 +37,12 @@ public:
 	int         getRSSI();
 	BLEScan*    getScan();
 	std::string getServiceData();
+	std::string getServiceData(int i);
 	BLEUUID     getServiceDataUUID();
+	BLEUUID     getServiceDataUUID(int i);
 	BLEUUID     getServiceUUID();
+	BLEUUID     getServiceUUID(int i);
+	int         getServiceDataCount();
 	int8_t      getTXPower();
 	uint8_t* 	getPayload();
 	size_t		getPayloadLength();
@@ -93,8 +98,8 @@ private:
 	int         m_rssi;
 	std::vector<BLEUUID> m_serviceUUIDs;
 	int8_t      m_txPower;
-	std::string m_serviceData;
-	BLEUUID     m_serviceDataUUID;
+	std::vector<std::string> m_serviceData;
+	std::vector<BLEUUID> m_serviceDataUUIDs;
 	uint8_t*	m_payload;
 	size_t		m_payloadLength = 0;
 	esp_ble_addr_type_t m_addressType;

libraries/BLE/src/BLEAdvertising.cpp

@@ -85,6 +85,10 @@ void BLEAdvertising::setAppearance(uint16_t appearance) {
 	m_advData.appearance = appearance;
 } // setAppearance
 
+void BLEAdvertising::setAdvertisementType(esp_ble_adv_type_t adv_type){
+	m_advParams.adv_type = adv_type;
+} // setAdvertisementType
+
 void BLEAdvertising::setMinInterval(uint16_t mininterval) {
 	m_advParams.adv_int_min = mininterval;
 } // setMinInterval
@@ -262,7 +266,7 @@ void BLEAdvertising::stop() {
 
 void BLEAdvertising::setDeviceAddress(esp_bd_addr_t addr, esp_ble_addr_type_t type)
 {
-	log_v(">> setPrivateAddress")
+	log_v(">> setPrivateAddress");
 
 	m_advParams.own_addr_type = type;
 	esp_err_t errRc = esp_ble_gap_set_rand_addr((uint8_t*)addr);
@@ -271,7 +275,7 @@ void BLEAdvertising::setDeviceAddress(esp_bd_addr_t addr, esp_ble_addr_type_t ty
 		log_e("esp_ble_gap_set_rand_addr: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 		return;
 	}
-	log_v("<< setPrivateAddress")
+	log_v("<< setPrivateAddress");
 } // setPrivateAddress
 
 /**
@@ -505,7 +509,7 @@ void BLEAdvertising::handleGAPEvent(
 		}
 		case ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT: {
 			log_i("STOP advertising");
-			start();
+			//start();
 			break;
 		}
 		default:

libraries/BLE/src/BLEAdvertising.h

@@ -52,6 +52,7 @@ public:
 	void start();
 	void stop();
 	void setAppearance(uint16_t appearance);
+	void setAdvertisementType(esp_ble_adv_type_t adv_type);
 	void setMaxInterval(uint16_t maxinterval);
 	void setMinInterval(uint16_t mininterval);
 	void setAdvertisementData(BLEAdvertisementData& advertisementData);
@@ -76,4 +77,4 @@ private:
 
 };
 #endif /* CONFIG_BT_ENABLED */
-#endif /* COMPONENTS_CPP_UTILS_BLEADVERTISING_H_ */
+#endif /* COMPONENTS_CPP_UTILS_BLEADVERTISING_H_ */

libraries/BLE/src/BLECharacteristic.cpp

@@ -22,6 +22,7 @@
 
 #define NULL_HANDLE (0xffff)
 
+static BLECharacteristicCallbacks defaultCallback; //null-object-pattern
 
 /**
  * @brief Construct a characteristic
@@ -40,7 +41,7 @@ BLECharacteristic::BLECharacteristic(BLEUUID uuid, uint32_t properties) {
 	m_bleUUID    = uuid;
 	m_handle     = NULL_HANDLE;
 	m_properties = (esp_gatt_char_prop_t)0;
-	m_pCallbacks = nullptr;
+	m_pCallbacks = &defaultCallback;
 
 	setBroadcastProperty((properties & PROPERTY_BROADCAST) != 0);
 	setReadProperty((properties & PROPERTY_READ) != 0);
@@ -220,9 +221,7 @@ void BLECharacteristic::handleGATTServerEvent(
 		case ESP_GATTS_EXEC_WRITE_EVT: {
 			if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
 				m_value.commit();
-				if (m_pCallbacks != nullptr) {
-					m_pCallbacks->onWrite(this); // Invoke the onWrite callback handler.
-				}
+				m_pCallbacks->onWrite(this); // Invoke the onWrite callback handler.
 			} else {
 				m_value.cancel();
 			}
@@ -307,7 +306,7 @@ void BLECharacteristic::handleGATTServerEvent(
 					}
 				} // Response needed
 
-				if (m_pCallbacks != nullptr && param->write.is_prep != true) {
+				if (param->write.is_prep != true) {
 					m_pCallbacks->onWrite(this); // Invoke the onWrite callback handler.
 				}
 			} // Match on handles.
@@ -378,6 +377,10 @@ void BLECharacteristic::handleGATTServerEvent(
 						}
 					} else { // read.is_long == false
 
+						// If is.long is false then this is the first (or only) request to read data, so invoke the callback
+						// Invoke the read callback.
+						m_pCallbacks->onRead(this);
+
 						std::string value = m_value.getValue();
 
 						if (value.length() + 1 > maxOffset) {
@@ -392,10 +395,6 @@ void BLECharacteristic::handleGATTServerEvent(
 							rsp.attr_value.offset = 0;
 							memcpy(rsp.attr_value.value, value.data(), rsp.attr_value.len);
 						}
-
-						if (m_pCallbacks != nullptr) {  // If is.long is false then this is the first (or only) request to read data, so invoke the callback
-							m_pCallbacks->onRead(this);   // Invoke the read callback.
-						}
 					}
 					rsp.attr_value.handle   = param->read.handle;
 					rsp.attr_value.auth_req = ESP_GATT_AUTH_REQ_NONE;
@@ -480,10 +479,13 @@ void BLECharacteristic::notify(bool is_notification) {
 	assert(getService() != nullptr);
 	assert(getService()->getServer() != nullptr);
 
+	m_pCallbacks->onNotify(this);   // Invoke the notify callback.
+
 	GeneralUtils::hexDump((uint8_t*)m_value.getValue().data(), m_value.getValue().length());
 
 	if (getService()->getServer()->getConnectedCount() == 0) {
 		log_v("<< notify: No connected clients.");
+		m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::ERROR_NO_CLIENT, 0);
 		return;
 	}
 
@@ -494,12 +496,14 @@ void BLECharacteristic::notify(bool is_notification) {
 	if(is_notification) {
 		if (p2902 != nullptr && !p2902->getNotifications()) {
 			log_v("<< notifications disabled; ignoring");
+			m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::ERROR_NOTIFY_DISABLED, 0);   // Invoke the notify callback.
 			return;
 		}
 	}
 	else{
 		if (p2902 != nullptr && !p2902->getIndications()) {
 			log_v("<< indications disabled; ignoring");
+			m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::ERROR_INDICATE_DISABLED, 0);   // Invoke the notify callback.
 			return;
 		}
 	}
@@ -510,7 +514,7 @@ void BLECharacteristic::notify(bool is_notification) {
 		}
 
 		size_t length = m_value.getValue().length();
-		if(!is_notification)
+		if(!is_notification) // is indication
 			m_semaphoreConfEvt.take("indicate");
 		esp_err_t errRc = ::esp_ble_gatts_send_indicate(
 				getService()->getServer()->getGattsIf(),
@@ -519,10 +523,23 @@ void BLECharacteristic::notify(bool is_notification) {
 		if (errRc != ESP_OK) {
 			log_e("<< esp_ble_gatts_send_ %s: rc=%d %s",is_notification?"notify":"indicate", errRc, GeneralUtils::errorToString(errRc));
 			m_semaphoreConfEvt.give();
+			m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::ERROR_GATT, errRc);   // Invoke the notify callback.
 			return;
 		}
-		if(!is_notification)
-			m_semaphoreConfEvt.wait("indicate");
+		if(!is_notification){ // is indication
+			if(!m_semaphoreConfEvt.timedWait("indicate", indicationTimeout)){
+				m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::ERROR_INDICATE_TIMEOUT, 0);   // Invoke the notify callback.
+			} else {
+				auto code = (esp_gatt_status_t) m_semaphoreConfEvt.value();
+				if(code == ESP_GATT_OK) {
+					m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::SUCCESS_INDICATE, code);   // Invoke the notify callback.
+				} else {
+					m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::ERROR_INDICATE_FAILURE, code);
+				}
+			}
+		} else {
+			m_pCallbacks->onStatus(this, BLECharacteristicCallbacks::Status::SUCCESS_NOTIFY, 0);   // Invoke the notify callback.
+		}
 	}
 	log_v("<< notify");
 } // Notify
@@ -551,7 +568,11 @@ void BLECharacteristic::setBroadcastProperty(bool value) {
  */
 void BLECharacteristic::setCallbacks(BLECharacteristicCallbacks* pCallbacks) {
 	log_v(">> setCallbacks: 0x%x", (uint32_t)pCallbacks);
-	m_pCallbacks = pCallbacks;
+	if (pCallbacks != nullptr){
+		m_pCallbacks = pCallbacks;
+	} else {
+		m_pCallbacks = &defaultCallback;
+	}
 	log_v("<< setCallbacks");
 } // setCallbacks
 
@@ -628,7 +649,9 @@ void BLECharacteristic::setValue(uint8_t* data, size_t length) {
 		log_e("Size %d too large, must be no bigger than %d", length, ESP_GATT_MAX_ATTR_LEN);
 		return;
 	}
+	m_semaphoreSetValue.take();  
 	m_value.setValue(data, length);
+	m_semaphoreSetValue.give();  
 	log_v("<< setValue");
 } // setValue
 
@@ -670,15 +693,13 @@ void BLECharacteristic::setValue(int& data32) {
 } // setValue
 
 void BLECharacteristic::setValue(float& data32) {
-	uint8_t temp[4];
-	*((float*)temp) = data32;
-	setValue(temp, 4);
+	float temp = data32;
+	setValue((uint8_t*)&temp, 4);
 } // setValue
 
 void BLECharacteristic::setValue(double& data64) {
-	uint8_t temp[8];
-	*((double*)temp) = data64;
-	setValue(temp, 8);
+	double temp = data64;
+	setValue((uint8_t*)&temp, 8);
 } // setValue
 
 
@@ -715,17 +736,18 @@ void BLECharacteristic::setWriteProperty(bool value) {
  * @return A string representation of the characteristic.
  */
 std::string BLECharacteristic::toString() {
-	std::stringstream stringstream;
-	stringstream << std::hex << std::setfill('0');
-	stringstream << "UUID: " << m_bleUUID.toString() + ", handle: 0x" << std::setw(2) << m_handle;
-	stringstream << " " <<
-		((m_properties & ESP_GATT_CHAR_PROP_BIT_READ) ? "Read " : "") <<
-		((m_properties & ESP_GATT_CHAR_PROP_BIT_WRITE) ? "Write " : "") <<
-		((m_properties & ESP_GATT_CHAR_PROP_BIT_WRITE_NR) ? "WriteNoResponse " : "") <<
-		((m_properties & ESP_GATT_CHAR_PROP_BIT_BROADCAST) ? "Broadcast " : "") <<
-		((m_properties & ESP_GATT_CHAR_PROP_BIT_NOTIFY) ? "Notify " : "") <<
-		((m_properties & ESP_GATT_CHAR_PROP_BIT_INDICATE) ? "Indicate " : "");
-	return stringstream.str();
+	std::string res = "UUID: " + m_bleUUID.toString() + ", handle : 0x";
+	char hex[5];
+	snprintf(hex, sizeof(hex), "%04x", m_handle);
+	res += hex;
+	res += " ";
+	if (m_properties & ESP_GATT_CHAR_PROP_BIT_READ) res += "Read ";
+	if (m_properties & ESP_GATT_CHAR_PROP_BIT_WRITE) res += "Write ";
+	if (m_properties & ESP_GATT_CHAR_PROP_BIT_WRITE_NR) res += "WriteNoResponse ";
+	if (m_properties & ESP_GATT_CHAR_PROP_BIT_BROADCAST) res += "Broadcast ";
+	if (m_properties & ESP_GATT_CHAR_PROP_BIT_NOTIFY) res += "Notify ";
+	if (m_properties & ESP_GATT_CHAR_PROP_BIT_INDICATE) res += "Indicate ";
+	return res;
 } // toString
 
 
@@ -751,4 +773,27 @@ void BLECharacteristicCallbacks::onWrite(BLECharacteristic* pCharacteristic) {
 	log_d("BLECharacteristicCallbacks", "<< onWrite");
 } // onWrite
 
+
+/**
+ * @brief Callback function to support a Notify request.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ */
+void BLECharacteristicCallbacks::onNotify(BLECharacteristic* pCharacteristic) {
+	log_d("BLECharacteristicCallbacks", ">> onNotify: default");
+	log_d("BLECharacteristicCallbacks", "<< onNotify");
+} // onNotify
+
+
+/**
+ * @brief Callback function to support a Notify/Indicate Status report.
+ * @param [in] pCharacteristic The characteristic that is the source of the event.
+ * @param [in] s Status of the notification/indication
+ * @param [in] code Additional code of underlying errors
+ */
+void BLECharacteristicCallbacks::onStatus(BLECharacteristic* pCharacteristic, Status s, uint32_t code) {
+	log_d("BLECharacteristicCallbacks", ">> onStatus: default");
+	log_d("BLECharacteristicCallbacks", "<< onStatus");
+} // onStatus
+
+
 #endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLECharacteristic.h

@@ -90,6 +90,8 @@ public:
 	static const uint32_t PROPERTY_INDICATE  = 1<<4;
 	static const uint32_t PROPERTY_WRITE_NR  = 1<<5;
 
+	static const uint32_t indicationTimeout = 1000;
+
 private:
 
 	friend class BLEServer;
@@ -117,6 +119,7 @@ private:
 	void                 setHandle(uint16_t handle);
 	FreeRTOS::Semaphore m_semaphoreCreateEvt = FreeRTOS::Semaphore("CreateEvt");
 	FreeRTOS::Semaphore m_semaphoreConfEvt   = FreeRTOS::Semaphore("ConfEvt");
+	FreeRTOS::Semaphore m_semaphoreSetValue  = FreeRTOS::Semaphore("SetValue");  
 }; // BLECharacteristic
 
 
@@ -129,9 +132,22 @@ private:
  */
 class BLECharacteristicCallbacks {
 public:
+	typedef enum {
+		SUCCESS_INDICATE,
+		SUCCESS_NOTIFY,
+		ERROR_INDICATE_DISABLED,
+		ERROR_NOTIFY_DISABLED,
+		ERROR_GATT,
+		ERROR_NO_CLIENT,
+		ERROR_INDICATE_TIMEOUT,
+		ERROR_INDICATE_FAILURE
+	}Status;
+
 	virtual ~BLECharacteristicCallbacks();
 	virtual void onRead(BLECharacteristic* pCharacteristic);
 	virtual void onWrite(BLECharacteristic* pCharacteristic);
+	virtual void onNotify(BLECharacteristic* pCharacteristic);
+	virtual void onStatus(BLECharacteristic* pCharacteristic, Status s, uint32_t code);
 };
 #endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLECHARACTERISTIC_H_ */

libraries/BLE/src/BLECharacteristicMap.cpp

@@ -116,17 +116,18 @@ void BLECharacteristicMap::setByUUID(BLECharacteristic* pCharacteristic, BLEUUID
  * @return A string representation of the characteristic map.
  */
 std::string BLECharacteristicMap::toString() {
-	std::stringstream stringStream;
-	stringStream << std::hex << std::setfill('0');
+	std::string res;
 	int count = 0;
+	char hex[5];
 	for (auto &myPair: m_uuidMap) {
-		if (count > 0) {
-			stringStream << "\n";
-		}
+		if (count > 0) {res += "\n";}
+		snprintf(hex, sizeof(hex), "%04x", myPair.first->getHandle());
 		count++;
-		stringStream << "handle: 0x" << std::setw(2) << myPair.first->getHandle() << ", uuid: " + myPair.first->getUUID().toString();
+		res += "handle: 0x";
+		res += hex;
+		res += ", uuid: " + myPair.first->getUUID().toString();
 	}
-	return stringStream.str();
+	return res;
 } // toString
 
 

libraries/BLE/src/BLEClient.cpp

@@ -184,10 +184,11 @@ void BLEClient::gattClientEventHandler(
 				if (m_pClientCallbacks != nullptr) {
 					m_pClientCallbacks->onDisconnect(this);
 				}
-				BLEDevice::removePeerDevice(m_appId, true);
 				esp_ble_gattc_app_unregister(m_gattc_if);
+				m_semaphoreOpenEvt.give(ESP_GATT_IF_NONE);
 				m_semaphoreRssiCmplEvt.give();
 				m_semaphoreSearchCmplEvt.give(1);
+				BLEDevice::removePeerDevice(m_appId, true);
 				break;
 		} // ESP_GATTC_DISCONNECT_EVT
 
@@ -515,14 +516,13 @@ uint16_t BLEClient::getMTU() {
  * @return A string representation of this client.
  */
 std::string BLEClient::toString() {
-	std::ostringstream ss;
-	ss << "peer address: " << m_peerAddress.toString();
-	ss << "\nServices:\n";
+	std::string res = "peer address: " + m_peerAddress.toString();
+	res += "\nServices:\n";
 	for (auto &myPair : m_servicesMap) {
-		ss << myPair.second->toString() << "\n";
+		res += myPair.second->toString() + "\n";
 	  // myPair.second is the value
 	}
-	return ss.str();
+	return res;
 } // toString
 
 

libraries/BLE/src/BLEClient.h

@@ -15,7 +15,7 @@
 #include <string.h>
 #include <map>
 #include <string>
-#include "BLEExceptions.h"
+//#include "BLEExceptions.h"
 #include "BLERemoteService.h"
 #include "BLEService.h"
 #include "BLEAddress.h"

libraries/BLE/src/BLEDescriptor.cpp

@@ -255,10 +255,10 @@ void BLEDescriptor::setAccessPermissions(esp_gatt_perm_t perm) {
  * @return A string representation of the descriptor.
  */
 std::string BLEDescriptor::toString() {
-	std::stringstream stringstream;
-	stringstream << std::hex << std::setfill('0');
-	stringstream << "UUID: " << m_bleUUID.toString() + ", handle: 0x" << std::setw(2) << m_handle;
-	return stringstream.str();
+	char hex[5];
+	snprintf(hex, sizeof(hex), "%04x", m_handle);
+	std::string res = "UUID: " + m_bleUUID.toString() + ", handle: 0x" + hex;
+	return res;
 } // toString
 
 

libraries/BLE/src/BLEDescriptorMap.cpp

@@ -90,17 +90,18 @@ void BLEDescriptorMap::setByHandle(uint16_t handle, BLEDescriptor* pDescriptor)
  * @return A string representation of the descriptor map.
  */
 std::string BLEDescriptorMap::toString() {
-	std::stringstream stringStream;
-	stringStream << std::hex << std::setfill('0');
+	std::string res;
+	char hex[5];
 	int count = 0;
 	for (auto &myPair : m_uuidMap) {
-		if (count > 0) {
-			stringStream << "\n";
-		}
+		if (count > 0) {res += "\n";}
+		snprintf(hex, sizeof(hex), "%04x", myPair.first->getHandle());
 		count++;
-		stringStream << "handle: 0x" << std::setw(2) << myPair.first->getHandle() << ", uuid: " + myPair.first->getUUID().toString();
+		res += "handle: 0x";
+		res += hex;
+		res += ", uuid: " + myPair.first->getUUID().toString();
 	}
-	return stringStream.str();
+	return res;
 } // toString
 
 

libraries/BLE/src/BLEDevice.cpp

@@ -32,14 +32,8 @@
 #include "esp32-hal-bt.h"
 #endif
 
-#if defined(CONFIG_ARDUHAL_ESP_LOG)
 #include "esp32-hal-log.h"
 
-#else
-#include "esp_log.h"
-static const char* LOG_TAG = "BLEDevice";
-#endif
-
 
 /**
  * Singletons for the BLEDevice.
@@ -447,11 +441,26 @@ gatts_event_handler BLEDevice::m_customGattsHandler = nullptr;
  * * ESP_PWR_LVL_P1
  * * ESP_PWR_LVL_P4
  * * ESP_PWR_LVL_P7
+ *
+ * The power types can be one of:
+ * * ESP_BLE_PWR_TYPE_CONN_HDL0
+ * * ESP_BLE_PWR_TYPE_CONN_HDL1
+ * * ESP_BLE_PWR_TYPE_CONN_HDL2
+ * * ESP_BLE_PWR_TYPE_CONN_HDL3
+ * * ESP_BLE_PWR_TYPE_CONN_HDL4
+ * * ESP_BLE_PWR_TYPE_CONN_HDL5
+ * * ESP_BLE_PWR_TYPE_CONN_HDL6
+ * * ESP_BLE_PWR_TYPE_CONN_HDL7
+ * * ESP_BLE_PWR_TYPE_CONN_HDL8
+ * * ESP_BLE_PWR_TYPE_ADV
+ * * ESP_BLE_PWR_TYPE_SCAN
+ * * ESP_BLE_PWR_TYPE_DEFAULT
+ * @param [in] powerType.
  * @param [in] powerLevel.
  */
-/* STATIC */ void BLEDevice::setPower(esp_power_level_t powerLevel) {
-	log_v(">> setPower: %d", powerLevel);
-	esp_err_t errRc = ::esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_DEFAULT, powerLevel);
+/* STATIC */ void BLEDevice::setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType) {
+	log_v(">> setPower: %d (type: %d)", powerLevel, powerType);
+	esp_err_t errRc = ::esp_ble_tx_power_set(powerType, powerLevel);
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_tx_power_set: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 	};
@@ -479,9 +488,8 @@ gatts_event_handler BLEDevice::m_customGattsHandler = nullptr;
  * @return A string representation of the nature of this device.
  */
 /* STATIC */ std::string BLEDevice::toString() {
-	std::ostringstream oss;
-	oss << "BD Address: " << getAddress().toString();
-	return oss.str();
+	std::string res = "BD Address: " + getAddress().toString();
+	return res;
 } // toString
 
 
@@ -491,7 +499,11 @@ gatts_event_handler BLEDevice::m_customGattsHandler = nullptr;
  */
 void BLEDevice::whiteListAdd(BLEAddress address) {
 	log_v(">> whiteListAdd: %s", address.toString().c_str());
-	esp_err_t errRc = esp_ble_gap_update_whitelist(true, *address.getNative());  // True to add an entry.
+#ifdef ESP_IDF_VERSION_MAJOR
+    esp_err_t errRc = esp_ble_gap_update_whitelist(true, *address.getNative(), BLE_WL_ADDR_TYPE_PUBLIC);  // HACK!!! True to add an entry.
+#else
+    esp_err_t errRc = esp_ble_gap_update_whitelist(true, *address.getNative());  // True to add an entry.
+#endif
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gap_update_whitelist: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 	}
@@ -505,7 +517,11 @@ void BLEDevice::whiteListAdd(BLEAddress address) {
  */
 void BLEDevice::whiteListRemove(BLEAddress address) {
 	log_v(">> whiteListRemove: %s", address.toString().c_str());
-	esp_err_t errRc = esp_ble_gap_update_whitelist(false, *address.getNative());  // False to remove an entry.
+#ifdef ESP_IDF_VERSION_MAJOR
+    esp_err_t errRc = esp_ble_gap_update_whitelist(false, *address.getNative(), BLE_WL_ADDR_TYPE_PUBLIC);  // HACK!!! False to remove an entry.
+#else
+    esp_err_t errRc = esp_ble_gap_update_whitelist(false, *address.getNative());  // False to remove an entry.
+#endif
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gap_update_whitelist: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 	}
@@ -570,6 +586,12 @@ void BLEDevice::startAdvertising() {
 	log_v("<< startAdvertising");
 } // startAdvertising
 
+void BLEDevice::stopAdvertising() {
+    log_v(">> stopAdvertising");
+    getAdvertising()->stop();
+    log_v("<< stopAdvertising");
+} // stopAdvertising
+
 /* multi connect support */
 /* requires a little more work */
 std::map<uint16_t, conn_status_t> BLEDevice::getPeerDevices(bool _client) {
@@ -626,7 +648,7 @@ void BLEDevice::removePeerDevice(uint16_t conn_id, bool _client) {
     esp_bluedroid_deinit();
     esp_bt_controller_disable();
     esp_bt_controller_deinit();
-#ifndef ARDUINO_ARCH_ESP32
+#ifdef ARDUINO_ARCH_ESP32
     if (release_memory) {
         esp_bt_controller_mem_release(ESP_BT_MODE_BTDM);  // <-- require tests because we released classic BT memory and this can cause crash (most likely not, esp-idf takes care of it)
     } else {

libraries/BLE/src/BLEDevice.h

@@ -37,7 +37,7 @@ public:
 	static BLEScan*    getScan();         // Get the scan object
 	static std::string getValue(BLEAddress bdAddress, BLEUUID serviceUUID, BLEUUID characteristicUUID);	  // Get the value of a characteristic of a service on a server.
 	static void        init(std::string deviceName);   // Initialize the local BLE environment.
-	static void        setPower(esp_power_level_t powerLevel);  // Set our power level.
+	static void        setPower(esp_power_level_t powerLevel, esp_ble_power_type_t powerType=ESP_BLE_PWR_TYPE_DEFAULT);  // Set our power level.
 	static void        setValue(BLEAddress bdAddress, BLEUUID serviceUUID, BLEUUID characteristicUUID, std::string value);   // Set the value of a characteristic on a service on a server.
 	static std::string toString();        // Return a string representation of our device.
 	static void        whiteListAdd(BLEAddress address);    // Add an entry to the BLE white list.
@@ -50,6 +50,7 @@ public:
 	/* move advertising to BLEDevice for saving ram and flash in beacons */
 	static BLEAdvertising* 	getAdvertising();
 	static void		   		startAdvertising();
+	static void		   		stopAdvertising();
 	static uint16_t 	m_appId;
 	/* multi connect */
 	static std::map<uint16_t, conn_status_t> getPeerDevices(bool client);

libraries/BLE/src/BLEEddystoneTLM.cpp

@@ -7,7 +7,7 @@
 #include "sdkconfig.h"
 #if defined(CONFIG_BT_ENABLED)
 #include <string.h>
-#include <sstream>
+#include <stdio.h>
 #include "esp32-hal-log.h"
 #include "BLEEddystoneTLM.h"
 
@@ -54,62 +54,44 @@ uint32_t BLEEddystoneTLM::getTime() {
 } // getTime
 
 std::string BLEEddystoneTLM::toString() {
-	std::stringstream ss;
-	std::string out = "";
-  uint32_t rawsec;
-  ss << "Version ";
-  ss << std::dec << m_eddystoneData.version;
-  ss << "\n";
+  std::string out = "";
+  uint32_t rawsec = ENDIAN_CHANGE_U32(m_eddystoneData.tmil);
+  char val[6];
 
-  ss << "Battery Voltage ";
-  ss << std::dec << ENDIAN_CHANGE_U16(m_eddystoneData.volt);
-  ss << " mV\n";
+  out += "Version " + m_eddystoneData.version;
+  out += "\n";
+  out += "Battery Voltage " + ENDIAN_CHANGE_U16(m_eddystoneData.volt);
+  out += " mV\n";
 
-  ss << "Temperature ";
-  ss << (float) m_eddystoneData.temp;
-  ss << " °C\n";
+  out += "Temperature ";
+  snprintf(val, sizeof(val), "%d", m_eddystoneData.temp);
+  out += val;
+  out += ".0 °C\n";
 
-  ss << "Adv. Count ";
-  ss << std::dec << ENDIAN_CHANGE_U32(m_eddystoneData.advCount);
+  out += "Adv. Count ";
+  snprintf(val, sizeof(val), "%d", ENDIAN_CHANGE_U32(m_eddystoneData.advCount));
+  out += val;
+  out += "\n";
 
-  ss << "\n";
+  out += "Time ";
 
-  ss << "Time ";
+  snprintf(val, sizeof(val), "%04d", rawsec / 864000);
+  out += val;
+  out += ".";
 
-  rawsec = ENDIAN_CHANGE_U32(m_eddystoneData.tmil);
-  std::stringstream buffstream;
-  buffstream << "0000";
-  buffstream << std::dec << rawsec / 864000;
-  std::string buff = buffstream.str();
+  snprintf(val, sizeof(val), "%02d", (rawsec / 36000) % 24);
+  out += val;
+  out += ":";
 
-  ss << buff.substr(buff.length() - 4, buff.length());
-  ss << ".";
+  snprintf(val, sizeof(val), "%02d", (rawsec / 600) % 60);
+  out += val;
+  out += ":";
 
-  buffstream.str("");
-  buffstream.clear();
-  buffstream << "00";
-  buffstream << std::dec << (rawsec / 36000) % 24;
-  buff = buffstream.str();
-  ss << buff.substr(buff.length()-2, buff.length());
-  ss << ":";
+  snprintf(val, sizeof(val), "%02d", (rawsec / 10) % 60);
+  out += val;
+  out += "\n";
 
-  buffstream.str("");
-  buffstream.clear();
-  buffstream << "00";
-  buffstream << std::dec << (rawsec / 600) % 60;
-  buff = buffstream.str();
-  ss << buff.substr(buff.length() - 2, buff.length());
-  ss << ":";
-
-  buffstream.str("");
-  buffstream.clear();
-  buffstream << "00";
-  buffstream << std::dec << (rawsec / 10) % 60;
-  buff = buffstream.str();
-  ss << buff.substr(buff.length() - 2, buff.length());
-  ss << "\n";
-
-  return ss.str();
+  return out;
 } // toString
 
 /**

libraries/BLE/src/BLEExceptions.cpp

@@ -5,5 +5,5 @@
  *      Author: kolban
  */
 
-#include "BLEExceptions.h"
+//#include "BLEExceptions.h"
 

libraries/BLE/src/BLERemoteCharacteristic.cpp

@@ -14,7 +14,7 @@
 #include <esp_err.h>
 
 #include <sstream>
-#include "BLEExceptions.h"
+//#include "BLEExceptions.h"
 #include "BLEUtils.h"
 #include "GeneralUtils.h"
 #include "BLERemoteDescriptor.h"
@@ -39,6 +39,8 @@ BLERemoteCharacteristic::BLERemoteCharacteristic(
 	m_charProp       = charProp;
 	m_pRemoteService = pRemoteService;
 	m_notifyCallback = nullptr;
+	m_rawData = nullptr;
+    m_auth           = ESP_GATT_AUTH_REQ_NONE;
 
 	retrieveDescriptors(); // Get the descriptors for this characteristic
 	log_v("<< BLERemoteCharacteristic");
@@ -388,6 +390,17 @@ uint8_t BLERemoteCharacteristic::readUInt8() {
 	return 0;
 } // readUInt8
 
+/**
+ * @brief Read a float value.
+ * @return the float value.
+ */
+float BLERemoteCharacteristic::readFloat() {
+	std::string value = readValue();
+	if (value.length() >= 4) {
+		return *(float*)(value.data());
+	}
+	return 0.0;
+} // readFloat
 
 /**
  * @brief Read the value of the remote characteristic.
@@ -399,7 +412,7 @@ std::string BLERemoteCharacteristic::readValue() {
 	// Check to see that we are connected.
 	if (!getRemoteService()->getClient()->isConnected()) {
 		log_e("Disconnected");
-		throw BLEDisconnectedException();
+		return std::string();
 	}
 
 	m_semaphoreReadCharEvt.take("readValue");
@@ -411,7 +424,7 @@ std::string BLERemoteCharacteristic::readValue() {
 		m_pRemoteService->getClient()->getGattcIf(),
 		m_pRemoteService->getClient()->getConnId(),    // The connection ID to the BLE server
 		getHandle(),                                   // The handle of this characteristic
-		ESP_GATT_AUTH_REQ_NONE);                       // Security
+		m_auth);                                         // Security
 
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gattc_read_char: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
@@ -500,11 +513,16 @@ void BLERemoteCharacteristic::removeDescriptors() {
  * @return a String representation.
  */
 std::string BLERemoteCharacteristic::toString() {
-	std::ostringstream ss;
-	ss << "Characteristic: uuid: " << m_uuid.toString() <<
-		", handle: " << getHandle() << " 0x" << std::hex << getHandle() <<
-		", props: " << BLEUtils::characteristicPropertiesToString(m_charProp);
-	return ss.str();
+	std::string res = "Characteristic: uuid: " + m_uuid.toString();
+	char val[6];
+	res += ", handle: ";
+	snprintf(val, sizeof(val), "%d", getHandle());
+	res += val;
+	res += " 0x";
+	snprintf(val, sizeof(val), "%04x", getHandle());
+	res += val;
+	res += ", props: " + BLEUtils::characteristicPropertiesToString(m_charProp);
+	return res;
 } // toString
 
 
@@ -545,7 +563,7 @@ void BLERemoteCharacteristic::writeValue(uint8_t* data, size_t length, bool resp
 	// Check to see that we are connected.
 	if (!getRemoteService()->getClient()->isConnected()) {
 		log_e("Disconnected");
-		throw BLEDisconnectedException();
+		return;
 	}
 
 	m_semaphoreWriteCharEvt.take("writeValue");
@@ -557,7 +575,7 @@ void BLERemoteCharacteristic::writeValue(uint8_t* data, size_t length, bool resp
 		length,
 		data,
 		response?ESP_GATT_WRITE_TYPE_RSP:ESP_GATT_WRITE_TYPE_NO_RSP,
-		ESP_GATT_AUTH_REQ_NONE
+        m_auth
 	);
 
 	if (errRc != ESP_OK) {
@@ -578,4 +596,12 @@ uint8_t* BLERemoteCharacteristic::readRawData() {
 	return m_rawData;
 }
 
+/**
+ * @brief Set authentication request type for characteristic
+ * @param [in] auth Authentication request type.
+ */
+void BLERemoteCharacteristic::setAuth(esp_gatt_auth_req_t auth) {
+    m_auth = auth;
+}
+
 #endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLERemoteCharacteristic.h

@@ -45,12 +45,14 @@ public:
 	uint8_t     readUInt8();
 	uint16_t    readUInt16();
 	uint32_t    readUInt32();
+	float       readFloat();
 	void        registerForNotify(notify_callback _callback, bool notifications = true);
 	void        writeValue(uint8_t* data, size_t length, bool response = false);
 	void        writeValue(std::string newValue, bool response = false);
 	void        writeValue(uint8_t newValue, bool response = false);
 	std::string toString();
 	uint8_t*	readRawData();
+    void        setAuth(esp_gatt_auth_req_t auth);
 
 private:
 	BLERemoteCharacteristic(uint16_t handle, BLEUUID uuid, esp_gatt_char_prop_t charProp, BLERemoteService* pRemoteService);
@@ -68,6 +70,7 @@ private:
 	// Private properties
 	BLEUUID              m_uuid;
 	esp_gatt_char_prop_t m_charProp;
+    esp_gatt_auth_req_t  m_auth;
 	uint16_t             m_handle;
 	BLERemoteService*    m_pRemoteService;
 	FreeRTOS::Semaphore  m_semaphoreReadCharEvt      = FreeRTOS::Semaphore("ReadCharEvt");

libraries/BLE/src/BLERemoteDescriptor.cpp

@@ -19,6 +19,7 @@ BLERemoteDescriptor::BLERemoteDescriptor(
 	m_handle                = handle;
 	m_uuid                  = uuid;
 	m_pRemoteCharacteristic = pRemoteCharacteristic;
+    m_auth                  = ESP_GATT_AUTH_REQ_NONE;
 }
 
 
@@ -55,7 +56,7 @@ std::string BLERemoteDescriptor::readValue() {
 	// Check to see that we are connected.
 	if (!getRemoteCharacteristic()->getRemoteService()->getClient()->isConnected()) {
 		log_e("Disconnected");
-		throw BLEDisconnectedException();
+		return std::string();
 	}
 
 	m_semaphoreReadDescrEvt.take("readValue");
@@ -65,7 +66,7 @@ std::string BLERemoteDescriptor::readValue() {
 		m_pRemoteCharacteristic->getRemoteService()->getClient()->getGattcIf(),
 		m_pRemoteCharacteristic->getRemoteService()->getClient()->getConnId(),    // The connection ID to the BLE server
 		getHandle(),                                   // The handle of this characteristic
-		ESP_GATT_AUTH_REQ_NONE);                       // Security
+		m_auth);                       // Security
 
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gattc_read_char: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
@@ -113,9 +114,12 @@ uint32_t BLERemoteDescriptor::readUInt32() {
  * @retun A string representation of this BLE Remote Descriptor.
  */
 std::string BLERemoteDescriptor::toString() {
-	std::stringstream ss;
-	ss << "handle: " << getHandle() << ", uuid: " << getUUID().toString();
-	return ss.str();
+	char val[6];
+	snprintf(val, sizeof(val), "%d", getHandle());
+	std::string res = "handle: ";
+	res += val;
+	res += ", uuid: " + getUUID().toString();
+	return res;
 } // toString
 
 
@@ -130,7 +134,7 @@ void BLERemoteDescriptor::writeValue(uint8_t* data, size_t length, bool response
 	// Check to see that we are connected.
 	if (!getRemoteCharacteristic()->getRemoteService()->getClient()->isConnected()) {
 		log_e("Disconnected");
-		throw BLEDisconnectedException();
+		return;
 	}
 
 	esp_err_t errRc = ::esp_ble_gattc_write_char_descr(
@@ -140,7 +144,7 @@ void BLERemoteDescriptor::writeValue(uint8_t* data, size_t length, bool response
 		length,                           // Data length
 		data,                             // Data
 		response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP,
-		ESP_GATT_AUTH_REQ_NONE
+		m_auth
 	);
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gattc_write_char_descr: %d", errRc);
@@ -168,5 +172,12 @@ void BLERemoteDescriptor::writeValue(uint8_t newValue, bool response) {
 	writeValue(&newValue, 1, response);
 } // writeValue
 
+/**
+ * @brief Set authentication request type for characteristic
+ * @param [in] auth Authentication request type.
+ */
+void BLERemoteDescriptor::setAuth(esp_gatt_auth_req_t auth) {
+    m_auth = auth;
+}
 
 #endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLERemoteDescriptor.h

@@ -34,6 +34,7 @@ public:
 	void        writeValue(uint8_t* data, size_t length, bool response = false);
 	void        writeValue(std::string newValue, bool response = false);
 	void        writeValue(uint8_t newValue, bool response = false);
+    void        setAuth(esp_gatt_auth_req_t auth);
 
 
 private:
@@ -48,6 +49,7 @@ private:
 	std::string              m_value;                   // Last received value of the descriptor.
 	BLERemoteCharacteristic* m_pRemoteCharacteristic;   // Reference to the Remote characteristic of which this descriptor is associated.
 	FreeRTOS::Semaphore      m_semaphoreReadDescrEvt      = FreeRTOS::Semaphore("ReadDescrEvt");
+    esp_gatt_auth_req_t      m_auth;
 
 
 };

libraries/BLE/src/BLERemoteService.cpp

@@ -14,6 +14,8 @@
 #include <esp_err.h>
 #include "esp32-hal-log.h"
 
+#pragma GCC diagnostic warning "-Wunused-but-set-parameter"
+
 BLERemoteService::BLERemoteService(
 		esp_gatt_id_t srvcId,
 		BLEClient*    pClient,
@@ -164,7 +166,7 @@ void BLERemoteService::retrieveCharacteristics() {
 	uint16_t offset = 0;
 	esp_gattc_char_elem_t result;
 	while (true) {
-		uint16_t count = 10;  // this value is used as in parameter that allows to search max 10 chars with the same uuid
+		uint16_t count = 1; // only room for 1 result allocated, so go one by one
 		esp_gatt_status_t status = ::esp_ble_gattc_get_all_char(
 			getClient()->getGattcIf(),
 			getClient()->getConnId(),
@@ -224,12 +226,25 @@ std::map<std::string, BLERemoteCharacteristic*>* BLERemoteService::getCharacteri
 	return &m_characteristicMap;
 } // getCharacteristics
 
+/**
+ * @brief Retrieve a map of all the characteristics of this service.
+ * @return A map of all the characteristics of this service.
+ */
+std::map<uint16_t, BLERemoteCharacteristic*>* BLERemoteService::getCharacteristicsByHandle() {
+	// If is possible that we have not read the characteristics associated with the service so do that
+	// now.  The request to retrieve the characteristics by calling "retrieveCharacteristics" is a blocking
+	// call and does not return until all the characteristics are available.
+	if (!m_haveCharacteristics) {
+		retrieveCharacteristics();
+	}
+	return &m_characteristicMapByHandle;
+} // getCharacteristicsByHandle
+
 /**
  * @brief This function is designed to get characteristics map when we have multiple characteristics with the same UUID
  */
-void BLERemoteService::getCharacteristics(std::map<uint16_t, BLERemoteCharacteristic*>* pCharacteristicMap) {
-#pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
-	pCharacteristicMap = &m_characteristicMapByHandle;
+void BLERemoteService::getCharacteristics(std::map<uint16_t, BLERemoteCharacteristic*>** pCharacteristicMap) {
+	*pCharacteristicMap = &m_characteristicMapByHandle;
 }  // Get the characteristics map.
 
 /**
@@ -317,15 +332,25 @@ void BLERemoteService::setValue(BLEUUID characteristicUuid, std::string value) {
  * @return A string representation of this remote service.
  */
 std::string BLERemoteService::toString() {
-	std::ostringstream ss;
-	ss << "Service: uuid: " + m_uuid.toString();
-	ss << ", start_handle: " << std::dec << m_startHandle << " 0x" << std::hex << m_startHandle <<
-			", end_handle: " << std::dec << m_endHandle << " 0x" << std::hex << m_endHandle;
+	std::string res = "Service: uuid: " + m_uuid.toString();
+	char val[6];
+	res += ", start_handle: ";
+	snprintf(val, sizeof(val), "%d", m_startHandle);
+	res += val;
+	snprintf(val, sizeof(val), "%04x", m_startHandle);
+	res += " 0x";
+	res += val;
+	res += ", end_handle: ";
+	snprintf(val, sizeof(val), "%d", m_endHandle);
+	res += val;
+	snprintf(val, sizeof(val), "%04x", m_endHandle);
+	res += " 0x";
+	res += val;
 	for (auto &myPair : m_characteristicMap) {
-		ss << "\n" << myPair.second->toString();
+		res += "\n" + myPair.second->toString();
 	   // myPair.second is the value
 	}
-	return ss.str();
+	return res;
 } // toString
 
 

libraries/BLE/src/BLERemoteService.h

@@ -34,7 +34,7 @@ public:
 	BLERemoteCharacteristic* getCharacteristic(uint16_t uuid);      // Get the specified characteristic reference.
 	std::map<std::string, BLERemoteCharacteristic*>* getCharacteristics();
 	std::map<uint16_t, BLERemoteCharacteristic*>* getCharacteristicsByHandle();  // Get the characteristics map.
-	void getCharacteristics(std::map<uint16_t, BLERemoteCharacteristic*>* pCharacteristicMap);
+	void getCharacteristics(std::map<uint16_t, BLERemoteCharacteristic*>** pCharacteristicMap);
 
 	BLEClient*               getClient(void);                                           // Get a reference to the client associated with this service.
 	uint16_t                 getHandle();                                               // Get the handle of this service.

libraries/BLE/src/BLEServer.cpp

@@ -412,4 +412,9 @@ void BLEServer::updateConnParams(esp_bd_addr_t remote_bda, uint16_t minInterval,
 	conn_params.timeout = timeout;    // timeout = 400*10ms = 4000ms
 	esp_ble_gap_update_conn_params(&conn_params); 
 }
+
+void BLEServer::disconnect(uint16_t connId) {
+	esp_ble_gatts_close(m_gatts_if, connId);
+}
+
 #endif // CONFIG_BT_ENABLED

libraries/BLE/src/BLEServer.h

@@ -72,6 +72,7 @@ public:
 	BLEService* 	getServiceByUUID(const char* uuid);
 	BLEService* 	getServiceByUUID(BLEUUID uuid);
 	bool 			connect(BLEAddress address);
+	void 			disconnect(uint16_t connId);
 	uint16_t		m_appId;
 	void			updateConnParams(esp_bd_addr_t remote_bda, uint16_t minInterval, uint16_t maxInterval, uint16_t latency, uint16_t timeout);
 

libraries/BLE/src/BLEService.cpp

@@ -381,10 +381,12 @@ BLECharacteristic* BLEService::getCharacteristic(BLEUUID uuid) {
  * @return A string representation of this service.
  */
 std::string BLEService::toString() {
-	std::stringstream stringStream;
-	stringStream << "UUID: " << getUUID().toString() <<
-		", handle: 0x" << std::hex << std::setfill('0') << std::setw(2) << getHandle();
-	return stringStream.str();
+	std::string res = "UUID: " + getUUID().toString();
+	char hex[5];
+	snprintf(hex, sizeof(hex), "%04x", getHandle());
+	res += ", handle: 0x";
+	res += hex;
+	return res;
 } // toString
 
 

libraries/BLE/src/BLEServiceMap.cpp

@@ -6,7 +6,7 @@
  */
 #include "sdkconfig.h"
 #if defined(CONFIG_BT_ENABLED)
-#include <sstream>
+#include <stdio.h>
 #include <iomanip>
 #include "BLEService.h"
 
@@ -73,12 +73,15 @@ void BLEServiceMap::setByHandle(uint16_t handle, BLEService* service) {
  * @return A string representation of the service map.
  */
 std::string BLEServiceMap::toString() {
-	std::stringstream stringStream;
-	stringStream << std::hex << std::setfill('0');
+	std::string res;
+	char hex[5];
 	for (auto &myPair: m_handleMap) {
-		stringStream << "handle: 0x" << std::setw(2) << myPair.first << ", uuid: " + myPair.second->getUUID().toString() << "\n";
+		res += "handle: 0x";
+		snprintf(hex, sizeof(hex), "%04x", myPair.first);
+		res += hex;
+		res += ", uuid: " + myPair.second->getUUID().toString() + "\n";
 	}
-	return stringStream.str();
+	return res;
 } // toString
 
 void BLEServiceMap::handleGATTServerEvent(

libraries/BLE/src/BLEUUID.cpp

@@ -349,51 +349,38 @@ BLEUUID BLEUUID::to128() {
  */
 std::string BLEUUID::toString() {
 	if (!m_valueSet) return "<NULL>";   // If we have no value, nothing to format.
-
 	// If the UUIDs are 16 or 32 bit, pad correctly.
-	std::stringstream ss;
 
 	if (m_uuid.len == ESP_UUID_LEN_16) {  // If the UUID is 16bit, pad correctly.
-		ss << "0000" <<
-			std::hex <<
-			std::setfill('0') <<
-			std::setw(4) <<
-			m_uuid.uuid.uuid16 <<
-			"-0000-1000-8000-00805f9b34fb";
-		return ss.str();                    // Return the string
+		char hex[9];
+		snprintf(hex, sizeof(hex), "%08x", m_uuid.uuid.uuid16);
+		return std::string(hex) + "-0000-1000-8000-00805f9b34fb";
 	} // End 16bit UUID
 
 	if (m_uuid.len == ESP_UUID_LEN_32) {  // If the UUID is 32bit, pad correctly.
-		ss << std::hex <<
-			std::setfill('0') <<
-			std::setw(8) <<
-			m_uuid.uuid.uuid32 <<
-			"-0000-1000-8000-00805f9b34fb";
-		return ss.str();                    // return the string
+		char hex[9];
+		snprintf(hex, sizeof(hex), "%08x", m_uuid.uuid.uuid32);
+		return std::string(hex) + "-0000-1000-8000-00805f9b34fb";
 	} // End 32bit UUID
 
 	// The UUID is not 16bit or 32bit which means that it is 128bit.
 	//
 	// UUID string format:
 	// AABBCCDD-EEFF-GGHH-IIJJ-KKLLMMNNOOPP
-	ss << std::hex << std::setfill('0') <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[15] <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[14] <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[13] <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[12] << "-" <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[11] <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[10] << "-" <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[9]  <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[8]  << "-" <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[7]  <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[6]  << "-" <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[5]  <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[4]  <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[3]  <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[2]  <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[1]  <<
-		std::setw(2) << (int) m_uuid.uuid.uuid128[0];
-	return ss.str();
+	auto size = 37; // 32 for UUID data, 4 for '-' delimiters and one for a terminator == 37 chars
+	char *hex = (char *)malloc(size);
+	snprintf(hex, size, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+			m_uuid.uuid.uuid128[15], m_uuid.uuid.uuid128[14],
+			m_uuid.uuid.uuid128[13], m_uuid.uuid.uuid128[12],
+			m_uuid.uuid.uuid128[11], m_uuid.uuid.uuid128[10],
+			m_uuid.uuid.uuid128[9], m_uuid.uuid.uuid128[8],
+			m_uuid.uuid.uuid128[7], m_uuid.uuid.uuid128[6],
+			m_uuid.uuid.uuid128[5], m_uuid.uuid.uuid128[4],
+			m_uuid.uuid.uuid128[3], m_uuid.uuid.uuid128[2],
+			m_uuid.uuid.uuid128[1], m_uuid.uuid.uuid128[0]);
+	std::string res(hex);
+	free(hex);
+	return res;
 } // toString
 
 #endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLEUtils.cpp

@@ -604,26 +604,32 @@ static const gattService_t g_gattServices[] = {
  * @return A string representation of characteristic properties.
  */
 std::string BLEUtils::characteristicPropertiesToString(esp_gatt_char_prop_t prop) {
-	std::stringstream stream;
-	stream <<
-			"broadcast: "  << ((prop & ESP_GATT_CHAR_PROP_BIT_BROADCAST)?"1":"0") <<
-			", read: "     << ((prop & ESP_GATT_CHAR_PROP_BIT_READ)?"1":"0") <<
-			", write_nr: " << ((prop & ESP_GATT_CHAR_PROP_BIT_WRITE_NR)?"1":"0") <<
-			", write: "    << ((prop & ESP_GATT_CHAR_PROP_BIT_WRITE)?"1":"0") <<
-			", notify: "   << ((prop & ESP_GATT_CHAR_PROP_BIT_NOTIFY)?"1":"0") <<
-			", indicate: " << ((prop & ESP_GATT_CHAR_PROP_BIT_INDICATE)?"1":"0") <<
-			", auth: "     << ((prop & ESP_GATT_CHAR_PROP_BIT_AUTH)?"1":"0");
-	return stream.str();
+	std::string res = "broadcast: ";
+	res += ((prop & ESP_GATT_CHAR_PROP_BIT_BROADCAST)?"1":"0");
+	res += ", read: ";
+	res += ((prop & ESP_GATT_CHAR_PROP_BIT_READ)?"1":"0");
+	res += ", write_nr: ";
+	res += ((prop & ESP_GATT_CHAR_PROP_BIT_WRITE_NR)?"1":"0");
+	res += ", write: ";
+	res += ((prop & ESP_GATT_CHAR_PROP_BIT_WRITE)?"1":"0");
+	res += ", notify: ";
+	res += ((prop & ESP_GATT_CHAR_PROP_BIT_NOTIFY)?"1":"0");
+	res += ", indicate: ";
+	res += ((prop & ESP_GATT_CHAR_PROP_BIT_INDICATE)?"1":"0");
+	res += ", auth: ";
+	res += ((prop & ESP_GATT_CHAR_PROP_BIT_AUTH)?"1":"0");
+	return res;
 } // characteristicPropertiesToString
 
 /**
  * @brief Convert an esp_gatt_id_t to a string.
  */
 static std::string gattIdToString(esp_gatt_id_t gattId) {
-	std::stringstream stream;
-	stream << "uuid: " << BLEUUID(gattId.uuid).toString() << ", inst_id: " << (int)gattId.inst_id;
-	//sprintf(buffer, "uuid: %s, inst_id: %d", uuidToString(gattId.uuid).c_str(), gattId.inst_id);
-	return stream.str();
+	std::string res = "uuid: " + BLEUUID(gattId.uuid).toString() + ", inst_id: ";
+	char val[8];
+	snprintf(val, sizeof(val), "%d", (int)gattId.inst_id);
+	res += val;
+	return res;
 } // gattIdToString
 
 
@@ -654,23 +660,23 @@ const char* BLEUtils::addressTypeToString(esp_ble_addr_type_t type) {
  * @return std::string A string representation of the advertising flags.
  */
 std::string BLEUtils::adFlagsToString(uint8_t adFlags) {
-	std::stringstream ss;
+	std::string res;
 	if (adFlags & (1 << 0)) {
-		ss << "[LE Limited Discoverable Mode] ";
+		res += "[LE Limited Discoverable Mode] ";
 	}
 	if (adFlags & (1 << 1)) {
-		ss << "[LE General Discoverable Mode] ";
+		res += "[LE General Discoverable Mode] ";
 	}
 	if (adFlags & (1 << 2)) {
-		ss << "[BR/EDR Not Supported] ";
+		res += "[BR/EDR Not Supported] ";
 	}
 	if (adFlags & (1 << 3)) {
-		ss << "[Simultaneous LE and BR/EDR to Same Device Capable (Controller)] ";
+		res += "[Simultaneous LE and BR/EDR to Same Device Capable (Controller)] ";
 	}
 	if (adFlags & (1 << 4)) {
-		ss << "[Simultaneous LE and BR/EDR to Same Device Capable (Host)] ";
+		res += "[Simultaneous LE and BR/EDR to Same Device Capable (Host)] ";
 	}
-	return ss.str();
+	return res;
 } // adFlagsToString
 
 
@@ -802,13 +808,13 @@ char* BLEUtils::buildHexData(uint8_t* target, uint8_t* source, uint8_t length) {
  * @return A string representation of a piece of memory.
  */
 std::string BLEUtils::buildPrintData(uint8_t* source, size_t length) {
-	std::ostringstream ss;
+	std::string res;
 	for (int i = 0; i < length; i++) {
 		char c = *source;
-		ss << (isprint(c) ? c : '.');
+		res += (isprint(c) ? c : '.');
 		source++;
 	}
-	return ss.str();
+	return res;
 } // buildPrintData
 
 
@@ -1848,14 +1854,22 @@ std::string BLEUtils::gattDescriptorUUIDToString(uint32_t descriptorUUID) {
  * @return A string representation of an esp_gattc_service_elem_t.
  */
 std::string BLEUtils::gattcServiceElementToString(esp_gattc_service_elem_t* pGATTCServiceElement) {
-	std::stringstream ss;
-
-	ss << "[uuid: " << BLEUUID(pGATTCServiceElement->uuid).toString() <<
-		", start_handle: " << pGATTCServiceElement->start_handle <<
-			" 0x" << std::hex << pGATTCServiceElement->start_handle <<
-		", end_handle: " << std::dec << pGATTCServiceElement->end_handle <<
-		  " 0x" << std::hex << pGATTCServiceElement->end_handle << "]";
-	return ss.str();
+	std::string res;
+	char val[6];
+	res += "[uuid: " + BLEUUID(pGATTCServiceElement->uuid).toString() + ", start_handle: ";
+	snprintf(val, sizeof(val), "%d", pGATTCServiceElement->start_handle);
+	res += val;
+	res += " 0x";
+	snprintf(val, sizeof(val), "%04x", pGATTCServiceElement->start_handle);
+	res += val;
+	res += ", end_handle: ";
+	snprintf(val, sizeof(val), "%d", pGATTCServiceElement->end_handle);
+	res += val;
+	res += " 0x";
+	snprintf(val, sizeof(val), "%04x", pGATTCServiceElement->end_handle);
+	res += val;
+	res += "]";
+	return res;
 } // gattcServiceElementToString
 
 

libraries/BLE/src/FreeRTOS.cpp

@@ -78,6 +78,38 @@ uint32_t FreeRTOS::Semaphore::wait(std::string owner) {
 	return m_value;
 } // wait
 
+/**
+ * @brief Wait for a semaphore to be released in a given period of time by trying to take it and
+ * then releasing it again. The value associated with the semaphore can be taken by value() call after return
+ * @param [in] owner A debug tag.
+ * @param [in] timeoutMs timeout to wait in ms.
+ * @return True if we took the semaphore within timeframe.
+ */
+bool FreeRTOS::Semaphore::timedWait(std::string owner, uint32_t timeoutMs) {
+	log_v(">> wait: Semaphore waiting: %s for %s", toString().c_str(), owner.c_str());
+
+	if (m_usePthreads && timeoutMs != portMAX_DELAY) {
+		assert(false);  // We apparently don't have a timed wait for pthreads.
+	}
+
+	auto ret = pdTRUE;
+
+	if (m_usePthreads) {
+		pthread_mutex_lock(&m_pthread_mutex);
+	} else {
+		ret = xSemaphoreTake(m_semaphore, timeoutMs);
+	}
+
+	if (m_usePthreads) {
+		pthread_mutex_unlock(&m_pthread_mutex);
+	} else {
+		xSemaphoreGive(m_semaphore);
+	}
+
+	log_v("<< wait: Semaphore %s released: %d", toString().c_str(), ret);
+	return ret;
+} // wait
+
 
 FreeRTOS::Semaphore::Semaphore(std::string name) {
 	m_usePthreads = false;   	// Are we using pThreads or FreeRTOS?
@@ -154,7 +186,7 @@ void FreeRTOS::Semaphore::giveFromISR() {
  * @return True if we took the semaphore.
  */
 bool FreeRTOS::Semaphore::take(std::string owner) {
-	log_d("Semaphore taking: %s for %s", toString().c_str(), owner.c_str());
+	log_v("Semaphore taking: %s for %s", toString().c_str(), owner.c_str());
 	bool rc = false;
 	if (m_usePthreads) {
 		pthread_mutex_lock(&m_pthread_mutex);
@@ -163,7 +195,7 @@ bool FreeRTOS::Semaphore::take(std::string owner) {
 	}
 	m_owner = owner;
 	if (rc) {
-		log_d("Semaphore taken:  %s", toString().c_str());
+		log_v("Semaphore taken:  %s", toString().c_str());
 	} else {
 		log_e("Semaphore NOT taken:  %s", toString().c_str());
 	}
@@ -202,9 +234,12 @@ bool FreeRTOS::Semaphore::take(uint32_t timeoutMs, std::string owner) {
  * @return A string representation of the semaphore.
  */
 std::string FreeRTOS::Semaphore::toString() {
-	std::stringstream stringStream;
-	stringStream << "name: "<< m_name << " (0x" << std::hex << std::setfill('0') << (uint32_t)m_semaphore << "), owner: " << m_owner;
-	return stringStream.str();
+	char hex[9];
+	std::string res = "name: " + m_name + " (0x";
+	snprintf(hex, sizeof(hex), "%08x", (uint32_t)m_semaphore);
+	res += hex;
+	res += "), owner: " + m_owner;
+	return res;
 } // toString
 
 
@@ -222,7 +257,12 @@ void FreeRTOS::Semaphore::setName(std::string name) {
  * @param [in] length The amount of storage to allocate for the ring buffer.
  * @param [in] type The type of buffer.  One of RINGBUF_TYPE_NOSPLIT, RINGBUF_TYPE_ALLOWSPLIT, RINGBUF_TYPE_BYTEBUF.
  */
-Ringbuffer::Ringbuffer(size_t length, ringbuf_type_t type) {
+#ifdef ESP_IDF_VERSION_MAJOR
+Ringbuffer::Ringbuffer(size_t length, RingbufferType_t type)
+#else
+Ringbuffer::Ringbuffer(size_t length, ringbuf_type_t type)
+#endif
+{
 	m_handle = ::xRingbufferCreate(length, type);
 } // Ringbuffer
 

libraries/BLE/src/FreeRTOS.h

@@ -40,6 +40,8 @@ public:
 		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;
@@ -58,7 +60,11 @@ public:
  */
 class Ringbuffer {
 public:
-	Ringbuffer(size_t length, ringbuf_type_t type = RINGBUF_TYPE_NOSPLIT);
+#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);

libraries/BLE/src/GeneralUtils.cpp

@@ -104,11 +104,10 @@ bool GeneralUtils::base64Encode(const std::string& in, std::string* out) {
  * * Amount of free RAM
  */
 void GeneralUtils::dumpInfo() {
-	size_t freeHeap = heap_caps_get_free_size(MALLOC_CAP_8BIT);
 	esp_chip_info_t chipInfo;
 	esp_chip_info(&chipInfo);
 	log_v("--- dumpInfo ---");
-	log_v("Free heap: %d", freeHeap);
+	log_v("Free heap: %d", heap_caps_get_free_size(MALLOC_CAP_8BIT));
 	log_v("Chip Info: Model: %d, cores: %d, revision: %d", chipInfo.model, chipInfo.cores, chipInfo.revision);
 	log_v("ESP-IDF version: %s", esp_get_idf_version());
 	log_v("---");
@@ -332,9 +331,12 @@ void GeneralUtils::hexDump(const uint8_t* pData, uint32_t length) {
  * @return A string representation of the IP address.
  */
 std::string GeneralUtils::ipToString(uint8_t *ip) {
-	std::stringstream s;
-	s << (int) ip[0] << '.' << (int) ip[1] << '.' << (int) ip[2] << '.' << (int) ip[3];
-	return s.str();
+	auto size = 16;
+	char *val = (char*)malloc(size);
+	snprintf(val, size, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
+	std::string res(val);
+	free(val);
+	return res;
 } // ipToString
 
 
@@ -347,11 +349,14 @@ std::string GeneralUtils::ipToString(uint8_t *ip) {
 std::vector<std::string> GeneralUtils::split(std::string source, char delimiter) {
 	// See also: https://stackoverflow.com/questions/5167625/splitting-a-c-stdstring-using-tokens-e-g
 	std::vector<std::string> strings;
-	std::istringstream iss(source);
-	std::string s;
-	while (std::getline(iss, s, delimiter)) {
-		strings.push_back(trim(s));
+	std::size_t current, previous = 0;
+	current = source.find(delimiter);
+	while (current != std::string::npos) {
+		strings.push_back(trim(source.substr(previous, current - previous)));
+		previous = current + 1;
+		current = source.find(delimiter, previous);
 	}
+	strings.push_back(trim(source.substr(previous, current - previous)));
 	return strings;
 } // split
 

libraries/BluetoothSerial/examples/SerialToSerialBTM/SerialToSerialBTM.ino

@@ -0,0 +1,56 @@
+//This example code is in the Public Domain (or CC0 licensed, at your option.)
+//By Victor Tchistiak - 2019
+//
+//This example demostrates master mode bluetooth connection and pin 
+//it creates a bridge between Serial and Classical Bluetooth (SPP)
+//this is an extention of the SerialToSerialBT example by Evandro Copercini - 2018
+//
+
+#include "BluetoothSerial.h"
+
+BluetoothSerial SerialBT;
+
+String MACadd = "AA:BB:CC:11:22:33";
+uint8_t address[6]  = {0xAA, 0xBB, 0xCC, 0x11, 0x22, 0x33};
+//uint8_t address[6]  = {0x00, 0x1D, 0xA5, 0x02, 0xC3, 0x22};
+String name = "OBDII";
+const char *pin = "1234"; //<- standard pin would be provided by default
+bool connected;
+
+void setup() {
+  Serial.begin(115200);
+  //SerialBT.setPin(pin);
+  SerialBT.begin("ESP32test", true); 
+  //SerialBT.setPin(pin);
+  Serial.println("The device started in master mode, make sure remote BT device is on!");
+  
+  // connect(address) is fast (upto 10 secs max), connect(name) is slow (upto 30 secs max) as it needs
+  // to resolve name to address first, but it allows to connect to different devices with the same name.
+  // Set CoreDebugLevel to Info to view devices bluetooth address and device names
+  connected = SerialBT.connect(name);
+  //connected = SerialBT.connect(address);
+  
+  if(connected) {
+    Serial.println("Connected Succesfully!");
+  } else {
+    while(!SerialBT.connected(10000)) {
+      Serial.println("Failed to connect. Make sure remote device is available and in range, then restart app."); 
+    }
+  }
+  // disconnect() may take upto 10 secs max
+  if (SerialBT.disconnect()) {
+    Serial.println("Disconnected Succesfully!");
+  }
+  // this would reconnect to the name(will use address, if resolved) or address used with connect(name/address).
+  SerialBT.connect();
+}
+
+void loop() {
+  if (Serial.available()) {
+    SerialBT.write(Serial.read());
+  }
+  if (SerialBT.available()) {
+    Serial.write(SerialBT.read());
+  }
+  delay(20);
+}