Update toolchain and move files to github

Co-authored-by: me-no-dev <me-no-dev@github.com>

.github/scripts/check-cmakelists.sh

@@ -8,8 +8,6 @@
 
 set -e
 
-cd "`dirname $0`/.."  # cd to arduino-esp32 root
-
 # pull all submodules
 git submodule update --init --recursive
 

.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,226 @@
+#!/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
+
+# Updated as of Nov 3rd 2020
+ARDUINO_IDE_URL="https://github.com/espressif/arduino-esp32/releases/download/1.0.4/arduino-nightly-"
+
+# Currently not working
+#ARDUINO_IDE_URL="https://www.arduino.cc/download.php?f=/arduino-nightly-"
+
+if [ ! -d "$ARDUINO_IDE_PATH" ]; then
+	echo "Installing Arduino IDE on $OS_NAME ..."
+	echo "Downloading '$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
+	if [ "$OS_IS_LINUX" == "1" ]; then
+		wget -O "arduino.$ARCHIVE_FORMAT" "$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
+		tar xf "arduino.$ARCHIVE_FORMAT" > /dev/null
+		mv arduino-nightly "$ARDUINO_IDE_PATH"
+	else
+		curl -o "arduino.$ARCHIVE_FORMAT" -L "$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		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,148 @@
+#!/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 > /dev/null 2>&1
+
+echo "Replacing the framework version ..."
+python -c "import json; import os; fp=open(os.path.expanduser('~/.platformio/platforms/espressif32/platform.json'), 'r+'); data=json.load(fp); data['packages']['framework-arduinoespressif32']['version'] = '*'; del data['packages']['framework-arduinoespressif32']['owner']; fp.seek(0); fp.truncate(); json.dump(data, fp); fp.close()"
+
+if [ "$GITHUB_REPOSITORY" == "espressif/arduino-esp32" ];  then
+	echo "Linking Core..."
+	ln -s $GITHUB_WORKSPACE "$PLATFORMIO_ESP32_PATH"
+else
+	echo "Cloning Core Repository ..."
+	git clone --recursive https://github.com/espressif/arduino-esp32.git "$PLATFORMIO_ESP32_PATH" > /dev/null 2>&1
+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/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,71 @@
+#!/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/AzureIoT/examples/GetStarted/GetStarted.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	elif [ "$OS_IS_MACOS" == "1" ]; then
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/AzureIoT/examples/GetStarted/GetStarted.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	else
+		# CMake Test
+		if [ "$CHUNK_INDEX" -eq 0 ]; then
+			bash "$ARDUINO_ESP32_PATH/.github/scripts/check-cmakelists.sh"
+		fi
+		build_sketches "$FQBN" "$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/AzureIoT/examples/GetStarted/GetStarted.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	#build_pio_sketches esp32dev "$PLATFORMIO_ESP32_PATH/libraries"
+fi

.github/scripts/on-release.sh

@@ -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..HEAD" > "$OUTPUT_DIR/commits.txt"
+    releaseNotes+=$'\r\n##### Commits\r\n'
+    IFS=$'\n'
+    for next in `cat $commitFile`
+    do
+        IFS=' ' read -r commitId commitMsg <<< "$next"
+        commitLine="- [$commitId](https://github.com/$GITHUB_REPOSITORY/commit/$commitId) $commitMsg"
+        releaseNotes+="$commitLine"
+        releaseNotes+=$'\r\n'
+    done
+    rm -f $commitFile
+fi
+
+# 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

@@ -33,17 +33,17 @@ staleLabel: stale
 
 # Comment to post when marking as stale. Set to `false` to disable
 markComment: >
-  This issue has been automatically marked as stale because it has not had
+  [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: >
-#   Your comment here.
+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: >
-  This stale issue has been automatically closed. Thank you for your contributions.
+  [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

.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/main.yml

@@ -1,376 +0,0 @@
-name: ESP32 Arduino CI
-
-on:
-  push:
-    branches:
-    - master
-    - release/*
-  pull_request:
-
-jobs:
-
-  build-arduino-0:
-    name: Build Arduino IDE Tests 0
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Run CMake Check
-      run: ./tools/ci/check-cmakelists.sh
-
-    - name: Install Arduino IDE
-      env:
-        #ESP32_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 0 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-1:
-    name: Build Arduino IDE Tests 1
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 1 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-2:
-    name: Build Arduino IDE Tests 2
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 2 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-3:
-    name: Build Arduino IDE Tests 3
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 3 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-4:
-    name: Build Arduino IDE Tests 4
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 4 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-5:
-    name: Build Arduino IDE Tests 5
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 5 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-6:
-    name: Build Arduino IDE Tests 6
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 6 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-7:
-    name: Build Arduino IDE Tests 7
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 7 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-8:
-    name: Build Arduino IDE Tests 8
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 8 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-9:
-    name: Build Arduino IDE Tests 9
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 9 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-10:
-    name: Build Arduino IDE Tests 10
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 10 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-11:
-    name: Build Arduino IDE Tests 11
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 11 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-12:
-    name: Build Arduino IDE Tests 12
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 12 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-13:
-    name: Build Arduino IDE Tests 13
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 13 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-14:
-    name: Build Arduino IDE Tests 14
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 14 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-15:
-    name: Build Arduino IDE Tests 15
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 15 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-16:
-    name: Build Arduino IDE Tests 16
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 16 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-  build-arduino-17:
-    name: Build Arduino IDE Tests 17
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-arduino-ide.sh
-    - name: Test Arduino IDE
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/test-arduino-ide.sh 17 18
-    - name: Sketch Sizes
-      run: cat size.log
-
-
-  build-platformio:
-    name: Build PlatformIO Tests
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v1
-    - name: Pull submodules
-      run: git submodule update --init --recursive
-    - name: Install Python Wheel
-      run: pip install wheel
-    - name: Install GCC Toolchain
-      run: cd tools && python get.py
-    - name: Install PlatformIO
-      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-      run: ./tools/ci/prep-platformio.sh
-    - name: Test PlatformIO
-      run: ./tools/ci/test-platformio.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,22 @@
+name: ESP32 Arduino Release
+
+on:
+  release:
+    types: published
+
+jobs:
+  build:
+    name: Publish Release
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@master
+      with:
+        fetch-depth: 0
+    - 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

@@ -1,9 +1,10 @@
 tools/xtensa-esp32-elf
+tools/xtensa-esp32s2-elf
 tools/dist
 tools/esptool
 tools/esptool.exe
-tools/mkspiffs/mkspiffs
-tools/mkspiffs/mkspiffs.exe
+tools/mkspiffs
+tools/mklittlefs
 .DS_Store
  
 #Ignore files built by Visual Studio/Visual Micro
@@ -12,3 +13,4 @@ tools/mkspiffs/mkspiffs.exe
 .vs/
 __vm/
 *.vcxproj*
+.vscode/

.travis.yml

@@ -21,42 +21,27 @@ jobs:
     - name: "Build Arduino 0"
       if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
       stage: build
-      script: $TRAVIS_BUILD_DIR/tools/ci/build-tests.sh 0 4
+      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/tools/ci/build-tests.sh 1 4
+      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/tools/ci/build-tests.sh 2 4
+      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/tools/ci/build-tests.sh 3 4
+      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/tools/ci/build-tests.sh 4 4
-
-    - name: "Package & Deploy"
-      if: tag IS present
-      stage: deploy
-      env:
-        - 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/ci/build-release.sh -a$ESP32_GITHUB_TOKEN
-      before_deploy: git submodule update --init
-      deploy:
-      - provider: script
-        skip_cleanup: true
-        script: bash $TRAVIS_BUILD_DIR/tools/ci/deploy-release.sh -t$TRAVIS_TAG -a$ESP32_GITHUB_TOKEN -s$TRAVIS_REPO_SLUG -drelease
-        on:
-          tags: true
+      script: $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 1 1
 
 notifications:
   email:

CMakeLists.txt

@@ -60,6 +60,7 @@ set(LIBRARY_SRCS
   libraries/SPI/src/SPI.cpp
   libraries/Ticker/src/Ticker.cpp
   libraries/Update/src/Updater.cpp
+  libraries/Update/src/HttpsOTAUpdate.cpp
   libraries/WebServer/src/WebServer.cpp
   libraries/WebServer/src/Parsing.cpp
   libraries/WebServer/src/detail/mimetable.cpp
@@ -75,6 +76,7 @@ set(LIBRARY_SRCS
   libraries/WiFi/src/WiFiServer.cpp
   libraries/WiFi/src/WiFiSTA.cpp
   libraries/WiFi/src/WiFiUdp.cpp
+  libraries/WiFiProv/src/WiFiProv.cpp
   libraries/Wire/src/Wire.cpp
   )
 
@@ -200,13 +202,14 @@ set(COMPONENT_ADD_INCLUDEDIRS
   libraries/WebServer/src
   libraries/WiFiClientSecure/src
   libraries/WiFi/src
+  libraries/WiFiProv/src
   libraries/Wire/src
   )
 
 set(COMPONENT_PRIV_INCLUDEDIRS cores/esp32/libb64)
 
-set(COMPONENT_REQUIRES spi_flash mbedtls mdns ethernet)
-set(COMPONENT_PRIV_REQUIRES fatfs nvs_flash app_update spiffs bootloader_support openssl bt)
+set(COMPONENT_REQUIRES spi_flash mbedtls mdns ethernet esp_adc_cal wifi_provisioning)
+set(COMPONENT_PRIV_REQUIRES fatfs nvs_flash app_update spiffs bootloader_support openssl bt esp_http_client esp_https_ota)
 
 register_component()
 

Kconfig.projbuild

@@ -40,6 +40,12 @@ config ARDUINO_RUNNING_CORE
     default 1 if ARDUINO_RUN_CORE1
     default -1 if ARDUINO_RUN_NO_AFFINITY
 
+config ARDUINO_LOOP_STACK_SIZE
+    int "Loop thread stack size"
+    default 8192
+    help
+        Amount of stack available for the Arduino task.
+
 choice ARDUINO_EVENT_RUNNING_CORE
     bool "Core on which Arduino's event handler is running"
     default ARDUINO_EVENT_RUN_CORE1
@@ -76,13 +82,18 @@ choice ARDUINO_UDP_RUNNING_CORE
 
 endchoice
 
+config ARDUINO_UDP_TASK_PRIORITY
+    int "Priority of the UDP task"
+    default 3
+    help
+        Select at what priority you want the UDP task to run.
+
 config ARDUINO_UDP_RUNNING_CORE
     int
     default 0 if ARDUINO_UDP_RUN_CORE0
     default 1 if ARDUINO_UDP_RUN_CORE1
     default -1 if ARDUINO_UDP_RUN_NO_AFFINITY
 
-
 config DISABLE_HAL_LOCKS
     bool "Disable mutex locks for HAL"
     default "n"

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,14 @@
 - [Issue/Bug report template](#issuebug-report-template)
 - [ESP32Dev Board PINMAP](#esp32dev-board-pinmap)
 
-## Development Status
-[Latest stable release ![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32.svg?style=plastic) ![Release Date](https://img.shields.io/github/release-date/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) ![Downloads](https://img.shields.io/github/downloads/espressif/arduino-esp32/latest/total.svg?style=plastic)
+### Development Status
 
-[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)
+Latest Stable Release  [![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Release Date](https://img.shields.io/github/release-date/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Downloads](https://img.shields.io/github/downloads/espressif/arduino-esp32/latest/total.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/)
 
-Most of the framework is implemented. Most noticeable 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
+Latest Development Release  [![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32/all.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Release Date](https://img.shields.io/github/release-date-pre/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Downloads](https://img.shields.io/github/downloads-pre/espressif/arduino-esp32/latest/total.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/)
 
-## 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 +31,19 @@ Most of the framework is implemented. Most noticeable 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

@@ -78,7 +78,7 @@
 #define interrupts() sei()
 #define noInterrupts() cli()
 
-#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
+#define clockCyclesPerMicrosecond() ( (long int)getCpuFrequencyMhz() )
 #define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
 #define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
 
@@ -88,7 +88,7 @@
 #define bitRead(value, bit) (((value) >> (bit)) & 0x01)
 #define bitSet(value, bit) ((value) |= (1UL << (bit)))
 #define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
-#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
+#define bitWrite(value, bit, bitvalue) ((bitvalue) ? bitSet(value, bit) : bitClear(value, bit))
 
 // avr-libc defines _NOP() since 1.6.2
 #ifndef _NOP

cores/esp32/Esp.cpp

@@ -218,6 +218,33 @@ uint8_t EspClass::getChipRevision(void)
     return chip_info.revision;
 }
 
+const char * EspClass::getChipModel(void)
+{
+    uint32_t chip_ver = REG_GET_FIELD(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_VER_PKG);
+    uint32_t pkg_ver = chip_ver & 0x7;
+    switch (pkg_ver) {
+        case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6 :
+            return "ESP32-D0WDQ6";
+        case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5 :
+            return "ESP32-D0WDQ5";
+        case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5 :
+            return "ESP32-D2WDQ5";
+        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2 :
+            return "ESP32-PICO-D2";
+        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4 :
+            return "ESP32-PICO-D4";
+        default:
+            return "Unknown";
+    }
+}
+
+uint8_t EspClass::getChipCores(void)
+{
+    esp_chip_info_t chip_info;
+    esp_chip_info(&chip_info);
+    return chip_info.cores;
+}
+
 const char * EspClass::getSdkVersion(void)
 {
     return esp_get_idf_version();
@@ -309,6 +336,20 @@ bool EspClass::flashRead(uint32_t offset, uint32_t *data, size_t size)
     return spi_flash_read(offset, (uint32_t*) data, size) == ESP_OK;
 }
 
+bool EspClass::partitionEraseRange(const esp_partition_t *partition, uint32_t offset, size_t size) 
+{
+    return esp_partition_erase_range(partition, offset, size) == ESP_OK;
+}
+
+bool EspClass::partitionWrite(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size) 
+{
+    return esp_partition_write(partition, offset, data, size) == ESP_OK;
+}
+
+bool EspClass::partitionRead(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size) 
+{
+    return esp_partition_read(partition, offset, data, size) == ESP_OK;
+}
 
 uint64_t EspClass::getEfuseMac(void)
 {

cores/esp32/Esp.h

@@ -21,6 +21,7 @@
 #define ESP_H
 
 #include <Arduino.h>
+#include <esp_partition.h>
 
 /**
  * AVR macros for WDT managment
@@ -75,6 +76,8 @@ public:
     uint32_t getMaxAllocPsram();
 
     uint8_t getChipRevision();
+    const char * getChipModel();
+    uint8_t getChipCores();
     uint32_t getCpuFreqMHz(){ return getCpuFrequencyMhz(); }
     inline uint32_t getCycleCount() __attribute__((always_inline));
     const char * getSdkVersion();
@@ -97,6 +100,10 @@ public:
     bool flashWrite(uint32_t offset, uint32_t *data, size_t size);
     bool flashRead(uint32_t offset, uint32_t *data, size_t size);
 
+    bool partitionEraseRange(const esp_partition_t *partition, uint32_t offset, size_t size);
+    bool partitionWrite(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size);
+    bool partitionRead(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size);
+
     uint64_t getEfuseMac();
 
 };

cores/esp32/HardwareSerial.cpp

@@ -53,6 +53,8 @@ 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);
+    _tx_pin = txPin;
+    _rx_pin = rxPin;
 
     if(!baud) {
         uartStartDetectBaudrate(_uart);
@@ -70,6 +72,8 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
         } else {
             log_e("Could not detect baudrate. Serial data at the port must be present within the timeout for detection to be possible");
             _uart = NULL;
+            _tx_pin = 255;
+            _rx_pin = 255;
         }
     }
 }
@@ -84,7 +88,8 @@ void HardwareSerial::end()
     if(uartGetDebug() == _uart_nr) {
         uartSetDebug(0);
     }
-    uartEnd(_uart);
+    log_v("pins %d %d",_tx_pin, _rx_pin);
+    uartEnd(_uart, _tx_pin, _rx_pin);
     _uart = 0;
 }
 
@@ -131,11 +136,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);
@@ -156,3 +184,8 @@ HardwareSerial::operator bool() const
 {
     return true;
 }
+
+void HardwareSerial::setRxInvert(bool invert)
+{
+    uartSetRxInvert(_uart, invert);
+}

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));
@@ -91,16 +100,22 @@ public:
 
     size_t setRxBufferSize(size_t);
     void setDebugOutput(bool);
+    
+    void setRxInvert(bool);
 
 protected:
     int _uart_nr;
     uart_t* _uart;
+    uint8_t _tx_pin;
+    uint8_t _rx_pin;
 };
 
+extern void serialEventRun(void) __attribute__((weak));
+
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
 extern HardwareSerial Serial;
 extern HardwareSerial Serial1;
 extern HardwareSerial Serial2;
 #endif
 
-#endif
+#endif // HardwareSerial_h

cores/esp32/Print.cpp

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

cores/esp32/Print.h

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

cores/esp32/Stream.cpp

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

cores/esp32/Stream.h

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

cores/esp32/Udp.h

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

cores/esp32/WMath.cpp

@@ -44,7 +44,7 @@ long random(long howbig)
         uint32_t t = -howbig;
         if (t >= howbig) {
             t -= howbig;
-            if (t >= howbig) 
+            if (t >= howbig)
                 t %= howbig;
         }
         while (l < t) {
@@ -66,11 +66,11 @@ long random(long howsmall, long howbig)
 }
 
 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;
+    const long dividend = out_max - out_min;
+    const long divisor = in_max - in_min;
+    const long delta = x - in_min;
+
+    return (delta * dividend + (divisor / 2)) / divisor + out_min;
 }
 
 unsigned int makeWord(unsigned int w)

cores/esp32/WString.h

@@ -203,8 +203,20 @@ 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 access
         char charAt(unsigned int index) const;
@@ -238,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);

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

@@ -22,14 +22,16 @@
 #include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
 
+#include "driver/adc.h"
+#include "esp_adc_cal.h"
+
+#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 +39,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 +72,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 +102,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 +228,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

@@ -28,6 +28,7 @@
 #include "esp32-hal-cpu.h"
 
 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;
@@ -53,9 +54,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);
 }
@@ -68,6 +79,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);
@@ -75,18 +87,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;
 }
@@ -95,24 +109,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;
@@ -186,7 +197,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-gpio.c

@@ -59,8 +59,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

@@ -945,6 +945,14 @@ static void IRAM_ATTR i2c_isr_handler_default(void* arg)
             activeInt &=~I2C_RXFIFO_FULL_INT_ST;
         }
 
+        if(activeInt & I2C_RXFIFO_OVF_INT_ST) {
+            emptyRxFifo(p_i2c);
+            p_i2c->dev->int_clr.rx_fifo_full=1;
+            p_i2c->dev->int_ena.rx_fifo_full=1; //why?
+
+            activeInt &=~I2C_RXFIFO_OVF_INT_ST;
+        }
+
         if (activeInt & I2C_ACK_ERR_INT_ST_M) {//fatal error, abort i2c service
             if (p_i2c->mode == I2C_MASTER) {
                 i2c_update_error_byte_cnt(p_i2c); // calc which byte caused ack Error, check if address or data

cores/esp32/esp32-hal-ledc.c

@@ -28,7 +28,7 @@
 #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 +55,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 +93,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 +116,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-misc.c

@@ -44,11 +44,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-rmt.c

@@ -94,6 +94,7 @@ struct rmt_obj_s
     transaction_state_t tx_state;
     rmt_rx_data_cb_t cb;
     bool data_alloc;
+    void * arg;
 };
 
 /**
@@ -104,14 +105,14 @@ static xSemaphoreHandle g_rmt_objlocks[MAX_CHANNELS] = {
 };
 
 static rmt_obj_t g_rmt_objects[MAX_CHANNELS] = {
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
 };
 
 /**
@@ -128,7 +129,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 +235,21 @@ 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 channel = rmt->channel;
+    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 +298,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);
     }
 }
 
@@ -309,6 +325,7 @@ bool rmtReadData(rmt_obj_t* rmt, uint32_t* data, size_t size)
     return true;
 }
 
+
 bool rmtBeginReceive(rmt_obj_t* rmt)
 {
     if (!rmt) {
@@ -342,7 +359,7 @@ bool rmtReceiveCompleted(rmt_obj_t* rmt)
     }
 }
 
-bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb)
+bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg)
 {
     if (!rmt && !cb) {
         return false;
@@ -350,6 +367,7 @@ bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb)
     int channel = rmt->channel;
 
     RMT_MUTEX_LOCK(channel);
+    rmt->arg = arg;
     rmt->intr_mode = E_RX_INTR;
     rmt->tx_state = E_FIRST_HALF;
     rmt->cb = cb;
@@ -376,6 +394,19 @@ bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb)
     return true;
 }
 
+bool rmtEnd(rmt_obj_t* rmt) {
+    if (!rmt) {
+        return false;
+    }
+    int channel = rmt->channel;
+
+    RMT_MUTEX_LOCK(channel);
+    RMT.conf_ch[channel].conf1.rx_en = 1;
+    RMT_MUTEX_UNLOCK(channel);
+
+    return  true;
+}
+
 bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag, bool waitForData, uint32_t timeout)
 {
     if (!rmt) {
@@ -483,7 +514,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;
     }
@@ -508,6 +539,8 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
     rmt->tx_not_rx = tx_not_rx;
     rmt->buffers =buffers;
     rmt->channel = channel;
+    rmt->arg = NULL;
+
     _initPin(pin, channel, tx_not_rx);
 
     // Initialize the registers in default mode:
@@ -529,6 +562,7 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
     RMT.conf_ch[channel].conf1.idle_out_lv = 0;     // signal level for idle
     RMT.conf_ch[channel].conf1.idle_out_en = 1;     // enable idle
     RMT.conf_ch[channel].conf1.ref_always_on = 0;     // base clock
+
     RMT.apb_conf.fifo_mask = 1;
 
     if (tx_not_rx) {
@@ -553,7 +587,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 +605,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);
@@ -643,7 +678,7 @@ static void IRAM_ATTR _rmt_isr(void* arg)
                     }
                     if (g_rmt_objects[ch].cb) {
                         // actually received data ptr                        
-                        (g_rmt_objects[ch].cb)(data_received, _rmt_get_mem_len(ch));
+                        (g_rmt_objects[ch].cb)(data_received, _rmt_get_mem_len(ch), g_rmt_objects[ch].arg);
 
                         // restart the reception
                         RMT.conf_ch[ch].conf1.mem_owner = 1;

cores/esp32/esp32-hal-rmt.h

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

cores/esp32/esp32-hal-spi.c

@@ -384,12 +384,8 @@ static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb
     }
 }
 
-void spiStopBus(spi_t * spi)
+static void spiInitBus(spi_t * spi)
 {
-    if(!spi) {
-        return;
-    }
-    SPI_MUTEX_LOCK();
     spi->dev->slave.trans_done = 0;
     spi->dev->slave.slave_mode = 0;
     spi->dev->pin.val = 0;
@@ -399,8 +395,19 @@ void spiStopBus(spi_t * spi)
     spi->dev->ctrl1.val = 0;
     spi->dev->ctrl2.val = 0;
     spi->dev->clock.val = 0;
-    SPI_MUTEX_UNLOCK();
+}
+
+void spiStopBus(spi_t * spi)
+{
+    if(!spi) {
+        return;
+    }
+
     removeApbChangeCallback(spi, _on_apb_change);
+
+    SPI_MUTEX_LOCK();
+    spiInitBus(spi);
+    SPI_MUTEX_UNLOCK();
 }
 
 spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder)
@@ -421,22 +428,18 @@ 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);
-    spiSetDataMode(spi, dataMode);
-    spiSetBitOrder(spi, bitOrder);
-    spiSetClockDiv(spi, clockDiv);
-
     SPI_MUTEX_LOCK();
+    spiInitBus(spi);
     spi->dev->user.usr_mosi = 1;
     spi->dev->user.usr_miso = 1;
     spi->dev->user.doutdin = 1;
@@ -447,6 +450,10 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
     }
     SPI_MUTEX_UNLOCK();
 
+    spiSetDataMode(spi, dataMode);
+    spiSetBitOrder(spi, bitOrder);
+    spiSetClockDiv(spi, clockDiv);
+
     addApbChangeCallback(spi, _on_apb_change);
     return spi;
 }
@@ -459,7 +466,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 +539,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 +627,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 +668,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 +858,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 +884,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 +971,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

@@ -54,7 +54,7 @@ extern "C" {
 struct spi_struct_t;
 typedef struct spi_struct_t spi_t;
 
-spi_t * spiStartBus(uint8_t spi_num, uint32_t freq, uint8_t dataMode, uint8_t bitOrder);
+spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
 void spiStopBus(spi_t * spi);
 
 //Attach/Detach Signal Pins
@@ -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

@@ -90,56 +90,56 @@ void IRAM_ATTR __timerISR(void * arg){
     }
 }
 
-uint64_t timerRead(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerRead(hw_timer_t *timer){
     timer->dev->update = 1;
     uint64_t h = timer->dev->cnt_high;
     uint64_t l = timer->dev->cnt_low;
     return (h << 32) | l;
 }
 
-uint64_t timerAlarmRead(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerAlarmRead(hw_timer_t *timer){
     uint64_t h = timer->dev->alarm_high;
     uint64_t l = timer->dev->alarm_low;
     return (h << 32) | l;
 }
 
-void timerWrite(hw_timer_t *timer, uint64_t val){
+void IRAM_ATTR timerWrite(hw_timer_t *timer, uint64_t val){
     timer->dev->load_high = (uint32_t) (val >> 32);
     timer->dev->load_low = (uint32_t) (val);
     timer->dev->reload = 1;
 }
 
-void timerAlarmWrite(hw_timer_t *timer, uint64_t alarm_value, bool autoreload){
+void IRAM_ATTR timerAlarmWrite(hw_timer_t *timer, uint64_t alarm_value, bool autoreload){
     timer->dev->alarm_high = (uint32_t) (alarm_value >> 32);
     timer->dev->alarm_low = (uint32_t) alarm_value;
     timer->dev->config.autoreload = autoreload;
 }
 
-void timerSetConfig(hw_timer_t *timer, uint32_t config){
+void IRAM_ATTR timerSetConfig(hw_timer_t *timer, uint32_t config){
     timer->dev->config.val = config;
 }
 
-uint32_t timerGetConfig(hw_timer_t *timer){
+uint32_t IRAM_ATTR timerGetConfig(hw_timer_t *timer){
     return timer->dev->config.val;
 }
 
-void timerSetCountUp(hw_timer_t *timer, bool countUp){
+void IRAM_ATTR timerSetCountUp(hw_timer_t *timer, bool countUp){
     timer->dev->config.increase = countUp;
 }
 
-bool timerGetCountUp(hw_timer_t *timer){
+bool IRAM_ATTR timerGetCountUp(hw_timer_t *timer){
     return timer->dev->config.increase;
 }
 
-void timerSetAutoReload(hw_timer_t *timer, bool autoreload){
+void IRAM_ATTR timerSetAutoReload(hw_timer_t *timer, bool autoreload){
     timer->dev->config.autoreload = autoreload;
 }
 
-bool timerGetAutoReload(hw_timer_t *timer){
+bool IRAM_ATTR timerGetAutoReload(hw_timer_t *timer){
     return timer->dev->config.autoreload;
 }
 
-void timerSetDivider(hw_timer_t *timer, uint16_t divider){//2 to 65536
+void IRAM_ATTR timerSetDivider(hw_timer_t *timer, uint16_t divider){//2 to 65536
     if(!divider){
         divider = 0xFFFF;
     } else if(divider == 1){
@@ -151,40 +151,41 @@ void timerSetDivider(hw_timer_t *timer, uint16_t divider){//2 to 65536
     timer->dev->config.enable = timer_en;
 }
 
-uint16_t timerGetDivider(hw_timer_t *timer){
+uint16_t IRAM_ATTR timerGetDivider(hw_timer_t *timer){
     return timer->dev->config.divider;
 }
 
-void timerStart(hw_timer_t *timer){
+void IRAM_ATTR timerStart(hw_timer_t *timer){
     timer->dev->config.enable = 1;
 }
 
-void timerStop(hw_timer_t *timer){
+void IRAM_ATTR timerStop(hw_timer_t *timer){
     timer->dev->config.enable = 0;
 }
 
-void timerRestart(hw_timer_t *timer){
+void IRAM_ATTR timerRestart(hw_timer_t *timer){
     timer->dev->config.enable = 0;
+    timer->dev->reload = 1;
     timer->dev->config.enable = 1;
 }
 
-bool timerStarted(hw_timer_t *timer){
+bool IRAM_ATTR timerStarted(hw_timer_t *timer){
     return timer->dev->config.enable;
 }
 
-void timerAlarmEnable(hw_timer_t *timer){
+void IRAM_ATTR timerAlarmEnable(hw_timer_t *timer){
     timer->dev->config.alarm_en = 1;
 }
 
-void timerAlarmDisable(hw_timer_t *timer){
+void IRAM_ATTR timerAlarmDisable(hw_timer_t *timer){
     timer->dev->config.alarm_en = 0;
 }
 
-bool timerAlarmEnabled(hw_timer_t *timer){
+bool IRAM_ATTR timerAlarmEnabled(hw_timer_t *timer){
     return timer->dev->config.alarm_en;
 }
 
-static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb){
+static void IRAM_ATTR _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb){
     hw_timer_t * timer = (hw_timer_t *)arg;
     if(ev_type == APB_BEFORE_CHANGE){
         timer->dev->config.enable = 0;
@@ -196,7 +197,7 @@ static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb
     }
 }
 
-hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
+hw_timer_t * IRAM_ATTR timerBegin(uint8_t num, uint16_t divider, bool countUp){
     if(num > 3){
         return NULL;
     }
@@ -221,13 +222,13 @@ hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
     return timer;
 }
 
-void timerEnd(hw_timer_t *timer){
+void IRAM_ATTR timerEnd(hw_timer_t *timer){
     timer->dev->config.enable = 0;
     timerAttachInterrupt(timer, NULL, false);
     removeApbChangeCallback(timer, _on_apb_change);
 }
 
-void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
+void IRAM_ATTR timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
     static bool initialized = false;
     static intr_handle_t intr_handle = NULL;
     if(intr_handle){
@@ -278,29 +279,29 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
     }
 }
 
-void timerDetachInterrupt(hw_timer_t *timer){
+void IRAM_ATTR timerDetachInterrupt(hw_timer_t *timer){
     timerAttachInterrupt(timer, NULL, false);
 }
 
-uint64_t timerReadMicros(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerReadMicros(hw_timer_t *timer){
     uint64_t timer_val = timerRead(timer);
     uint16_t div = timerGetDivider(timer);
     return timer_val * div / (getApbFrequency() / 1000000);
 }
 
-double timerReadSeconds(hw_timer_t *timer){
+double IRAM_ATTR timerReadSeconds(hw_timer_t *timer){
     uint64_t timer_val = timerRead(timer);
     uint16_t div = timerGetDivider(timer);
     return (double)timer_val * div / getApbFrequency();
 }
 
-uint64_t timerAlarmReadMicros(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerAlarmReadMicros(hw_timer_t *timer){
     uint64_t timer_val = timerAlarmRead(timer);
     uint16_t div = timerGetDivider(timer);
     return timer_val * div / (getApbFrequency() / 1000000);
 }
 
-double timerAlarmReadSeconds(hw_timer_t *timer){
+double IRAM_ATTR timerAlarmReadSeconds(hw_timer_t *timer){
     uint64_t timer_val = timerAlarmRead(timer);
     uint16_t div = timerGetDivider(timer);
     return (double)timer_val * div / getApbFrequency();

cores/esp32/esp32-hal-uart.c

@@ -85,7 +85,7 @@ static void IRAM_ATTR _uart_isr(void *arg)
         uart->dev->int_clr.rxfifo_tout = 1;
         while(uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
             c = uart->dev->fifo.rw_byte;
-            if(uart->queue != NULL && !xQueueIsQueueFullFromISR(uart->queue)) {
+            if(uart->queue != NULL)  {
                 xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
             }
         }
@@ -124,21 +124,21 @@ void uartDisableInterrupt(uart_t* uart)
     UART_MUTEX_UNLOCK();
 }
 
-void uartDetachRx(uart_t* uart)
+void uartDetachRx(uart_t* uart, uint8_t rxPin)
 {
     if(uart == NULL) {
         return;
     }
-    pinMatrixInDetach(UART_RXD_IDX(uart->num), false, false);
+    pinMatrixInDetach(rxPin, false, false);
     uartDisableInterrupt(uart);
 }
 
-void uartDetachTx(uart_t* uart)
+void uartDetachTx(uart_t* uart, uint8_t txPin)
 {
     if(uart == NULL) {
         return;
     }
-    pinMatrixOutDetach(UART_TXD_IDX(uart->num), false, false);
+    pinMatrixOutDetach(txPin, false, false);
 }
 
 void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
@@ -208,6 +208,11 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
         uart->dev->conf0.stop_bit_num = ONE_STOP_BITS_CONF;
         uart->dev->rs485_conf.dl1_en = 1;
     }
+
+    // tx_idle_num : idle interval after tx FIFO is empty(unit: the time it takes to send one bit under current baudrate)
+    // Setting it to 0 prevents line idle time/delays when sending messages with small intervals
+    uart->dev->idle_conf.tx_idle_num = 0;  //
+
     UART_MUTEX_UNLOCK();
 
     if(rxPin != -1) {
@@ -217,12 +222,11 @@ 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;
 }
 
-void uartEnd(uart_t* uart)
+void uartEnd(uart_t* uart, uint8_t txPin, uint8_t rxPin)
 {
     if(uart == NULL) {
         return;
@@ -239,8 +243,8 @@ void uartEnd(uart_t* uart)
 
     UART_MUTEX_UNLOCK();
 
-    uartDetachRx(uart);
-    uartDetachTx(uart);
+    uartDetachRx(uart, rxPin);
+    uartDetachTx(uart, txPin);
 }
 
 size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
@@ -253,6 +257,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) {
+            UART_MUTEX_UNLOCK();
             return NULL;
         }
     }
@@ -261,12 +266,23 @@ size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
     return new_size;
 }
 
+void uartSetRxInvert(uart_t* uart, bool invert)
+{
+    if (uart == NULL)
+        return;
+    
+    if (invert)
+        uart->dev->conf0.rxd_inv = 1;
+    else
+        uart->dev->conf0.rxd_inv = 0;
+}
+
 uint32_t uartAvailable(uart_t* uart)
 {
     if(uart == NULL || uart->queue == NULL) {
         return 0;
     }
-    return uxQueueMessagesWaiting(uart->queue);
+    return (uxQueueMessagesWaiting(uart->queue) + uart->dev->status.rxfifo_cnt) ;
 }
 
 uint32_t uartAvailableForWrite(uart_t* uart)
@@ -277,12 +293,35 @@ uint32_t uartAvailableForWrite(uart_t* uart)
     return 0x7f - uart->dev->status.txfifo_cnt;
 }
 
+void uartRxFifoToQueue(uart_t* uart)
+{
+	uint8_t c;
+    UART_MUTEX_LOCK();
+	//disable interrupts
+	uart->dev->int_ena.val = 0;
+	uart->dev->int_clr.val = 0xffffffff;
+	while (uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
+		c = uart->dev->fifo.rw_byte;
+		xQueueSend(uart->queue, &c, 0);
+	}
+	//enable interrupts
+	uart->dev->int_ena.rxfifo_full = 1;
+	uart->dev->int_ena.frm_err = 1;
+	uart->dev->int_ena.rxfifo_tout = 1;
+	uart->dev->int_clr.val = 0xffffffff;
+    UART_MUTEX_UNLOCK();
+}
+
 uint8_t uartRead(uart_t* uart)
 {
     if(uart == NULL || uart->queue == NULL) {
         return 0;
     }
     uint8_t c;
+    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
+    {
+    	uartRxFifoToQueue(uart);
+    }
     if(xQueueReceive(uart->queue, &c, 0)) {
         return c;
     }
@@ -295,6 +334,10 @@ uint8_t uartPeek(uart_t* uart)
         return 0;
     }
     uint8_t c;
+    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
+    {
+    	uartRxFifoToQueue(uart);
+    }
     if(xQueuePeek(uart->queue, &c, 0)) {
         return c;
     }
@@ -327,6 +370,11 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
 }
 
 void uartFlush(uart_t* uart)
+{
+    uartFlushTxOnly(uart,true);
+}
+
+void uartFlushTxOnly(uart_t* uart, bool txOnly)
 {
     if(uart == NULL) {
         return;
@@ -334,17 +382,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);
     }
-
-    xQueueReset(uart->queue);
-
+    
     UART_MUTEX_UNLOCK();
 }
 
@@ -370,18 +420,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);

cores/esp32/esp32-hal-uart.h

@@ -52,7 +52,7 @@ struct uart_struct_t;
 typedef struct uart_struct_t uart_t;
 
 uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted);
-void uartEnd(uart_t* uart);
+void uartEnd(uart_t* uart, uint8_t rxPin, uint8_t txPin);
 
 uint32_t uartAvailable(uart_t* uart);
 uint32_t uartAvailableForWrite(uart_t* uart);
@@ -63,12 +63,15 @@ 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);
 
 size_t uartResizeRxBuffer(uart_t* uart, size_t new_size);
 
+void uartSetRxInvert(uart_t* uart, bool invert);
+
 void uartSetDebug(uart_t* uart);
 int uartGetDebug();
 

cores/esp32/main.cpp

@@ -3,6 +3,10 @@
 #include "esp_task_wdt.h"
 #include "Arduino.h"
 
+#ifndef CONFIG_ARDUINO_LOOP_STACK_SIZE
+#define CONFIG_ARDUINO_LOOP_STACK_SIZE 8192
+#endif
+
 TaskHandle_t loopTaskHandle = NULL;
 
 #if CONFIG_AUTOSTART_ARDUINO
@@ -17,6 +21,7 @@ void loopTask(void *pvParameters)
             esp_task_wdt_reset();
         }
         loop();
+        if (serialEventRun) serialEventRun();
     }
 }
 
@@ -24,7 +29,7 @@ extern "C" void app_main()
 {
     loopTaskWDTEnabled = false;
     initArduino();
-    xTaskCreateUniversal(loopTask, "loopTask", 8192, NULL, 1, &loopTaskHandle, CONFIG_ARDUINO_RUNNING_CORE);
+    xTaskCreateUniversal(loopTask, "loopTask", CONFIG_ARDUINO_LOOP_STACK_SIZE, NULL, 1, &loopTaskHandle, CONFIG_ARDUINO_RUNNING_CORE);
 }
 
 #endif

cores/esp32/pgmspace.h

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

cores/esp32/wiring_shift.c

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

docs/ISSUE_TEMPLATE.md

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

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 (x86, amd64, armhf and arm64).
 
 - 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/arduino-ide/mac.md

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

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

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.

libraries/ArduinoOTA/examples/OTAWebUpdater/OTAWebUpdater.ino

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

libraries/ArduinoOTA/src/ArduinoOTA.cpp

@@ -88,6 +88,17 @@ ArduinoOTAClass& ArduinoOTAClass::setPasswordHash(const char * password) {
     return *this;
 }
 
+ArduinoOTAClass& ArduinoOTAClass::setPartitionLabel(const char * partition_label) {
+    if (!_initialized && !_partition_label.length() && partition_label) {
+        _partition_label = partition_label;
+    }
+    return *this;
+}
+
+String ArduinoOTAClass::getPartitionLabel() {
+    return _partition_label;
+}
+
 ArduinoOTAClass& ArduinoOTAClass::setRebootOnSuccess(bool reboot){
     _rebootOnSuccess = reboot;
     return *this;
@@ -127,9 +138,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 +182,7 @@ void ArduinoOTAClass::_onRx(){
         _md5 = readStringUntil('\n');
         _md5.trim();
         if(_md5.length() != 32){
+            log_e("bad md5 length");
             return;
         }
 
@@ -198,6 +208,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 +216,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 +237,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;
@@ -233,10 +246,11 @@ void ArduinoOTAClass::_onRx(){
 }
 
 void ArduinoOTAClass::_runUpdate() {
-    if (!Update.begin(_size, _cmd)) {
-#ifdef OTA_DEBUG
-        Update.printError(OTA_DEBUG);
-#endif
+    const char *partition_label = _partition_label.length() ? _partition_label.c_str() : NULL;
+    if (!Update.begin(_size, _cmd, -1, LOW, partition_label)) {
+
+        log_e("Begin ERROR: %s", Update.errorString());
+
         if (_error_callback) {
             _error_callback(OTA_BEGIN_ERROR);
         }
@@ -272,21 +286,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 +303,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 +323,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 +353,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,14 +365,12 @@ 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() {
     if (!_initialized) {
-        return; 
+        return;
     }
     if (_state == OTA_RUNUPDATE) {
         _runUpdate();
@@ -395,4 +392,4 @@ void ArduinoOTAClass::setTimeout(int timeoutInMillis) {
 
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_ARDUINOOTA)
 ArduinoOTAClass ArduinoOTA;
-#endif
+#endif

libraries/ArduinoOTA/src/ArduinoOTA.h

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

libraries/AsyncUDP/src/AsyncUDP.cpp

@@ -150,7 +150,7 @@ static bool _udp_task_start(){
         }
     }
     if(!_udp_task_handle){
-        xTaskCreateUniversal(_udp_task, "async_udp", 4096, NULL, 3, (TaskHandle_t*)&_udp_task_handle, CONFIG_ARDUINO_UDP_RUNNING_CORE);
+        xTaskCreateUniversal(_udp_task, "async_udp", 4096, NULL, CONFIG_ARDUINO_UDP_TASK_PRIORITY, (TaskHandle_t*)&_udp_task_handle, CONFIG_ARDUINO_UDP_RUNNING_CORE);
         if(!_udp_task_handle){
             return false;
         }

libraries/BLE/examples/BLE_Beacon_Scanner/BLE_Beacon_Scanner.ino

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

libraries/BLE/examples/BLE_Beacon_Scanner/BLE_Beacon_Scanner.md

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

libraries/BLE/examples/BLE_EddystoneTLM_Beacon/BLE_EddystoneTLM_Beacon.ino

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

libraries/BLE/examples/BLE_EddystoneTLM_Beacon/BLE_EddystoneTLM_Beacon.md

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

libraries/BLE/examples/BLE_EddystoneURL_Beacon/BLE_EddystoneURL_Beacon.ino

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

libraries/BLE/examples/BLE_EddystoneURL_Beacon/BLE_EddystoneURL_Beacon.md

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

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/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
@@ -354,6 +388,15 @@ void BLEAdvertisedDevice::parseAdvertisement(uint8_t* payload, size_t total_len)
 	} // !finished
 } // parseAdvertisement
 
+/**
+ * @brief Parse the advertising payload.
+ * @param [in] payload The payload of the advertised device.
+ * @param [in] total_len The length of payload
+ */
+void BLEAdvertisedDevice::setPayload(uint8_t* payload, size_t total_len) {
+	m_payload = payload;
+	m_payloadLength = total_len;
+} // setPayload
 
 /**
  * @brief Set the address of the advertised device.
@@ -454,7 +497,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 +507,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
 
 
@@ -498,7 +542,9 @@ std::string BLEAdvertisedDevice::toString() {
 		free(pHex);
 	}
 	if (haveServiceUUID()) {
-		res += ", serviceUUID: " + getServiceUUID().toString();
+		for (int i=0; i < m_serviceUUIDs.size(); i++) {
+		    res += ", serviceUUID: " + getServiceUUID(i).toString();
+		}
 	}
 	if (haveTXPower()) {
 		char val[4];

libraries/BLE/src/BLEAdvertisedDevice.h

@@ -36,8 +36,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();
@@ -60,6 +64,7 @@ private:
 	friend class BLEScan;
 
 	void parseAdvertisement(uint8_t* payload, size_t total_len=62);
+	void setPayload(uint8_t* payload, size_t total_len=62);
 	void setAddress(BLEAddress address);
 	void setAdFlag(uint8_t adFlag);
 	void setAdvertizementResult(uint8_t* payload);
@@ -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

@@ -28,7 +28,9 @@
  * @brief Construct a default advertising object.
  *
  */
-BLEAdvertising::BLEAdvertising() {
+BLEAdvertising::BLEAdvertising()
+: m_scanRespData{}
+{
 	m_advData.set_scan_rsp        = false;
 	m_advData.include_name        = true;
 	m_advData.include_txpower     = true;
@@ -85,6 +87,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
@@ -211,10 +217,15 @@ void BLEAdvertising::start() {
 	}
 
 	if (!m_customScanResponseData && m_scanResp) {
-		m_advData.set_scan_rsp = true;
-		m_advData.include_name = m_scanResp;
-		m_advData.include_txpower = m_scanResp;
-		errRc = ::esp_ble_gap_config_adv_data(&m_advData);
+		// Set the configuration for scan response.
+		memcpy(&m_scanRespData, &m_advData, sizeof(esp_ble_adv_data_t)); // Copy the content of m_advData.
+		m_scanRespData.set_scan_rsp = true; // Define this struct as scan response data
+		m_scanRespData.include_name = true; // Caution: This may lead to a crash if the device name has more than 29 characters
+		m_scanRespData.include_txpower = true;
+		m_scanRespData.appearance = 0; // If defined the 'Appearance' attribute is already included in the advertising data
+		m_scanRespData.flag = 0; // 'Flags' attribute should no be included in the scan response
+
+		errRc = ::esp_ble_gap_config_adv_data(&m_scanRespData);
 		if (errRc != ESP_OK) {
 			log_e("<< esp_ble_gap_config_adv_data (Scan response): rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 			return;

libraries/BLE/src/BLEAdvertising.h

@@ -30,7 +30,7 @@ public:
 	void setPartialServices(BLEUUID uuid);
 	void setServiceData(BLEUUID uuid, std::string data);
 	void setShortName(std::string name);
-	void        addData(std::string data);  // Add data to the payload.
+	void addData(std::string data);         // Add data to the payload.
 	std::string getPayload();               // Retrieve the current advert payload.
 
 private:
@@ -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);
@@ -67,13 +68,14 @@ public:
 
 private:
 	esp_ble_adv_data_t   m_advData;
+	esp_ble_adv_data_t   m_scanRespData; // Used for configuration of scan response data when m_scanResp is true
 	esp_ble_adv_params_t m_advParams;
 	std::vector<BLEUUID> m_serviceUUIDs;
 	bool                 m_customAdvData = false;  // Are we using custom advertising data?
 	bool                 m_customScanResponseData = false;  // Are we using custom scan response data?
 	FreeRTOS::Semaphore  m_semaphoreSetAdv = FreeRTOS::Semaphore("startAdvert");
-	bool				m_scanResp = true;
+	bool                 m_scanResp = true;
 
 };
 #endif /* CONFIG_BT_ENABLED */
-#endif /* COMPONENTS_CPP_UTILS_BLEADVERTISING_H_ */
+#endif /* COMPONENTS_CPP_UTILS_BLEADVERTISING_H_ */

libraries/BLE/src/BLECharacteristic.cpp

@@ -219,19 +219,22 @@ void BLECharacteristic::handleGATTServerEvent(
 		// - uint8_t exec_write_flag - Either ESP_GATT_PREP_WRITE_EXEC or ESP_GATT_PREP_WRITE_CANCEL
 		//
 		case ESP_GATTS_EXEC_WRITE_EVT: {
-			if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
-				m_value.commit();
-				m_pCallbacks->onWrite(this); // Invoke the onWrite callback handler.
-			} else {
-				m_value.cancel();
-			}
-// ???
-			esp_err_t errRc = ::esp_ble_gatts_send_response(
-					gatts_if,
-					param->write.conn_id,
-					param->write.trans_id, ESP_GATT_OK, nullptr);
-			if (errRc != ESP_OK) {
-				log_e("esp_ble_gatts_send_response: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+			if(m_writeEvt){
+				m_writeEvt = false;
+				if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
+					m_value.commit();
+					m_pCallbacks->onWrite(this); // Invoke the onWrite callback handler.
+				} else {
+					m_value.cancel();
+				}
+	// ???
+				esp_err_t errRc = ::esp_ble_gatts_send_response(
+						gatts_if,
+						param->write.conn_id,
+						param->write.trans_id, ESP_GATT_OK, nullptr);
+				if (errRc != ESP_OK) {
+					log_e("esp_ble_gatts_send_response: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+				}
 			}
 			break;
 		} // ESP_GATTS_EXEC_WRITE_EVT
@@ -277,6 +280,7 @@ void BLECharacteristic::handleGATTServerEvent(
 			if (param->write.handle == m_handle) {
 				if (param->write.is_prep) {
 					m_value.addPart(param->write.value, param->write.len);
+					m_writeEvt = true;
 				} else {
 					setValue(param->write.value, param->write.len);
 				}
@@ -693,15 +697,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
 
 

libraries/BLE/src/BLECharacteristic.h

@@ -107,6 +107,7 @@ private:
 	BLEService*                 m_pService;
 	BLEValue                    m_value;
 	esp_gatt_perm_t             m_permissions = ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE;
+	bool						m_writeEvt = false; // If we have started a long write, this tells the commit code that we were the target
 
 	void handleGATTServerEvent(
 			esp_gatts_cb_event_t      event,

libraries/BLE/src/BLEClient.cpp

@@ -105,6 +105,7 @@ bool BLEClient::connect(BLEAddress address, esp_ble_addr_type_t type) {
 	esp_err_t errRc = ::esp_ble_gattc_app_register(m_appId);
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gattc_app_register: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+		BLEDevice::removePeerDevice(m_appId, true);
 		return false;
 	}
 
@@ -122,6 +123,7 @@ bool BLEClient::connect(BLEAddress address, esp_ble_addr_type_t type) {
 	);
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gattc_open: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
+		BLEDevice::removePeerDevice(m_appId, true);
 		return false;
 	}
 
@@ -178,12 +180,13 @@ void BLEClient::gattClientEventHandler(
 		// - uint16_t          conn_id
 		// - esp_bd_addr_t     remote_bda
 		case ESP_GATTC_DISCONNECT_EVT: {
+				if (evtParam->disconnect.conn_id != getConnId()) break;
 				// If we receive a disconnect event, set the class flag that indicates that we are
 				// no longer connected.
-				m_isConnected = false;
-				if (m_pClientCallbacks != nullptr) {
+				if (m_isConnected && m_pClientCallbacks != nullptr) {
 					m_pClientCallbacks->onDisconnect(this);
 				}
+				m_isConnected = false;
 				esp_ble_gattc_app_unregister(m_gattc_if);
 				m_semaphoreOpenEvt.give(ESP_GATT_IF_NONE);
 				m_semaphoreRssiCmplEvt.give();
@@ -202,11 +205,13 @@ void BLEClient::gattClientEventHandler(
 		//
 		case ESP_GATTC_OPEN_EVT: {
 			m_conn_id = evtParam->open.conn_id;
-			if (m_pClientCallbacks != nullptr) {
-				m_pClientCallbacks->onConnect(this);
-			}
 			if (evtParam->open.status == ESP_GATT_OK) {
 				m_isConnected = true;   // Flag us as connected.
+				if (m_pClientCallbacks != nullptr) {
+					m_pClientCallbacks->onConnect(this);
+				}
+			} else {
+				log_e("Failed to connect, status=%s", GeneralUtils::errorToString(evtParam->open.status));
 			}
 			m_semaphoreOpenEvt.give(evtParam->open.status);
 			break;
@@ -227,6 +232,7 @@ void BLEClient::gattClientEventHandler(
 		} // ESP_GATTC_REG_EVT
 
 		case ESP_GATTC_CFG_MTU_EVT:
+			if (evtParam->cfg_mtu.conn_id != getConnId()) break;
 			if(evtParam->cfg_mtu.status != ESP_GATT_OK) {
 				log_e("Config mtu failed");
 			}
@@ -234,7 +240,8 @@ void BLEClient::gattClientEventHandler(
 			break;
 
 		case ESP_GATTC_CONNECT_EVT: {
-			BLEDevice::updatePeerDevice(this, true, m_gattc_if);
+			if (evtParam->connect.conn_id != getConnId()) break;
+			BLEDevice::updatePeerDevice(this, true, m_appId);
 			esp_err_t errRc = esp_ble_gattc_send_mtu_req(gattc_if, evtParam->connect.conn_id);
 			if (errRc != ESP_OK) {
 				log_e("esp_ble_gattc_send_mtu_req: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
@@ -255,6 +262,7 @@ void BLEClient::gattClientEventHandler(
 		// - uint16_t          conn_id
 		//
 		case ESP_GATTC_SEARCH_CMPL_EVT: {
+			if (evtParam->search_cmpl.conn_id != getConnId()) break;
 			esp_ble_gattc_cb_param_t* p_data = (esp_ble_gattc_cb_param_t*)evtParam;
 			if (p_data->search_cmpl.status != ESP_GATT_OK){
 				log_e("search service failed, error status = %x", p_data->search_cmpl.status);
@@ -285,6 +293,7 @@ void BLEClient::gattClientEventHandler(
 		// - esp_gatt_id_t srvc_id
 		//
 		case ESP_GATTC_SEARCH_RES_EVT: {
+			if (evtParam->search_res.conn_id != getConnId()) break;
 			BLEUUID uuid = BLEUUID(evtParam->search_res.srvc_id);
 			BLERemoteService* pRemoteService = new BLERemoteService(
 				evtParam->search_res.srvc_id,

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));
 	};
@@ -569,6 +578,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) {
@@ -625,7 +640,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

@@ -3,6 +3,11 @@
  *
  *  Created on: Mar 12, 2018
  *      Author: pcbreflux
+ *  Edited on: Mar 20, 2020 by beegee-tokyo
+ *  Fix temperature value (8.8 fixed format)
+ *  Fix time stamp (0.1 second resolution)
+ *  Fixes based on EddystoneTLM frame specification https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md
+ * 
  */
 #include "sdkconfig.h"
 #if defined(CONFIG_BT_ENABLED)
@@ -20,7 +25,7 @@ BLEEddystoneTLM::BLEEddystoneTLM() {
 	m_eddystoneData.frameType = EDDYSTONE_TLM_FRAME_TYPE;
 	m_eddystoneData.version = 0;
 	m_eddystoneData.volt = 3300; // 3300mV = 3.3V
-	m_eddystoneData.temp = (uint16_t) ((float) 23.00);
+	m_eddystoneData.temp = (uint16_t) ((float) 23.00)/256;
 	m_eddystoneData.advCount = 0;
 	m_eddystoneData.tmil = 0;
 } // BLEEddystoneTLM
@@ -38,41 +43,50 @@ uint8_t BLEEddystoneTLM::getVersion() {
 } // getVersion
 
 uint16_t BLEEddystoneTLM::getVolt() {
-	return m_eddystoneData.volt;
+	return ENDIAN_CHANGE_U16(m_eddystoneData.volt);
 } // getVolt
 
 float BLEEddystoneTLM::getTemp() {
-	return (float)m_eddystoneData.temp;
+	return ENDIAN_CHANGE_U16(m_eddystoneData.temp) / 256.0f;
 } // getTemp
 
 uint32_t BLEEddystoneTLM::getCount() {
-	return m_eddystoneData.advCount;
+	return ENDIAN_CHANGE_U32(m_eddystoneData.advCount);
 } // getCount
 
 uint32_t BLEEddystoneTLM::getTime() {
-	return m_eddystoneData.tmil;
+	return (ENDIAN_CHANGE_U32(m_eddystoneData.tmil)) / 10;
 } // getTime
 
 std::string BLEEddystoneTLM::toString() {
   std::string out = "";
   uint32_t rawsec = ENDIAN_CHANGE_U32(m_eddystoneData.tmil);
-  char val[6];
+  char val[12];
 
-  out += "Version " + m_eddystoneData.version;
+  out += "Version "; // + std::string(m_eddystoneData.version);
+  snprintf(val, sizeof(val), "%d", m_eddystoneData.version);
+  out += val;
   out += "\n";
-  out += "Battery Voltage " + ENDIAN_CHANGE_U16(m_eddystoneData.volt);
+  out += "Battery Voltage "; // + ENDIAN_CHANGE_U16(m_eddystoneData.volt);
+  snprintf(val, sizeof(val), "%d", ENDIAN_CHANGE_U16(m_eddystoneData.volt));
+  out += val;
   out += " mV\n";
 
   out += "Temperature ";
-  snprintf(val, sizeof(val), "%d", m_eddystoneData.temp);
+  snprintf(val, sizeof(val), "%.2f", ENDIAN_CHANGE_U16(m_eddystoneData.temp) / 256.0f);
   out += val;
-  out += ".0 °C\n";
+  out += " C\n";
 
   out += "Adv. Count ";
   snprintf(val, sizeof(val), "%d", ENDIAN_CHANGE_U32(m_eddystoneData.advCount));
   out += val;
   out += "\n";
 
+  out += "Time in seconds ";
+  snprintf(val, sizeof(val), "%d", rawsec/10);
+  out += val;
+  out += "\n";
+
   out += "Time ";
 
   snprintf(val, sizeof(val), "%04d", rawsec / 864000);

libraries/BLE/src/BLEHIDDevice.cpp

@@ -194,6 +194,7 @@ BLECharacteristic* BLEHIDDevice::protocolMode() {
 
 void BLEHIDDevice::setBatteryLevel(uint8_t level) {
 	m_batteryLevelCharacteristic->setValue(&level, 1);
+	m_batteryLevelCharacteristic->notify();	
 }
 /*
  * @brief Returns battery level characteristic

libraries/BLE/src/BLERemoteCharacteristic.cpp

@@ -40,6 +40,7 @@ BLERemoteCharacteristic::BLERemoteCharacteristic(
 	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");
@@ -236,6 +237,13 @@ void BLERemoteCharacteristic::gattClientEventHandler(esp_gattc_cb_event_t event,
 			break;
 		} // ESP_GATTC_WRITE_CHAR_EVT
 
+		case ESP_GATTC_READ_DESCR_EVT:
+		case ESP_GATTC_WRITE_DESCR_EVT:
+			for (auto &myPair : m_descriptorMap) {
+				myPair.second->gattClientEventHandler(
+					event, gattc_if, evtParam);
+			}
+			break;
 
 		default:
 			break;
@@ -389,6 +397,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.
@@ -412,7 +431,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));
@@ -434,7 +453,7 @@ std::string BLERemoteCharacteristic::readValue() {
  * unregistering a notification.
  * @return N/A.
  */
-void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback, bool notifications) {
+void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback, bool notifications, bool descriptorRequiresRegistration) {
 	log_v(">> registerForNotify(): %s", toString().c_str());
 
 	m_notifyCallback = notifyCallback;   // Save the notification callback.
@@ -455,7 +474,8 @@ void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback,
 		uint8_t val[] = {0x01, 0x00};
 		if(!notifications) val[0] = 0x02;
 		BLERemoteDescriptor* desc = getDescriptor(BLEUUID((uint16_t)0x2902));
-		desc->writeValue(val, 2);
+		if (desc != nullptr && descriptorRequiresRegistration)
+			desc->writeValue(val, 2, true);
 	} // End Register
 	else {   // If we weren't passed a callback function, then this is an unregistration.
 		esp_err_t errRc = ::esp_ble_gattc_unregister_for_notify(
@@ -470,7 +490,8 @@ void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback,
 
 		uint8_t val[] = {0x00, 0x00};
 		BLERemoteDescriptor* desc = getDescriptor((uint16_t)0x2902);
-		desc->writeValue(val, 2);
+		if (desc != nullptr && descriptorRequiresRegistration)
+			desc->writeValue(val, 2, true);
 	} // End Unregister
 
 	m_semaphoreRegForNotifyEvt.wait("registerForNotify");
@@ -521,7 +542,7 @@ std::string BLERemoteCharacteristic::toString() {
  * @return N/A.
  */
 void BLERemoteCharacteristic::writeValue(std::string newValue, bool response) {
-	writeValue((uint8_t*)newValue.c_str(), strlen(newValue.c_str()), response);
+	writeValue((uint8_t*)newValue.data(), newValue.length(), response);
 } // writeValue
 
 
@@ -563,7 +584,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) {
@@ -584,4 +605,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();
-	void        registerForNotify(notify_callback _callback, bool notifications = true);
+	float       readFloat();
+	void        registerForNotify(notify_callback _callback, bool notifications = true, bool descriptorRequiresRegistration = 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;
 }
 
 
@@ -48,6 +49,23 @@ BLEUUID BLERemoteDescriptor::getUUID() {
 	return m_uuid;
 } // getUUID
 
+void BLERemoteDescriptor::gattClientEventHandler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t* evtParam) {
+	switch(event) {
+		case ESP_GATTC_READ_DESCR_EVT:
+			if (evtParam->read.handle != getHandle())
+				break;
+			m_semaphoreReadDescrEvt.give();
+			break;
+
+		case ESP_GATTC_WRITE_DESCR_EVT:
+			if (evtParam->write.handle != getHandle())
+				break;
+			m_semaphoreWriteDescrEvt.give();
+			break;
+		default:
+			break;
+	}
+}
 
 std::string BLERemoteDescriptor::readValue() {
 	log_v(">> readValue: %s", toString().c_str());
@@ -65,7 +83,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));
@@ -136,6 +154,8 @@ void BLERemoteDescriptor::writeValue(uint8_t* data, size_t length, bool response
 		return;
 	}
 
+	m_semaphoreWriteDescrEvt.take("writeValue");
+
 	esp_err_t errRc = ::esp_ble_gattc_write_char_descr(
 		m_pRemoteCharacteristic->getRemoteService()->getClient()->getGattcIf(),
 		m_pRemoteCharacteristic->getRemoteService()->getClient()->getConnId(),
@@ -143,11 +163,13 @@ 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);
 	}
+
+	m_semaphoreWriteDescrEvt.wait("writeValue");
 	log_v("<< writeValue");
 } // writeValue
 
@@ -171,5 +193,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,7 +34,8 @@ 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);
+	void        gattClientEventHandler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t* evtParam);
 
 private:
 	friend class BLERemoteCharacteristic;
@@ -48,6 +49,8 @@ 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");
+	FreeRTOS::Semaphore      m_semaphoreWriteDescrEvt      = FreeRTOS::Semaphore("WriteDescrEvt");
+    esp_gatt_auth_req_t      m_auth;
 
 
 };

libraries/BLE/src/BLERemoteService.cpp

@@ -226,11 +226,34 @@ 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) {
-	pCharacteristicMap = &m_characteristicMapByHandle;
+	log_v(">> getCharacteristics() for service: %s", getUUID().toString().c_str());
+	(void)pCharacteristicMap;
+	// If is possible that we have not read the characteristics associated with the service so do that
+	// now.  The request to retrieve the characteristics by calling "retrieveCharacteristics" is a blocking
+	// call and does not return until all the characteristics are available.
+	if (!m_haveCharacteristics) {
+		retrieveCharacteristics();
+	}
+	log_v("<< getCharacteristics() for service: %s", getUUID().toString().c_str());
+	*pCharacteristicMap = m_characteristicMapByHandle;
 }  // Get the characteristics map.
 
 /**
@@ -288,13 +311,10 @@ std::string BLERemoteService::getValue(BLEUUID characteristicUuid) {
  * @return N/A.
  */
 void BLERemoteService::removeCharacteristics() {
-	for (auto &myPair : m_characteristicMap) {
-	   delete myPair.second;
-	   //m_characteristicMap.erase(myPair.first);  // Should be no need to delete as it will be deleted by the clear
-	}
 	m_characteristicMap.clear();   // Clear the map
 	for (auto &myPair : m_characteristicMapByHandle) {
 	   delete myPair.second;
+	   // delete the characteristics only once
 	}
 	m_characteristicMapByHandle.clear();   // Clear the map
 } // removeCharacteristics

libraries/BLE/src/BLEScan.cpp

@@ -22,12 +22,15 @@
  * Constructor
  */
 BLEScan::BLEScan() {
+	memset(&m_scan_params, 0, sizeof(m_scan_params)); // Initialize all params
 	m_scan_params.scan_type          = BLE_SCAN_TYPE_PASSIVE; // Default is a passive scan.
 	m_scan_params.own_addr_type      = BLE_ADDR_TYPE_PUBLIC;
 	m_scan_params.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
+	m_scan_params.scan_duplicate     = BLE_SCAN_DUPLICATE_DISABLE;
 	m_pAdvertisedDeviceCallbacks     = nullptr;
 	m_stopped                        = true;
 	m_wantDuplicates                 = false;
+	m_shouldParse                    = true;
 	setInterval(100);
 	setWindow(100);
 } // BLEScan
@@ -88,15 +91,18 @@ void BLEScan::handleGAPEvent(
 // ignore it.
 					BLEAddress advertisedAddress(param->scan_rst.bda);
 					bool found = false;
+					bool shouldDelete = true;
 
-					if (m_scanResults.m_vectorAdvertisedDevices.count(advertisedAddress.toString()) != 0) {
-						found = true;
-					}
+					if (!m_wantDuplicates) {
+						if (m_scanResults.m_vectorAdvertisedDevices.count(advertisedAddress.toString()) != 0) {
+							found = true;
+						}
 
-					if (found && !m_wantDuplicates) {  // If we found a previous entry AND we don't want duplicates, then we are done.
-						log_d("Ignoring %s, already seen it.", advertisedAddress.toString().c_str());
-						vTaskDelay(1);  // <--- allow to switch task in case we scan infinity and dont have new devices to report, or we are blocked here
-						break;
+						if (found) {  // If we found a previous entry AND we don't want duplicates, then we are done.
+							log_d("Ignoring %s, already seen it.", advertisedAddress.toString().c_str());
+							vTaskDelay(1);  // <--- allow to switch task in case we scan infinity and dont have new devices to report, or we are blocked here
+							break;
+						}
 					}
 
 					// We now construct a model of the advertised device that we have just found for the first
@@ -107,19 +113,23 @@ void BLEScan::handleGAPEvent(
 					advertisedDevice->setAddress(advertisedAddress);
 					advertisedDevice->setRSSI(param->scan_rst.rssi);
 					advertisedDevice->setAdFlag(param->scan_rst.flag);
-					advertisedDevice->parseAdvertisement((uint8_t*)param->scan_rst.ble_adv, param->scan_rst.adv_data_len + param->scan_rst.scan_rsp_len);
+					if (m_shouldParse) {
+						advertisedDevice->parseAdvertisement((uint8_t*)param->scan_rst.ble_adv, param->scan_rst.adv_data_len + param->scan_rst.scan_rsp_len);
+					} else {
+						advertisedDevice->setPayload((uint8_t*)param->scan_rst.ble_adv, param->scan_rst.adv_data_len + param->scan_rst.scan_rsp_len);
+					}
 					advertisedDevice->setScan(this);
 					advertisedDevice->setAddressType(param->scan_rst.ble_addr_type);
 
-					if (!found) {   // If we have previously seen this device, don't record it again.
-						m_scanResults.m_vectorAdvertisedDevices.insert(std::pair<std::string, BLEAdvertisedDevice*>(advertisedAddress.toString(), advertisedDevice));
-					}
-
-					if (m_pAdvertisedDeviceCallbacks) {
+					if (m_pAdvertisedDeviceCallbacks) { // if has callback, no need to record to vector
 						m_pAdvertisedDeviceCallbacks->onResult(*advertisedDevice);
+					} else if (!m_wantDuplicates && !found) {   // if no callback and not want duplicate, and not already in vector, record it
+						m_scanResults.m_vectorAdvertisedDevices.insert(std::pair<std::string, BLEAdvertisedDevice*>(advertisedAddress.toString(), advertisedDevice));
+						shouldDelete = false;
 					}
-					if(found)
+					if (shouldDelete) {
 						delete advertisedDevice;
+					}
 
 					break;
 				} // ESP_GAP_SEARCH_INQ_RES_EVT
@@ -159,13 +169,14 @@ void BLEScan::setActiveScan(bool active) {
  * @brief Set the call backs to be invoked.
  * @param [in] pAdvertisedDeviceCallbacks Call backs to be invoked.
  * @param [in] wantDuplicates  True if we wish to be called back with duplicates.  Default is false.
+ * @param [in] shouldParse  True if we wish to parse advertised package or raw payload.  Default is true.
  */
-void BLEScan::setAdvertisedDeviceCallbacks(BLEAdvertisedDeviceCallbacks* pAdvertisedDeviceCallbacks, bool wantDuplicates) {
+void BLEScan::setAdvertisedDeviceCallbacks(BLEAdvertisedDeviceCallbacks* pAdvertisedDeviceCallbacks, bool wantDuplicates, bool shouldParse) {
 	m_wantDuplicates = wantDuplicates;
 	m_pAdvertisedDeviceCallbacks = pAdvertisedDeviceCallbacks;
+	m_shouldParse = shouldParse;
 } // setAdvertisedDeviceCallbacks
 
-
 /**
  * @brief Set the interval to scan.
  * @param [in] The interval in msecs.

libraries/BLE/src/BLEScan.h

@@ -51,7 +51,8 @@ public:
 	void           setActiveScan(bool active);
 	void           setAdvertisedDeviceCallbacks(
 			              BLEAdvertisedDeviceCallbacks* pAdvertisedDeviceCallbacks,
-										bool wantDuplicates = false);
+										bool wantDuplicates = false,
+										bool shouldParse = true);
 	void           setInterval(uint16_t intervalMSecs);
 	void           setWindow(uint16_t windowMSecs);
 	bool           start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults), bool is_continue = false);
@@ -73,6 +74,7 @@ private:
 	esp_ble_scan_params_t         m_scan_params;
 	BLEAdvertisedDeviceCallbacks* m_pAdvertisedDeviceCallbacks = nullptr;
 	bool                          m_stopped = true;
+	bool                          m_shouldParse = true;
 	FreeRTOS::Semaphore           m_semaphoreScanEnd = FreeRTOS::Semaphore("ScanEnd");
 	BLEScanResults                m_scanResults;
 	bool                          m_wantDuplicates;

libraries/BLE/src/BLESecurity.cpp

@@ -61,6 +61,17 @@ void BLESecurity::setKeySize(uint8_t key_size) {
 	esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &m_keySize, sizeof(uint8_t));
 } //setKeySize
 
+/**
+ * Setup for static PIN connection, call it first and then call setAuthenticationMode eventually to change it
+ */
+void BLESecurity::setStaticPIN(uint32_t pin){
+    uint32_t passkey = pin;
+    esp_ble_gap_set_security_param(ESP_BLE_SM_SET_STATIC_PASSKEY, &passkey, sizeof(uint32_t));
+	setCapability(ESP_IO_CAP_OUT);
+	setKeySize();
+	setAuthenticationMode(ESP_LE_AUTH_REQ_SC_ONLY);
+	setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
+}
 
 /**
  * @brief Debug function to display what keys are exchanged by peers

libraries/BLE/src/BLESecurity.h

@@ -21,6 +21,7 @@ public:
 	void setInitEncryptionKey(uint8_t init_key);
 	void setRespEncryptionKey(uint8_t resp_key);
 	void setKeySize(uint8_t key_size = 16);
+	void setStaticPIN(uint32_t pin);
 	static char* esp_key_type_to_str(esp_ble_key_type_t key_type);
 
 private:

libraries/BLE/src/BLEServer.cpp

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

libraries/BLE/src/BLEServer.h

@@ -79,7 +79,7 @@ public:
 	/* multi connection support */
 	std::map<uint16_t, conn_status_t> getPeerDevices(bool client);
 	void addPeerDevice(void* peer, bool is_client, uint16_t conn_id);
-	void removePeerDevice(uint16_t conn_id, bool client);
+	bool removePeerDevice(uint16_t conn_id, bool client);
 	BLEServer* getServerByConnId(uint16_t conn_id);
 	void updatePeerMTU(uint16_t connId, uint16_t mtu);
 	uint16_t getPeerMTU(uint16_t conn_id);

libraries/BLE/src/BLEUUID.cpp

@@ -352,8 +352,8 @@ std::string BLEUUID::toString() {
 	// If the UUIDs are 16 or 32 bit, pad correctly.
 
 	if (m_uuid.len == ESP_UUID_LEN_16) {  // If the UUID is 16bit, pad correctly.
-		char hex[5];
-		snprintf(hex, sizeof(hex), "%04x", m_uuid.uuid.uuid16);
+		char hex[9];
+		snprintf(hex, sizeof(hex), "%08x", m_uuid.uuid.uuid16);
 		return std::string(hex) + "-0000-1000-8000-00805f9b34fb";
 	} // End 16bit UUID
 
@@ -367,7 +367,7 @@ std::string BLEUUID::toString() {
 	//
 	// UUID string format:
 	// AABBCCDD-EEFF-GGHH-IIJJ-KKLLMMNNOOPP
-	auto size = 35;
+	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],

libraries/BLE/src/FreeRTOS.cpp

@@ -186,16 +186,16 @@ 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);
 	} else {
 		rc = ::xSemaphoreTake(m_semaphore, portMAX_DELAY) == pdTRUE;
 	}
-	m_owner = owner;
 	if (rc) {
-		log_d("Semaphore taken:  %s", toString().c_str());
+		m_owner = owner;
+		log_v("Semaphore taken:  %s", toString().c_str());
 	} else {
 		log_e("Semaphore NOT taken:  %s", toString().c_str());
 	}
@@ -218,8 +218,8 @@ bool FreeRTOS::Semaphore::take(uint32_t timeoutMs, std::string owner) {
 	} else {
 		rc = ::xSemaphoreTake(m_semaphore, timeoutMs / portTICK_PERIOD_MS) == pdTRUE;
 	}
-	m_owner = owner;
 	if (rc) {
+		m_owner = owner;
 		log_v("Semaphore taken:  %s", toString().c_str());
 	} else {
 		log_e("Semaphore NOT taken:  %s", toString().c_str());

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("---");

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";
+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);
+}

libraries/BluetoothSerial/examples/SerialToSerialBT_SSP_pairing/SerialToSerialBT_SSP_pairing.ino

@@ -0,0 +1,75 @@
+//This example code is in the Public Domain (or CC0 licensed, at your option.)
+//By Richard Li - 2020
+//
+//This example creates a bridge between Serial and Classical Bluetooth (SPP with authentication)
+//and also demonstrate that SerialBT have the same functionalities of a normal Serial
+
+#include "BluetoothSerial.h"
+
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+BluetoothSerial SerialBT;
+boolean confirmRequestPending = true;
+
+void BTConfirmRequestCallback(uint32_t numVal)
+{
+  confirmRequestPending = true;
+  Serial.println(numVal);
+}
+
+void BTAuthCompleteCallback(boolean success)
+{
+  confirmRequestPending = false;
+  if (success)
+  {
+    Serial.println("Pairing success!!");
+  }
+  else
+  {
+    Serial.println("Pairing failed, rejected by user!!");
+  }
+}
+
+
+void setup()
+{
+  Serial.begin(115200);
+  SerialBT.enableSSP();
+  SerialBT.onConfirmRequest(BTConfirmRequestCallback);
+  SerialBT.onAuthComplete(BTAuthCompleteCallback);
+  SerialBT.begin("ESP32test"); //Bluetooth device name
+  Serial.println("The device started, now you can pair it with bluetooth!");
+}
+
+void loop()
+{
+  if (confirmRequestPending)
+  {
+    if (Serial.available())
+    {
+      int dat = Serial.read();
+      if (dat == 'Y' || dat == 'y')
+      {
+        SerialBT.confirmReply(true);
+      }
+      else
+      {
+        SerialBT.confirmReply(false);
+      }
+    }
+  }
+  else
+  {
+    if (Serial.available())
+    {
+      SerialBT.write(Serial.read());
+    }
+    if (SerialBT.available())
+    {
+      Serial.write(SerialBT.read());
+    }
+    delay(20);
+  }
+}

libraries/BluetoothSerial/examples/bt_remove_paired_devices/bt_remove_paired_devices.ino

@@ -0,0 +1,87 @@
+//This example code is in the Public Domain (or CC0 licensed, at your option.)
+//By Victor Tchistiak - 2019
+//
+//This example demonstrates reading and removing paired devices stored on the ESP32 flash memory
+//Sometimes you may find your ESP32 device could not connect to the remote device despite
+//many successful connections earlier. This is most likely a result of client replacing your paired
+//device info with new one from other device. The BT clients store connection info for paired devices,
+//but it is limited to a few devices only. When new device pairs and number of stored devices is exceeded,
+//one of the previously paired devices would be replaced with new one.
+//The only remedy is to delete this saved bound device from your device flash memory
+//and pair with the other device again.
+//
+#include "esp_bt_main.h"
+#include "esp_bt_device.h"
+#include"esp_gap_bt_api.h"
+#include "esp_err.h"
+
+#define REMOVE_BONDED_DEVICES 0   // <- Set to 0 to view all bonded devices addresses, set to 1 to remove
+
+#define PAIR_MAX_DEVICES 20
+uint8_t pairedDeviceBtAddr[PAIR_MAX_DEVICES][6];
+char bda_str[18];
+
+bool initBluetooth()
+{
+  if(!btStart()) {
+    Serial.println("Failed to initialize controller");
+    return false;
+  }
+ 
+  if(esp_bluedroid_init() != ESP_OK) {
+    Serial.println("Failed to initialize bluedroid");
+    return false;
+  }
+ 
+  if(esp_bluedroid_enable() != ESP_OK) {
+    Serial.println("Failed to enable bluedroid");
+    return false;
+  }
+  return true;
+}
+
+char *bda2str(const uint8_t* bda, char *str, size_t size)
+{
+  if (bda == NULL || str == NULL || size < 18) {
+    return NULL;
+  }
+  sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x",
+          bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
+  return str;
+}
+ 
+void setup() {
+  Serial.begin(115200);
+ 
+  initBluetooth();
+  Serial.print("ESP32 bluetooth address: "); Serial.println(bda2str(esp_bt_dev_get_address(), bda_str, 18));
+  // Get the numbers of bonded/paired devices in the BT module
+  int count = esp_bt_gap_get_bond_device_num();
+  if(!count) {
+    Serial.println("No bonded device found.");
+  } else {
+    Serial.print("Bonded device count: "); Serial.println(count);
+    if(PAIR_MAX_DEVICES < count) {
+      count = PAIR_MAX_DEVICES; 
+      Serial.print("Reset bonded device count: "); Serial.println(count);
+    }
+    esp_err_t tError =  esp_bt_gap_get_bond_device_list(&count, pairedDeviceBtAddr);
+    if(ESP_OK == tError) {
+      for(int i = 0; i < count; i++) {
+        Serial.print("Found bonded device # "); Serial.print(i); Serial.print(" -> ");
+        Serial.println(bda2str(pairedDeviceBtAddr[i], bda_str, 18));     
+        if(REMOVE_BONDED_DEVICES) {
+          esp_err_t tError = esp_bt_gap_remove_bond_device(pairedDeviceBtAddr[i]);
+          if(ESP_OK == tError) {
+            Serial.print("Removed bonded device # "); 
+          } else {
+            Serial.print("Failed to remove bonded device # ");
+          }
+          Serial.println(i);
+        }
+      }        
+    }
+  }
+}
+ 
+void loop() {}

libraries/BluetoothSerial/src/BluetoothSerial.cpp

@@ -36,9 +36,7 @@
 #include "esp_spp_api.h"
 #include <esp_log.h>
 
-#ifdef ARDUINO_ARCH_ESP32
 #include "esp32-hal-log.h"
-#endif
 
 const char * _spp_server_name = "ESP32SPP";
 
@@ -52,16 +50,87 @@ static TaskHandle_t _spp_task_handle = NULL;
 static EventGroupHandle_t _spp_event_group = NULL;
 static boolean secondConnectionAttempt;
 static esp_spp_cb_t * custom_spp_callback = NULL;
+static BluetoothSerialDataCb custom_data_callback = NULL;
+static esp_bd_addr_t current_bd_addr;
+static ConfirmRequestCb confirm_request_callback = NULL;
+static AuthCompleteCb auth_complete_callback = NULL;
+
+#define INQ_LEN 0x10
+#define INQ_NUM_RSPS 20
+#define READY_TIMEOUT (10 * 1000)
+#define SCAN_TIMEOUT (INQ_LEN * 2 * 1000)
+static esp_bd_addr_t _peer_bd_addr;
+static char _remote_name[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
+static bool _isRemoteAddressSet;
+static bool _isMaster;
+static esp_bt_pin_code_t _pin_code;
+static int _pin_len;
+static bool _isPinSet;
+static bool _enableSSP;
 
 #define SPP_RUNNING     0x01
 #define SPP_CONNECTED   0x02
 #define SPP_CONGESTED   0x04
+#define SPP_DISCONNECTED 0x08
 
 typedef struct {
         size_t len;
         uint8_t data[];
 } spp_packet_t;
 
+#if (ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO)
+static char *bda2str(esp_bd_addr_t bda, char *str, size_t size)
+{
+  if (bda == NULL || str == NULL || size < 18) {
+    return NULL;
+  }
+
+  uint8_t *p = bda;
+  sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x",
+          p[0], p[1], p[2], p[3], p[4], p[5]);
+  return str;
+}
+#endif
+
+static bool get_name_from_eir(uint8_t *eir, char *bdname, uint8_t *bdname_len)
+{
+    if (!eir || !bdname || !bdname_len) {
+        return false;
+    }
+
+    uint8_t *rmt_bdname, rmt_bdname_len;
+    *bdname = *bdname_len = rmt_bdname_len = 0;
+
+    rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME, &rmt_bdname_len);
+    if (!rmt_bdname) {
+        rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME, &rmt_bdname_len);
+    }
+    if (rmt_bdname) {
+        rmt_bdname_len = rmt_bdname_len > ESP_BT_GAP_MAX_BDNAME_LEN ? ESP_BT_GAP_MAX_BDNAME_LEN : rmt_bdname_len;
+        memcpy(bdname, rmt_bdname, rmt_bdname_len);
+        bdname[rmt_bdname_len] = 0;
+        *bdname_len = rmt_bdname_len;
+        return true;
+    }
+    return false;
+}
+
+static bool btSetPin() {
+    esp_bt_pin_type_t pin_type;
+    if (_isPinSet) {
+        if (_pin_len) {
+            log_i("pin set");
+            pin_type = ESP_BT_PIN_TYPE_FIXED;
+        } else {
+            _isPinSet = false;
+            log_i("pin reset");
+            pin_type = ESP_BT_PIN_TYPE_VARIABLE; // pin_code would be ignored (default)
+        }
+        return (esp_bt_gap_set_pin(pin_type, _pin_len, _pin_code) == ESP_OK);        
+    }
+    return false;
+}
+
 static esp_err_t _spp_queue_packet(uint8_t *data, size_t len){
     if(!data || !len){
         log_w("No data provided");
@@ -87,7 +156,7 @@ static uint8_t _spp_tx_buffer[SPP_TX_MAX];
 static uint16_t _spp_tx_buffer_len = 0;
 
 static bool _spp_send_buffer(){
-    if((xEventGroupWaitBits(_spp_event_group, SPP_CONGESTED, pdFALSE, pdTRUE, portMAX_DELAY) & SPP_CONGESTED)){
+    if((xEventGroupWaitBits(_spp_event_group, SPP_CONGESTED, pdFALSE, pdTRUE, portMAX_DELAY) & SPP_CONGESTED) != 0){
         esp_err_t err = esp_spp_write(_spp_client, _spp_tx_buffer_len, _spp_tx_buffer);
         if(err != ESP_OK){
             log_e("SPP Write Failed! [0x%X]", err);
@@ -136,12 +205,12 @@ static void _spp_tx_task(void * arg){
                 if(len){
                     memcpy(_spp_tx_buffer, data, len);
                     _spp_tx_buffer_len += len;
-                    free(packet);
-                    packet = NULL;
                     if(uxQueueMessagesWaiting(_spp_tx_queue) == 0){
                         _spp_send_buffer();
                     }
                 }
+                free(packet);
+                packet = NULL;
             }
         } else {
             log_e("Something went horribly wrong");
@@ -151,7 +220,6 @@ static void _spp_tx_task(void * arg){
     _spp_task_handle = NULL;
 }
 
-
 static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
 {
     switch (event)
@@ -159,29 +227,34 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
     case ESP_SPP_INIT_EVT:
         log_i("ESP_SPP_INIT_EVT");
         esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
-        esp_spp_start_srv(ESP_SPP_SEC_NONE, ESP_SPP_ROLE_SLAVE, 0, _spp_server_name);
+        if (!_isMaster) {
+            log_i("ESP_SPP_INIT_EVT: slave: start");
+            esp_spp_start_srv(ESP_SPP_SEC_NONE, ESP_SPP_ROLE_SLAVE, 0, _spp_server_name);
+        }
         xEventGroupSetBits(_spp_event_group, SPP_RUNNING);
         break;
 
     case ESP_SPP_SRV_OPEN_EVT://Server connection open
+        log_i("ESP_SPP_SRV_OPEN_EVT");
         if (!_spp_client){
             _spp_client = param->open.handle;
         } else {
             secondConnectionAttempt = true;
             esp_spp_disconnect(param->open.handle);
         }
+        xEventGroupClearBits(_spp_event_group, SPP_DISCONNECTED);
         xEventGroupSetBits(_spp_event_group, SPP_CONNECTED);
-        log_i("ESP_SPP_SRV_OPEN_EVT");
         break;
 
     case ESP_SPP_CLOSE_EVT://Client connection closed
+        log_i("ESP_SPP_CLOSE_EVT");
         if(secondConnectionAttempt) {
             secondConnectionAttempt = false;
         } else {
             _spp_client = 0;
-        }
+            xEventGroupSetBits(_spp_event_group, SPP_DISCONNECTED);
+        }        
         xEventGroupClearBits(_spp_event_group, SPP_CONNECTED);
-        log_i("ESP_SPP_CLOSE_EVT");
         break;
 
     case ESP_SPP_CONG_EVT://connection congestion status changed
@@ -206,7 +279,9 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
         //esp_log_buffer_hex("",param->data_ind.data,param->data_ind.len); //for low level debug
         //ets_printf("r:%u\n", param->data_ind.len);
 
-        if (_spp_rx_queue != NULL){
+        if(custom_data_callback){
+            custom_data_callback(param->data_ind.data, param->data_ind.len);
+        } else if (_spp_rx_queue != NULL){
             for (int i = 0; i < param->data_ind.len; i++){
                 if(xQueueSend(_spp_rx_queue, param->data_ind.data + i, (TickType_t)0) != pdTRUE){
                     log_e("RX Full! Discarding %u bytes", param->data_ind.len - i);
@@ -216,25 +291,167 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
         }
         break;
 
-        //should maybe delete those.
     case ESP_SPP_DISCOVERY_COMP_EVT://discovery complete
         log_i("ESP_SPP_DISCOVERY_COMP_EVT");
+        if (param->disc_comp.status == ESP_SPP_SUCCESS) {
+            log_i("ESP_SPP_DISCOVERY_COMP_EVT: spp connect to remote");
+            esp_spp_connect(ESP_SPP_SEC_AUTHENTICATE, ESP_SPP_ROLE_MASTER, param->disc_comp.scn[0], _peer_bd_addr);
+        }
         break;
+
     case ESP_SPP_OPEN_EVT://Client connection open
         log_i("ESP_SPP_OPEN_EVT");
+        if (!_spp_client){
+                _spp_client = param->open.handle;
+        } else {
+            secondConnectionAttempt = true;
+            esp_spp_disconnect(param->open.handle);
+        }
+        xEventGroupClearBits(_spp_event_group, SPP_DISCONNECTED);
+        xEventGroupSetBits(_spp_event_group, SPP_CONNECTED);
         break;
+
     case ESP_SPP_START_EVT://server started
         log_i("ESP_SPP_START_EVT");
         break;
+
     case ESP_SPP_CL_INIT_EVT://client initiated a connection
         log_i("ESP_SPP_CL_INIT_EVT");
         break;
+
     default:
         break;
     }
     if(custom_spp_callback)(*custom_spp_callback)(event, param);
 }
 
+void BluetoothSerial::onData(BluetoothSerialDataCb cb){
+    custom_data_callback = cb;
+}
+
+static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
+{
+    switch(event){
+        case ESP_BT_GAP_DISC_RES_EVT:
+            log_i("ESP_BT_GAP_DISC_RES_EVT");
+#if (ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO)
+            char bda_str[18];
+            log_i("Scanned device: %s", bda2str(param->disc_res.bda, bda_str, 18));
+#endif
+            for (int i = 0; i < param->disc_res.num_prop; i++) {
+                uint8_t peer_bdname_len;
+                char peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
+                switch(param->disc_res.prop[i].type) {
+                    case ESP_BT_GAP_DEV_PROP_EIR:  
+                        if (get_name_from_eir((uint8_t*)param->disc_res.prop[i].val, peer_bdname, &peer_bdname_len)) {
+                            log_i("ESP_BT_GAP_DISC_RES_EVT : EIR : %s : %d", peer_bdname, peer_bdname_len);
+                            if (strlen(_remote_name) == peer_bdname_len
+                                && strncmp(peer_bdname, _remote_name, peer_bdname_len) == 0) {
+                                log_v("ESP_BT_GAP_DISC_RES_EVT : SPP_START_DISCOVERY_EIR : %s", peer_bdname, peer_bdname_len);
+                                _isRemoteAddressSet = true;
+                                memcpy(_peer_bd_addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
+                                esp_bt_gap_cancel_discovery();
+                                esp_spp_start_discovery(_peer_bd_addr);
+                            }
+                        }
+                        break;
+
+                    case ESP_BT_GAP_DEV_PROP_BDNAME:
+                        peer_bdname_len = param->disc_res.prop[i].len;
+                        memcpy(peer_bdname, param->disc_res.prop[i].val, peer_bdname_len);
+                        peer_bdname_len--; // len includes 0 terminator
+                        log_v("ESP_BT_GAP_DISC_RES_EVT : BDNAME :  %s : %d", peer_bdname, peer_bdname_len);
+                        if (strlen(_remote_name) == peer_bdname_len
+                            && strncmp(peer_bdname, _remote_name, peer_bdname_len) == 0) {
+                            log_i("ESP_BT_GAP_DISC_RES_EVT : SPP_START_DISCOVERY_BDNAME : %s", peer_bdname);
+                            _isRemoteAddressSet = true;
+                            memcpy(_peer_bd_addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
+                            esp_bt_gap_cancel_discovery();
+                            esp_spp_start_discovery(_peer_bd_addr);
+                        } 
+                        break;
+
+                    case ESP_BT_GAP_DEV_PROP_COD:
+                        log_d("ESP_BT_GAP_DEV_PROP_COD");
+                        break;
+
+                    case ESP_BT_GAP_DEV_PROP_RSSI:
+                        log_d("ESP_BT_GAP_DEV_PROP_RSSI");
+                        break;
+                        
+                    default:
+                        break;
+                }
+                if (_isRemoteAddressSet)
+                    break;
+            }
+            break;
+        case ESP_BT_GAP_DISC_STATE_CHANGED_EVT:
+            log_i("ESP_BT_GAP_DISC_STATE_CHANGED_EVT");
+            break;
+
+        case ESP_BT_GAP_RMT_SRVCS_EVT:
+            log_i( "ESP_BT_GAP_RMT_SRVCS_EVT");
+            break;
+
+        case ESP_BT_GAP_RMT_SRVC_REC_EVT:
+            log_i("ESP_BT_GAP_RMT_SRVC_REC_EVT");
+            break;
+
+        case ESP_BT_GAP_AUTH_CMPL_EVT:
+            if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
+                log_v("authentication success: %s", param->auth_cmpl.device_name);
+                if (auth_complete_callback) {
+                    auth_complete_callback(true);
+                }
+            } else {
+                log_e("authentication failed, status:%d", param->auth_cmpl.stat);
+                if (auth_complete_callback) {
+                    auth_complete_callback(false);
+                }
+            }
+            break;
+
+        case ESP_BT_GAP_PIN_REQ_EVT:
+            // default pairing pins
+            log_i("ESP_BT_GAP_PIN_REQ_EVT min_16_digit:%d", param->pin_req.min_16_digit);
+            if (param->pin_req.min_16_digit) {
+                log_i("Input pin code: 0000 0000 0000 0000");
+                esp_bt_pin_code_t pin_code;
+                memset(pin_code, '0', ESP_BT_PIN_CODE_LEN);
+                esp_bt_gap_pin_reply(param->pin_req.bda, true, 16, pin_code);
+            } else {
+                log_i("Input pin code: 1234");
+                esp_bt_pin_code_t pin_code;
+                memcpy(pin_code, "1234", 4);
+                esp_bt_gap_pin_reply(param->pin_req.bda, true, 4, pin_code);
+            }
+            break;
+       
+        case ESP_BT_GAP_CFM_REQ_EVT:
+            log_i("ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %d", param->cfm_req.num_val);
+            if (confirm_request_callback) {
+                memcpy(current_bd_addr, param->cfm_req.bda, sizeof(esp_bd_addr_t));
+                confirm_request_callback(param->cfm_req.num_val);
+            }
+            else {
+                esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
+            }
+            break;
+
+        case ESP_BT_GAP_KEY_NOTIF_EVT:
+            log_i("ESP_BT_GAP_KEY_NOTIF_EVT passkey:%d", param->key_notif.passkey);
+            break;
+
+        case ESP_BT_GAP_KEY_REQ_EVT:
+            log_i("ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
+            break;
+
+        default:
+            break;
+    }
+}
+
 static bool _init_bt(const char *deviceName)
 {
     if(!_spp_event_group){
@@ -245,6 +462,7 @@ static bool _init_bt(const char *deviceName)
         }
         xEventGroupClearBits(_spp_event_group, 0xFFFFFF);
         xEventGroupSetBits(_spp_event_group, SPP_CONGESTED);
+        xEventGroupSetBits(_spp_event_group, SPP_DISCONNECTED);
     }
     if (_spp_rx_queue == NULL){
         _spp_rx_queue = xQueueCreate(RX_QUEUE_SIZE, sizeof(uint8_t)); //initialize the queue
@@ -270,7 +488,7 @@ static bool _init_bt(const char *deviceName)
     }
 
     if(!_spp_task_handle){
-        xTaskCreate(_spp_tx_task, "spp_tx", 4096, NULL, 2, &_spp_task_handle);
+        xTaskCreatePinnedToCore(_spp_tx_task, "spp_tx", 4096, NULL, 2, &_spp_task_handle, 0);
         if(!_spp_task_handle){
             log_e("Network Event Task Start Failed!");
             return false;
@@ -297,6 +515,13 @@ static bool _init_bt(const char *deviceName)
         }
     }
 
+    // Why only master need this?  Slave need this during pairing as well
+//    if (_isMaster && esp_bt_gap_register_callback(esp_bt_gap_cb) != ESP_OK) {
+    if (esp_bt_gap_register_callback(esp_bt_gap_cb) != ESP_OK) {
+        log_e("gap register failed");
+        return false;
+    }
+
     if (esp_spp_register_callback(esp_spp_cb) != ESP_OK){
         log_e("spp register failed");
         return false;
@@ -307,8 +532,24 @@ static bool _init_bt(const char *deviceName)
         return false;
     }
 
+    if (esp_bt_sleep_disable() != ESP_OK){
+        log_e("esp_bt_sleep_disable failed");
+    }
+
+    log_i("device name set");
     esp_bt_dev_set_device_name(deviceName);
 
+    if (_isPinSet) {
+        btSetPin();
+    }
+
+    if (_enableSSP) {
+        log_i("Simple Secure Pairing");
+        esp_bt_sp_param_t param_type = ESP_BT_SP_IOCAP_MODE;
+        esp_bt_io_cap_t iocap = ESP_BT_IO_CAP_IO;
+        esp_bt_gap_set_security_param(param_type, &iocap, sizeof(uint8_t));
+    }
+
     // the default BTA_DM_COD_LOUDSPEAKER does not work with the macOS BT stack
     esp_bt_cod_t cod;
     cod.major = 0b00001;
@@ -318,7 +559,6 @@ static bool _init_bt(const char *deviceName)
         log_e("set cod failed");
         return false;
     }
-
     return true;
 }
 
@@ -361,6 +601,11 @@ static bool _stop_bt()
     return true;
 }
 
+static bool waitForConnect(int timeout) {
+    TickType_t xTicksToWait = timeout / portTICK_PERIOD_MS;
+    return (xEventGroupWaitBits(_spp_event_group, SPP_CONNECTED, pdFALSE, pdTRUE, xTicksToWait) & SPP_CONNECTED) != 0;
+}
+
 /*
  * Serial Bluetooth Arduino
  *
@@ -376,8 +621,9 @@ BluetoothSerial::~BluetoothSerial(void)
     _stop_bt();
 }
 
-bool BluetoothSerial::begin(String localName)
+bool BluetoothSerial::begin(String localName, bool isMaster)
 {
+    _isMaster = isMaster;
     if (localName.length()){
         local_name = localName;
     }
@@ -431,7 +677,11 @@ size_t BluetoothSerial::write(const uint8_t *buffer, size_t size)
 
 void BluetoothSerial::flush()
 {
-    while(read() >= 0){}
+    if (_spp_tx_queue != NULL){
+        while(uxQueueMessagesWaiting(_spp_tx_queue) > 0){
+	    delay(5);
+        }
+    }
 }
 
 void BluetoothSerial::end()
@@ -439,10 +689,151 @@ void BluetoothSerial::end()
     _stop_bt();
 }
 
+void BluetoothSerial::onConfirmRequest(ConfirmRequestCb cb)
+{
+    confirm_request_callback = cb;
+}
+
+void BluetoothSerial::onAuthComplete(AuthCompleteCb cb)
+{
+    auth_complete_callback = cb;
+}
+
+void BluetoothSerial::confirmReply(boolean confirm)
+{
+    esp_bt_gap_ssp_confirm_reply(current_bd_addr, confirm);  
+}
+
+
 esp_err_t BluetoothSerial::register_callback(esp_spp_cb_t * callback)
 {
     custom_spp_callback = callback;
     return ESP_OK;
 }
 
+//Simple Secure Pairing
+void BluetoothSerial::enableSSP() {
+    _enableSSP = true;
+}
+/*
+     * Set default parameters for Legacy Pairing
+     * Use fixed pin code
+*/
+bool BluetoothSerial::setPin(const char *pin) {
+    bool isEmpty =  !(pin  && *pin);
+    if (isEmpty && !_isPinSet) {
+        return true; // nothing to do
+    } else if (!isEmpty){
+        _pin_len = strlen(pin);
+        memcpy(_pin_code, pin, _pin_len);
+    } else {
+        _pin_len = 0; // resetting pin to none (default)
+    }
+    _pin_code[_pin_len] = 0;
+    _isPinSet = true;
+    if (isReady(false, READY_TIMEOUT)) {
+        btSetPin();
+    }
+    return true;
+}
+
+bool BluetoothSerial::connect(String remoteName)
+{
+    if (!isReady(true, READY_TIMEOUT)) return false;
+    if (remoteName && remoteName.length() < 1) {
+        log_e("No remote name is provided");
+        return false; 
+    }
+    disconnect();
+    _isRemoteAddressSet = false;
+    strncpy(_remote_name, remoteName.c_str(), ESP_BT_GAP_MAX_BDNAME_LEN);
+    _remote_name[ESP_BT_GAP_MAX_BDNAME_LEN] = 0;
+    log_i("master : remoteName");
+    // will first resolve name to address
+    esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
+    if (esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, INQ_LEN, INQ_NUM_RSPS) == ESP_OK) {
+        return waitForConnect(SCAN_TIMEOUT);
+    }
+    return false;
+}
+
+bool BluetoothSerial::connect(uint8_t remoteAddress[])
+{
+    if (!isReady(true, READY_TIMEOUT)) return false;
+    if (!remoteAddress) {
+        log_e("No remote address is provided");
+        return false; 
+    }
+    disconnect();
+    _remote_name[0] = 0;
+    _isRemoteAddressSet = true;
+    memcpy(_peer_bd_addr, remoteAddress, ESP_BD_ADDR_LEN);
+    log_i("master : remoteAddress");
+    if (esp_spp_start_discovery(_peer_bd_addr) == ESP_OK) {
+        return waitForConnect(READY_TIMEOUT);
+    }
+    return false;
+}
+
+bool BluetoothSerial::connect()
+{
+    if (!isReady(true, READY_TIMEOUT)) return false;
+    if (_isRemoteAddressSet){
+        disconnect();
+        // use resolved or set address first
+        log_i("master : remoteAddress");
+        if (esp_spp_start_discovery(_peer_bd_addr) == ESP_OK) {
+            return waitForConnect(READY_TIMEOUT);
+        }
+        return false;
+    } else if (_remote_name[0]) {
+        disconnect();
+        log_i("master : remoteName");
+        // will resolve name to address first - it may take a while
+        esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
+        if (esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, INQ_LEN, INQ_NUM_RSPS) == ESP_OK) {
+            return waitForConnect(SCAN_TIMEOUT);
+        }
+        return false;
+    }
+    log_e("Neither Remote name nor address was provided");
+    return false;
+}
+
+bool BluetoothSerial::disconnect() {
+    if (_spp_client) {
+        flush();
+        log_i("disconnecting");
+        if (esp_spp_disconnect(_spp_client) == ESP_OK) {
+            TickType_t xTicksToWait = READY_TIMEOUT / portTICK_PERIOD_MS;
+            return (xEventGroupWaitBits(_spp_event_group, SPP_DISCONNECTED, pdFALSE, pdTRUE, xTicksToWait) & SPP_DISCONNECTED) != 0;
+        }
+    }
+    return false;
+}
+
+bool BluetoothSerial::unpairDevice(uint8_t remoteAddress[]) {
+    if (isReady(false, READY_TIMEOUT)) {
+        log_i("removing bonded device");
+        return (esp_bt_gap_remove_bond_device(remoteAddress) == ESP_OK);
+    }
+    return false;
+}
+
+bool BluetoothSerial::connected(int timeout) {
+    return waitForConnect(timeout);
+}
+
+bool BluetoothSerial::isReady(bool checkMaster, int timeout) {
+    if (checkMaster && !_isMaster) {
+        log_e("Master mode is not active. Call begin(localName, true) to enable Master mode");
+        return false;
+    }
+    if (!btStarted()) {
+        log_e("BT is not initialized. Call begin() first");
+        return false;
+    }
+    TickType_t xTicksToWait = timeout / portTICK_PERIOD_MS;
+    return (xEventGroupWaitBits(_spp_event_group, SPP_RUNNING, pdFALSE, pdTRUE, xTicksToWait) & SPP_RUNNING) != 0;
+}
 #endif