diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-arduino-core-esp32.sh b/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-arduino-core-esp32.sh
new file mode 100755
index 00000000..cf1026d6
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.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
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-arduino-ide.sh b/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-arduino-ide.sh
new file mode 100755
index 00000000..7e268b1f
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-arduino-ide.sh
@@ -0,0 +1,220 @@
+#!/bin/bash
+
+#OSTYPE: 'linux-gnu', ARCH: 'x86_64' => linux64
+#OSTYPE: 'msys', ARCH: 'x86_64' => win32
+#OSTYPE: 'darwin18', ARCH: 'i386' => macos
+
+OSBITS=`arch`
+if [[ "$OSTYPE" == "linux"* ]]; then
+	export OS_IS_LINUX="1"
+	ARCHIVE_FORMAT="tar.xz"
+	if [[ "$OSBITS" == "i686" ]]; then
+		OS_NAME="linux32"
+	elif [[ "$OSBITS" == "x86_64" ]]; then
+		OS_NAME="linux64"
+	elif [[ "$OSBITS" == "armv7l" || "$OSBITS" == "aarch64" ]]; then
+		OS_NAME="linuxarm"
+	else
+		OS_NAME="$OSTYPE-$OSBITS"
+		echo "Unknown OS '$OS_NAME'"
+		exit 1
+	fi
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+	export OS_IS_MACOS="1"
+	ARCHIVE_FORMAT="zip"
+	OS_NAME="macosx"
+elif [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "win32" ]]; then
+	export OS_IS_WINDOWS="1"
+	ARCHIVE_FORMAT="zip"
+	OS_NAME="windows"
+else
+	OS_NAME="$OSTYPE-$OSBITS"
+	echo "Unknown OS '$OS_NAME'"
+	exit 1
+fi
+export OS_NAME
+
+ARDUINO_BUILD_DIR="$HOME/.arduino/build.tmp"
+ARDUINO_CACHE_DIR="$HOME/.arduino/cache.tmp"
+
+if [ "$OS_IS_MACOS" == "1" ]; then
+	export ARDUINO_IDE_PATH="/Applications/Arduino.app/Contents/Java"
+	export ARDUINO_USR_PATH="$HOME/Documents/Arduino"
+elif [ "$OS_IS_WINDOWS" == "1" ]; then
+	export ARDUINO_IDE_PATH="$HOME/arduino_ide"
+	export ARDUINO_USR_PATH="$HOME/Documents/Arduino"
+else
+	export ARDUINO_IDE_PATH="$HOME/arduino_ide"
+	export ARDUINO_USR_PATH="$HOME/Arduino"
+fi
+
+if [ ! -d "$ARDUINO_IDE_PATH" ]; then
+	echo "Installing Arduino IDE on $OS_NAME ..."
+	echo "Downloading 'arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
+	if [ "$OS_IS_LINUX" == "1" ]; then
+		wget -O "arduino.$ARCHIVE_FORMAT" "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
+		tar xf "arduino.$ARCHIVE_FORMAT" > /dev/null
+		mv arduino-nightly "$ARDUINO_IDE_PATH"
+	else
+		curl -o "arduino.$ARCHIVE_FORMAT" -L "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
+		unzip "arduino.$ARCHIVE_FORMAT" > /dev/null
+		if [ "$OS_IS_MACOS" == "1" ]; then
+			mv "Arduino.app" "/Applications/Arduino.app"
+		else
+			mv arduino-nightly "$ARDUINO_IDE_PATH"
+		fi
+	fi
+	rm -rf "arduino.$ARCHIVE_FORMAT"
+
+	mkdir -p "$ARDUINO_USR_PATH/libraries"
+	mkdir -p "$ARDUINO_USR_PATH/hardware"
+
+	echo "Arduino IDE Installed in '$ARDUINO_IDE_PATH'"
+	echo ""
+fi
+
+function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
+    if [ "$#" -lt 2 ]; then
+		echo "ERROR: Illegal number of parameters"
+		echo "USAGE: build_sketch <fqbn> <path-to-ino> [extra-options]"
+		return 1
+	fi
+
+	local fqbn="$1"
+	local sketch="$2"
+	local xtra_opts="$3"
+	local win_opts=""
+	if [ "$OS_IS_WINDOWS" == "1" ]; then
+		local ctags_version=`ls "$ARDUINO_IDE_PATH/tools-builder/ctags/"`
+		local preprocessor_version=`ls "$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/"`
+		win_opts="-prefs=runtime.tools.ctags.path=$ARDUINO_IDE_PATH/tools-builder/ctags/$ctags_version -prefs=runtime.tools.arduino-preprocessor.path=$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/$preprocessor_version"
+	fi
+
+	echo ""
+	echo "Compiling '"$(basename "$sketch")"' ..."
+	mkdir -p "$ARDUINO_BUILD_DIR"
+	mkdir -p "$ARDUINO_CACHE_DIR"
+	$ARDUINO_IDE_PATH/arduino-builder -compile -logger=human -core-api-version=10810 \
+		-fqbn=$fqbn \
+		-warnings="all" \
+		-tools "$ARDUINO_IDE_PATH/tools-builder" \
+		-tools "$ARDUINO_IDE_PATH/tools" \
+		-built-in-libraries "$ARDUINO_IDE_PATH/libraries" \
+		-hardware "$ARDUINO_IDE_PATH/hardware" \
+		-hardware "$ARDUINO_USR_PATH/hardware" \
+		-libraries "$ARDUINO_USR_PATH/libraries" \
+		-build-cache "$ARDUINO_CACHE_DIR" \
+		-build-path "$ARDUINO_BUILD_DIR" \
+		$win_opts $xtra_opts "$sketch"
+}
+
+function count_sketches() # count_sketches <examples-path>
+{
+	local examples="$1"
+    rm -rf sketches.txt
+	if [ ! -d "$examples" ]; then
+		touch sketches.txt
+		return 0
+	fi
+    local sketches=$(find $examples -name *.ino)
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
+            continue
+        fi;
+        if [[ -f "$sketchdir/.test.skip" ]]; then
+            continue
+        fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
+    done
+    return $sketchnum
+}
+
+function build_sketches() # build_sketches <fqbn> <examples-path> <chunk> <total-chunks> [extra-options]
+{
+    local fqbn=$1
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
+    local xtra_opts=$5
+
+    if [ "$#" -lt 2 ]; then
+		echo "ERROR: Illegal number of parameters"
+		echo "USAGE: build_sketches <fqbn> <examples-path> [<chunk> <total-chunks>] [extra-options]"
+		return 1
+	fi
+
+    if [ "$#" -lt 4 ]; then
+		chunk_idex="0"
+		chunks_num="1"
+		xtra_opts=$3
+	fi
+
+	if [ "$chunks_num" -le 0 ]; then
+		echo "ERROR: Chunks count must be positive number"
+		return 1
+	fi
+	if [ "$chunk_idex" -ge "$chunks_num" ]; then
+		echo "ERROR: Chunk index must be less than chunks count"
+		return 1
+	fi
+
+	set +e
+    count_sketches "$examples"
+    local sketchcount=$?
+	set -e
+    local sketches=$(cat sketches.txt)
+    rm -rf sketches.txt
+
+    local chunk_size=$(( $sketchcount / $chunks_num ))
+    local all_chunks=$(( $chunks_num * $chunk_size ))
+    if [ "$all_chunks" -lt "$sketchcount" ]; then
+    	chunk_size=$(( $chunk_size + 1 ))
+    fi
+
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+    	echo "Skipping job"
+    	return 0
+    fi
+
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+    	end_index=$sketchcount
+    fi
+
+    local start_num=$(( $start_index + 1 ))
+    echo "Found $sketchcount Sketches";
+    echo "Chunk Count : $chunks_num"
+    echo "Chunk Size  : $chunk_size"
+    echo "Start Sketch: $start_num"
+    echo "End Sketch  : $end_index"
+
+    local sketchnum=0
+    for sketch in $sketches; do
+        local sketchdir=$(dirname $sketch)
+        local sketchdirname=$(basename $sketchdir)
+        local sketchname=$(basename $sketch)
+        if [ "${sketchdirname}.ino" != "$sketchname" ] \
+        || [ -f "$sketchdir/.test.skip" ]; then
+            continue
+        fi
+        sketchnum=$(($sketchnum + 1))
+        if [ "$sketchnum" -le "$start_index" ] \
+        || [ "$sketchnum" -gt "$end_index" ]; then
+        	continue
+        fi
+        build_sketch "$fqbn" "$sketch" "$xtra_opts"
+        local result=$?
+        if [ $result -ne 0 ]; then
+            return $result
+        fi
+    done
+    return 0
+}
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-platformio.sh b/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-platformio.sh
new file mode 100644
index 00000000..61c94fec
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/install-platformio.sh
@@ -0,0 +1,133 @@
+#!/bin/bash
+
+echo "Installing Python Wheel ..."
+pip install wheel > /dev/null 2>&1
+
+echo "Installing PlatformIO ..."
+pip install -U platformio > /dev/null 2>&1
+
+echo "PlatformIO 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 -l '.' --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
+}
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/on-push.sh b/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/on-push.sh
new file mode 100755
index 00000000..ece5d7a4
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.github/scripts/on-push.sh
@@ -0,0 +1,64 @@
+#!/bin/bash
+
+set -e
+
+if [ ! -z "$TRAVIS_BUILD_DIR" ]; then
+	export GITHUB_WORKSPACE="$TRAVIS_BUILD_DIR"
+	export GITHUB_REPOSITORY="$TRAVIS_REPO_SLUG"
+elif [ -z "$GITHUB_WORKSPACE" ]; then
+	export GITHUB_WORKSPACE="$PWD"
+	export GITHUB_REPOSITORY="me-no-dev/AsyncTCP"
+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
+
+if [ "$BUILD_PIO" -eq 0 ]; then
+	# ArduinoIDE Test
+	source ./.github/scripts/install-arduino-ide.sh
+	source ./.github/scripts/install-arduino-core-esp32.sh
+
+	echo "Installing AsyncTCP ..."
+	cp -rf "$GITHUB_WORKSPACE" "$ARDUINO_USR_PATH/libraries/AsyncTCP"
+
+	FQBN="espressif:esp32:esp32:PSRAM=enabled,PartitionScheme=huge_app"
+	build_sketches "$FQBN" "$GITHUB_WORKSPACE/examples"
+	if [ ! "$OS_IS_WINDOWS" == "1" ]; then
+		echo "Installing ESPAsyncWebServer ..."
+		git clone https://github.com/me-no-dev/ESPAsyncWebServer "$ARDUINO_USR_PATH/libraries/ESPAsyncWebServer" > /dev/null 2>&1
+
+		echo "Installing ArduinoJson ..."
+		git clone https://github.com/bblanchon/ArduinoJson "$ARDUINO_USR_PATH/libraries/ArduinoJson" > /dev/null 2>&1
+
+		build_sketches "$FQBN" "$ARDUINO_USR_PATH/libraries/ESPAsyncWebServer/examples"
+	fi
+else
+	# PlatformIO Test
+	source ./.github/scripts/install-platformio.sh
+
+	echo "Installing AsyncTCP ..."
+	python -m platformio lib --storage-dir "$GITHUB_WORKSPACE" install
+
+	BOARD="esp32dev"
+	build_pio_sketches "$BOARD" "$GITHUB_WORKSPACE/examples"
+
+	if [[ "$OSTYPE" != "cygwin" ]] && [[ "$OSTYPE" != "msys" ]] && [[ "$OSTYPE" != "win32" ]]; then
+		echo "Installing ESPAsyncWebServer ..."
+		python -m platformio lib -g install https://github.com/me-no-dev/ESPAsyncWebServer.git > /dev/null 2>&1
+		git clone https://github.com/me-no-dev/ESPAsyncWebServer "$HOME/ESPAsyncWebServer" > /dev/null 2>&1
+
+		echo "Installing ArduinoJson ..."
+		python -m platformio lib -g install https://github.com/bblanchon/ArduinoJson.git > /dev/null 2>&1
+
+		build_pio_sketches "$BOARD" "$HOME/ESPAsyncWebServer/examples"
+	fi
+fi
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.github/stale.yml b/Software/src/lib/me-no-dev-AsyncTCP/.github/stale.yml
new file mode 100644
index 00000000..ce7a8e3f
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.github/stale.yml
@@ -0,0 +1,31 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+daysUntilStale: 60
+daysUntilClose: 14
+limitPerRun: 30
+staleLabel: stale
+exemptLabels:
+  - pinned
+  - security
+  - "to be implemented"
+  - "for reference"
+  - "move to PR"
+  - "enhancement"
+
+only: issues
+onlyLabels: []
+exemptProjects: false
+exemptMilestones: false
+exemptAssignees: false
+
+markComment: >
+  [STALE_SET] This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed in 14 days if no further activity occurs. Thank you
+  for your contributions.
+
+unmarkComment: >
+  [STALE_CLR] This issue has been removed from the stale queue. Please ensure activity to keep it openin the future.
+
+closeComment: >
+  [STALE_DEL] This stale issue has been automatically closed. Thank you for your contributions.
+
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.github/workflows/push.yml b/Software/src/lib/me-no-dev-AsyncTCP/.github/workflows/push.yml
new file mode 100644
index 00000000..15cd441b
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.github/workflows/push.yml
@@ -0,0 +1,32 @@
+name: Async TCP CI
+
+on:
+  push:
+    branches:
+    - master
+    - release/*
+  pull_request:
+
+jobs:
+
+  build-arduino:
+    name: Arduino on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Build Tests
+      run: bash ./.github/scripts/on-push.sh 0 1
+
+  build-pio:
+    name: PlatformIO on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Build Tests
+      run: bash ./.github/scripts/on-push.sh 1 1
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.gitignore b/Software/src/lib/me-no-dev-AsyncTCP/.gitignore
new file mode 100644
index 00000000..9bea4330
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.gitignore
@@ -0,0 +1,2 @@
+
+.DS_Store
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/.travis.yml b/Software/src/lib/me-no-dev-AsyncTCP/.travis.yml
new file mode 100644
index 00000000..dbfc064a
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/.travis.yml
@@ -0,0 +1,34 @@
+sudo: false
+language: python
+os:
+  - linux
+
+git:
+  depth: false
+
+stages:
+  - build
+
+jobs:
+  include:
+
+    - name: "Arduino Build"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh
+
+    - name: "PlatformIO Build"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 1 1
+
+notifications:
+  email:
+    on_success: change
+    on_failure: change
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/60e65d0c78ea0a920347
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/CMakeLists.txt b/Software/src/lib/me-no-dev-AsyncTCP/CMakeLists.txt
new file mode 100644
index 00000000..f52e1c93
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/CMakeLists.txt
@@ -0,0 +1,15 @@
+set(COMPONENT_SRCDIRS
+    "src"
+)
+
+set(COMPONENT_ADD_INCLUDEDIRS
+    "src"
+)
+
+set(COMPONENT_REQUIRES
+    "arduino-esp32"
+)
+
+register_component()
+
+target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti)
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/Kconfig.projbuild b/Software/src/lib/me-no-dev-AsyncTCP/Kconfig.projbuild
new file mode 100644
index 00000000..17749264
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/Kconfig.projbuild
@@ -0,0 +1,30 @@
+menu "AsyncTCP Configuration"
+
+choice ASYNC_TCP_RUNNING_CORE
+    bool "Core on which AsyncTCP's thread is running"
+    default ASYNC_TCP_RUN_CORE1
+    help
+        Select on which core AsyncTCP is running
+
+    config ASYNC_TCP_RUN_CORE0
+        bool "CORE 0"
+    config ASYNC_TCP_RUN_CORE1
+        bool "CORE 1"
+    config ASYNC_TCP_RUN_NO_AFFINITY
+        bool "BOTH"
+
+endchoice
+
+config ASYNC_TCP_RUNNING_CORE
+    int
+    default 0 if ASYNC_TCP_RUN_CORE0
+    default 1 if ASYNC_TCP_RUN_CORE1
+    default -1 if ASYNC_TCP_RUN_NO_AFFINITY
+
+config ASYNC_TCP_USE_WDT
+    bool "Enable WDT for the AsyncTCP task"
+    default "y"
+    help
+        Enable WDT for the AsyncTCP task, so it will trigger if a handler is locking the thread.
+
+endmenu
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/LICENSE b/Software/src/lib/me-no-dev-AsyncTCP/LICENSE
new file mode 100644
index 00000000..65c5ca88
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/LICENSE
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/README.md b/Software/src/lib/me-no-dev-AsyncTCP/README.md
new file mode 100644
index 00000000..79ffa9ef
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/README.md
@@ -0,0 +1,15 @@
+This is commit ca8ac5f from https://github.com/me-no-dev/AsyncTCP
+
+# AsyncTCP 
+[![Build Status](https://travis-ci.org/me-no-dev/AsyncTCP.svg?branch=master)](https://travis-ci.org/me-no-dev/AsyncTCP) ![](https://github.com/me-no-dev/AsyncTCP/workflows/Async%20TCP%20CI/badge.svg) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/2f7e4d1df8b446d192cbfec6dc174d2d)](https://www.codacy.com/manual/me-no-dev/AsyncTCP?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=me-no-dev/AsyncTCP&amp;utm_campaign=Badge_Grade)
+
+### Async TCP Library for ESP32 Arduino
+
+[![Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer](https://badges.gitter.im/me-no-dev/ESPAsyncWebServer.svg)](https://gitter.im/me-no-dev/ESPAsyncWebServer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+This is a fully asynchronous TCP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP32 MCUs.
+
+This library is the base for [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer)
+
+## AsyncClient and AsyncServer
+The base classes on which everything else is built. They expose all possible scenarios, but are really raw and require more skills to use.
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/component.mk b/Software/src/lib/me-no-dev-AsyncTCP/component.mk
new file mode 100644
index 00000000..bb5bb161
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/component.mk
@@ -0,0 +1,3 @@
+COMPONENT_ADD_INCLUDEDIRS := src
+COMPONENT_SRCDIRS := src
+CXXFLAGS += -fno-rtti
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/library.json b/Software/src/lib/me-no-dev-AsyncTCP/library.json
new file mode 100644
index 00000000..89f90e4e
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/library.json
@@ -0,0 +1,22 @@
+{
+  "name":"AsyncTCP",
+  "description":"Asynchronous TCP Library for ESP32",
+  "keywords":"async,tcp",
+  "authors":
+  {
+    "name": "Hristo Gochkov",
+    "maintainer": true
+  },
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/me-no-dev/AsyncTCP.git"
+  },
+  "version": "1.1.1",
+  "license": "LGPL-3.0",
+  "frameworks": "arduino",
+  "platforms": "espressif32",
+  "build": {
+    "libCompatMode": 2
+  }  
+}
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/library.properties b/Software/src/lib/me-no-dev-AsyncTCP/library.properties
new file mode 100644
index 00000000..eb4e26e9
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/library.properties
@@ -0,0 +1,9 @@
+name=AsyncTCP
+version=1.1.1
+author=Me-No-Dev
+maintainer=Me-No-Dev
+sentence=Async TCP Library for ESP32
+paragraph=Async TCP Library for ESP32
+category=Other
+url=https://github.com/me-no-dev/AsyncTCP
+architectures=*
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/src/AsyncTCP.cpp b/Software/src/lib/me-no-dev-AsyncTCP/src/AsyncTCP.cpp
new file mode 100644
index 00000000..89ff6ee3
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/src/AsyncTCP.cpp
@@ -0,0 +1,1357 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "Arduino.h"
+
+#include "AsyncTCP.h"
+extern "C"{
+#include "lwip/opt.h"
+#include "lwip/tcp.h"
+#include "lwip/inet.h"
+#include "lwip/dns.h"
+#include "lwip/err.h"
+}
+#include "esp_task_wdt.h"
+
+/*
+ * TCP/IP Event Task
+ * */
+
+typedef enum {
+    LWIP_TCP_SENT, LWIP_TCP_RECV, LWIP_TCP_FIN, LWIP_TCP_ERROR, LWIP_TCP_POLL, LWIP_TCP_CLEAR, LWIP_TCP_ACCEPT, LWIP_TCP_CONNECTED, LWIP_TCP_DNS
+} lwip_event_t;
+
+typedef struct {
+        lwip_event_t event;
+        void *arg;
+        union {
+                struct {
+                        void * pcb;
+                        int8_t err;
+                } connected;
+                struct {
+                        int8_t err;
+                } error;
+                struct {
+                        tcp_pcb * pcb;
+                        uint16_t len;
+                } sent;
+                struct {
+                        tcp_pcb * pcb;
+                        pbuf * pb;
+                        int8_t err;
+                } recv;
+                struct {
+                        tcp_pcb * pcb;
+                        int8_t err;
+                } fin;
+                struct {
+                        tcp_pcb * pcb;
+                } poll;
+                struct {
+                        AsyncClient * client;
+                } accept;
+                struct {
+                        const char * name;
+                        ip_addr_t addr;
+                } dns;
+        };
+} lwip_event_packet_t;
+
+static xQueueHandle _async_queue;
+static TaskHandle_t _async_service_task_handle = NULL;
+
+
+SemaphoreHandle_t _slots_lock;
+const int _number_of_closed_slots = CONFIG_LWIP_MAX_ACTIVE_TCP;
+static uint32_t _closed_slots[_number_of_closed_slots];
+static uint32_t _closed_index = []() {
+    _slots_lock = xSemaphoreCreateBinary();
+    xSemaphoreGive(_slots_lock);
+    for (int i = 0; i < _number_of_closed_slots; ++ i) {
+        _closed_slots[i] = 1;
+    }
+    return 1;
+}();
+
+
+static inline bool _init_async_event_queue(){
+    if(!_async_queue){
+        _async_queue = xQueueCreate(32, sizeof(lwip_event_packet_t *));
+        if(!_async_queue){
+            return false;
+        }
+    }
+    return true;
+}
+
+static inline bool _send_async_event(lwip_event_packet_t ** e){
+    return _async_queue && xQueueSend(_async_queue, e, portMAX_DELAY) == pdPASS;
+}
+
+static inline bool _prepend_async_event(lwip_event_packet_t ** e){
+    return _async_queue && xQueueSendToFront(_async_queue, e, portMAX_DELAY) == pdPASS;
+}
+
+static inline bool _get_async_event(lwip_event_packet_t ** e){
+    return _async_queue && xQueueReceive(_async_queue, e, portMAX_DELAY) == pdPASS;
+}
+
+static bool _remove_events_with_arg(void * arg){
+    lwip_event_packet_t * first_packet = NULL;
+    lwip_event_packet_t * packet = NULL;
+
+    if(!_async_queue){
+        return false;
+    }
+    //figure out which is the first packet so we can keep the order
+    while(!first_packet){
+        if(xQueueReceive(_async_queue, &first_packet, 0) != pdPASS){
+            return false;
+        }
+        //discard packet if matching
+        if((int)first_packet->arg == (int)arg){
+            free(first_packet);
+            first_packet = NULL;
+        //return first packet to the back of the queue
+        } else if(xQueueSend(_async_queue, &first_packet, portMAX_DELAY) != pdPASS){
+            return false;
+        }
+    }
+
+    while(xQueuePeek(_async_queue, &packet, 0) == pdPASS && packet != first_packet){
+        if(xQueueReceive(_async_queue, &packet, 0) != pdPASS){
+            return false;
+        }
+        if((int)packet->arg == (int)arg){
+            free(packet);
+            packet = NULL;
+        } else if(xQueueSend(_async_queue, &packet, portMAX_DELAY) != pdPASS){
+            return false;
+        }
+    }
+    return true;
+}
+
+static void _handle_async_event(lwip_event_packet_t * e){
+    if(e->arg == NULL){
+        // do nothing when arg is NULL
+        //ets_printf("event arg == NULL: 0x%08x\n", e->recv.pcb);
+    } else if(e->event == LWIP_TCP_CLEAR){
+        _remove_events_with_arg(e->arg);
+    } else if(e->event == LWIP_TCP_RECV){
+        //ets_printf("-R: 0x%08x\n", e->recv.pcb);
+        AsyncClient::_s_recv(e->arg, e->recv.pcb, e->recv.pb, e->recv.err);
+    } else if(e->event == LWIP_TCP_FIN){
+        //ets_printf("-F: 0x%08x\n", e->fin.pcb);
+        AsyncClient::_s_fin(e->arg, e->fin.pcb, e->fin.err);
+    } else if(e->event == LWIP_TCP_SENT){
+        //ets_printf("-S: 0x%08x\n", e->sent.pcb);
+        AsyncClient::_s_sent(e->arg, e->sent.pcb, e->sent.len);
+    } else if(e->event == LWIP_TCP_POLL){
+        //ets_printf("-P: 0x%08x\n", e->poll.pcb);
+        AsyncClient::_s_poll(e->arg, e->poll.pcb);
+    } else if(e->event == LWIP_TCP_ERROR){
+        //ets_printf("-E: 0x%08x %d\n", e->arg, e->error.err);
+        AsyncClient::_s_error(e->arg, e->error.err);
+    } else if(e->event == LWIP_TCP_CONNECTED){
+        //ets_printf("C: 0x%08x 0x%08x %d\n", e->arg, e->connected.pcb, e->connected.err);
+        AsyncClient::_s_connected(e->arg, e->connected.pcb, e->connected.err);
+    } else if(e->event == LWIP_TCP_ACCEPT){
+        //ets_printf("A: 0x%08x 0x%08x\n", e->arg, e->accept.client);
+        AsyncServer::_s_accepted(e->arg, e->accept.client);
+    } else if(e->event == LWIP_TCP_DNS){
+        //ets_printf("D: 0x%08x %s = %s\n", e->arg, e->dns.name, ipaddr_ntoa(&e->dns.addr));
+        AsyncClient::_s_dns_found(e->dns.name, &e->dns.addr, e->arg);
+    }
+    free((void*)(e));
+}
+
+static void _async_service_task(void *pvParameters){
+    lwip_event_packet_t * packet = NULL;
+    for (;;) {
+        if(_get_async_event(&packet)){
+#if CONFIG_ASYNC_TCP_USE_WDT
+            if(esp_task_wdt_add(NULL) != ESP_OK){
+                log_e("Failed to add async task to WDT");
+            }
+#endif
+            _handle_async_event(packet);
+#if CONFIG_ASYNC_TCP_USE_WDT
+            if(esp_task_wdt_delete(NULL) != ESP_OK){
+                log_e("Failed to remove loop task from WDT");
+            }
+#endif
+        }
+    }
+    vTaskDelete(NULL);
+    _async_service_task_handle = NULL;
+}
+/*
+static void _stop_async_task(){
+    if(_async_service_task_handle){
+        vTaskDelete(_async_service_task_handle);
+        _async_service_task_handle = NULL;
+    }
+}
+*/
+static bool _start_async_task(){
+    if(!_init_async_event_queue()){
+        return false;
+    }
+    if(!_async_service_task_handle){
+        xTaskCreateUniversal(_async_service_task, "async_tcp", 8192 * 2, NULL, 3, &_async_service_task_handle, CONFIG_ASYNC_TCP_RUNNING_CORE);
+        if(!_async_service_task_handle){
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+ * LwIP Callbacks
+ * */
+
+static int8_t _tcp_clear_events(void * arg) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_CLEAR;
+    e->arg = arg;
+    if (!_prepend_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_connected(void * arg, tcp_pcb * pcb, int8_t err) {
+    //ets_printf("+C: 0x%08x\n", pcb);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_CONNECTED;
+    e->arg = arg;
+    e->connected.pcb = pcb;
+    e->connected.err = err;
+    if (!_prepend_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_poll(void * arg, struct tcp_pcb * pcb) {
+    //ets_printf("+P: 0x%08x\n", pcb);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_POLL;
+    e->arg = arg;
+    e->poll.pcb = pcb;
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_recv(void * arg, struct tcp_pcb * pcb, struct pbuf *pb, int8_t err) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->arg = arg;
+    if(pb){
+        //ets_printf("+R: 0x%08x\n", pcb);
+        e->event = LWIP_TCP_RECV;
+        e->recv.pcb = pcb;
+        e->recv.pb = pb;
+        e->recv.err = err;
+    } else {
+        //ets_printf("+F: 0x%08x\n", pcb);
+        e->event = LWIP_TCP_FIN;
+        e->fin.pcb = pcb;
+        e->fin.err = err;
+        //close the PCB in LwIP thread
+        AsyncClient::_s_lwip_fin(e->arg, e->fin.pcb, e->fin.err);
+    }
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static int8_t _tcp_sent(void * arg, struct tcp_pcb * pcb, uint16_t len) {
+    //ets_printf("+S: 0x%08x\n", pcb);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_SENT;
+    e->arg = arg;
+    e->sent.pcb = pcb;
+    e->sent.len = len;
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+static void _tcp_error(void * arg, int8_t err) {
+    //ets_printf("+E: 0x%08x\n", arg);
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_ERROR;
+    e->arg = arg;
+    e->error.err = err;
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+}
+
+static void _tcp_dns_found(const char * name, struct ip_addr * ipaddr, void * arg) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    //ets_printf("+DNS: name=%s ipaddr=0x%08x arg=%x\n", name, ipaddr, arg);
+    e->event = LWIP_TCP_DNS;
+    e->arg = arg;
+    e->dns.name = name;
+    if (ipaddr) {
+        memcpy(&e->dns.addr, ipaddr, sizeof(struct ip_addr));
+    } else {
+        memset(&e->dns.addr, 0, sizeof(e->dns.addr));
+    }
+    if (!_send_async_event(&e)) {
+        free((void*)(e));
+    }
+}
+
+//Used to switch out from LwIP thread
+static int8_t _tcp_accept(void * arg, AsyncClient * client) {
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    e->event = LWIP_TCP_ACCEPT;
+    e->arg = arg;
+    e->accept.client = client;
+    if (!_prepend_async_event(&e)) {
+        free((void*)(e));
+    }
+    return ERR_OK;
+}
+
+/*
+ * TCP/IP API Calls
+ * */
+
+#include "lwip/priv/tcpip_priv.h"
+
+typedef struct {
+    struct tcpip_api_call_data call;
+    tcp_pcb * pcb;
+    int8_t closed_slot;
+    int8_t err;
+    union {
+            struct {
+                    const char* data;
+                    size_t size;
+                    uint8_t apiflags;
+            } write;
+            size_t received;
+            struct {
+                    ip_addr_t * addr;
+                    uint16_t port;
+                    tcp_connected_fn cb;
+            } connect;
+            struct {
+                    ip_addr_t * addr;
+                    uint16_t port;
+            } bind;
+            uint8_t backlog;
+    };
+} tcp_api_call_t;
+
+static err_t _tcp_output_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = ERR_CONN;
+    if(msg->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        msg->err = tcp_output(msg->pcb);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_output(tcp_pcb * pcb, int8_t closed_slot) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    tcpip_api_call(_tcp_output_api, (struct tcpip_api_call_data*)&msg);
+    return msg.err;
+}
+
+static err_t _tcp_write_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = ERR_CONN;
+    if(msg->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        msg->err = tcp_write(msg->pcb, msg->write.data, msg->write.size, msg->write.apiflags);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_write(tcp_pcb * pcb, int8_t closed_slot, const char* data, size_t size, uint8_t apiflags) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    msg.write.data = data;
+    msg.write.size = size;
+    msg.write.apiflags = apiflags;
+    tcpip_api_call(_tcp_write_api, (struct tcpip_api_call_data*)&msg);
+    return msg.err;
+}
+
+static err_t _tcp_recved_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = ERR_CONN;
+    if(msg->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        msg->err = 0;
+        tcp_recved(msg->pcb, msg->received);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_recved(tcp_pcb * pcb, int8_t closed_slot, size_t len) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    msg.received = len;
+    tcpip_api_call(_tcp_recved_api, (struct tcpip_api_call_data*)&msg);
+    return msg.err;
+}
+
+static err_t _tcp_close_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = ERR_CONN;
+    if(msg->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        msg->err = tcp_close(msg->pcb);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_close(tcp_pcb * pcb, int8_t closed_slot) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    tcpip_api_call(_tcp_close_api, (struct tcpip_api_call_data*)&msg);
+    return msg.err;
+}
+
+static err_t _tcp_abort_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = ERR_CONN;
+    if(msg->closed_slot == -1 || !_closed_slots[msg->closed_slot]) {
+        tcp_abort(msg->pcb);
+    }
+    return msg->err;
+}
+
+static esp_err_t _tcp_abort(tcp_pcb * pcb, int8_t closed_slot) {
+    if(!pcb){
+        return ERR_CONN;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    tcpip_api_call(_tcp_abort_api, (struct tcpip_api_call_data*)&msg);
+    return msg.err;
+}
+
+static err_t _tcp_connect_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = tcp_connect(msg->pcb, msg->connect.addr, msg->connect.port, msg->connect.cb);
+    return msg->err;
+}
+
+static esp_err_t _tcp_connect(tcp_pcb * pcb, int8_t closed_slot, ip_addr_t * addr, uint16_t port, tcp_connected_fn cb) {
+    if(!pcb){
+        return ESP_FAIL;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = closed_slot;
+    msg.connect.addr = addr;
+    msg.connect.port = port;
+    msg.connect.cb = cb;
+    tcpip_api_call(_tcp_connect_api, (struct tcpip_api_call_data*)&msg);
+    return msg.err;
+}
+
+static err_t _tcp_bind_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = tcp_bind(msg->pcb, msg->bind.addr, msg->bind.port);
+    return msg->err;
+}
+
+static esp_err_t _tcp_bind(tcp_pcb * pcb, ip_addr_t * addr, uint16_t port) {
+    if(!pcb){
+        return ESP_FAIL;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = -1;
+    msg.bind.addr = addr;
+    msg.bind.port = port;
+    tcpip_api_call(_tcp_bind_api, (struct tcpip_api_call_data*)&msg);
+    return msg.err;
+}
+
+static err_t _tcp_listen_api(struct tcpip_api_call_data *api_call_msg){
+    tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
+    msg->err = 0;
+    msg->pcb = tcp_listen_with_backlog(msg->pcb, msg->backlog);
+    return msg->err;
+}
+
+static tcp_pcb * _tcp_listen_with_backlog(tcp_pcb * pcb, uint8_t backlog) {
+    if(!pcb){
+        return NULL;
+    }
+    tcp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.closed_slot = -1;
+    msg.backlog = backlog?backlog:0xFF;
+    tcpip_api_call(_tcp_listen_api, (struct tcpip_api_call_data*)&msg);
+    return msg.pcb;
+}
+
+
+
+/*
+  Async TCP Client
+ */
+
+AsyncClient::AsyncClient(tcp_pcb* pcb)
+: _connect_cb(0)
+, _connect_cb_arg(0)
+, _discard_cb(0)
+, _discard_cb_arg(0)
+, _sent_cb(0)
+, _sent_cb_arg(0)
+, _error_cb(0)
+, _error_cb_arg(0)
+, _recv_cb(0)
+, _recv_cb_arg(0)
+, _pb_cb(0)
+, _pb_cb_arg(0)
+, _timeout_cb(0)
+, _timeout_cb_arg(0)
+, _pcb_busy(false)
+, _pcb_sent_at(0)
+, _ack_pcb(true)
+, _rx_last_packet(0)
+, _rx_since_timeout(0)
+, _ack_timeout(ASYNC_MAX_ACK_TIME)
+, _connect_port(0)
+, prev(NULL)
+, next(NULL)
+{
+    _pcb = pcb;
+    _closed_slot = -1;
+    if(_pcb){
+        _allocate_closed_slot();
+        _rx_last_packet = millis();
+        tcp_arg(_pcb, this);
+        tcp_recv(_pcb, &_tcp_recv);
+        tcp_sent(_pcb, &_tcp_sent);
+        tcp_err(_pcb, &_tcp_error);
+        tcp_poll(_pcb, &_tcp_poll, 1);
+    }
+}
+
+AsyncClient::~AsyncClient(){
+    if(_pcb) {
+        _close();
+    }
+    _free_closed_slot();
+}
+
+/*
+ * Operators
+ * */
+
+AsyncClient& AsyncClient::operator=(const AsyncClient& other){
+    if (_pcb) {
+        _close();
+    }
+
+    _pcb = other._pcb;
+    _closed_slot = other._closed_slot;
+    if (_pcb) {
+        _rx_last_packet = millis();
+        tcp_arg(_pcb, this);
+        tcp_recv(_pcb, &_tcp_recv);
+        tcp_sent(_pcb, &_tcp_sent);
+        tcp_err(_pcb, &_tcp_error);
+        tcp_poll(_pcb, &_tcp_poll, 1);
+    }
+    return *this;
+}
+
+bool AsyncClient::operator==(const AsyncClient &other) {
+    return _pcb == other._pcb;
+}
+
+AsyncClient & AsyncClient::operator+=(const AsyncClient &other) {
+    if(next == NULL){
+        next = (AsyncClient*)(&other);
+        next->prev = this;
+    } else {
+        AsyncClient *c = next;
+        while(c->next != NULL) {
+            c = c->next;
+        }
+        c->next =(AsyncClient*)(&other);
+        c->next->prev = c;
+    }
+    return *this;
+}
+
+/*
+ * Callback Setters
+ * */
+
+void AsyncClient::onConnect(AcConnectHandler cb, void* arg){
+    _connect_cb = cb;
+    _connect_cb_arg = arg;
+}
+
+void AsyncClient::onDisconnect(AcConnectHandler cb, void* arg){
+    _discard_cb = cb;
+    _discard_cb_arg = arg;
+}
+
+void AsyncClient::onAck(AcAckHandler cb, void* arg){
+    _sent_cb = cb;
+    _sent_cb_arg = arg;
+}
+
+void AsyncClient::onError(AcErrorHandler cb, void* arg){
+    _error_cb = cb;
+    _error_cb_arg = arg;
+}
+
+void AsyncClient::onData(AcDataHandler cb, void* arg){
+    _recv_cb = cb;
+    _recv_cb_arg = arg;
+}
+
+void AsyncClient::onPacket(AcPacketHandler cb, void* arg){
+  _pb_cb = cb;
+  _pb_cb_arg = arg;
+}
+
+void AsyncClient::onTimeout(AcTimeoutHandler cb, void* arg){
+    _timeout_cb = cb;
+    _timeout_cb_arg = arg;
+}
+
+void AsyncClient::onPoll(AcConnectHandler cb, void* arg){
+    _poll_cb = cb;
+    _poll_cb_arg = arg;
+}
+
+/*
+ * Main Public Methods
+ * */
+
+bool AsyncClient::connect(IPAddress ip, uint16_t port){
+    if (_pcb){
+        log_w("already connected, state %d", _pcb->state);
+        return false;
+    }
+    if(!_start_async_task()){
+        log_e("failed to start task");
+        return false;
+    }
+
+    ip_addr_t addr;
+    addr.type = IPADDR_TYPE_V4;
+    addr.u_addr.ip4.addr = ip;
+
+    tcp_pcb* pcb = tcp_new_ip_type(IPADDR_TYPE_V4);
+    if (!pcb){
+        log_e("pcb == NULL");
+        return false;
+    }
+
+    tcp_arg(pcb, this);
+    tcp_err(pcb, &_tcp_error);
+    tcp_recv(pcb, &_tcp_recv);
+    tcp_sent(pcb, &_tcp_sent);
+    tcp_poll(pcb, &_tcp_poll, 1);
+    //_tcp_connect(pcb, &addr, port,(tcp_connected_fn)&_s_connected);
+    _tcp_connect(pcb, _closed_slot, &addr, port,(tcp_connected_fn)&_tcp_connected);
+    return true;
+}
+
+bool AsyncClient::connect(const char* host, uint16_t port){
+    ip_addr_t addr;
+    
+    if(!_start_async_task()){
+      log_e("failed to start task");
+      return false;
+    }
+    
+    err_t err = dns_gethostbyname(host, &addr, (dns_found_callback)&_tcp_dns_found, this);
+    if(err == ERR_OK) {
+        return connect(IPAddress(addr.u_addr.ip4.addr), port);
+    } else if(err == ERR_INPROGRESS) {
+        _connect_port = port;
+        return true;
+    }
+    log_e("error: %d", err);
+    return false;
+}
+
+void AsyncClient::close(bool now){
+    if(_pcb){
+        _tcp_recved(_pcb, _closed_slot, _rx_ack_len);
+    }
+    _close();
+}
+
+int8_t AsyncClient::abort(){
+    if(_pcb) {
+        _tcp_abort(_pcb, _closed_slot );
+        _pcb = NULL;
+    }
+    return ERR_ABRT;
+}
+
+size_t AsyncClient::space(){
+    if((_pcb != NULL) && (_pcb->state == 4)){
+        return tcp_sndbuf(_pcb);
+    }
+    return 0;
+}
+
+size_t AsyncClient::add(const char* data, size_t size, uint8_t apiflags) {
+    if(!_pcb || size == 0 || data == NULL) {
+        return 0;
+    }
+    size_t room = space();
+    if(!room) {
+        return 0;
+    }
+    size_t will_send = (room < size) ? room : size;
+    int8_t err = ERR_OK;
+    err = _tcp_write(_pcb, _closed_slot, data, will_send, apiflags);
+    if(err != ERR_OK) {
+        return 0;
+    }
+    return will_send;
+}
+
+bool AsyncClient::send(){
+    int8_t err = ERR_OK;
+    err = _tcp_output(_pcb, _closed_slot);
+    if(err == ERR_OK){
+        _pcb_busy = true;
+        _pcb_sent_at = millis();
+        return true;
+    }
+    return false;
+}
+
+size_t AsyncClient::ack(size_t len){
+    if(len > _rx_ack_len)
+        len = _rx_ack_len;
+    if(len){
+        _tcp_recved(_pcb, _closed_slot, len);
+    }
+    _rx_ack_len -= len;
+    return len;
+}
+
+void AsyncClient::ackPacket(struct pbuf * pb){
+  if(!pb){
+    return;
+  }
+  _tcp_recved(_pcb, _closed_slot, pb->len);
+  pbuf_free(pb);
+}
+
+/*
+ * Main Private Methods
+ * */
+
+int8_t AsyncClient::_close(){
+    //ets_printf("X: 0x%08x\n", (uint32_t)this);
+    int8_t err = ERR_OK;
+    if(_pcb) {
+        //log_i("");
+        tcp_arg(_pcb, NULL);
+        tcp_sent(_pcb, NULL);
+        tcp_recv(_pcb, NULL);
+        tcp_err(_pcb, NULL);
+        tcp_poll(_pcb, NULL, 0);
+        _tcp_clear_events(this);
+        err = _tcp_close(_pcb, _closed_slot);
+        if(err != ERR_OK) {
+            err = abort();
+        }
+        _pcb = NULL;
+        if(_discard_cb) {
+            _discard_cb(_discard_cb_arg, this);
+        }
+    }
+    return err;
+}
+
+void AsyncClient::_allocate_closed_slot(){
+    xSemaphoreTake(_slots_lock, portMAX_DELAY);
+    uint32_t closed_slot_min_index = 0;
+    for (int i = 0; i < _number_of_closed_slots; ++ i) {
+        if ((_closed_slot == -1 || _closed_slots[i] <= closed_slot_min_index) && _closed_slots[i] != 0) {
+            closed_slot_min_index = _closed_slots[i];
+            _closed_slot = i;
+        }
+    }
+    if (_closed_slot != -1) {
+        _closed_slots[_closed_slot] = 0;
+    }
+    xSemaphoreGive(_slots_lock);
+}
+
+void AsyncClient::_free_closed_slot(){
+    if (_closed_slot != -1) {
+        _closed_slots[_closed_slot] = _closed_index;
+        _closed_slot = -1;
+        ++ _closed_index;
+    }
+}
+
+/*
+ * Private Callbacks
+ * */
+
+int8_t AsyncClient::_connected(void* pcb, int8_t err){
+    _pcb = reinterpret_cast<tcp_pcb*>(pcb);
+    if(_pcb){
+        _rx_last_packet = millis();
+        _pcb_busy = false;
+//        tcp_recv(_pcb, &_tcp_recv);
+//        tcp_sent(_pcb, &_tcp_sent);
+//        tcp_poll(_pcb, &_tcp_poll, 1);
+    }
+    if(_connect_cb) {
+        _connect_cb(_connect_cb_arg, this);
+    }
+    return ERR_OK;
+}
+
+void AsyncClient::_error(int8_t err) {
+    if(_pcb){
+        tcp_arg(_pcb, NULL);
+        if(_pcb->state == LISTEN) {
+            tcp_sent(_pcb, NULL);
+            tcp_recv(_pcb, NULL);
+            tcp_err(_pcb, NULL);
+            tcp_poll(_pcb, NULL, 0);
+        }
+        _pcb = NULL;
+    }
+    if(_error_cb) {
+        _error_cb(_error_cb_arg, this, err);
+    }
+    if(_discard_cb) {
+        _discard_cb(_discard_cb_arg, this);
+    }
+}
+
+//In LwIP Thread
+int8_t AsyncClient::_lwip_fin(tcp_pcb* pcb, int8_t err) {
+    if(!_pcb || pcb != _pcb){
+        log_e("0x%08x != 0x%08x", (uint32_t)pcb, (uint32_t)_pcb);
+        return ERR_OK;
+    }
+    tcp_arg(_pcb, NULL);
+    if(_pcb->state == LISTEN) {
+        tcp_sent(_pcb, NULL);
+        tcp_recv(_pcb, NULL);
+        tcp_err(_pcb, NULL);
+        tcp_poll(_pcb, NULL, 0);
+    }
+    if(tcp_close(_pcb) != ERR_OK) {
+        tcp_abort(_pcb);
+    }
+    _free_closed_slot();
+    _pcb = NULL;
+    return ERR_OK;
+}
+
+//In Async Thread
+int8_t AsyncClient::_fin(tcp_pcb* pcb, int8_t err) {
+    _tcp_clear_events(this);
+    if(_discard_cb) {
+        _discard_cb(_discard_cb_arg, this);
+    }
+    return ERR_OK;
+}
+
+int8_t AsyncClient::_sent(tcp_pcb* pcb, uint16_t len) {
+    _rx_last_packet = millis();
+    //log_i("%u", len);
+    _pcb_busy = false;
+    if(_sent_cb) {
+        _sent_cb(_sent_cb_arg, this, len, (millis() - _pcb_sent_at));
+    }
+    return ERR_OK;
+}
+
+int8_t AsyncClient::_recv(tcp_pcb* pcb, pbuf* pb, int8_t err) {
+    while(pb != NULL) {
+        _rx_last_packet = millis();
+        //we should not ack before we assimilate the data
+        _ack_pcb = true;
+        pbuf *b = pb;
+        pb = b->next;
+        b->next = NULL;
+        if(_pb_cb){
+            _pb_cb(_pb_cb_arg, this, b);
+        } else {
+            if(_recv_cb) {
+                _recv_cb(_recv_cb_arg, this, b->payload, b->len);
+            }
+            if(!_ack_pcb) {
+                _rx_ack_len += b->len;
+            } else if(_pcb) {
+                _tcp_recved(_pcb, _closed_slot, b->len);
+            }
+            pbuf_free(b);
+        }
+    }
+    return ERR_OK;
+}
+
+int8_t AsyncClient::_poll(tcp_pcb* pcb){
+    if(!_pcb){
+        log_w("pcb is NULL");
+        return ERR_OK;
+    }
+    if(pcb != _pcb){
+        log_e("0x%08x != 0x%08x", (uint32_t)pcb, (uint32_t)_pcb);
+        return ERR_OK;
+    }
+
+    uint32_t now = millis();
+
+    // ACK Timeout
+    if(_pcb_busy && _ack_timeout && (now - _pcb_sent_at) >= _ack_timeout){
+        _pcb_busy = false;
+        log_w("ack timeout %d", pcb->state);
+        if(_timeout_cb)
+            _timeout_cb(_timeout_cb_arg, this, (now - _pcb_sent_at));
+        return ERR_OK;
+    }
+    // RX Timeout
+    if(_rx_since_timeout && (now - _rx_last_packet) >= (_rx_since_timeout * 1000)){
+        log_w("rx timeout %d", pcb->state);
+        _close();
+        return ERR_OK;
+    }
+    // Everything is fine
+    if(_poll_cb) {
+        _poll_cb(_poll_cb_arg, this);
+    }
+    return ERR_OK;
+}
+
+void AsyncClient::_dns_found(struct ip_addr *ipaddr){
+    if(ipaddr && ipaddr->u_addr.ip4.addr){
+        connect(IPAddress(ipaddr->u_addr.ip4.addr), _connect_port);
+    } else {
+        if(_error_cb) {
+            _error_cb(_error_cb_arg, this, -55);
+        }
+        if(_discard_cb) {
+            _discard_cb(_discard_cb_arg, this);
+        }
+    }
+}
+
+/*
+ * Public Helper Methods
+ * */
+
+void AsyncClient::stop() {
+    close(false);
+}
+
+bool AsyncClient::free(){
+    if(!_pcb) {
+        return true;
+    }
+    if(_pcb->state == 0 || _pcb->state > 4) {
+        return true;
+    }
+    return false;
+}
+
+size_t AsyncClient::write(const char* data) {
+    if(data == NULL) {
+        return 0;
+    }
+    return write(data, strlen(data));
+}
+
+size_t AsyncClient::write(const char* data, size_t size, uint8_t apiflags) {
+    size_t will_send = add(data, size, apiflags);
+    if(!will_send || !send()) {
+        return 0;
+    }
+    return will_send;
+}
+
+void AsyncClient::setRxTimeout(uint32_t timeout){
+    _rx_since_timeout = timeout;
+}
+
+uint32_t AsyncClient::getRxTimeout(){
+    return _rx_since_timeout;
+}
+
+uint32_t AsyncClient::getAckTimeout(){
+    return _ack_timeout;
+}
+
+void AsyncClient::setAckTimeout(uint32_t timeout){
+    _ack_timeout = timeout;
+}
+
+void AsyncClient::setNoDelay(bool nodelay){
+    if(!_pcb) {
+        return;
+    }
+    if(nodelay) {
+        tcp_nagle_disable(_pcb);
+    } else {
+        tcp_nagle_enable(_pcb);
+    }
+}
+
+bool AsyncClient::getNoDelay(){
+    if(!_pcb) {
+        return false;
+    }
+    return tcp_nagle_disabled(_pcb);
+}
+
+uint16_t AsyncClient::getMss(){
+    if(!_pcb) {
+        return 0;
+    }
+    return tcp_mss(_pcb);
+}
+
+uint32_t AsyncClient::getRemoteAddress() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->remote_ip.u_addr.ip4.addr;
+}
+
+uint16_t AsyncClient::getRemotePort() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->remote_port;
+}
+
+uint32_t AsyncClient::getLocalAddress() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->local_ip.u_addr.ip4.addr;
+}
+
+uint16_t AsyncClient::getLocalPort() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->local_port;
+}
+
+IPAddress AsyncClient::remoteIP() {
+    return IPAddress(getRemoteAddress());
+}
+
+uint16_t AsyncClient::remotePort() {
+    return getRemotePort();
+}
+
+IPAddress AsyncClient::localIP() {
+    return IPAddress(getLocalAddress());
+}
+
+uint16_t AsyncClient::localPort() {
+    return getLocalPort();
+}
+
+uint8_t AsyncClient::state() {
+    if(!_pcb) {
+        return 0;
+    }
+    return _pcb->state;
+}
+
+bool AsyncClient::connected(){
+    if (!_pcb) {
+        return false;
+    }
+    return _pcb->state == 4;
+}
+
+bool AsyncClient::connecting(){
+    if (!_pcb) {
+        return false;
+    }
+    return _pcb->state > 0 && _pcb->state < 4;
+}
+
+bool AsyncClient::disconnecting(){
+    if (!_pcb) {
+        return false;
+    }
+    return _pcb->state > 4 && _pcb->state < 10;
+}
+
+bool AsyncClient::disconnected(){
+    if (!_pcb) {
+        return true;
+    }
+    return _pcb->state == 0 || _pcb->state == 10;
+}
+
+bool AsyncClient::freeable(){
+    if (!_pcb) {
+        return true;
+    }
+    return _pcb->state == 0 || _pcb->state > 4;
+}
+
+bool AsyncClient::canSend(){
+    return space() > 0;
+}
+
+const char * AsyncClient::errorToString(int8_t error){
+    switch(error){
+        case ERR_OK: return "OK";
+        case ERR_MEM: return "Out of memory error";
+        case ERR_BUF: return "Buffer error";
+        case ERR_TIMEOUT: return "Timeout";
+        case ERR_RTE: return "Routing problem";
+        case ERR_INPROGRESS: return "Operation in progress";
+        case ERR_VAL: return "Illegal value";
+        case ERR_WOULDBLOCK: return "Operation would block";
+        case ERR_USE: return "Address in use";
+        case ERR_ALREADY: return "Already connected";
+        case ERR_CONN: return "Not connected";
+        case ERR_IF: return "Low-level netif error";
+        case ERR_ABRT: return "Connection aborted";
+        case ERR_RST: return "Connection reset";
+        case ERR_CLSD: return "Connection closed";
+        case ERR_ARG: return "Illegal argument";
+        case -55: return "DNS failed";
+        default: return "UNKNOWN";
+    }
+}
+
+const char * AsyncClient::stateToString(){
+    switch(state()){
+        case 0: return "Closed";
+        case 1: return "Listen";
+        case 2: return "SYN Sent";
+        case 3: return "SYN Received";
+        case 4: return "Established";
+        case 5: return "FIN Wait 1";
+        case 6: return "FIN Wait 2";
+        case 7: return "Close Wait";
+        case 8: return "Closing";
+        case 9: return "Last ACK";
+        case 10: return "Time Wait";
+        default: return "UNKNOWN";
+    }
+}
+
+/*
+ * Static Callbacks (LwIP C2C++ interconnect)
+ * */
+
+void AsyncClient::_s_dns_found(const char * name, struct ip_addr * ipaddr, void * arg){
+    reinterpret_cast<AsyncClient*>(arg)->_dns_found(ipaddr);
+}
+
+int8_t AsyncClient::_s_poll(void * arg, struct tcp_pcb * pcb) {
+    return reinterpret_cast<AsyncClient*>(arg)->_poll(pcb);
+}
+
+int8_t AsyncClient::_s_recv(void * arg, struct tcp_pcb * pcb, struct pbuf *pb, int8_t err) {
+    return reinterpret_cast<AsyncClient*>(arg)->_recv(pcb, pb, err);
+}
+
+int8_t AsyncClient::_s_fin(void * arg, struct tcp_pcb * pcb, int8_t err) {
+    return reinterpret_cast<AsyncClient*>(arg)->_fin(pcb, err);
+}
+
+int8_t AsyncClient::_s_lwip_fin(void * arg, struct tcp_pcb * pcb, int8_t err) {
+    return reinterpret_cast<AsyncClient*>(arg)->_lwip_fin(pcb, err);
+}
+
+int8_t AsyncClient::_s_sent(void * arg, struct tcp_pcb * pcb, uint16_t len) {
+    return reinterpret_cast<AsyncClient*>(arg)->_sent(pcb, len);
+}
+
+void AsyncClient::_s_error(void * arg, int8_t err) {
+    reinterpret_cast<AsyncClient*>(arg)->_error(err);
+}
+
+int8_t AsyncClient::_s_connected(void * arg, void * pcb, int8_t err){
+    return reinterpret_cast<AsyncClient*>(arg)->_connected(pcb, err);
+}
+
+/*
+  Async TCP Server
+ */
+
+AsyncServer::AsyncServer(IPAddress addr, uint16_t port)
+: _port(port)
+, _addr(addr)
+, _noDelay(false)
+, _pcb(0)
+, _connect_cb(0)
+, _connect_cb_arg(0)
+{}
+
+AsyncServer::AsyncServer(uint16_t port)
+: _port(port)
+, _addr((uint32_t) IPADDR_ANY)
+, _noDelay(false)
+, _pcb(0)
+, _connect_cb(0)
+, _connect_cb_arg(0)
+{}
+
+AsyncServer::~AsyncServer(){
+    end();
+}
+
+void AsyncServer::onClient(AcConnectHandler cb, void* arg){
+    _connect_cb = cb;
+    _connect_cb_arg = arg;
+}
+
+void AsyncServer::begin(){
+    if(_pcb) {
+        return;
+    }
+
+    if(!_start_async_task()){
+        log_e("failed to start task");
+        return;
+    }
+    int8_t err;
+    _pcb = tcp_new_ip_type(IPADDR_TYPE_V4);
+    if (!_pcb){
+        log_e("_pcb == NULL");
+        return;
+    }
+
+    ip_addr_t local_addr;
+    local_addr.type = IPADDR_TYPE_V4;
+    local_addr.u_addr.ip4.addr = (uint32_t) _addr;
+    err = _tcp_bind(_pcb, &local_addr, _port);
+
+    if (err != ERR_OK) {
+        _tcp_close(_pcb, -1);
+        log_e("bind error: %d", err);
+        return;
+    }
+
+    static uint8_t backlog = 5;
+    _pcb = _tcp_listen_with_backlog(_pcb, backlog);
+    if (!_pcb) {
+        log_e("listen_pcb == NULL");
+        return;
+    }
+    tcp_arg(_pcb, (void*) this);
+    tcp_accept(_pcb, &_s_accept);
+}
+
+void AsyncServer::end(){
+    if(_pcb){
+        tcp_arg(_pcb, NULL);
+        tcp_accept(_pcb, NULL);
+        if(tcp_close(_pcb) != ERR_OK){
+            _tcp_abort(_pcb, -1);
+        }
+        _pcb = NULL;
+    }
+}
+
+//runs on LwIP thread
+int8_t AsyncServer::_accept(tcp_pcb* pcb, int8_t err){
+    //ets_printf("+A: 0x%08x\n", pcb);
+    if(_connect_cb){
+        AsyncClient *c = new AsyncClient(pcb);
+        if(c){
+            c->setNoDelay(_noDelay);
+            return _tcp_accept(this, c);
+        }
+    }
+    if(tcp_close(pcb) != ERR_OK){
+        tcp_abort(pcb);
+    }
+    log_e("FAIL");
+    return ERR_OK;
+}
+
+int8_t AsyncServer::_accepted(AsyncClient* client){
+    if(_connect_cb){
+        _connect_cb(_connect_cb_arg, client);
+    }
+    return ERR_OK;
+}
+
+void AsyncServer::setNoDelay(bool nodelay){
+    _noDelay = nodelay;
+}
+
+bool AsyncServer::getNoDelay(){
+    return _noDelay;
+}
+
+uint8_t AsyncServer::status(){
+    if (!_pcb) {
+        return 0;
+    }
+    return _pcb->state;
+}
+
+int8_t AsyncServer::_s_accept(void * arg, tcp_pcb * pcb, int8_t err){
+    return reinterpret_cast<AsyncServer*>(arg)->_accept(pcb, err);
+}
+
+int8_t AsyncServer::_s_accepted(void *arg, AsyncClient* client){
+    return reinterpret_cast<AsyncServer*>(arg)->_accepted(client);
+}
diff --git a/Software/src/lib/me-no-dev-AsyncTCP/src/AsyncTCP.h b/Software/src/lib/me-no-dev-AsyncTCP/src/AsyncTCP.h
new file mode 100644
index 00000000..ac87deda
--- /dev/null
+++ b/Software/src/lib/me-no-dev-AsyncTCP/src/AsyncTCP.h
@@ -0,0 +1,217 @@
+/*
+  Asynchronous TCP library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef ASYNCTCP_H_
+#define ASYNCTCP_H_
+
+#include "IPAddress.h"
+#include "sdkconfig.h"
+#include <functional>
+extern "C" {
+    #include "freertos/semphr.h"
+    #include "lwip/pbuf.h"
+}
+
+//If core is not defined, then we are running in Arduino or PIO
+#ifndef CONFIG_ASYNC_TCP_RUNNING_CORE
+#define CONFIG_ASYNC_TCP_RUNNING_CORE -1 //any available core
+#define CONFIG_ASYNC_TCP_USE_WDT 1 //if enabled, adds between 33us and 200us per event
+#endif
+
+class AsyncClient;
+
+#define ASYNC_MAX_ACK_TIME 5000
+#define ASYNC_WRITE_FLAG_COPY 0x01 //will allocate new buffer to hold the data while sending (else will hold reference to the data given)
+#define ASYNC_WRITE_FLAG_MORE 0x02 //will not send PSH flag, meaning that there should be more data to be sent before the application should react.
+
+typedef std::function<void(void*, AsyncClient*)> AcConnectHandler;
+typedef std::function<void(void*, AsyncClient*, size_t len, uint32_t time)> AcAckHandler;
+typedef std::function<void(void*, AsyncClient*, int8_t error)> AcErrorHandler;
+typedef std::function<void(void*, AsyncClient*, void *data, size_t len)> AcDataHandler;
+typedef std::function<void(void*, AsyncClient*, struct pbuf *pb)> AcPacketHandler;
+typedef std::function<void(void*, AsyncClient*, uint32_t time)> AcTimeoutHandler;
+
+struct tcp_pcb;
+struct ip_addr;
+
+class AsyncClient {
+  public:
+    AsyncClient(tcp_pcb* pcb = 0);
+    ~AsyncClient();
+
+    AsyncClient & operator=(const AsyncClient &other);
+    AsyncClient & operator+=(const AsyncClient &other);
+
+    bool operator==(const AsyncClient &other);
+
+    bool operator!=(const AsyncClient &other) {
+      return !(*this == other);
+    }
+    bool connect(IPAddress ip, uint16_t port);
+    bool connect(const char* host, uint16_t port);
+    void close(bool now = false);
+    void stop();
+    int8_t abort();
+    bool free();
+
+    bool canSend();//ack is not pending
+    size_t space();//space available in the TCP window
+    size_t add(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY);//add for sending
+    bool send();//send all data added with the method above
+
+    //write equals add()+send()
+    size_t write(const char* data);
+    size_t write(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY); //only when canSend() == true
+
+    uint8_t state();
+    bool connecting();
+    bool connected();
+    bool disconnecting();
+    bool disconnected();
+    bool freeable();//disconnected or disconnecting
+
+    uint16_t getMss();
+
+    uint32_t getRxTimeout();
+    void setRxTimeout(uint32_t timeout);//no RX data timeout for the connection in seconds
+
+    uint32_t getAckTimeout();
+    void setAckTimeout(uint32_t timeout);//no ACK timeout for the last sent packet in milliseconds
+
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+
+    uint32_t getRemoteAddress();
+    uint16_t getRemotePort();
+    uint32_t getLocalAddress();
+    uint16_t getLocalPort();
+
+    //compatibility
+    IPAddress remoteIP();
+    uint16_t  remotePort();
+    IPAddress localIP();
+    uint16_t  localPort();
+
+    void onConnect(AcConnectHandler cb, void* arg = 0);     //on successful connect
+    void onDisconnect(AcConnectHandler cb, void* arg = 0);  //disconnected
+    void onAck(AcAckHandler cb, void* arg = 0);             //ack received
+    void onError(AcErrorHandler cb, void* arg = 0);         //unsuccessful connect or error
+    void onData(AcDataHandler cb, void* arg = 0);           //data received (called if onPacket is not used)
+    void onPacket(AcPacketHandler cb, void* arg = 0);       //data received
+    void onTimeout(AcTimeoutHandler cb, void* arg = 0);     //ack timeout
+    void onPoll(AcConnectHandler cb, void* arg = 0);        //every 125ms when connected
+
+    void ackPacket(struct pbuf * pb);//ack pbuf from onPacket
+    size_t ack(size_t len); //ack data that you have not acked using the method below
+    void ackLater(){ _ack_pcb = false; } //will not ack the current packet. Call from onData
+
+    const char * errorToString(int8_t error);
+    const char * stateToString();
+
+    //Do not use any of the functions below!
+    static int8_t _s_poll(void *arg, struct tcp_pcb *tpcb);
+    static int8_t _s_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *pb, int8_t err);
+    static int8_t _s_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
+    static int8_t _s_lwip_fin(void *arg, struct tcp_pcb *tpcb, int8_t err);
+    static void _s_error(void *arg, int8_t err);
+    static int8_t _s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len);
+    static int8_t _s_connected(void* arg, void* tpcb, int8_t err);
+    static void _s_dns_found(const char *name, struct ip_addr *ipaddr, void *arg);
+
+    int8_t _recv(tcp_pcb* pcb, pbuf* pb, int8_t err);
+    tcp_pcb * pcb(){ return _pcb; }
+
+  protected:
+    tcp_pcb* _pcb;
+    int8_t  _closed_slot;
+
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+    AcConnectHandler _discard_cb;
+    void* _discard_cb_arg;
+    AcAckHandler _sent_cb;
+    void* _sent_cb_arg;
+    AcErrorHandler _error_cb;
+    void* _error_cb_arg;
+    AcDataHandler _recv_cb;
+    void* _recv_cb_arg;
+    AcPacketHandler _pb_cb;
+    void* _pb_cb_arg;
+    AcTimeoutHandler _timeout_cb;
+    void* _timeout_cb_arg;
+    AcConnectHandler _poll_cb;
+    void* _poll_cb_arg;
+
+    bool _pcb_busy;
+    uint32_t _pcb_sent_at;
+    bool _ack_pcb;
+    uint32_t _rx_ack_len;
+    uint32_t _rx_last_packet;
+    uint32_t _rx_since_timeout;
+    uint32_t _ack_timeout;
+    uint16_t _connect_port;
+
+    int8_t _close();
+    void _free_closed_slot();
+    void _allocate_closed_slot();
+    int8_t _connected(void* pcb, int8_t err);
+    void _error(int8_t err);
+    int8_t _poll(tcp_pcb* pcb);
+    int8_t _sent(tcp_pcb* pcb, uint16_t len);
+    int8_t _fin(tcp_pcb* pcb, int8_t err);
+    int8_t _lwip_fin(tcp_pcb* pcb, int8_t err);
+    void _dns_found(struct ip_addr *ipaddr);
+
+  public:
+    AsyncClient* prev;
+    AsyncClient* next;
+};
+
+class AsyncServer {
+  public:
+    AsyncServer(IPAddress addr, uint16_t port);
+    AsyncServer(uint16_t port);
+    ~AsyncServer();
+    void onClient(AcConnectHandler cb, void* arg);
+    void begin();
+    void end();
+    void setNoDelay(bool nodelay);
+    bool getNoDelay();
+    uint8_t status();
+
+    //Do not use any of the functions below!
+    static int8_t _s_accept(void *arg, tcp_pcb* newpcb, int8_t err);
+    static int8_t _s_accepted(void *arg, AsyncClient* client);
+
+  protected:
+    uint16_t _port;
+    IPAddress _addr;
+    bool _noDelay;
+    tcp_pcb* _pcb;
+    AcConnectHandler _connect_cb;
+    void* _connect_cb_arg;
+
+    int8_t _accept(tcp_pcb* newpcb, int8_t err);
+    int8_t _accepted(AsyncClient* client);
+};
+
+
+#endif /* ASYNCTCP_H_ */