reverting version

lib/ESP8266-StringCommand/StringCommand.cpp

@@ -0,0 +1,137 @@
+/**
+ * SerialCommand - A Wiring/Arduino library to tokenize and parse commands
+ * received over a serial port.
+ *
+ * Copyright (C) 2012 Stefan Rado
+ * Copyright (C) 2011 Steven Cogswell <steven.cogswell@gmail.com>
+ *                    http://husks.wordpress.com
+ *
+ * Version 20120522
+ *
+ * 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 3 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 General Public License
+ * along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "StringCommand.h"
+
+/**
+ * Constructor makes sure some things are set.
+ */
+StringCommand::StringCommand()
+  : commandList(NULL),
+    commandCount(0),
+    defaultHandler(NULL),
+    term('\n'),           // default terminator for commands, newline character
+    last(NULL),
+    main(NULL)
+{
+  strcpy(delim, " "); // strtok_r needs a null-terminated string
+  clearBuffer();
+}
+
+/**
+ * Adds a "command" and a handler function to the list of available commands.
+ * This is used for matching a found token in the buffer, and gives the pointer
+ * to the handler function to deal with it.
+ */
+void StringCommand::addCommand(const char *command, void (*function)()) {
+  #ifdef SERIALCOMMAND_DEBUG
+    Serial.print("Adding command (");
+    Serial.print(commandCount);
+    Serial.print("): ");
+    Serial.println(command);
+  #endif
+
+  commandList = (StringCommandCallback *) realloc(commandList, (commandCount + 1) * sizeof(StringCommandCallback));
+  strncpy(commandList[commandCount].command, command, SERIALCOMMAND_MAXCOMMANDLENGTH);
+  commandList[commandCount].function = function;
+  commandCount++;
+}
+
+/**
+ * This sets up a handler to be called in the event that the receveived command string
+ * isn't in the list of commands.
+ */
+void StringCommand::setDefaultHandler(void (*function)(const char *)) {
+  defaultHandler = function;
+}
+
+
+/**
+ * This checks the Serial stream for characters, and assembles them into a buffer.
+ * When the terminator character (default '\n') is seen, it starts parsing the
+ * buffer for a prefix command, and calls handlers setup by addCommand() member
+ */
+void StringCommand::readStr(String sBuffer ) {
+	sBuffer.toCharArray(buffer, SERIALCOMMAND_BUFFER);
+	  #ifdef SERIALCOMMAND_DEBUG
+        Serial.print("Received: ");
+        Serial.println(buffer);
+      #endif
+
+      char *command = strtok_r(buffer, delim, &last);   // Search for command at start of buffer
+      if (command != NULL) {
+        boolean matched = false;
+        for (int i = 0; i < commandCount; i++) {
+          #ifdef SERIALCOMMAND_DEBUG
+            Serial.print("Comparing [");
+            Serial.print(command);
+            Serial.print("] to [");
+            Serial.print(commandList[i].command);
+            Serial.println("]");
+          #endif
+
+
+
+          // Compare the found command against the list of known commands for a match
+          if (strncmp(command, commandList[i].command, SERIALCOMMAND_MAXCOMMANDLENGTH) == 0) {
+            #ifdef SERIALCOMMAND_DEBUG
+              Serial.print("Matched Command: ");
+              Serial.println(command);
+            #endif
+
+            // Execute the stored handler function for the command
+            (*commandList[i].function)();
+            matched = true;
+            break;
+          }
+        }
+
+
+        if (!matched && (defaultHandler != NULL)) {
+          (*defaultHandler)(command);
+        }
+
+
+      clearBuffer();
+    }
+}
+
+/*
+ * Clear the input buffer.
+ */
+void StringCommand::clearBuffer() {
+  buffer[0] = '\0';
+  bufPos = 0;
+}
+
+/**
+ * Retrieve the next token ("word" or "argument") from the command buffer.
+ * Returns NULL if no more tokens exist.
+ */
+char *StringCommand::next() {
+  return strtok_r(NULL, delim, &last);
+}
+
+char *StringCommand::order() {
+  return strtok_r(buffer, delim, &main);
+}

lib/ESP8266-StringCommand/StringCommand.h

@@ -0,0 +1,77 @@
+/**
+ * SerialCommand - A Wiring/Arduino library to tokenize and parse commands
+ * received over a serial port.
+ *
+ * Copyright (C) 2012 Stefan Rado
+ * Copyright (C) 2011 Steven Cogswell <steven.cogswell@gmail.com>
+ *                    http://husks.wordpress.com
+ *
+ * Version 20120522
+ *
+ * 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 3 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 General Public License
+ * along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef StringCommand_h
+#define StringCommand_h
+
+#if defined(WIRING) && WIRING >= 100
+  #include <Wiring.h>
+#elif defined(ARDUINO) && ARDUINO >= 100
+  #include <Arduino.h>
+#else
+  #include <WProgram.h>
+#endif
+#include <string.h>
+
+// Size of the input buffer in bytes (maximum length of one command plus arguments)
+#define SERIALCOMMAND_BUFFER 128  //256
+// Maximum length of a command excluding the terminating null
+#define SERIALCOMMAND_MAXCOMMANDLENGTH 16
+
+// Uncomment the next line to run the library in debug mode (verbose messages)
+//#define SERIALCOMMAND_DEBUG
+
+
+class StringCommand {
+  public:
+    StringCommand();      // Constructor
+    void addCommand(const char *command, void(*function)());  // Add a command to the processing dictionary.
+    void setDefaultHandler(void (*function)(const char *));   // A handler to call when no valid command received.
+
+    void readStr(String sBuffer );    // Main entry point.
+    void clearBuffer();   // Clears the input buffer.
+    char *next();         // Returns pointer to next token found in command buffer (for getting arguments to commands).
+    char *order();
+
+  private:
+    // Command/handler dictionary
+    struct StringCommandCallback {
+      char command[SERIALCOMMAND_MAXCOMMANDLENGTH + 1];
+      void (*function)();
+    };                                    // Data structure to hold Command/Handler function key-value pairs
+    StringCommandCallback *commandList;   // Actual definition for command/handler array
+    byte commandCount;
+
+    // Pointer to the default handler function
+    void (*defaultHandler)(const char *);
+
+    char delim[2]; // null-terminated list of character to be used as delimeters for tokenizing (default " ")
+    char term;     // Character that signals end of command (default '\n')
+
+    char buffer[SERIALCOMMAND_BUFFER + 1]; // Buffer of stored characters while waiting for terminator character
+    byte bufPos;                        // Current position in the buffer
+    char *last;                         // State variable used by strtok_r during processing
+    char *main;
+};
+
+#endif //StringCommand_h

lib/ESP8266-StringCommand/keywords.txt

@@ -0,0 +1,23 @@
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+StringCommand KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+addCommand        KEYWORD2
+setDefaultHandler KEYWORD2
+readString        KEYWORD2
+clearBuffer       KEYWORD2
+next              KEYWORD2
+
+#######################################
+# Instances (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+####################################### 

lib/ESP8266-StringCommand/readme.md

@@ -0,0 +1,5 @@
+StringCommand
+=============
+Библиотека для ESP8266 позволяющая связать запуск пользовательских функций с строковой переменной.
+
+

lib/ESPAsyncWebServer/.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

lib/ESPAsyncWebServer/.github/scripts/install-arduino-core-esp8266.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+echo "Installing ESP8266 Arduino Core ..."
+script_init_path="$PWD"
+mkdir -p "$ARDUINO_USR_PATH/hardware/esp8266com"
+cd "$ARDUINO_USR_PATH/hardware/esp8266com"
+
+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
+
+echo "Cloning Core Repository ..."
+git clone https://github.com/esp8266/Arduino.git esp8266 > /dev/null 2>&1
+
+echo "Updating submodules ..."
+cd esp8266
+git submodule update --init --recursive > /dev/null 2>&1
+
+echo "Installing Platform Tools ..."
+cd tools
+python get.py > /dev/null
+cd $script_init_path
+
+echo "ESP8266 Arduino has been installed in '$ARDUINO_USR_PATH/hardware/esp8266com'"
+echo ""

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

@@ -0,0 +1,228 @@
+#!/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> <build-flags> [extra-options]
+    if [ "$#" -lt 2 ]; then
+		echo "ERROR: Illegal number of parameters"
+		echo "USAGE: build_sketch <fqbn> <path-to-ino> <build-flags> [extra-options]"
+		return 1
+	fi
+
+	local fqbn="$1"
+	local sketch="$2"
+    local build_flags="$3"
+    local xtra_opts="$4"
+	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" \
+        -prefs=compiler.cpp.extra_flags="$build_flags" \
+		$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
+        local sketchBuildFlags=""
+        if [ -f "$sketchdir/.test.build_flags" ]; then
+            while read line; do
+                sketchBuildFlags="$sketchBuildFlags $line"
+            done < "$sketchdir/.test.build_flags"
+        fi
+        build_sketch "$fqbn" "$sketch" "$sketchBuildFlags" "$xtra_opts"
+        local result=$?
+        if [ $result -ne 0 ]; then
+            return $result
+        fi
+    done
+    return 0
+}

lib/ESPAsyncWebServer/.github/scripts/install-platformio.sh

@@ -0,0 +1,140 @@
+#!/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> <build-flags>
+    if [ "$#" -lt 3 ]; then
+        echo "ERROR: Illegal number of parameters"
+        echo "USAGE: build_pio_sketch <board> <path-to-ino> <build-flags>"
+        return 1
+    fi
+
+	local board="$1"
+	local sketch="$2"
+    local buildFlags="$3"
+	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" --project-option="build_flags=$buildFlags"
+}
+
+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
+        local sketchBuildFlags=""
+        if [ -f "$sketchdir/.test.build_flags" ]; then
+            while read line; do
+                sketchBuildFlags="$sketchBuildFlags $line"
+            done < "$sketchdir/.test.build_flags"
+        fi
+        sketchnum=$(($sketchnum + 1))
+        if [ "$sketchnum" -le "$start_index" ] \
+        || [ "$sketchnum" -gt "$end_index" ]; then
+        	continue
+        fi
+        build_pio_sketch "$board" "$sketch" "$sketchBuildFlags"
+        local result=$?
+        if [ $result -ne 0 ]; then
+            return $result
+        fi
+    done
+    return 0
+}

lib/ESPAsyncWebServer/.github/scripts/on-push.sh

@@ -0,0 +1,71 @@
+#!/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/ESPAsyncWebServer"
+fi
+
+TARGET_PLATFORM="$1"
+CHUNK_INDEX=$2
+CHUNKS_CNT=$3
+BUILD_PIO=0
+if [ "$#" -lt 1 ]; then
+	TARGET_PLATFORM="esp32"
+fi
+if [ "$#" -lt 3 ] || [ "$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
+
+	echo "Installing ESPAsyncWebServer ..."
+	cp -rf "$GITHUB_WORKSPACE" "$ARDUINO_USR_PATH/libraries/ESPAsyncWebServer"
+	echo "Installing ArduinoJson ..."
+	git clone https://github.com/bblanchon/ArduinoJson "$ARDUINO_USR_PATH/libraries/ArduinoJson" > /dev/null 2>&1
+
+	if [[ "$TARGET_PLATFORM" == "esp32" ]]; then
+		echo "Installing AsyncTCP ..."
+		git clone https://github.com/me-no-dev/AsyncTCP "$ARDUINO_USR_PATH/libraries/AsyncTCP" > /dev/null 2>&1
+		FQBN="espressif:esp32:esp32:PSRAM=enabled,PartitionScheme=huge_app"
+		source ./.github/scripts/install-arduino-core-esp32.sh
+		echo "BUILDING ESP32 EXAMPLES"
+	else
+		echo "Installing ESPAsyncTCP ..."
+		git clone https://github.com/me-no-dev/ESPAsyncTCP "$ARDUINO_USR_PATH/libraries/ESPAsyncTCP" > /dev/null 2>&1
+		FQBN="esp8266com:esp8266:generic:eesz=4M1M,ip=lm2f"
+		source ./.github/scripts/install-arduino-core-esp8266.sh
+		echo "BUILDING ESP8266 EXAMPLES"
+	fi
+	build_sketches "$FQBN" "$GITHUB_WORKSPACE/examples" "$CHUNK_INDEX" "$CHUNKS_CNT"
+else
+	# PlatformIO Test
+	source ./.github/scripts/install-platformio.sh
+
+	python -m platformio lib --storage-dir "$GITHUB_WORKSPACE" install
+	echo "Installing ArduinoJson ..."
+	python -m platformio lib -g install https://github.com/bblanchon/ArduinoJson.git > /dev/null 2>&1
+	if [[ "$TARGET_PLATFORM" == "esp32" ]]; then
+		BOARD="esp32dev"
+		echo "Installing AsyncTCP ..."
+		python -m platformio lib -g install https://github.com/me-no-dev/AsyncTCP.git > /dev/null 2>&1
+		echo "BUILDING ESP32 EXAMPLES"
+	else
+		BOARD="esp12e"
+		echo "Installing ESPAsyncTCP ..."
+		python -m platformio lib -g install https://github.com/me-no-dev/ESPAsyncTCP.git > /dev/null 2>&1
+		echo "BUILDING ESP8266 EXAMPLES"
+	fi
+	build_pio_sketches "$BOARD" "$GITHUB_WORKSPACE/examples"
+fi

lib/ESPAsyncWebServer/.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.
+

lib/ESPAsyncWebServer/.github/workflows/push.yml

@@ -0,0 +1,34 @@
+name: ESP Async Web Server CI
+
+on:
+  push:
+    branches:
+    - master
+    - release/*
+  pull_request:
+
+jobs:
+
+  build-arduino:
+    name: Arduino for ${{ matrix.board }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        board: [esp32, esp8266]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Build Tests
+      run: bash ./.github/scripts/on-push.sh ${{ matrix.board }} 0 1
+
+  build-pio:
+    name: PlatformIO for ${{ matrix.board }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        board: [esp32, esp8266]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Build Tests
+      run: bash ./.github/scripts/on-push.sh ${{ matrix.board }} 1 1

lib/ESPAsyncWebServer/.gitignore

@@ -0,0 +1,2 @@
+.vscode
+.DS_Store

lib/ESPAsyncWebServer/.travis.yml

@@ -0,0 +1,46 @@
+sudo: false
+
+language: python
+
+os:
+  - linux
+
+git:
+  depth: false
+
+stages:
+  - build
+
+jobs:
+  include:
+
+    - name: "Build Arduino ESP32"
+      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 esp32
+
+    - name: "Build Arduino ESP8266"
+      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 esp8266
+
+    - name: "Build Platformio ESP32"
+      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 esp32 1 1
+
+    - name: "Build Platformio ESP8266"
+      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 esp8266 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: never     # options: [always|never|change] default: always

lib/ESPAsyncWebServer/CMakeLists.txt

@@ -0,0 +1,17 @@
+set(COMPONENT_SRCDIRS
+    "src"
+)
+
+set(COMPONENT_ADD_INCLUDEDIRS
+    "src"
+)
+
+set(COMPONENT_REQUIRES
+    "arduino-esp32"
+    "AsyncTCP"
+)
+
+register_component()
+
+target_compile_definitions(${COMPONENT_TARGET} PUBLIC -DESP32)
+target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti)

lib/ESPAsyncWebServer/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

lib/ESPAsyncWebServer/component.mk

@@ -0,0 +1,3 @@
+COMPONENT_ADD_INCLUDEDIRS := src
+COMPONENT_SRCDIRS := src
+CXXFLAGS += -fno-rtti

lib/ESPAsyncWebServer/examples/CaptivePortal/CaptivePortal.ino

@@ -0,0 +1,47 @@
+#include <DNSServer.h>
+#ifdef ESP32
+#include <WiFi.h>
+#include <AsyncTCP.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#endif
+#include "ESPAsyncWebServer.h"
+
+DNSServer dnsServer;
+AsyncWebServer server(80);
+
+class CaptiveRequestHandler : public AsyncWebHandler {
+public:
+  CaptiveRequestHandler() {}
+  virtual ~CaptiveRequestHandler() {}
+
+  bool canHandle(AsyncWebServerRequest *request){
+    //request->addInterestingHeader("ANY");
+    return true;
+  }
+
+  void handleRequest(AsyncWebServerRequest *request) {
+    AsyncResponseStream *response = request->beginResponseStream("text/html");
+    response->print("<!DOCTYPE html><html><head><title>Captive Portal</title></head><body>");
+    response->print("<p>This is out captive portal front page.</p>");
+    response->printf("<p>You were trying to reach: http://%s%s</p>", request->host().c_str(), request->url().c_str());
+    response->printf("<p>Try opening <a href='http://%s'>this link</a> instead</p>", WiFi.softAPIP().toString().c_str());
+    response->print("</body></html>");
+    request->send(response);
+  }
+};
+
+
+void setup(){
+  //your other setup stuff...
+  WiFi.softAP("esp-captive");
+  dnsServer.start(53, "*", WiFi.softAPIP());
+  server.addHandler(new CaptiveRequestHandler()).setFilter(ON_AP_FILTER);//only when requested from AP
+  //more handlers...
+  server.begin();
+}
+
+void loop(){
+  dnsServer.processNextRequest();
+}

lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/ESP_AsyncFSBrowser.ino

@@ -0,0 +1,221 @@
+#include <ArduinoOTA.h>
+#ifdef ESP32
+#include <FS.h>
+#include <SPIFFS.h>
+#include <ESPmDNS.h>
+#include <WiFi.h>
+#include <AsyncTCP.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#include <ESP8266mDNS.h>
+#endif
+#include <ESPAsyncWebServer.h>
+#include <SPIFFSEditor.h>
+
+// SKETCH BEGIN
+AsyncWebServer server(80);
+AsyncWebSocket ws("/ws");
+AsyncEventSource events("/events");
+
+void onWsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len){
+  if(type == WS_EVT_CONNECT){
+    Serial.printf("ws[%s][%u] connect\n", server->url(), client->id());
+    client->printf("Hello Client %u :)", client->id());
+    client->ping();
+  } else if(type == WS_EVT_DISCONNECT){
+    Serial.printf("ws[%s][%u] disconnect\n", server->url(), client->id());
+  } else if(type == WS_EVT_ERROR){
+    Serial.printf("ws[%s][%u] error(%u): %s\n", server->url(), client->id(), *((uint16_t*)arg), (char*)data);
+  } else if(type == WS_EVT_PONG){
+    Serial.printf("ws[%s][%u] pong[%u]: %s\n", server->url(), client->id(), len, (len)?(char*)data:"");
+  } else if(type == WS_EVT_DATA){
+    AwsFrameInfo * info = (AwsFrameInfo*)arg;
+    String msg = "";
+    if(info->final && info->index == 0 && info->len == len){
+      //the whole message is in a single frame and we got all of it's data
+      Serial.printf("ws[%s][%u] %s-message[%llu]: ", server->url(), client->id(), (info->opcode == WS_TEXT)?"text":"binary", info->len);
+
+      if(info->opcode == WS_TEXT){
+        for(size_t i=0; i < info->len; i++) {
+          msg += (char) data[i];
+        }
+      } else {
+        char buff[3];
+        for(size_t i=0; i < info->len; i++) {
+          sprintf(buff, "%02x ", (uint8_t) data[i]);
+          msg += buff ;
+        }
+      }
+      Serial.printf("%s\n",msg.c_str());
+
+      if(info->opcode == WS_TEXT)
+        client->text("I got your text message");
+      else
+        client->binary("I got your binary message");
+    } else {
+      //message is comprised of multiple frames or the frame is split into multiple packets
+      if(info->index == 0){
+        if(info->num == 0)
+          Serial.printf("ws[%s][%u] %s-message start\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary");
+        Serial.printf("ws[%s][%u] frame[%u] start[%llu]\n", server->url(), client->id(), info->num, info->len);
+      }
+
+      Serial.printf("ws[%s][%u] frame[%u] %s[%llu - %llu]: ", server->url(), client->id(), info->num, (info->message_opcode == WS_TEXT)?"text":"binary", info->index, info->index + len);
+
+      if(info->opcode == WS_TEXT){
+        for(size_t i=0; i < len; i++) {
+          msg += (char) data[i];
+        }
+      } else {
+        char buff[3];
+        for(size_t i=0; i < len; i++) {
+          sprintf(buff, "%02x ", (uint8_t) data[i]);
+          msg += buff ;
+        }
+      }
+      Serial.printf("%s\n",msg.c_str());
+
+      if((info->index + len) == info->len){
+        Serial.printf("ws[%s][%u] frame[%u] end[%llu]\n", server->url(), client->id(), info->num, info->len);
+        if(info->final){
+          Serial.printf("ws[%s][%u] %s-message end\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary");
+          if(info->message_opcode == WS_TEXT)
+            client->text("I got your text message");
+          else
+            client->binary("I got your binary message");
+        }
+      }
+    }
+  }
+}
+
+
+const char* ssid = "*******";
+const char* password = "*******";
+const char * hostName = "esp-async";
+const char* http_username = "admin";
+const char* http_password = "admin";
+
+void setup(){
+  Serial.begin(115200);
+  Serial.setDebugOutput(true);
+  WiFi.mode(WIFI_AP_STA);
+  WiFi.softAP(hostName);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.printf("STA: Failed!\n");
+    WiFi.disconnect(false);
+    delay(1000);
+    WiFi.begin(ssid, password);
+  }
+
+  //Send OTA events to the browser
+  ArduinoOTA.onStart([]() { events.send("Update Start", "ota"); });
+  ArduinoOTA.onEnd([]() { events.send("Update End", "ota"); });
+  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
+    char p[32];
+    sprintf(p, "Progress: %u%%\n", (progress/(total/100)));
+    events.send(p, "ota");
+  });
+  ArduinoOTA.onError([](ota_error_t error) {
+    if(error == OTA_AUTH_ERROR) events.send("Auth Failed", "ota");
+    else if(error == OTA_BEGIN_ERROR) events.send("Begin Failed", "ota");
+    else if(error == OTA_CONNECT_ERROR) events.send("Connect Failed", "ota");
+    else if(error == OTA_RECEIVE_ERROR) events.send("Recieve Failed", "ota");
+    else if(error == OTA_END_ERROR) events.send("End Failed", "ota");
+  });
+  ArduinoOTA.setHostname(hostName);
+  ArduinoOTA.begin();
+
+  MDNS.addService("http","tcp",80);
+
+  SPIFFS.begin();
+
+  ws.onEvent(onWsEvent);
+  server.addHandler(&ws);
+
+  events.onConnect([](AsyncEventSourceClient *client){
+    client->send("hello!",NULL,millis(),1000);
+  });
+  server.addHandler(&events);
+
+#ifdef ESP32
+  server.addHandler(new SPIFFSEditor(SPIFFS, http_username,http_password));
+#elif defined(ESP8266)
+  server.addHandler(new SPIFFSEditor(http_username,http_password));
+#endif
+  
+  server.on("/heap", HTTP_GET, [](AsyncWebServerRequest *request){
+    request->send(200, "text/plain", String(ESP.getFreeHeap()));
+  });
+
+  server.serveStatic("/", SPIFFS, "/").setDefaultFile("index.htm");
+
+  server.onNotFound([](AsyncWebServerRequest *request){
+    Serial.printf("NOT_FOUND: ");
+    if(request->method() == HTTP_GET)
+      Serial.printf("GET");
+    else if(request->method() == HTTP_POST)
+      Serial.printf("POST");
+    else if(request->method() == HTTP_DELETE)
+      Serial.printf("DELETE");
+    else if(request->method() == HTTP_PUT)
+      Serial.printf("PUT");
+    else if(request->method() == HTTP_PATCH)
+      Serial.printf("PATCH");
+    else if(request->method() == HTTP_HEAD)
+      Serial.printf("HEAD");
+    else if(request->method() == HTTP_OPTIONS)
+      Serial.printf("OPTIONS");
+    else
+      Serial.printf("UNKNOWN");
+    Serial.printf(" http://%s%s\n", request->host().c_str(), request->url().c_str());
+
+    if(request->contentLength()){
+      Serial.printf("_CONTENT_TYPE: %s\n", request->contentType().c_str());
+      Serial.printf("_CONTENT_LENGTH: %u\n", request->contentLength());
+    }
+
+    int headers = request->headers();
+    int i;
+    for(i=0;i<headers;i++){
+      AsyncWebHeader* h = request->getHeader(i);
+      Serial.printf("_HEADER[%s]: %s\n", h->name().c_str(), h->value().c_str());
+    }
+
+    int params = request->params();
+    for(i=0;i<params;i++){
+      AsyncWebParameter* p = request->getParam(i);
+      if(p->isFile()){
+        Serial.printf("_FILE[%s]: %s, size: %u\n", p->name().c_str(), p->value().c_str(), p->size());
+      } else if(p->isPost()){
+        Serial.printf("_POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
+      } else {
+        Serial.printf("_GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
+      }
+    }
+
+    request->send(404);
+  });
+  server.onFileUpload([](AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final){
+    if(!index)
+      Serial.printf("UploadStart: %s\n", filename.c_str());
+    Serial.printf("%s", (const char*)data);
+    if(final)
+      Serial.printf("UploadEnd: %s (%u)\n", filename.c_str(), index+len);
+  });
+  server.onRequestBody([](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){
+    if(!index)
+      Serial.printf("BodyStart: %u\n", total);
+    Serial.printf("%s", (const char*)data);
+    if(index + len == total)
+      Serial.printf("BodyEnd: %u\n", total);
+  });
+  server.begin();
+}
+
+void loop(){
+  ArduinoOTA.handle();
+  ws.cleanupClients();
+}

lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/.exclude.files

@@ -0,0 +1,2 @@
+/*.js.gz
+/.exclude.files

lib/ESPAsyncWebServer/examples/ESP_AsyncFSBrowser/data/index.htm

@@ -0,0 +1,131 @@
+<!--
+  FSWebServer - Example Index Page
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the ESP8266WebServer library 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
+-->
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>WebSocketTester</title>
+    <style type="text/css" media="screen">
+    body {
+      margin:0;
+      padding:0;
+      background-color: black;
+    }
+
+    #dbg, #input_div, #input_el {
+      font-family: monaco;
+      font-size: 12px;
+      line-height: 13px;
+      color: #AAA;
+    }
+
+    #dbg, #input_div {
+      margin:0;
+      padding:0;
+      padding-left:4px;
+    }
+
+    #input_el {
+      width:98%;
+      background-color: rgba(0,0,0,0);
+      border: 0px;
+    }
+    #input_el:focus {
+      outline: none;
+    }
+    </style>
+    <script type="text/javascript">
+    var ws = null;
+    function ge(s){ return document.getElementById(s);}
+    function ce(s){ return document.createElement(s);}
+    function stb(){ window.scrollTo(0, document.body.scrollHeight || document.documentElement.scrollHeight); }
+    function sendBlob(str){
+      var buf = new Uint8Array(str.length);
+      for (var i = 0; i < str.length; ++i) buf[i] = str.charCodeAt(i);
+      ws.send(buf);
+    }
+    function addMessage(m){
+      var msg = ce("div");
+      msg.innerText = m;
+      ge("dbg").appendChild(msg);
+      stb();
+    }
+    function startSocket(){
+      ws = new WebSocket('ws://'+document.location.host+'/ws',['arduino']);
+      ws.binaryType = "arraybuffer";
+      ws.onopen = function(e){
+        addMessage("Connected");
+      };
+      ws.onclose = function(e){
+        addMessage("Disconnected");
+      };
+      ws.onerror = function(e){
+        console.log("ws error", e);
+        addMessage("Error");
+      };
+      ws.onmessage = function(e){
+        var msg = "";
+        if(e.data instanceof ArrayBuffer){
+          msg = "BIN:";
+          var bytes = new Uint8Array(e.data);
+          for (var i = 0; i < bytes.length; i++) {
+            msg += String.fromCharCode(bytes[i]);
+          }
+        } else {
+          msg = "TXT:"+e.data;
+        }
+        addMessage(msg);
+      };
+      ge("input_el").onkeydown = function(e){
+        stb();
+        if(e.keyCode == 13 && ge("input_el").value != ""){
+          ws.send(ge("input_el").value);
+          ge("input_el").value = "";
+        }
+      }
+    }
+    function startEvents(){
+      var es = new EventSource('/events');
+      es.onopen = function(e) {
+        addMessage("Events Opened");
+      };
+      es.onerror = function(e) {
+        if (e.target.readyState != EventSource.OPEN) {
+          addMessage("Events Closed");
+        }
+      };
+      es.onmessage = function(e) {
+        addMessage("Event: " + e.data);
+      };
+      es.addEventListener('ota', function(e) {
+        addMessage("Event[ota]: " + e.data);
+      }, false);
+    }
+    function onBodyLoad(){
+      startSocket();
+      startEvents();
+    }
+    </script>
+  </head>
+  <body id="body" onload="onBodyLoad()">
+    <pre id="dbg"></pre>
+    <div id="input_div">
+      $<input type="text" value="" id="input_el">
+    </div>
+  </body>
+</html>

lib/ESPAsyncWebServer/examples/regex_patterns/.test.build_flags

@@ -0,0 +1 @@
+-DASYNCWEBSERVER_REGEX=1

lib/ESPAsyncWebServer/examples/regex_patterns/regex_patterns.ino

@@ -0,0 +1,77 @@
+//
+// A simple server implementation with regex routes:
+//  * serve static messages
+//  * read GET and POST parameters
+//  * handle missing pages / 404s
+//
+
+// Add buildflag ASYNCWEBSERVER_REGEX to enable the regex support
+
+// For platformio: platformio.ini:
+//  build_flags = 
+//      -DASYNCWEBSERVER_REGEX
+
+// For arduino IDE: create/update platform.local.txt
+// Windows: C:\Users\(username)\AppData\Local\Arduino15\packages\espxxxx\hardware\espxxxx\{version}\platform.local.txt
+// Linux: ~/.arduino15/packages/espxxxx/hardware/espxxxx/{version}/platform.local.txt
+//
+// compiler.cpp.extra_flags=-DASYNCWEBSERVER_REGEX=1
+
+#include <Arduino.h>
+#ifdef ESP32
+#include <WiFi.h>
+#include <AsyncTCP.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#endif
+#include <ESPAsyncWebServer.h>
+
+AsyncWebServer server(80);
+
+const char* ssid = "YOUR_SSID";
+const char* password = "YOUR_PASSWORD";
+
+const char* PARAM_MESSAGE = "message";
+
+void notFound(AsyncWebServerRequest *request) {
+    request->send(404, "text/plain", "Not found");
+}
+
+void setup() {
+
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.printf("WiFi Failed!\n");
+        return;
+    }
+
+    Serial.print("IP Address: ");
+    Serial.println(WiFi.localIP());
+
+    server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
+        request->send(200, "text/plain", "Hello, world");
+    });
+
+    // Send a GET request to <IP>/sensor/<number>
+    server.on("^\\/sensor\\/([0-9]+)$", HTTP_GET, [] (AsyncWebServerRequest *request) {
+        String sensorNumber = request->pathArg(0);
+        request->send(200, "text/plain", "Hello, sensor: " + sensorNumber);
+    });
+	
+	// Send a GET request to <IP>/sensor/<number>/action/<action>
+    server.on("^\\/sensor\\/([0-9]+)\\/action\\/([a-zA-Z0-9]+)$", HTTP_GET, [] (AsyncWebServerRequest *request) {
+        String sensorNumber = request->pathArg(0);
+        String action = request->pathArg(1);
+        request->send(200, "text/plain", "Hello, sensor: " + sensorNumber + ", with action: " + action);
+    });
+
+    server.onNotFound(notFound);
+
+    server.begin();
+}
+
+void loop() {
+}

lib/ESPAsyncWebServer/examples/simple_server/simple_server.ino

@@ -0,0 +1,74 @@
+//
+// A simple server implementation showing how to:
+//  * serve static messages
+//  * read GET and POST parameters
+//  * handle missing pages / 404s
+//
+
+#include <Arduino.h>
+#ifdef ESP32
+#include <WiFi.h>
+#include <AsyncTCP.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#endif
+#include <ESPAsyncWebServer.h>
+
+AsyncWebServer server(80);
+
+const char* ssid = "YOUR_SSID";
+const char* password = "YOUR_PASSWORD";
+
+const char* PARAM_MESSAGE = "message";
+
+void notFound(AsyncWebServerRequest *request) {
+    request->send(404, "text/plain", "Not found");
+}
+
+void setup() {
+
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.printf("WiFi Failed!\n");
+        return;
+    }
+
+    Serial.print("IP Address: ");
+    Serial.println(WiFi.localIP());
+
+    server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
+        request->send(200, "text/plain", "Hello, world");
+    });
+
+    // Send a GET request to <IP>/get?message=<message>
+    server.on("/get", HTTP_GET, [] (AsyncWebServerRequest *request) {
+        String message;
+        if (request->hasParam(PARAM_MESSAGE)) {
+            message = request->getParam(PARAM_MESSAGE)->value();
+        } else {
+            message = "No message sent";
+        }
+        request->send(200, "text/plain", "Hello, GET: " + message);
+    });
+
+    // Send a POST request to <IP>/post with a form field message set to <message>
+    server.on("/post", HTTP_POST, [](AsyncWebServerRequest *request){
+        String message;
+        if (request->hasParam(PARAM_MESSAGE, true)) {
+            message = request->getParam(PARAM_MESSAGE, true)->value();
+        } else {
+            message = "No message sent";
+        }
+        request->send(200, "text/plain", "Hello, POST: " + message);
+    });
+
+    server.onNotFound(notFound);
+
+    server.begin();
+}
+
+void loop() {
+}

lib/ESPAsyncWebServer/keywords.txt

@@ -0,0 +1,3 @@
+JsonArray	KEYWORD1
+add	KEYWORD2
+createArray	KEYWORD3

lib/ESPAsyncWebServer/library.json

@@ -0,0 +1,33 @@
+{
+  "name":"ESP Async WebServer",
+  "description":"Asynchronous HTTP and WebSocket Server Library for ESP8266 and ESP32",
+  "keywords":"http,async,websocket,webserver",
+  "authors":
+  {
+    "name": "Hristo Gochkov",
+    "maintainer": true
+  },
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/me-no-dev/ESPAsyncWebServer.git"
+  },
+  "version": "1.2.3",
+  "license": "LGPL-3.0",
+  "frameworks": "arduino",
+  "platforms": ["espressif8266", "espressif32"],
+  "dependencies": [
+    {
+      "name": "ESPAsyncTCP",
+      "platforms": "espressif8266"
+    },
+    {
+      "name": "AsyncTCP",
+      "platforms": "espressif32"
+    },
+    {
+      "name": "Hash",
+      "platforms": "espressif8266"
+    }
+  ]
+}

lib/ESPAsyncWebServer/library.properties

@@ -0,0 +1,9 @@
+name=ESP Async WebServer
+version=1.2.3
+author=Me-No-Dev
+maintainer=Me-No-Dev
+sentence=Async Web Server for ESP8266 and ESP31B
+paragraph=Async Web Server for ESP8266 and ESP31B
+category=Other
+url=https://github.com/me-no-dev/ESPAsyncWebServer
+architectures=*

lib/ESPAsyncWebServer/src/AsyncEventSource.cpp

@@ -0,0 +1,368 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+
+  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 "AsyncEventSource.h"
+
+static String generateEventMessage(const char *message, const char *event, uint32_t id, uint32_t reconnect){
+  String ev = "";
+
+  if(reconnect){
+    ev += "retry: ";
+    ev += String(reconnect);
+    ev += "\r\n";
+  }
+
+  if(id){
+    ev += "id: ";
+    ev += String(id);
+    ev += "\r\n";
+  }
+
+  if(event != NULL){
+    ev += "event: ";
+    ev += String(event);
+    ev += "\r\n";
+  }
+
+  if(message != NULL){
+    size_t messageLen = strlen(message);
+    char * lineStart = (char *)message;
+    char * lineEnd;
+    do {
+      char * nextN = strchr(lineStart, '\n');
+      char * nextR = strchr(lineStart, '\r');
+      if(nextN == NULL && nextR == NULL){
+        size_t llen = ((char *)message + messageLen) - lineStart;
+        char * ldata = (char *)malloc(llen+1);
+        if(ldata != NULL){
+          memcpy(ldata, lineStart, llen);
+          ldata[llen] = 0;
+          ev += "data: ";
+          ev += ldata;
+          ev += "\r\n\r\n";
+          free(ldata);
+        }
+        lineStart = (char *)message + messageLen;
+      } else {
+        char * nextLine = NULL;
+        if(nextN != NULL && nextR != NULL){
+          if(nextR < nextN){
+            lineEnd = nextR;
+            if(nextN == (nextR + 1))
+              nextLine = nextN + 1;
+            else
+              nextLine = nextR + 1;
+          } else {
+            lineEnd = nextN;
+            if(nextR == (nextN + 1))
+              nextLine = nextR + 1;
+            else
+              nextLine = nextN + 1;
+          }
+        } else if(nextN != NULL){
+          lineEnd = nextN;
+          nextLine = nextN + 1;
+        } else {
+          lineEnd = nextR;
+          nextLine = nextR + 1;
+        }
+
+        size_t llen = lineEnd - lineStart;
+        char * ldata = (char *)malloc(llen+1);
+        if(ldata != NULL){
+          memcpy(ldata, lineStart, llen);
+          ldata[llen] = 0;
+          ev += "data: ";
+          ev += ldata;
+          ev += "\r\n";
+          free(ldata);
+        }
+        lineStart = nextLine;
+        if(lineStart == ((char *)message + messageLen))
+          ev += "\r\n";
+      }
+    } while(lineStart < ((char *)message + messageLen));
+  }
+
+  return ev;
+}
+
+// Message
+
+AsyncEventSourceMessage::AsyncEventSourceMessage(const char * data, size_t len)
+: _data(nullptr), _len(len), _sent(0), _acked(0)
+{
+  _data = (uint8_t*)malloc(_len+1);
+  if(_data == nullptr){
+    _len = 0;
+  } else {
+    memcpy(_data, data, len);
+    _data[_len] = 0;
+  }
+}
+
+AsyncEventSourceMessage::~AsyncEventSourceMessage() {
+     if(_data != NULL)
+        free(_data);
+}
+
+size_t AsyncEventSourceMessage::ack(size_t len, uint32_t time) {
+  (void)time;
+  // If the whole message is now acked...
+  if(_acked + len > _len){
+     // Return the number of extra bytes acked (they will be carried on to the next message)
+     const size_t extra = _acked + len - _len;
+     _acked = _len;
+     return extra;
+  }
+  // Return that no extra bytes left.
+  _acked += len;
+  return 0;
+}
+
+size_t AsyncEventSourceMessage::send(AsyncClient *client) {
+  const size_t len = _len - _sent;
+  if(client->space() < len){
+    return 0;
+  }
+  size_t sent = client->add((const char *)_data, len);
+  if(client->canSend())
+    client->send();
+  _sent += sent;
+  return sent; 
+}
+
+// Client
+
+AsyncEventSourceClient::AsyncEventSourceClient(AsyncWebServerRequest *request, AsyncEventSource *server)
+: _messageQueue(LinkedList<AsyncEventSourceMessage *>([](AsyncEventSourceMessage *m){ delete  m; }))
+{
+  _client = request->client();
+  _server = server;
+  _lastId = 0;
+  if(request->hasHeader("Last-Event-ID"))
+    _lastId = atoi(request->getHeader("Last-Event-ID")->value().c_str());
+    
+  _client->setRxTimeout(0);
+  _client->onError(NULL, NULL);
+  _client->onAck([](void *r, AsyncClient* c, size_t len, uint32_t time){ (void)c; ((AsyncEventSourceClient*)(r))->_onAck(len, time); }, this);
+  _client->onPoll([](void *r, AsyncClient* c){ (void)c; ((AsyncEventSourceClient*)(r))->_onPoll(); }, this);
+  _client->onData(NULL, NULL);
+  _client->onTimeout([this](void *r, AsyncClient* c __attribute__((unused)), uint32_t time){ ((AsyncEventSourceClient*)(r))->_onTimeout(time); }, this);
+  _client->onDisconnect([this](void *r, AsyncClient* c){ ((AsyncEventSourceClient*)(r))->_onDisconnect(); delete c; }, this);
+
+  _server->_addClient(this);
+  delete request;
+}
+
+AsyncEventSourceClient::~AsyncEventSourceClient(){
+   _messageQueue.free();
+  close();
+}
+
+void AsyncEventSourceClient::_queueMessage(AsyncEventSourceMessage *dataMessage){
+  if(dataMessage == NULL)
+    return;
+  if(!connected()){
+    delete dataMessage;
+    return;
+  }
+  if(_messageQueue.length() >= SSE_MAX_QUEUED_MESSAGES){
+      ets_printf("ERROR: Too many messages queued\n");
+      delete dataMessage;
+  } else {
+      _messageQueue.add(dataMessage);
+  }
+  if(_client->canSend())
+    _runQueue();
+}
+
+void AsyncEventSourceClient::_onAck(size_t len, uint32_t time){
+  while(len && !_messageQueue.isEmpty()){
+    len = _messageQueue.front()->ack(len, time);
+    if(_messageQueue.front()->finished())
+      _messageQueue.remove(_messageQueue.front());
+  }
+
+  _runQueue();
+}
+
+void AsyncEventSourceClient::_onPoll(){
+  if(!_messageQueue.isEmpty()){
+    _runQueue();
+  }
+}
+
+
+void AsyncEventSourceClient::_onTimeout(uint32_t time __attribute__((unused))){
+  _client->close(true);
+}
+
+void AsyncEventSourceClient::_onDisconnect(){
+  _client = NULL;
+  _server->_handleDisconnect(this);
+}
+
+void AsyncEventSourceClient::close(){
+  if(_client != NULL)
+    _client->close();
+}
+
+void AsyncEventSourceClient::write(const char * message, size_t len){
+  _queueMessage(new AsyncEventSourceMessage(message, len));
+}
+
+void AsyncEventSourceClient::send(const char *message, const char *event, uint32_t id, uint32_t reconnect){
+  String ev = generateEventMessage(message, event, id, reconnect);
+  _queueMessage(new AsyncEventSourceMessage(ev.c_str(), ev.length()));
+}
+
+void AsyncEventSourceClient::_runQueue(){
+  while(!_messageQueue.isEmpty() && _messageQueue.front()->finished()){
+    _messageQueue.remove(_messageQueue.front());
+  }
+
+  for(auto i = _messageQueue.begin(); i != _messageQueue.end(); ++i)
+  {
+    if(!(*i)->sent())
+      (*i)->send(_client);
+  }
+}
+
+
+// Handler
+
+AsyncEventSource::AsyncEventSource(const String& url)
+  : _url(url)
+  , _clients(LinkedList<AsyncEventSourceClient *>([](AsyncEventSourceClient *c){ delete c; }))
+  , _connectcb(NULL)
+{}
+
+AsyncEventSource::~AsyncEventSource(){
+  close();
+}
+
+void AsyncEventSource::onConnect(ArEventHandlerFunction cb){
+  _connectcb = cb;
+}
+
+void AsyncEventSource::_addClient(AsyncEventSourceClient * client){
+  /*char * temp = (char *)malloc(2054);
+  if(temp != NULL){
+    memset(temp+1,' ',2048);
+    temp[0] = ':';
+    temp[2049] = '\r';
+    temp[2050] = '\n';
+    temp[2051] = '\r';
+    temp[2052] = '\n';
+    temp[2053] = 0;
+    client->write((const char *)temp, 2053);
+    free(temp);
+  }*/
+  
+  _clients.add(client);
+  if(_connectcb)
+    _connectcb(client);
+}
+
+void AsyncEventSource::_handleDisconnect(AsyncEventSourceClient * client){
+  _clients.remove(client);
+}
+
+void AsyncEventSource::close(){
+  for(const auto &c: _clients){
+    if(c->connected())
+      c->close();
+  }
+}
+
+// pmb fix
+size_t AsyncEventSource::avgPacketsWaiting() const {
+  if(_clients.isEmpty())
+    return 0;
+  
+  size_t    aql=0;
+  uint32_t  nConnectedClients=0;
+  
+  for(const auto &c: _clients){
+    if(c->connected()) {
+      aql+=c->packetsWaiting();
+      ++nConnectedClients;
+    }
+  }
+//  return aql / nConnectedClients;
+  return ((aql) + (nConnectedClients/2))/(nConnectedClients); // round up
+}
+
+void AsyncEventSource::send(const char *message, const char *event, uint32_t id, uint32_t reconnect){
+
+
+  String ev = generateEventMessage(message, event, id, reconnect);
+  for(const auto &c: _clients){
+    if(c->connected()) {
+      c->write(ev.c_str(), ev.length());
+    }
+  }
+}
+
+size_t AsyncEventSource::count() const {
+  return _clients.count_if([](AsyncEventSourceClient *c){
+    return c->connected();
+  });
+}
+
+bool AsyncEventSource::canHandle(AsyncWebServerRequest *request){
+  if(request->method() != HTTP_GET || !request->url().equals(_url)) {
+    return false;
+  }
+  request->addInterestingHeader("Last-Event-ID");
+  return true;
+}
+
+void AsyncEventSource::handleRequest(AsyncWebServerRequest *request){
+  if((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+    return request->requestAuthentication();
+  request->send(new AsyncEventSourceResponse(this));
+}
+
+// Response
+
+AsyncEventSourceResponse::AsyncEventSourceResponse(AsyncEventSource *server){
+  _server = server;
+  _code = 200;
+  _contentType = "text/event-stream";
+  _sendContentLength = false;
+  addHeader("Cache-Control", "no-cache");
+  addHeader("Connection","keep-alive");
+}
+
+void AsyncEventSourceResponse::_respond(AsyncWebServerRequest *request){
+  String out = _assembleHead(request->version());
+  request->client()->write(out.c_str(), _headLength);
+  _state = RESPONSE_WAIT_ACK;
+}
+
+size_t AsyncEventSourceResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time __attribute__((unused))){
+  if(len){
+    new AsyncEventSourceClient(request, _server);
+  }
+  return 0;
+}
+

lib/ESPAsyncWebServer/src/AsyncEventSource.h

@@ -0,0 +1,133 @@
+/*
+  Asynchronous WebServer library for Espressif MCUs
+
+  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
+
+  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 ASYNCEVENTSOURCE_H_
+#define ASYNCEVENTSOURCE_H_
+
+#include <Arduino.h>
+#ifdef ESP32
+#include <AsyncTCP.h>
+#define SSE_MAX_QUEUED_MESSAGES 32
+#else
+#include <ESPAsyncTCP.h>
+#define SSE_MAX_QUEUED_MESSAGES 8
+#endif
+#include <ESPAsyncWebServer.h>
+
+#include "AsyncWebSynchronization.h"
+
+#ifdef ESP8266
+#include <Hash.h>
+#ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library
+#include <../src/Hash.h>
+#endif
+#endif
+
+#ifdef ESP32
+#define DEFAULT_MAX_SSE_CLIENTS 8
+#else
+#define DEFAULT_MAX_SSE_CLIENTS 4
+#endif
+
+class AsyncEventSource;
+class AsyncEventSourceResponse;
+class AsyncEventSourceClient;
+typedef std::function<void(AsyncEventSourceClient *client)> ArEventHandlerFunction;
+
+class AsyncEventSourceMessage {
+  private:
+    uint8_t * _data; 
+    size_t _len;
+    size_t _sent;
+    //size_t _ack;
+    size_t _acked; 
+  public:
+    AsyncEventSourceMessage(const char * data, size_t len);
+    ~AsyncEventSourceMessage();
+    size_t ack(size_t len, uint32_t time __attribute__((unused)));
+    size_t send(AsyncClient *client);
+    bool finished(){ return _acked == _len; }
+    bool sent() { return _sent == _len; }
+};
+
+class AsyncEventSourceClient {
+  private:
+    AsyncClient *_client;
+    AsyncEventSource *_server;
+    uint32_t _lastId;
+    LinkedList<AsyncEventSourceMessage *> _messageQueue;
+    void _queueMessage(AsyncEventSourceMessage *dataMessage);
+    void _runQueue();
+
+  public:
+
+    AsyncEventSourceClient(AsyncWebServerRequest *request, AsyncEventSource *server);
+    ~AsyncEventSourceClient();
+
+    AsyncClient* client(){ return _client; }
+    void close();
+    void write(const char * message, size_t len);
+    void send(const char *message, const char *event=NULL, uint32_t id=0, uint32_t reconnect=0);
+    bool connected() const { return (_client != NULL) && _client->connected(); }
+    uint32_t lastId() const { return _lastId; }
+    size_t  packetsWaiting() const { return _messageQueue.length(); }
+
+    //system callbacks (do not call)
+    void _onAck(size_t len, uint32_t time);
+    void _onPoll(); 
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+};
+
+class AsyncEventSource: public AsyncWebHandler {
+  private:
+    String _url;
+    LinkedList<AsyncEventSourceClient *> _clients;
+    ArEventHandlerFunction _connectcb;
+  public:
+    AsyncEventSource(const String& url);
+    ~AsyncEventSource();
+
+    const char * url() const { return _url.c_str(); }
+    void close();
+    void onConnect(ArEventHandlerFunction cb);
+    void send(const char *message, const char *event=NULL, uint32_t id=0, uint32_t reconnect=0);
+    size_t count() const; //number clinets connected
+    size_t  avgPacketsWaiting() const;
+
+    //system callbacks (do not call)
+    void _addClient(AsyncEventSourceClient * client);
+    void _handleDisconnect(AsyncEventSourceClient * client);
+    virtual bool canHandle(AsyncWebServerRequest *request) override final;
+    virtual void handleRequest(AsyncWebServerRequest *request) override final;
+};
+
+class AsyncEventSourceResponse: public AsyncWebServerResponse {
+  private:
+    String _content;
+    AsyncEventSource *_server;
+  public:
+    AsyncEventSourceResponse(AsyncEventSource *server);
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+
+#endif /* ASYNCEVENTSOURCE_H_ */

lib/ESPAsyncWebServer/src/AsyncJson.h

@@ -0,0 +1,252 @@
+// AsyncJson.h
+/*
+  Async Response to use with ArduinoJson and AsyncWebServer
+  Written by Andrew Melvin (SticilFace) with help from me-no-dev and BBlanchon.
+
+  Example of callback in use
+
+   server.on("/json", HTTP_ANY, [](AsyncWebServerRequest * request) {
+
+    AsyncJsonResponse * response = new AsyncJsonResponse();
+    JsonObject& root = response->getRoot();
+    root["key1"] = "key number one";
+    JsonObject& nested = root.createNestedObject("nested");
+    nested["key1"] = "key number one";
+
+    response->setLength();
+    request->send(response);
+  });
+
+  --------------------
+
+  Async Request to use with ArduinoJson and AsyncWebServer
+  Written by Arsène von Wyss (avonwyss)
+
+  Example
+
+  AsyncCallbackJsonWebHandler* handler = new AsyncCallbackJsonWebHandler("/rest/endpoint");
+  handler->onRequest([](AsyncWebServerRequest *request, JsonVariant &json) {
+    JsonObject& jsonObj = json.as<JsonObject>();
+    // ...
+  });
+  server.addHandler(handler);
+  
+*/
+#ifndef ASYNC_JSON_H_
+#define ASYNC_JSON_H_
+#include <ArduinoJson.h>
+#include <ESPAsyncWebServer.h>
+#include <Print.h>
+
+#if ARDUINOJSON_VERSION_MAJOR == 5
+  #define ARDUINOJSON_5_COMPATIBILITY
+#else
+  #define DYNAMIC_JSON_DOCUMENT_SIZE  1024
+#endif
+
+constexpr const char* JSON_MIMETYPE = "application/json";
+
+/*
+ * Json Response
+ * */
+
+class ChunkPrint : public Print {
+  private:
+    uint8_t* _destination;
+    size_t _to_skip;
+    size_t _to_write;
+    size_t _pos;
+  public:
+    ChunkPrint(uint8_t* destination, size_t from, size_t len)
+      : _destination(destination), _to_skip(from), _to_write(len), _pos{0} {}
+    virtual ~ChunkPrint(){}
+    size_t write(uint8_t c){
+      if (_to_skip > 0) {
+        _to_skip--;
+        return 1;
+      } else if (_to_write > 0) {
+        _to_write--;
+        _destination[_pos++] = c;
+        return 1;
+      }
+      return 0;
+    }
+    size_t write(const uint8_t *buffer, size_t size)
+    {
+      return this->Print::write(buffer, size);
+    }
+};
+
+class AsyncJsonResponse: public AsyncAbstractResponse {
+  protected:
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+    DynamicJsonBuffer _jsonBuffer;
+#else
+    DynamicJsonDocument _jsonBuffer;
+#endif
+
+    JsonVariant _root;
+    bool _isValid;
+
+  public:    
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+    AsyncJsonResponse(bool isArray=false): _isValid{false} {
+      _code = 200;
+      _contentType = JSON_MIMETYPE;
+      if(isArray)
+        _root = _jsonBuffer.createArray();
+      else
+        _root = _jsonBuffer.createObject();
+    }
+#else
+    AsyncJsonResponse(bool isArray=false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : _jsonBuffer(maxJsonBufferSize), _isValid{false} {
+      _code = 200;
+      _contentType = JSON_MIMETYPE;
+      if(isArray)
+        _root = _jsonBuffer.createNestedArray();
+      else
+        _root = _jsonBuffer.createNestedObject();
+    }
+#endif
+
+    ~AsyncJsonResponse() {}
+    JsonVariant & getRoot() { return _root; }
+    bool _sourceValid() const { return _isValid; }
+    size_t setLength() {
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY      
+      _contentLength = _root.measureLength();
+#else
+      _contentLength = measureJson(_root);
+#endif
+
+      if (_contentLength) { _isValid = true; }
+      return _contentLength;
+    }
+
+   size_t getSize() { return _jsonBuffer.size(); }
+
+    size_t _fillBuffer(uint8_t *data, size_t len){
+      ChunkPrint dest(data, _sentLength, len);
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY      
+      _root.printTo( dest ) ;
+#else
+      serializeJson(_root, dest);
+#endif
+      return len;
+    }
+};
+
+class PrettyAsyncJsonResponse: public AsyncJsonResponse {	
+public:
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+	PrettyAsyncJsonResponse (bool isArray=false) : AsyncJsonResponse{isArray} {}
+#else
+	PrettyAsyncJsonResponse (bool isArray=false, size_t maxJsonBufferSize = DYNAMIC_JSON_DOCUMENT_SIZE) : AsyncJsonResponse{isArray, maxJsonBufferSize} {}
+#endif
+	size_t setLength () {
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+		_contentLength = _root.measurePrettyLength ();
+#else
+		_contentLength = measureJsonPretty(_root);
+#endif
+		if (_contentLength) {_isValid = true;}
+		return _contentLength;
+	}
+	size_t _fillBuffer (uint8_t *data, size_t len) {
+		ChunkPrint dest (data, _sentLength, len);
+#ifdef ARDUINOJSON_5_COMPATIBILITY
+		_root.prettyPrintTo (dest);
+#else
+		serializeJsonPretty(_root, dest);
+#endif
+		return len;
+	}
+};
+
+typedef std::function<void(AsyncWebServerRequest *request, JsonVariant &json)> ArJsonRequestHandlerFunction;
+
+class AsyncCallbackJsonWebHandler: public AsyncWebHandler {
+private:
+protected:
+  const String _uri;
+  WebRequestMethodComposite _method;
+  ArJsonRequestHandlerFunction _onRequest;
+  size_t _contentLength;
+#ifndef ARDUINOJSON_5_COMPATIBILITY   
+  const size_t maxJsonBufferSize;
+#endif
+  size_t _maxContentLength;
+public:
+#ifdef ARDUINOJSON_5_COMPATIBILITY      
+  AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest) 
+  : _uri(uri), _method(HTTP_POST|HTTP_PUT|HTTP_PATCH), _onRequest(onRequest), _maxContentLength(16384) {}
+#else
+  AsyncCallbackJsonWebHandler(const String& uri, ArJsonRequestHandlerFunction onRequest, size_t maxJsonBufferSize=DYNAMIC_JSON_DOCUMENT_SIZE) 
+  : _uri(uri), _method(HTTP_POST|HTTP_PUT|HTTP_PATCH), _onRequest(onRequest), maxJsonBufferSize(maxJsonBufferSize), _maxContentLength(16384) {}
+#endif
+  
+  void setMethod(WebRequestMethodComposite method){ _method = method; }
+  void setMaxContentLength(int maxContentLength){ _maxContentLength = maxContentLength; }
+  void onRequest(ArJsonRequestHandlerFunction fn){ _onRequest = fn; }
+
+  virtual bool canHandle(AsyncWebServerRequest *request) override final{
+    if(!_onRequest)
+      return false;
+
+    if(!(_method & request->method()))
+      return false;
+
+    if(_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri+"/")))
+      return false;
+
+    if ( !request->contentType().equalsIgnoreCase(JSON_MIMETYPE) )
+      return false;
+
+    request->addInterestingHeader("ANY");
+    return true;
+  }
+
+  virtual void handleRequest(AsyncWebServerRequest *request) override final {
+    if(_onRequest) {
+      if (request->_tempObject != NULL) {
+
+#ifdef ARDUINOJSON_5_COMPATIBILITY    
+        DynamicJsonBuffer jsonBuffer;
+        JsonVariant json = jsonBuffer.parse((uint8_t*)(request->_tempObject));
+        if (json.success()) {
+#else
+        DynamicJsonDocument jsonBuffer(this->maxJsonBufferSize);
+        DeserializationError error = deserializeJson(jsonBuffer, (uint8_t*)(request->_tempObject));
+        if(!error) {
+          JsonVariant json = jsonBuffer.as<JsonVariant>();
+#endif
+
+          _onRequest(request, json);
+          return;
+        }
+      }
+      request->send(_contentLength > _maxContentLength ? 413 : 400);
+    } else {
+      request->send(500);
+    }
+  }
+  virtual void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final) override final {
+  }
+  virtual void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final {
+    if (_onRequest) {
+      _contentLength = total;
+      if (total > 0 && request->_tempObject == NULL && total < _maxContentLength) {
+        request->_tempObject = malloc(total);
+      }
+      if (request->_tempObject != NULL) {
+        memcpy((uint8_t*)(request->_tempObject) + index, data, len);
+      }
+    }
+  }
+  virtual bool isRequestHandlerTrivial() override final {return _onRequest ? false : true;}
+};
+#endif

lib/ESPAsyncWebServer/src/AsyncWebSocket.h

@@ -0,0 +1,350 @@
+/*
+  Asynchronous WebServer 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 ASYNCWEBSOCKET_H_
+#define ASYNCWEBSOCKET_H_
+
+#include <Arduino.h>
+#ifdef ESP32
+#include <AsyncTCP.h>
+#define WS_MAX_QUEUED_MESSAGES 32
+#else
+#include <ESPAsyncTCP.h>
+#define WS_MAX_QUEUED_MESSAGES 8
+#endif
+#include <ESPAsyncWebServer.h>
+
+#include "AsyncWebSynchronization.h"
+
+#ifdef ESP8266
+#include <Hash.h>
+#ifdef CRYPTO_HASH_h // include Hash.h from espressif framework if the first include was from the crypto library
+#include <../src/Hash.h>
+#endif
+#endif
+
+#ifdef ESP32
+#define DEFAULT_MAX_WS_CLIENTS 8
+#else
+#define DEFAULT_MAX_WS_CLIENTS 4
+#endif
+
+class AsyncWebSocket;
+class AsyncWebSocketResponse;
+class AsyncWebSocketClient;
+class AsyncWebSocketControl;
+
+typedef struct {
+    /** Message type as defined by enum AwsFrameType.
+     * Note: Applications will only see WS_TEXT and WS_BINARY.
+     * All other types are handled by the library. */
+    uint8_t message_opcode;
+    /** Frame number of a fragmented message. */
+    uint32_t num;
+    /** Is this the last frame in a fragmented message ?*/
+    uint8_t final;
+    /** Is this frame masked? */
+    uint8_t masked;
+    /** Message type as defined by enum AwsFrameType.
+     * This value is the same as message_opcode for non-fragmented
+     * messages, but may also be WS_CONTINUATION in a fragmented message. */
+    uint8_t opcode;
+    /** Length of the current frame.
+     * This equals the total length of the message if num == 0 && final == true */
+    uint64_t len;
+    /** Mask key */
+    uint8_t mask[4];
+    /** Offset of the data inside the current frame. */
+    uint64_t index;
+} AwsFrameInfo;
+
+typedef enum { WS_DISCONNECTED, WS_CONNECTED, WS_DISCONNECTING } AwsClientStatus;
+typedef enum { WS_CONTINUATION, WS_TEXT, WS_BINARY, WS_DISCONNECT = 0x08, WS_PING, WS_PONG } AwsFrameType;
+typedef enum { WS_MSG_SENDING, WS_MSG_SENT, WS_MSG_ERROR } AwsMessageStatus;
+typedef enum { WS_EVT_CONNECT, WS_EVT_DISCONNECT, WS_EVT_PONG, WS_EVT_ERROR, WS_EVT_DATA } AwsEventType;
+
+class AsyncWebSocketMessageBuffer {
+  private:
+    uint8_t * _data;
+    size_t _len;
+    bool _lock; 
+    uint32_t _count;  
+
+  public:
+    AsyncWebSocketMessageBuffer();
+    AsyncWebSocketMessageBuffer(size_t size);
+    AsyncWebSocketMessageBuffer(uint8_t * data, size_t size); 
+    AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer &); 
+    AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer &&); 
+    ~AsyncWebSocketMessageBuffer(); 
+    void operator ++(int i) { (void)i; _count++; }
+    void operator --(int i) { (void)i; if (_count > 0) { _count--; } ;  }
+    bool reserve(size_t size);
+    void lock() { _lock = true; }
+    void unlock() { _lock = false; }
+    uint8_t * get() { return _data; }
+    size_t length() { return _len; }
+    uint32_t count() { return _count; }
+    bool canDelete() { return (!_count && !_lock); } 
+
+    friend AsyncWebSocket; 
+
+};
+
+class AsyncWebSocketMessage {
+  protected:
+    uint8_t _opcode;
+    bool _mask;
+    AwsMessageStatus _status;
+  public:
+    AsyncWebSocketMessage():_opcode(WS_TEXT),_mask(false),_status(WS_MSG_ERROR){}
+    virtual ~AsyncWebSocketMessage(){}
+    virtual void ack(size_t len __attribute__((unused)), uint32_t time __attribute__((unused))){}
+    virtual size_t send(AsyncClient *client __attribute__((unused))){ return 0; }
+    virtual bool finished(){ return _status != WS_MSG_SENDING; }
+    virtual bool betweenFrames() const { return false; }
+};
+
+class AsyncWebSocketBasicMessage: public AsyncWebSocketMessage {
+  private:
+    size_t _len;
+    size_t _sent;
+    size_t _ack;
+    size_t _acked;
+    uint8_t * _data;
+public:
+    AsyncWebSocketBasicMessage(const char * data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
+    AsyncWebSocketBasicMessage(uint8_t opcode=WS_TEXT, bool mask=false);
+    virtual ~AsyncWebSocketBasicMessage() override;
+    virtual bool betweenFrames() const override { return _acked == _ack; }
+    virtual void ack(size_t len, uint32_t time) override ;
+    virtual size_t send(AsyncClient *client) override ;
+};
+
+class AsyncWebSocketMultiMessage: public AsyncWebSocketMessage {
+  private:
+    uint8_t * _data;
+    size_t _len;
+    size_t _sent;
+    size_t _ack;
+    size_t _acked;
+    AsyncWebSocketMessageBuffer * _WSbuffer; 
+public:
+    AsyncWebSocketMultiMessage(AsyncWebSocketMessageBuffer * buffer, uint8_t opcode=WS_TEXT, bool mask=false); 
+    virtual ~AsyncWebSocketMultiMessage() override;
+    virtual bool betweenFrames() const override { return _acked == _ack; }
+    virtual void ack(size_t len, uint32_t time) override ;
+    virtual size_t send(AsyncClient *client) override ;
+};
+
+class AsyncWebSocketClient {
+  private:
+    AsyncClient *_client;
+    AsyncWebSocket *_server;
+    uint32_t _clientId;
+    AwsClientStatus _status;
+
+    LinkedList<AsyncWebSocketControl *> _controlQueue;
+    LinkedList<AsyncWebSocketMessage *> _messageQueue;
+
+    uint8_t _pstate;
+    AwsFrameInfo _pinfo;
+
+    uint32_t _lastMessageTime;
+    uint32_t _keepAlivePeriod;
+
+    void _queueMessage(AsyncWebSocketMessage *dataMessage);
+    void _queueControl(AsyncWebSocketControl *controlMessage);
+    void _runQueue();
+
+  public:
+    void *_tempObject;
+
+    AsyncWebSocketClient(AsyncWebServerRequest *request, AsyncWebSocket *server);
+    ~AsyncWebSocketClient();
+
+    //client id increments for the given server
+    uint32_t id(){ return _clientId; }
+    AwsClientStatus status(){ return _status; }
+    AsyncClient* client(){ return _client; }
+    AsyncWebSocket *server(){ return _server; }
+    AwsFrameInfo const &pinfo() const { return _pinfo; }
+
+    IPAddress remoteIP();
+    uint16_t  remotePort();
+
+    //control frames
+    void close(uint16_t code=0, const char * message=NULL);
+    void ping(uint8_t *data=NULL, size_t len=0);
+
+    //set auto-ping period in seconds. disabled if zero (default)
+    void keepAlivePeriod(uint16_t seconds){
+      _keepAlivePeriod = seconds * 1000;
+    }
+    uint16_t keepAlivePeriod(){
+      return (uint16_t)(_keepAlivePeriod / 1000);
+    }
+
+    //data packets
+    void message(AsyncWebSocketMessage *message){ _queueMessage(message); }
+    bool queueIsFull();
+
+    size_t printf(const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
+#ifndef ESP32
+    size_t printf_P(PGM_P formatP, ...)  __attribute__ ((format (printf, 2, 3)));
+#endif
+    void text(const char * message, size_t len);
+    void text(const char * message);
+    void text(uint8_t * message, size_t len);
+    void text(char * message);
+    void text(const String &message);
+    void text(const __FlashStringHelper *data);
+    void text(AsyncWebSocketMessageBuffer *buffer); 
+
+    void binary(const char * message, size_t len);
+    void binary(const char * message);
+    void binary(uint8_t * message, size_t len);
+    void binary(char * message);
+    void binary(const String &message);
+    void binary(const __FlashStringHelper *data, size_t len);
+    void binary(AsyncWebSocketMessageBuffer *buffer); 
+
+    bool canSend() { return _messageQueue.length() < WS_MAX_QUEUED_MESSAGES; }
+
+    //system callbacks (do not call)
+    void _onAck(size_t len, uint32_t time);
+    void _onError(int8_t);
+    void _onPoll();
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+    void _onData(void *pbuf, size_t plen);
+};
+
+typedef std::function<void(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len)> AwsEventHandler;
+
+//WebServer Handler implementation that plays the role of a socket server
+class AsyncWebSocket: public AsyncWebHandler {
+  public:
+    typedef LinkedList<AsyncWebSocketClient *> AsyncWebSocketClientLinkedList;
+  private:
+    String _url;
+    AsyncWebSocketClientLinkedList _clients;
+    uint32_t _cNextId;
+    AwsEventHandler _eventHandler;
+    bool _enabled;
+    AsyncWebLock _lock;
+
+  public:
+    AsyncWebSocket(const String& url);
+    ~AsyncWebSocket();
+    const char * url() const { return _url.c_str(); }
+    void enable(bool e){ _enabled = e; }
+    bool enabled() const { return _enabled; }
+    bool availableForWriteAll();
+    bool availableForWrite(uint32_t id);
+
+    size_t count() const;
+    AsyncWebSocketClient * client(uint32_t id);
+    bool hasClient(uint32_t id){ return client(id) != NULL; }
+
+    void close(uint32_t id, uint16_t code=0, const char * message=NULL);
+    void closeAll(uint16_t code=0, const char * message=NULL);
+    void cleanupClients(uint16_t maxClients = DEFAULT_MAX_WS_CLIENTS);
+
+    void ping(uint32_t id, uint8_t *data=NULL, size_t len=0);
+    void pingAll(uint8_t *data=NULL, size_t len=0); //  done
+
+    void text(uint32_t id, const char * message, size_t len);
+    void text(uint32_t id, const char * message);
+    void text(uint32_t id, uint8_t * message, size_t len);
+    void text(uint32_t id, char * message);
+    void text(uint32_t id, const String &message);
+    void text(uint32_t id, const __FlashStringHelper *message);
+
+    void textAll(const char * message, size_t len);
+    void textAll(const char * message);
+    void textAll(uint8_t * message, size_t len);
+    void textAll(char * message);
+    void textAll(const String &message);
+    void textAll(const __FlashStringHelper *message); //  need to convert
+    void textAll(AsyncWebSocketMessageBuffer * buffer); 
+
+    void binary(uint32_t id, const char * message, size_t len);
+    void binary(uint32_t id, const char * message);
+    void binary(uint32_t id, uint8_t * message, size_t len);
+    void binary(uint32_t id, char * message);
+    void binary(uint32_t id, const String &message);
+    void binary(uint32_t id, const __FlashStringHelper *message, size_t len);
+
+    void binaryAll(const char * message, size_t len);
+    void binaryAll(const char * message);
+    void binaryAll(uint8_t * message, size_t len);
+    void binaryAll(char * message);
+    void binaryAll(const String &message);
+    void binaryAll(const __FlashStringHelper *message, size_t len);
+    void binaryAll(AsyncWebSocketMessageBuffer * buffer); 
+
+    void message(uint32_t id, AsyncWebSocketMessage *message);
+    void messageAll(AsyncWebSocketMultiMessage *message);
+
+    size_t printf(uint32_t id, const char *format, ...)  __attribute__ ((format (printf, 3, 4)));
+    size_t printfAll(const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
+#ifndef ESP32
+    size_t printf_P(uint32_t id, PGM_P formatP, ...)  __attribute__ ((format (printf, 3, 4)));
+#endif
+    size_t printfAll_P(PGM_P formatP, ...)  __attribute__ ((format (printf, 2, 3)));
+
+    //event listener
+    void onEvent(AwsEventHandler handler){
+      _eventHandler = handler;
+    }
+
+    //system callbacks (do not call)
+    uint32_t _getNextId(){ return _cNextId++; }
+    void _addClient(AsyncWebSocketClient * client);
+    void _handleDisconnect(AsyncWebSocketClient * client);
+    void _handleEvent(AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len);
+    virtual bool canHandle(AsyncWebServerRequest *request) override final;
+    virtual void handleRequest(AsyncWebServerRequest *request) override final;
+
+
+    //  messagebuffer functions/objects. 
+    AsyncWebSocketMessageBuffer * makeBuffer(size_t size = 0); 
+    AsyncWebSocketMessageBuffer * makeBuffer(uint8_t * data, size_t size); 
+    LinkedList<AsyncWebSocketMessageBuffer *> _buffers;
+    void _cleanBuffers(); 
+
+    AsyncWebSocketClientLinkedList getClients() const;
+};
+
+//WebServer response to authenticate the socket and detach the tcp client from the web server request
+class AsyncWebSocketResponse: public AsyncWebServerResponse {
+  private:
+    String _content;
+    AsyncWebSocket *_server;
+  public:
+    AsyncWebSocketResponse(const String& key, AsyncWebSocket *server);
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+
+#endif /* ASYNCWEBSOCKET_H_ */

lib/ESPAsyncWebServer/src/AsyncWebSynchronization.h

@@ -0,0 +1,87 @@
+#ifndef ASYNCWEBSYNCHRONIZATION_H_
+#define ASYNCWEBSYNCHRONIZATION_H_
+
+// Synchronisation is only available on ESP32, as the ESP8266 isn't using FreeRTOS by default
+
+#include <ESPAsyncWebServer.h>
+
+#ifdef ESP32
+
+// This is the ESP32 version of the Sync Lock, using the FreeRTOS Semaphore
+class AsyncWebLock
+{
+private:
+  SemaphoreHandle_t _lock;
+  mutable void *_lockedBy;
+
+public:
+  AsyncWebLock() {
+    _lock = xSemaphoreCreateBinary();
+    _lockedBy = NULL;
+    xSemaphoreGive(_lock);
+  }
+
+  ~AsyncWebLock() {
+    vSemaphoreDelete(_lock);
+  }
+
+  bool lock() const {
+    extern void *pxCurrentTCB;
+    if (_lockedBy != pxCurrentTCB) {
+      xSemaphoreTake(_lock, portMAX_DELAY);
+      _lockedBy = pxCurrentTCB;
+      return true;
+    }
+    return false;
+  }
+
+  void unlock() const {
+    _lockedBy = NULL;
+    xSemaphoreGive(_lock);
+  }
+};
+
+#else
+
+// This is the 8266 version of the Sync Lock which is currently unimplemented
+class AsyncWebLock
+{
+
+public:
+  AsyncWebLock() {
+  }
+
+  ~AsyncWebLock() {
+  }
+
+  bool lock() const {
+    return false;
+  }
+
+  void unlock() const {
+  }
+};
+#endif
+
+class AsyncWebLockGuard
+{
+private:
+  const AsyncWebLock *_lock;
+
+public:
+  AsyncWebLockGuard(const AsyncWebLock &l) {
+    if (l.lock()) {
+      _lock = &l;
+    } else {
+      _lock = NULL;
+    }
+  }
+
+  ~AsyncWebLockGuard() {
+    if (_lock) {
+      _lock->unlock();
+    }
+  }
+};
+
+#endif // ASYNCWEBSYNCHRONIZATION_H_

lib/ESPAsyncWebServer/src/ESPAsyncWebServer.h

@@ -0,0 +1,501 @@
+/*
+  Asynchronous WebServer 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 _ESPAsyncWebServer_H_
+#define _ESPAsyncWebServer_H_
+
+#include <functional>
+
+#include "Arduino.h"
+#include "FS.h"
+#include "StringArray.h"
+
+#ifdef ESP32
+#include <AsyncTCP.h>
+#include <WiFi.h>
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#else
+#error Platform not supported
+#endif
+
+#ifdef ASYNCWEBSERVER_REGEX
+#define ASYNCWEBSERVER_REGEX_ATTRIBUTE
+#else
+#define ASYNCWEBSERVER_REGEX_ATTRIBUTE __attribute__((warning("ASYNCWEBSERVER_REGEX not defined")))
+#endif
+
+#define DEBUGF(...)  //Serial.printf(__VA_ARGS__)
+
+class AsyncWebServer;
+class AsyncWebServerRequest;
+class AsyncWebServerResponse;
+class AsyncWebHeader;
+class AsyncWebParameter;
+class AsyncWebRewrite;
+class AsyncWebHandler;
+class AsyncStaticWebHandler;
+class AsyncCallbackWebHandler;
+class AsyncResponseStream;
+
+#ifdef ESP32
+#ifdef WEBSERVER_H
+#define HTTP_ENUM
+#endif
+#elif defined(ESP8266)
+#ifdef ESP8266WEBSERVER_H
+#define HTTP_ENUM
+#endif
+#endif
+
+#ifndef HTTP_ENUM
+typedef enum { HTTP_GET = 0b00000001,
+               HTTP_POST = 0b00000010,
+               HTTP_DELETE = 0b00000100,
+               HTTP_PUT = 0b00001000,
+               HTTP_PATCH = 0b00010000,
+               HTTP_HEAD = 0b00100000,
+               HTTP_OPTIONS = 0b01000000,
+               HTTP_ANY = 0b01111111,
+} WebRequestMethod;
+#endif
+
+//if this value is returned when asked for data, packet will not be sent and you will be asked for data again
+#define RESPONSE_TRY_AGAIN 0xFFFFFFFF
+
+typedef uint8_t WebRequestMethodComposite;
+typedef std::function<void(void)> ArDisconnectHandler;
+
+/*
+ * PARAMETER :: Chainable object to hold GET/POST and FILE parameters
+ * */
+
+class AsyncWebParameter {
+   private:
+    String _name;
+    String _value;
+    size_t _size;
+    bool _isForm;
+    bool _isFile;
+
+   public:
+    AsyncWebParameter(const String& name, const String& value, bool form = false, bool file = false, size_t size = 0) : _name(name), _value(value), _size(size), _isForm(form), _isFile(file) {}
+    const String& name() const { return _name; }
+    const String& value() const { return _value; }
+    size_t size() const { return _size; }
+    bool isPost() const { return _isForm; }
+    bool isFile() const { return _isFile; }
+};
+
+/*
+ * HEADER :: Chainable object to hold the headers
+ * */
+
+class AsyncWebHeader {
+   private:
+    String _name;
+    String _value;
+
+   public:
+    AsyncWebHeader(const String& name, const String& value) : _name(name), _value(value) {}
+    AsyncWebHeader(const String& data) : _name(), _value() {
+        if (!data) return;
+        int index = data.indexOf(':');
+        if (index < 0) return;
+        _name = data.substring(0, index);
+        _value = data.substring(index + 2);
+    }
+    ~AsyncWebHeader() {}
+    const String& name() const { return _name; }
+    const String& value() const { return _value; }
+    String toString() const { return String(_name + ": " + _value + "\r\n"); }
+};
+
+/*
+ * REQUEST :: Each incoming Client is wrapped inside a Request and both live together until disconnect
+ * */
+
+typedef enum { RCT_NOT_USED = -1,
+               RCT_DEFAULT = 0,
+               RCT_HTTP,
+               RCT_WS,
+               RCT_EVENT,
+               RCT_MAX } RequestedConnectionType;
+
+typedef std::function<size_t(uint8_t*, size_t, size_t)> AwsResponseFiller;
+typedef std::function<String(const String&)> AwsTemplateProcessor;
+
+class AsyncWebServerRequest {
+    using File = fs::File;
+    using FS = fs::FS;
+    friend class AsyncWebServer;
+    friend class AsyncCallbackWebHandler;
+
+   private:
+    AsyncClient* _client;
+    AsyncWebServer* _server;
+    AsyncWebHandler* _handler;
+    AsyncWebServerResponse* _response;
+    StringArray _interestingHeaders;
+    ArDisconnectHandler _onDisconnectfn;
+
+    String _temp;
+    uint8_t _parseState;
+
+    uint8_t _version;
+    WebRequestMethodComposite _method;
+    String _url;
+    String _host;
+    String _contentType;
+    String _boundary;
+    String _authorization;
+    RequestedConnectionType _reqconntype;
+    void _removeNotInterestingHeaders();
+    bool _isDigest;
+    bool _isMultipart;
+    bool _isPlainPost;
+    bool _expectingContinue;
+    size_t _contentLength;
+    size_t _parsedLength;
+
+    LinkedList<AsyncWebHeader*> _headers;
+    LinkedList<AsyncWebParameter*> _params;
+    LinkedList<String*> _pathParams;
+
+    uint8_t _multiParseState;
+    uint8_t _boundaryPosition;
+    size_t _itemStartIndex;
+    size_t _itemSize;
+    String _itemName;
+    String _itemFilename;
+    String _itemType;
+    String _itemValue;
+    uint8_t* _itemBuffer;
+    size_t _itemBufferIndex;
+    bool _itemIsFile;
+
+    void _onPoll();
+    void _onAck(size_t len, uint32_t time);
+    void _onError(int8_t error);
+    void _onTimeout(uint32_t time);
+    void _onDisconnect();
+    void _onData(void* buf, size_t len);
+
+    void _addParam(AsyncWebParameter*);
+    void _addPathParam(const char* param);
+
+    bool _parseReqHead();
+    bool _parseReqHeader();
+    void _parseLine();
+    void _parsePlainPostChar(uint8_t data);
+    void _parseMultipartPostByte(uint8_t data, bool last);
+    void _addGetParams(const String& params);
+
+    void _handleUploadStart();
+    void _handleUploadByte(uint8_t data, bool last);
+    void _handleUploadEnd();
+
+   public:
+    File _tempFile;
+    void* _tempObject;
+
+    AsyncWebServerRequest(AsyncWebServer*, AsyncClient*);
+    ~AsyncWebServerRequest();
+
+    AsyncClient* client() { return _client; }
+    uint8_t version() const { return _version; }
+    WebRequestMethodComposite method() const { return _method; }
+    const String& url() const { return _url; }
+    const String& host() const { return _host; }
+    const String& contentType() const { return _contentType; }
+    size_t contentLength() const { return _contentLength; }
+    bool multipart() const { return _isMultipart; }
+    const char* methodToString() const;
+    const char* requestedConnTypeToString() const;
+    RequestedConnectionType requestedConnType() const { return _reqconntype; }
+    bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED);
+    void onDisconnect(ArDisconnectHandler fn);
+
+    //hash is the string representation of:
+    // base64(user:pass) for basic or
+    // user:realm:md5(user:realm:pass) for digest
+    bool authenticate(const char* hash);
+    bool authenticate(const char* username, const char* password, const char* realm = NULL, bool passwordIsHash = false);
+    void requestAuthentication(const char* realm = NULL, bool isDigest = true);
+
+    void setHandler(AsyncWebHandler* handler) { _handler = handler; }
+    void addInterestingHeader(const String& name);
+
+    void redirect(const String& url);
+
+    void send(AsyncWebServerResponse* response);
+    void send(int code, const String& contentType = String(), const String& content = String());
+    void send(FS& fs, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    void send(File content, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    void send(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr);
+    void send(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    void sendChunked(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    void send_P(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr);
+    void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr);
+
+    AsyncWebServerResponse* beginResponse(int code, const String& contentType = String(), const String& content = String());
+    AsyncWebServerResponse* beginResponse(FS& fs, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(File content, const String& path, const String& contentType = String(), bool download = false, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncWebServerResponse* beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr);
+    AsyncResponseStream* beginResponseStream(const String& contentType, size_t bufferSize = 1460);
+    AsyncWebServerResponse* beginResponse_P(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr);
+    AsyncWebServerResponse* beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback = nullptr);
+
+    size_t headers() const;                                 // get header count
+    bool hasHeader(const String& name) const;               // check if header exists
+    bool hasHeader(const __FlashStringHelper* data) const;  // check if header exists
+
+    AsyncWebHeader* getHeader(const String& name) const;
+    AsyncWebHeader* getHeader(const __FlashStringHelper* data) const;
+    AsyncWebHeader* getHeader(size_t num) const;
+
+    size_t params() const;  // get arguments count
+    bool hasParam(const String& name, bool post = false, bool file = false) const;
+    bool hasParam(const __FlashStringHelper* data, bool post = false, bool file = false) const;
+
+    AsyncWebParameter* getParam(const String& name, bool post = false, bool file = false) const;
+    AsyncWebParameter* getParam(const __FlashStringHelper* data, bool post, bool file) const;
+    AsyncWebParameter* getParam(size_t num) const;
+
+    size_t args() const { return params(); }                   // get arguments count
+    const String& arg(const String& name) const;               // get request argument value by name
+    const String& arg(const __FlashStringHelper* data) const;  // get request argument value by F(name)
+    const String& arg(size_t i) const;                         // get request argument value by number
+    const String& argName(size_t i) const;                     // get request argument name by number
+    bool hasArg(const char* name) const;                       // check if argument exists
+    bool hasArg(const __FlashStringHelper* data) const;        // check if F(argument) exists
+
+    const String& ASYNCWEBSERVER_REGEX_ATTRIBUTE pathArg(size_t i) const;
+
+    const String& header(const char* name) const;                 // get request header value by name
+    const String& header(const __FlashStringHelper* data) const;  // get request header value by F(name)
+    const String& header(size_t i) const;                         // get request header value by number
+    const String& headerName(size_t i) const;                     // get request header name by number
+    String urlDecode(const String& text) const;
+};
+
+/*
+ * FILTER :: Callback to filter AsyncWebRewrite and AsyncWebHandler (done by the Server)
+ * */
+
+typedef std::function<bool(AsyncWebServerRequest* request)> ArRequestFilterFunction;
+
+bool ON_STA_FILTER(AsyncWebServerRequest* request);
+
+bool ON_AP_FILTER(AsyncWebServerRequest* request);
+
+/*
+ * REWRITE :: One instance can be handle any Request (done by the Server)
+ * */
+
+class AsyncWebRewrite {
+   protected:
+    String _from;
+    String _toUrl;
+    String _params;
+    ArRequestFilterFunction _filter;
+
+   public:
+    AsyncWebRewrite(const char* from, const char* to) : _from(from), _toUrl(to), _params(String()), _filter(NULL) {
+        int index = _toUrl.indexOf('?');
+        if (index > 0) {
+            _params = _toUrl.substring(index + 1);
+            _toUrl = _toUrl.substring(0, index);
+        }
+    }
+    virtual ~AsyncWebRewrite() {}
+    AsyncWebRewrite& setFilter(ArRequestFilterFunction fn) {
+        _filter = fn;
+        return *this;
+    }
+    bool filter(AsyncWebServerRequest* request) const { return _filter == NULL || _filter(request); }
+    const String& from(void) const { return _from; }
+    const String& toUrl(void) const { return _toUrl; }
+    const String& params(void) const { return _params; }
+    virtual bool match(AsyncWebServerRequest* request) { return from() == request->url() && filter(request); }
+};
+
+/*
+ * HANDLER :: One instance can be attached to any Request (done by the Server)
+ * */
+
+class AsyncWebHandler {
+   protected:
+    ArRequestFilterFunction _filter;
+    String _username;
+    String _password;
+
+   public:
+    AsyncWebHandler() : _username(""), _password("") {}
+    AsyncWebHandler& setFilter(ArRequestFilterFunction fn) {
+        _filter = fn;
+        return *this;
+    }
+    AsyncWebHandler& setAuthentication(const char* username, const char* password) {
+        _username = String(username);
+        _password = String(password);
+        return *this;
+    };
+    bool filter(AsyncWebServerRequest* request) { return _filter == NULL || _filter(request); }
+    virtual ~AsyncWebHandler() {}
+    virtual bool canHandle(AsyncWebServerRequest* request __attribute__((unused))) {
+        return false;
+    }
+    virtual void handleRequest(AsyncWebServerRequest* request __attribute__((unused))) {}
+    virtual void handleUpload(AsyncWebServerRequest* request __attribute__((unused)), const String& filename __attribute__((unused)), size_t index __attribute__((unused)), uint8_t* data __attribute__((unused)), size_t len __attribute__((unused)), bool final __attribute__((unused))) {}
+    virtual void handleBody(AsyncWebServerRequest* request __attribute__((unused)), uint8_t* data __attribute__((unused)), size_t len __attribute__((unused)), size_t index __attribute__((unused)), size_t total __attribute__((unused))) {}
+    virtual bool isRequestHandlerTrivial() { return true; }
+};
+
+/*
+ * RESPONSE :: One instance is created for each Request (attached by the Handler)
+ * */
+
+typedef enum {
+    RESPONSE_SETUP,
+    RESPONSE_HEADERS,
+    RESPONSE_CONTENT,
+    RESPONSE_WAIT_ACK,
+    RESPONSE_END,
+    RESPONSE_FAILED
+} WebResponseState;
+
+class AsyncWebServerResponse {
+   protected:
+    int _code;
+    LinkedList<AsyncWebHeader*> _headers;
+    String _contentType;
+    size_t _contentLength;
+    bool _sendContentLength;
+    bool _chunked;
+    size_t _headLength;
+    size_t _sentLength;
+    size_t _ackedLength;
+    size_t _writtenLength;
+    WebResponseState _state;
+    const char* _responseCodeToString(int code);
+
+   public:
+    AsyncWebServerResponse();
+    virtual ~AsyncWebServerResponse();
+    virtual void setCode(int code);
+    virtual void setContentLength(size_t len);
+    virtual void setContentType(const String& type);
+    virtual void addHeader(const String& name, const String& value);
+    virtual String _assembleHead(uint8_t version);
+    virtual bool _started() const;
+    virtual bool _finished() const;
+    virtual bool _failed() const;
+    virtual bool _sourceValid() const;
+    virtual void _respond(AsyncWebServerRequest* request);
+    virtual size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time);
+};
+
+/*
+ * SERVER :: One instance
+ * */
+
+typedef std::function<void(AsyncWebServerRequest* request)> ArRequestHandlerFunction;
+typedef std::function<void(AsyncWebServerRequest* request, const String& filename, size_t index, uint8_t* data, size_t len, bool final)> ArUploadHandlerFunction;
+typedef std::function<void(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total)> ArBodyHandlerFunction;
+
+class AsyncWebServer {
+   protected:
+    AsyncServer _server;
+    LinkedList<AsyncWebRewrite*> _rewrites;
+    LinkedList<AsyncWebHandler*> _handlers;
+    AsyncCallbackWebHandler* _catchAllHandler;
+
+   public:
+    AsyncWebServer(uint16_t port);
+    ~AsyncWebServer();
+
+    void begin();
+    void end();
+
+#if ASYNC_TCP_SSL_ENABLED
+    void onSslFileRequest(AcSSlFileHandler cb, void* arg);
+    void beginSecure(const char* cert, const char* private_key_file, const char* password);
+#endif
+
+    AsyncWebRewrite& addRewrite(AsyncWebRewrite* rewrite);
+    bool removeRewrite(AsyncWebRewrite* rewrite);
+    AsyncWebRewrite& rewrite(const char* from, const char* to);
+
+    AsyncWebHandler& addHandler(AsyncWebHandler* handler);
+    bool removeHandler(AsyncWebHandler* handler);
+
+    AsyncCallbackWebHandler& on(const char* uri, ArRequestHandlerFunction onRequest);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload);
+    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody);
+
+    AsyncStaticWebHandler& serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control = NULL);
+
+    void onNotFound(ArRequestHandlerFunction fn);   //called when handler is not assigned
+    void onFileUpload(ArUploadHandlerFunction fn);  //handle file uploads
+    void onRequestBody(ArBodyHandlerFunction fn);   //handle posts with plain body content (JSON often transmitted this way as a request)
+
+    void reset();  //remove all writers and handlers, with onNotFound/onFileUpload/onRequestBody
+
+    void _handleDisconnect(AsyncWebServerRequest* request);
+    void _attachHandler(AsyncWebServerRequest* request);
+    void _rewriteRequest(AsyncWebServerRequest* request);
+};
+
+class DefaultHeaders {
+    using headers_t = LinkedList<AsyncWebHeader*>;
+    headers_t _headers;
+
+    DefaultHeaders()
+        : _headers(headers_t([](AsyncWebHeader* h) { delete h; })) {}
+
+   public:
+    using ConstIterator = headers_t::ConstIterator;
+
+    void addHeader(const String& name, const String& value) {
+        _headers.add(new AsyncWebHeader(name, value));
+    }
+
+    ConstIterator begin() const { return _headers.begin(); }
+    ConstIterator end() const { return _headers.end(); }
+
+    DefaultHeaders(DefaultHeaders const&) = delete;
+    DefaultHeaders& operator=(DefaultHeaders const&) = delete;
+    static DefaultHeaders& Instance() {
+        static DefaultHeaders instance;
+        return instance;
+    }
+};
+
+#include "AsyncEventSource.h"
+#include "AsyncWebSocket.h"
+#include "WebHandlerImpl.h"
+#include "WebResponseImpl.h"
+
+#endif /* _AsyncWebServer_H_ */

lib/ESPAsyncWebServer/src/SPIFFSEditor.cpp

@@ -0,0 +1,544 @@
+#include "SPIFFSEditor.h"
+#include <FS.h>
+
+//File: edit.htm.gz, Size: 4151
+#define edit_htm_gz_len 4151
+const uint8_t edit_htm_gz[] PROGMEM = {
+ 0x1F, 0x8B, 0x08, 0x08, 0xB8, 0x94, 0xB1, 0x59, 0x00, 0x03, 0x65, 0x64, 0x69, 0x74, 0x2E, 0x68,
+ 0x74, 0x6D, 0x00, 0xB5, 0x3A, 0x0B, 0x7B, 0xDA, 0xB8, 0xB2, 0x7F, 0xC5, 0x71, 0xCF, 0x66, 0xED,
+ 0x83, 0x31, 0x90, 0xA4, 0xD9, 0xD6, 0xC4, 0xC9, 0x42, 0x92, 0x36, 0x6D, 0xF3, 0x6A, 0x80, 0xB6,
+ 0x69, 0x4F, 0xEE, 0x7E, 0xC2, 0x16, 0xA0, 0xC6, 0x96, 0x5D, 0x5B, 0x0E, 0x49, 0x59, 0xFE, 0xFB,
+ 0x9D, 0x91, 0x6C, 0xB0, 0x09, 0x69, 0x77, 0xCF, 0xBD, 0xBB, 0xDD, 0x2D, 0x92, 0x46, 0x33, 0x9A,
+ 0x19, 0xCD, 0x53, 0xDE, 0xBD, 0x8D, 0xA3, 0x8B, 0xC3, 0xFE, 0xF5, 0xE5, 0xB1, 0x36, 0x11, 0x61,
+ 0xB0, 0xBF, 0x87, 0x7F, 0x6B, 0x01, 0xE1, 0x63, 0x97, 0xF2, 0xFD, 0x3D, 0xC1, 0x44, 0x40, 0xF7,
+ 0x8F, 0x7B, 0x97, 0xDA, 0xB1, 0xCF, 0x44, 0x94, 0xEC, 0x35, 0xD4, 0xCA, 0x5E, 0x2A, 0x1E, 0x02,
+ 0xAA, 0x85, 0xD4, 0x67, 0xC4, 0x4D, 0xBD, 0x84, 0xC2, 0x66, 0xDB, 0x0B, 0x67, 0xDF, 0xEB, 0x8C,
+ 0xFB, 0xF4, 0xDE, 0xD9, 0x6E, 0x36, 0xDB, 0x71, 0x94, 0x32, 0xC1, 0x22, 0xEE, 0x90, 0x61, 0x1A,
+ 0x05, 0x99, 0xA0, 0xED, 0x80, 0x8E, 0x84, 0xF3, 0x3C, 0xBE, 0x6F, 0x0F, 0xA3, 0xC4, 0xA7, 0x89,
+ 0xD3, 0x8A, 0xEF, 0x35, 0x00, 0x31, 0x5F, 0x7B, 0xB6, 0xB3, 0xB3, 0xD3, 0x1E, 0x12, 0xEF, 0x76,
+ 0x9C, 0x44, 0x19, 0xF7, 0xEB, 0x5E, 0x14, 0x44, 0x89, 0xF3, 0x6C, 0xF4, 0x1C, 0xFF, 0xB4, 0x7D,
+ 0x96, 0xC6, 0x01, 0x79, 0x70, 0x78, 0xC4, 0x29, 0xE0, 0xDE, 0xD7, 0xD3, 0x09, 0xF1, 0xA3, 0xA9,
+ 0xD3, 0xD4, 0x9A, 0x5A, 0xAB, 0x09, 0x44, 0x92, 0xF1, 0x90, 0x18, 0x4D, 0x0B, 0xFF, 0xD8, 0x3B,
+ 0x66, 0x7B, 0x14, 0x71, 0x51, 0x4F, 0xD9, 0x77, 0xEA, 0xB4, 0xB6, 0xE0, 0x34, 0x39, 0x1D, 0x91,
+ 0x90, 0x05, 0x0F, 0x4E, 0x4A, 0x78, 0x5A, 0x4F, 0x69, 0xC2, 0x46, 0x6A, 0x79, 0x4A, 0xD9, 0x78,
+ 0x22, 0x9C, 0xDF, 0x9A, 0xCD, 0x39, 0xF0, 0xAF, 0x65, 0xC1, 0x2C, 0x60, 0x29, 0x20, 0xA3, 0x78,
+ 0xEA, 0x3C, 0x11, 0xC5, 0x4E, 0x53, 0xB1, 0xDE, 0x6C, 0x87, 0x24, 0x19, 0x33, 0x0E, 0x83, 0x98,
+ 0xF8, 0x3E, 0xE3, 0x63, 0x47, 0xA1, 0x05, 0x6C, 0xB6, 0x90, 0x36, 0xA1, 0x01, 0x11, 0xEC, 0x8E,
+ 0xB6, 0x43, 0xC6, 0xEB, 0x53, 0xE6, 0x8B, 0x89, 0xB3, 0x0B, 0x3C, 0xB6, 0xBD, 0x2C, 0x49, 0x41,
+ 0xA6, 0x38, 0x62, 0x5C, 0xD0, 0x44, 0xA2, 0xA5, 0x31, 0xE1, 0xB3, 0x5C, 0x54, 0x54, 0x40, 0x21,
+ 0x27, 0xE3, 0x01, 0xE3, 0xB4, 0x3E, 0x0C, 0x22, 0xEF, 0x76, 0x71, 0xD2, 0x6E, 0x7C, 0x9F, 0x9F,
+ 0xE5, 0x4C, 0xA2, 0x3B, 0x9A, 0xCC, 0x96, 0xEA, 0x92, 0xD8, 0x15, 0x60, 0x85, 0x34, 0xA5, 0x74,
+ 0x6E, 0x8B, 0xBB, 0x0C, 0xA0, 0x96, 0xFC, 0x05, 0x29, 0x17, 0xFC, 0x2F, 0x45, 0x5A, 0x11, 0x5C,
+ 0xA1, 0x30, 0x1E, 0x67, 0x62, 0xF6, 0xF8, 0x2A, 0xA3, 0x98, 0x78, 0x4C, 0x3C, 0xA0, 0xFC, 0xB0,
+ 0x6D, 0x86, 0xBA, 0x04, 0xAC, 0x24, 0x24, 0x81, 0x86, 0x3A, 0xD7, 0x3E, 0xD0, 0xC4, 0x27, 0x9C,
+ 0x58, 0x9D, 0x84, 0x91, 0xC0, 0xEA, 0x2D, 0xB5, 0x5E, 0x0F, 0xA3, 0xEF, 0xF5, 0x0C, 0xC6, 0x30,
+ 0x0F, 0xA8, 0x27, 0x94, 0x92, 0xE1, 0x1E, 0x86, 0xB7, 0x4C, 0x3C, 0x06, 0x3C, 0x5A, 0x28, 0xA9,
+ 0x4B, 0x2A, 0x69, 0xA2, 0x2E, 0xB0, 0x25, 0xD5, 0x83, 0x1C, 0x4B, 0xC9, 0x95, 0x50, 0xF5, 0x61,
+ 0x24, 0x44, 0x14, 0x4A, 0x93, 0x5B, 0x08, 0xAC, 0x49, 0xAB, 0x79, 0xF1, 0xE8, 0x46, 0xD6, 0x6B,
+ 0xBF, 0x44, 0xBE, 0x0D, 0x7A, 0x15, 0xCC, 0x23, 0x41, 0x9D, 0x04, 0x6C, 0xCC, 0x9D, 0x90, 0xF9,
+ 0x7E, 0x40, 0x4B, 0x56, 0xEB, 0x64, 0x49, 0x60, 0xF8, 0x44, 0x10, 0x87, 0x85, 0x64, 0x4C, 0x1B,
+ 0x31, 0x1F, 0x03, 0x34, 0xA5, 0xBB, 0x3B, 0x16, 0xFB, 0xD0, 0xBD, 0xB8, 0x9A, 0x36, 0xDF, 0xBD,
+ 0x1E, 0x47, 0x1D, 0xF8, 0xE7, 0xBC, 0x37, 0x98, 0x1C, 0x0F, 0xC6, 0x30, 0xEA, 0xE2, 0xB4, 0xF3,
+ 0xFE, 0xB0, 0xF3, 0x1E, 0x7E, 0x0E, 0x5B, 0xB5, 0xAF, 0xA3, 0x6F, 0xB8, 0xD0, 0x7D, 0xED, 0x77,
+ 0xFB, 0x83, 0xE3, 0x4E, 0xE7, 0x5D, 0xE3, 0xCD, 0xF9, 0xF4, 0xE3, 0xBB, 0x5D, 0x04, 0x77, 0x83,
+ 0xE6, 0xD5, 0x87, 0x49, 0x73, 0xB0, 0xF5, 0x32, 0xF4, 0x4F, 0xFC, 0x89, 0x17, 0x0E, 0x3A, 0xEF,
+ 0x3F, 0x5E, 0xDD, 0x5D, 0x87, 0x83, 0x71, 0xEF, 0x63, 0x6B, 0xF2, 0x79, 0xEB, 0x43, 0xEF, 0xF3,
+ 0xC7, 0x57, 0xB7, 0xF4, 0xD3, 0xC9, 0xDB, 0xCF, 0xFD, 0x29, 0x20, 0x1C, 0x45, 0xBD, 0xC1, 0x55,
+ 0xF7, 0x43, 0x77, 0xFC, 0xB9, 0xEB, 0x1D, 0xDF, 0x0F, 0x83, 0xF3, 0xEE, 0xEB, 0xCE, 0xB0, 0xB3,
+ 0xE5, 0x51, 0x3A, 0xEE, 0x5F, 0x75, 0xB3, 0x37, 0xEF, 0x2E, 0xC6, 0x8C, 0x4D, 0x7A, 0x9F, 0xCF,
+ 0xFB, 0xDE, 0xE1, 0xF3, 0xD3, 0xC1, 0x49, 0x87, 0x4D, 0xCE, 0xDF, 0x5E, 0x35, 0x6F, 0x5F, 0xBF,
+ 0x3B, 0x3C, 0xF2, 0xAE, 0xDF, 0x5E, 0xEF, 0x1E, 0x6D, 0x37, 0x7E, 0xFB, 0xED, 0xCC, 0xBF, 0x60,
+ 0xBC, 0x7F, 0xF7, 0xBD, 0x33, 0x3E, 0x9C, 0xBE, 0x78, 0x48, 0xFB, 0x93, 0x37, 0x77, 0xBC, 0xF1,
+ 0x21, 0xFA, 0xFA, 0xE6, 0xE1, 0x0C, 0xFE, 0xBB, 0xBC, 0xAC, 0x0D, 0x7B, 0xAD, 0x74, 0xF0, 0xFE,
+ 0xCD, 0x87, 0xAD, 0xF4, 0xE5, 0xF3, 0xB8, 0x7B, 0x74, 0x74, 0x17, 0x0E, 0x2F, 0x1B, 0xA1, 0x7F,
+ 0x3B, 0x12, 0x2F, 0xB6, 0x45, 0x7C, 0x3D, 0xCE, 0x3E, 0x7F, 0x7B, 0xFE, 0x76, 0xD2, 0xB8, 0xA0,
+ 0xE4, 0x7A, 0x52, 0x7B, 0xF8, 0xFE, 0xF0, 0x62, 0xD2, 0x3F, 0xB9, 0x3B, 0x0F, 0xC8, 0xFD, 0xF9,
+ 0xB9, 0xF7, 0x3D, 0xAC, 0x05, 0xE4, 0xE5, 0x45, 0x3F, 0x20, 0x49, 0x6B, 0xE0, 0x77, 0x1A, 0xB5,
+ 0xC3, 0xAD, 0xCE, 0x8E, 0x48, 0xAE, 0x0E, 0xF9, 0xD1, 0xF6, 0xD7, 0xDE, 0x8B, 0x6E, 0xB7, 0x15,
+ 0x0D, 0xBF, 0x6D, 0xBD, 0xBE, 0xDD, 0x7D, 0x3D, 0xD8, 0x7D, 0x3F, 0x7C, 0xDF, 0xE9, 0xED, 0x74,
+ 0x07, 0xE4, 0xBA, 0xF7, 0xBE, 0x33, 0xDA, 0x19, 0x4E, 0x26, 0xEF, 0xDE, 0xF5, 0x5F, 0xF9, 0x9D,
+ 0xEF, 0x49, 0xE7, 0x62, 0xDA, 0xB9, 0x3F, 0x1E, 0x74, 0x4E, 0x6A, 0xEF, 0x8E, 0xCF, 0x9A, 0xAD,
+ 0xDE, 0xF5, 0xF6, 0xF8, 0x6C, 0x77, 0xDA, 0x4D, 0x8F, 0x3B, 0xEF, 0xBB, 0xCD, 0xF1, 0xDB, 0x5A,
+ 0x48, 0x3E, 0x47, 0x87, 0xDB, 0xE3, 0x37, 0xBB, 0xEC, 0xF2, 0x9A, 0x74, 0xDE, 0x74, 0xDF, 0xA6,
+ 0xEC, 0x2A, 0x3C, 0x19, 0x34, 0x3B, 0x9D, 0xD3, 0x0B, 0xFA, 0xEA, 0x70, 0x9B, 0xBC, 0xDB, 0xF2,
+ 0x3E, 0x82, 0xFE, 0x07, 0x9F, 0xE8, 0x6F, 0xB5, 0xCE, 0xF4, 0xA2, 0x19, 0x78, 0x2F, 0x69, 0xFF,
+ 0xE4, 0xBA, 0x2F, 0x6F, 0xE7, 0x38, 0x78, 0xD5, 0xBF, 0xED, 0x65, 0xEF, 0xC3, 0xC3, 0x43, 0x53,
+ 0xE3, 0x51, 0x3D, 0xA1, 0x31, 0x25, 0xA2, 0x1C, 0xAE, 0x16, 0xFE, 0x01, 0xB6, 0xB5, 0xB4, 0xC2,
+ 0xDC, 0x4F, 0x05, 0xBD, 0x17, 0x75, 0x9F, 0x7A, 0x51, 0x42, 0xE4, 0x1E, 0x40, 0xA0, 0x09, 0x9A,
+ 0xD8, 0xFC, 0x77, 0x19, 0x3F, 0x35, 0x15, 0x3F, 0x35, 0xC2, 0x7D, 0xCD, 0x28, 0x1C, 0x01, 0x83,
+ 0x87, 0x4F, 0xEF, 0x98, 0x47, 0xEB, 0x31, 0xBB, 0xA7, 0x41, 0x5D, 0x22, 0x3B, 0x4D, 0x73, 0x26,
+ 0xFD, 0xAD, 0xD8, 0x46, 0x38, 0x98, 0x9A, 0xA4, 0x5A, 0x2C, 0xF8, 0x5F, 0x89, 0x47, 0x21, 0xB0,
+ 0x81, 0xCB, 0x84, 0xF8, 0xAB, 0x7C, 0x27, 0x4A, 0xEA, 0xC3, 0x6C, 0x3C, 0x62, 0xF7, 0xE0, 0xD0,
+ 0x23, 0xC6, 0x99, 0xA0, 0x5A, 0x2B, 0x9D, 0xFF, 0x5E, 0x90, 0xB9, 0xA5, 0x0F, 0xA3, 0x84, 0x84,
+ 0x34, 0xD5, 0xFE, 0x22, 0x99, 0xD9, 0x28, 0x89, 0xC2, 0x65, 0x10, 0x99, 0x8B, 0xA8, 0x34, 0x99,
+ 0xCF, 0x9F, 0x65, 0x71, 0x10, 0x11, 0x10, 0x73, 0x4D, 0xE4, 0x50, 0xF1, 0x34, 0x91, 0x6E, 0xB5,
+ 0x88, 0xAB, 0xB9, 0x9B, 0x6D, 0xA1, 0x5B, 0x96, 0xDD, 0x7A, 0x6B, 0x67, 0xE9, 0xBA, 0x75, 0xB9,
+ 0x17, 0xE3, 0xFD, 0x9A, 0x4C, 0x81, 0xF1, 0xA0, 0x14, 0xEE, 0x9E, 0x09, 0x50, 0xE9, 0x13, 0x87,
+ 0xCB, 0x43, 0xF2, 0xC8, 0xB0, 0x60, 0x40, 0x05, 0xEA, 0x96, 0x8C, 0xD4, 0x85, 0x24, 0xB0, 0x6F,
+ 0xFE, 0x8C, 0xCA, 0xBC, 0x67, 0x3D, 0x8B, 0x13, 0xB8, 0x0D, 0x3A, 0xFD, 0x11, 0xCD, 0x42, 0xA6,
+ 0x2A, 0x6D, 0x45, 0x53, 0x65, 0xBC, 0x5C, 0x84, 0x65, 0xDA, 0x93, 0xBC, 0x16, 0xA4, 0x1F, 0x4B,
+ 0x05, 0xE0, 0x05, 0x37, 0xCF, 0x91, 0x9B, 0x1F, 0x6A, 0x75, 0x7B, 0xF7, 0x97, 0x9C, 0x87, 0x9D,
+ 0xE6, 0x2F, 0x73, 0x3B, 0xDF, 0x5B, 0xA4, 0xE4, 0x56, 0x13, 0xFE, 0x29, 0x32, 0xEF, 0x8B, 0x25,
+ 0x0B, 0xC3, 0xE7, 0xF8, 0xA7, 0x60, 0x10, 0xE9, 0x94, 0x80, 0xDB, 0x3B, 0x2F, 0x5F, 0xF8, 0xC3,
+ 0x02, 0x98, 0x0B, 0xF6, 0x24, 0x3C, 0x21, 0x3E, 0xCB, 0x52, 0xE7, 0x79, 0xF3, 0x97, 0x5C, 0x9F,
+ 0x5B, 0x3B, 0x28, 0xFB, 0xE2, 0x2E, 0x71, 0xB2, 0xB4, 0xD8, 0x34, 0x66, 0x5C, 0xDB, 0x4A, 0x35,
+ 0xBC, 0x6F, 0x92, 0x2C, 0x0C, 0xB3, 0x92, 0xED, 0xE7, 0xBF, 0x2F, 0x4D, 0x13, 0xF7, 0xCF, 0x9A,
+ 0xBF, 0xCC, 0x44, 0x02, 0xD9, 0x64, 0x04, 0xB9, 0xC6, 0x49, 0x22, 0x41, 0x04, 0x35, 0x9A, 0xE6,
+ 0x1C, 0x84, 0x5B, 0x03, 0xD8, 0xDE, 0x6D, 0xFA, 0x74, 0x6C, 0xCE, 0xE7, 0x7B, 0x0D, 0x99, 0xD7,
+ 0xA0, 0x6C, 0xF1, 0x12, 0x16, 0x8B, 0xFD, 0x51, 0xC6, 0x3D, 0xE4, 0x41, 0x1B, 0x53, 0x83, 0x9A,
+ 0xB3, 0x84, 0x8A, 0x2C, 0xE1, 0x9A, 0x1F, 0x79, 0x19, 0x1A, 0xBB, 0x3D, 0xA6, 0xE2, 0x58, 0xD9,
+ 0x7D, 0xF7, 0xE1, 0x8D, 0x0F, 0x3B, 0xE6, 0x0B, 0x04, 0x6F, 0x2D, 0x02, 0x38, 0x30, 0x9C, 0x97,
+ 0xE3, 0x54, 0xF6, 0x43, 0x82, 0x01, 0x22, 0xEF, 0xE8, 0x83, 0x41, 0x2D, 0xB1, 0x40, 0xA4, 0x36,
+ 0xAE, 0x1B, 0xC5, 0x2E, 0x80, 0x71, 0x73, 0x76, 0x07, 0x4A, 0x20, 0x2E, 0xFD, 0x22, 0x6E, 0x2C,
+ 0xE6, 0x72, 0xF8, 0x69, 0xE7, 0xBB, 0xC9, 0x1E, 0x3B, 0xA8, 0xB7, 0x1C, 0xB2, 0xCF, 0x0E, 0x5A,
+ 0xE0, 0x5E, 0x65, 0x6E, 0xE4, 0xB9, 0xAF, 0x58, 0x40, 0x07, 0xB9, 0xC3, 0xE1, 0x31, 0x48, 0x6C,
+ 0xB1, 0x85, 0x28, 0xE2, 0x5B, 0xCD, 0xE6, 0x86, 0x4B, 0x0F, 0x48, 0x00, 0x39, 0xCC, 0xD0, 0x8F,
+ 0xAF, 0xAE, 0x2E, 0xAE, 0xBE, 0xE8, 0x35, 0x5A, 0xD3, 0x6F, 0x1C, 0x4D, 0xAF, 0x71, 0xD3, 0x11,
+ 0x76, 0x42, 0x47, 0x09, 0x4D, 0x27, 0x97, 0x44, 0x4C, 0x8C, 0xD4, 0xBE, 0x23, 0x41, 0x56, 0x16,
+ 0x84, 0xA1, 0xDC, 0xC8, 0xA2, 0x70, 0x39, 0x9D, 0x6A, 0xAF, 0x40, 0xCD, 0x47, 0x90, 0xEA, 0xDA,
+ 0xC2, 0x26, 0x71, 0x4C, 0xB9, 0x6F, 0xE8, 0x31, 0x20, 0xEA, 0x16, 0x35, 0xAD, 0x84, 0x7E, 0xCB,
+ 0x68, 0x2A, 0x52, 0x1B, 0x2C, 0xD7, 0xD0, 0x2F, 0x07, 0x7D, 0xDD, 0xD2, 0x1B, 0xE8, 0x47, 0x3A,
+ 0xF0, 0x46, 0xCC, 0x39, 0x52, 0x89, 0x5C, 0xD0, 0xA4, 0x3E, 0xCC, 0xC0, 0xA0, 0xB8, 0x6E, 0xB6,
+ 0x23, 0x9B, 0x71, 0x4E, 0x93, 0x93, 0xFE, 0xD9, 0xA9, 0xAB, 0x5F, 0x29, 0x46, 0xB4, 0x53, 0x28,
+ 0x48, 0x74, 0x4B, 0x5E, 0x51, 0x7E, 0xC8, 0xE1, 0x84, 0x05, 0xBE, 0x11, 0x99, 0x6D, 0x24, 0xE1,
+ 0x49, 0x12, 0xB2, 0x40, 0x01, 0x0A, 0x9E, 0x2D, 0x1E, 0x62, 0xEA, 0xEA, 0x23, 0x50, 0x86, 0x6E,
+ 0x79, 0x76, 0x98, 0x05, 0x82, 0xC5, 0x01, 0x75, 0x37, 0x5A, 0x30, 0xE3, 0x60, 0x41, 0xAE, 0x8E,
+ 0xB9, 0x19, 0x61, 0xCC, 0x77, 0x75, 0x15, 0xA1, 0xF2, 0xB8, 0xB6, 0xEE, 0x14, 0x4F, 0x9D, 0x92,
+ 0x56, 0x4E, 0x49, 0xCB, 0xB8, 0x4A, 0xE0, 0x34, 0x3F, 0x18, 0xC3, 0x3C, 0xCE, 0xD4, 0x51, 0x05,
+ 0xCC, 0xA7, 0x23, 0x02, 0x9C, 0x7C, 0x40, 0x6D, 0xBA, 0x7A, 0x63, 0xDD, 0x41, 0xA9, 0x3A, 0xC8,
+ 0xAF, 0x6A, 0xC4, 0x2F, 0x6B, 0x44, 0xDD, 0xEE, 0x3A, 0x64, 0x5F, 0x21, 0x07, 0x55, 0xE4, 0xA0,
+ 0x8C, 0x7C, 0x28, 0x8D, 0x64, 0x1D, 0x72, 0xA0, 0x90, 0x93, 0x8A, 0x88, 0x89, 0x14, 0x51, 0x85,
+ 0xBD, 0x3A, 0x6A, 0x13, 0x05, 0xD2, 0xAD, 0xA4, 0x22, 0x66, 0x62, 0x83, 0x97, 0x92, 0x61, 0x40,
+ 0x7D, 0x77, 0xA3, 0x09, 0x33, 0x2C, 0xB6, 0xDD, 0xAD, 0xE6, 0x9A, 0x33, 0x12, 0x75, 0x46, 0x56,
+ 0x65, 0x30, 0x2B, 0x33, 0xA8, 0xF5, 0xC8, 0x1D, 0xD5, 0xD6, 0x31, 0x98, 0x99, 0x56, 0x60, 0x47,
+ 0xDC, 0x0B, 0x98, 0x77, 0xEB, 0x2E, 0xBD, 0xC5, 0x9C, 0xB1, 0x85, 0x85, 0x5A, 0x5C, 0x06, 0xBA,
+ 0x01, 0x94, 0x5E, 0x8B, 0xA5, 0x7C, 0x80, 0xFA, 0x9E, 0x5B, 0xD9, 0x5A, 0x02, 0xDC, 0xA6, 0xF7,
+ 0xD4, 0x3B, 0x8C, 0xC2, 0x90, 0xA0, 0xED, 0xA6, 0xC0, 0x41, 0x3E, 0xD1, 0xCD, 0xB9, 0x15, 0xAD,
+ 0xC5, 0x79, 0xC2, 0x45, 0x2C, 0x7F, 0x3D, 0x8B, 0x23, 0x03, 0x5C, 0xCE, 0xF5, 0x6C, 0xD4, 0x61,
+ 0x6A, 0x83, 0x1E, 0xC7, 0x62, 0xF2, 0x13, 0x17, 0x2A, 0x0C, 0x54, 0xA2, 0x7C, 0x69, 0xDE, 0x58,
+ 0x0B, 0x91, 0x56, 0x7C, 0xEA, 0xA2, 0xB7, 0xE2, 0x54, 0xA8, 0xBC, 0x8A, 0x5D, 0x9A, 0x4B, 0x1D,
+ 0x94, 0x61, 0xB9, 0xBD, 0x2F, 0xA0, 0xFA, 0x7C, 0x0E, 0xE7, 0x01, 0xFF, 0x13, 0x68, 0xF9, 0xE8,
+ 0x5F, 0x17, 0x60, 0xC9, 0xA3, 0x34, 0x78, 0x8B, 0xBB, 0x0D, 0xE3, 0xC0, 0xF9, 0x8F, 0x6D, 0x7C,
+ 0xF9, 0x1F, 0xFB, 0xA6, 0x66, 0x9A, 0x07, 0xFF, 0x6A, 0x48, 0x0D, 0x1B, 0xC2, 0xFC, 0xD2, 0xBA,
+ 0xB1, 0x08, 0x80, 0xED, 0x7F, 0x9B, 0xFF, 0xB1, 0x25, 0xB8, 0x02, 0x6B, 0xDF, 0x45, 0x90, 0x49,
+ 0xF0, 0x24, 0x34, 0xB0, 0x68, 0xA4, 0x91, 0xCD, 0x4D, 0x43, 0xB8, 0xA4, 0x72, 0x8D, 0x35, 0x51,
+ 0xD3, 0x6D, 0x88, 0x53, 0x50, 0x5B, 0xAC, 0x04, 0xBF, 0x3E, 0x24, 0x7A, 0x15, 0x5B, 0x17, 0x00,
+ 0xC9, 0x3D, 0xCA, 0x0C, 0x3D, 0x22, 0x97, 0x52, 0xCB, 0x0C, 0x02, 0x42, 0xA7, 0x89, 0xE7, 0x2A,
+ 0xAD, 0x1D, 0x14, 0x30, 0x17, 0xA2, 0xE0, 0xBC, 0x1C, 0x2D, 0x15, 0xEA, 0xAA, 0xFD, 0x17, 0x0A,
+ 0xA3, 0xD6, 0x12, 0x8A, 0x04, 0x31, 0xAD, 0xD8, 0x79, 0xC6, 0x72, 0x75, 0x4C, 0x59, 0xBA, 0x35,
+ 0x59, 0x5D, 0x96, 0xAD, 0x04, 0xAE, 0x2F, 0x8D, 0xFE, 0xD7, 0x3D, 0x16, 0x8E, 0xB5, 0x12, 0x3F,
+ 0xF8, 0x97, 0xFB, 0x2B, 0x46, 0xE4, 0xCD, 0x3F, 0xBC, 0x21, 0x70, 0x05, 0xA6, 0x41, 0x6D, 0x1E,
+ 0x4D, 0x0D, 0xB3, 0xF6, 0xAB, 0xAE, 0x49, 0x8A, 0xAE, 0x1E, 0x92, 0xFB, 0xBC, 0xA7, 0xC4, 0x8C,
+ 0xD7, 0xD6, 0x70, 0x5E, 0xB4, 0x28, 0xF9, 0x82, 0xEC, 0xE6, 0x48, 0x26, 0xA2, 0xB6, 0x56, 0x64,
+ 0x52, 0xD5, 0xCA, 0xE8, 0x5A, 0x63, 0xFF, 0xD7, 0x4A, 0x40, 0xB7, 0x98, 0xBA, 0x4E, 0x15, 0x8C,
+ 0xB3, 0x00, 0x1C, 0x93, 0x3E, 0x1D, 0x69, 0x03, 0x26, 0x03, 0x75, 0x35, 0x46, 0x5A, 0x81, 0xC1,
+ 0xCC, 0x03, 0xC3, 0x2B, 0xFB, 0xF3, 0x1E, 0x16, 0xBF, 0xFB, 0x97, 0xAA, 0xAA, 0x81, 0xD4, 0x8B,
+ 0x33, 0x5D, 0x59, 0x59, 0xD5, 0x4B, 0xE0, 0xD2, 0x08, 0xA0, 0x5B, 0x8B, 0x3C, 0x3A, 0x8C, 0xFC,
+ 0x87, 0x52, 0xF6, 0x4D, 0xBB, 0x0F, 0x87, 0x01, 0x49, 0xD3, 0x73, 0xB8, 0x01, 0x43, 0xF7, 0x42,
+ 0x50, 0xB8, 0xB2, 0xC2, 0xFD, 0xE6, 0xE6, 0x66, 0x15, 0x29, 0xA1, 0x21, 0x14, 0xDB, 0x8A, 0x2B,
+ 0xF0, 0x49, 0xD3, 0xF1, 0x81, 0x30, 0x18, 0xD2, 0x1A, 0xC6, 0xF0, 0x25, 0xE3, 0x47, 0x5C, 0x71,
+ 0xF4, 0xF4, 0x22, 0xA6, 0xFC, 0x33, 0xDC, 0x95, 0x32, 0xCB, 0x1A, 0xAD, 0xA6, 0x68, 0xFA, 0x8F,
+ 0xD8, 0x3E, 0xCA, 0x0D, 0x76, 0xC1, 0x7A, 0xBA, 0x56, 0xA1, 0xFC, 0x9F, 0x61, 0xB9, 0x94, 0x28,
+ 0xD6, 0x70, 0x9C, 0x40, 0x80, 0x5A, 0xC3, 0x31, 0xC4, 0x1A, 0x41, 0x17, 0xFC, 0x26, 0x6B, 0xF9,
+ 0xCD, 0xFE, 0x19, 0x7E, 0x97, 0x76, 0x1E, 0x15, 0x25, 0x91, 0xAA, 0xAF, 0x50, 0x02, 0x9F, 0xDD,
+ 0xE9, 0xA6, 0x15, 0xB9, 0x55, 0x0A, 0x50, 0x1B, 0x46, 0x41, 0xD0, 0x8F, 0xE2, 0x83, 0x27, 0xD6,
+ 0x9D, 0xC5, 0x7A, 0x31, 0xC8, 0xD9, 0x5C, 0x6E, 0xB1, 0xBC, 0xB5, 0x44, 0x4F, 0xA1, 0xEC, 0x5F,
+ 0x4B, 0x15, 0x01, 0x3F, 0x23, 0x8B, 0x7B, 0xAC, 0xD4, 0xA5, 0x36, 0x28, 0x0F, 0x56, 0x3F, 0xD5,
+ 0x3C, 0xCB, 0x5F, 0xCC, 0xAE, 0x6B, 0x51, 0x9B, 0xC0, 0x38, 0x57, 0x92, 0x8B, 0x4A, 0xB2, 0xC8,
+ 0x13, 0x01, 0xA8, 0x58, 0xC7, 0x2E, 0xC4, 0x4D, 0x6B, 0x7A, 0x7C, 0xBF, 0x5C, 0x83, 0xC2, 0xDF,
+ 0xF5, 0xD5, 0x12, 0x33, 0x08, 0xC4, 0xD3, 0x95, 0x4B, 0x29, 0x5F, 0x37, 0x29, 0x8A, 0x0E, 0x62,
+ 0x47, 0xA3, 0x51, 0x4A, 0xC5, 0x47, 0x0C, 0x49, 0x56, 0xB2, 0x98, 0x9F, 0xC8, 0x90, 0x04, 0x8C,
+ 0x45, 0x3C, 0x8C, 0xB2, 0x94, 0x46, 0x99, 0xA8, 0xA4, 0x16, 0x63, 0x21, 0xCC, 0x5E, 0xFA, 0xE7,
+ 0x9F, 0x8B, 0xC9, 0x7E, 0x5A, 0x0B, 0x96, 0xD3, 0xEB, 0x3D, 0xBF, 0x34, 0xD9, 0xF7, 0x6B, 0x89,
+ 0xB9, 0x7A, 0xE9, 0xFF, 0x67, 0x4B, 0x21, 0x65, 0x4B, 0xF1, 0xB0, 0x54, 0x2E, 0x62, 0x62, 0x29,
+ 0xE6, 0xC9, 0x82, 0x91, 0x97, 0x7C, 0x16, 0x0D, 0x1A, 0x2B, 0x25, 0x55, 0x9E, 0x97, 0x7D, 0x95,
+ 0x43, 0x40, 0x59, 0x71, 0xE5, 0x35, 0x11, 0x06, 0x34, 0xE0, 0x63, 0x64, 0xF2, 0x41, 0xEB, 0xA7,
+ 0xD1, 0x94, 0x26, 0x87, 0x24, 0xA5, 0x06, 0x24, 0xCD, 0x65, 0xDC, 0x41, 0xA8, 0xE9, 0x04, 0xEB,
+ 0x76, 0x6D, 0x6E, 0x12, 0x05, 0xCE, 0x33, 0x77, 0xC4, 0xB1, 0x26, 0x03, 0xF9, 0xB2, 0xCA, 0x09,
+ 0xD4, 0xC6, 0xBE, 0x12, 0xA4, 0x3E, 0x52, 0x25, 0xA8, 0x61, 0x5A, 0xD0, 0x76, 0xC0, 0x35, 0x5F,
+ 0x26, 0x51, 0x4C, 0xC6, 0xB2, 0x07, 0x83, 0x35, 0x74, 0x0F, 0xA4, 0x66, 0x6D, 0x34, 0x91, 0x60,
+ 0xA9, 0x73, 0x29, 0xFC, 0x66, 0xD9, 0xC2, 0x70, 0x4B, 0x57, 0xC9, 0xB0, 0xBD, 0xF4, 0xA5, 0x35,
+ 0x59, 0x83, 0xE0, 0x0B, 0x6C, 0x62, 0xE0, 0x1E, 0x68, 0x64, 0xF2, 0x7B, 0x00, 0x77, 0x6B, 0xB6,
+ 0xA3, 0x3D, 0xD6, 0x8E, 0x6A, 0x35, 0x53, 0x55, 0xE9, 0xAE, 0x0B, 0x6D, 0x4E, 0x74, 0x23, 0x0B,
+ 0x4B, 0x10, 0xAA, 0x9A, 0x59, 0x0C, 0x38, 0x1B, 0x81, 0xAA, 0xBA, 0xC0, 0x11, 0xD6, 0x98, 0x66,
+ 0xA9, 0x23, 0xF1, 0x97, 0x1D, 0xC9, 0x13, 0xB5, 0x07, 0x95, 0xF5, 0x05, 0xD4, 0x31, 0xAB, 0x25,
+ 0x86, 0x30, 0xD3, 0x29, 0x13, 0xDE, 0x04, 0x03, 0x90, 0x07, 0x5A, 0xD5, 0x05, 0x14, 0xB5, 0x8E,
+ 0x1C, 0x4D, 0x44, 0xB8, 0x1C, 0x05, 0xF9, 0xF0, 0x6B, 0x9A, 0x0F, 0xBC, 0xB4, 0x18, 0xDD, 0x97,
+ 0x80, 0x50, 0xD2, 0xE6, 0xE0, 0x88, 0x8F, 0xF2, 0x21, 0xF4, 0xB2, 0x05, 0x9D, 0x02, 0x58, 0xFC,
+ 0xC6, 0x71, 0x3E, 0x8A, 0x27, 0xC5, 0x68, 0x42, 0xEF, 0x17, 0x78, 0x51, 0x01, 0xF5, 0xA9, 0xEE,
+ 0x28, 0x1B, 0xDB, 0x68, 0xCE, 0xF3, 0x41, 0x6B, 0x29, 0x7F, 0xF0, 0xFF, 0x28, 0x7F, 0xCC, 0xC7,
+ 0x85, 0x34, 0x71, 0x31, 0x1A, 0xB3, 0x42, 0x96, 0x61, 0x18, 0xFF, 0x90, 0x93, 0xA4, 0xD4, 0x13,
+ 0x97, 0x7A, 0x5A, 0xF1, 0xB3, 0xB6, 0x53, 0x98, 0x8E, 0x31, 0xAA, 0xF8, 0xE3, 0xC8, 0xF6, 0xF0,
+ 0xF7, 0x3C, 0xF2, 0x65, 0x6D, 0x69, 0x5A, 0xA1, 0x31, 0x82, 0x3A, 0x57, 0x37, 0xCB, 0x7E, 0x9A,
+ 0xFD, 0xB7, 0xAD, 0xE8, 0xD1, 0xF1, 0xE9, 0x71, 0xFF, 0xB8, 0x5C, 0x38, 0x23, 0xE7, 0x25, 0x93,
+ 0x8A, 0x2B, 0x5D, 0xFA, 0xB2, 0x22, 0x80, 0x02, 0x1B, 0x45, 0x01, 0x7B, 0xDD, 0xDC, 0x54, 0x7E,
+ 0xF1, 0xB6, 0x77, 0x71, 0x6E, 0xC7, 0x24, 0x01, 0x8F, 0x24, 0x15, 0xE6, 0xC2, 0x82, 0x44, 0xF9,
+ 0xE0, 0xD7, 0xC7, 0xA5, 0x72, 0x5D, 0x7E, 0x61, 0x70, 0xC4, 0xDC, 0x52, 0xA7, 0xA9, 0x7E, 0x78,
+ 0xE2, 0x62, 0x5D, 0x99, 0xBF, 0x04, 0x41, 0x72, 0x1A, 0x2D, 0x13, 0x55, 0x11, 0x67, 0x46, 0xE5,
+ 0x30, 0x2F, 0xEE, 0xB2, 0x75, 0x0D, 0xD3, 0xC8, 0xB4, 0xC4, 0x84, 0xA5, 0xE5, 0x46, 0xA5, 0x12,
+ 0x14, 0xFE, 0xA2, 0xB6, 0xE7, 0x8B, 0x91, 0x24, 0xB7, 0x5A, 0x73, 0xAB, 0x6F, 0x41, 0x2A, 0x3E,
+ 0x58, 0x04, 0x23, 0x66, 0x39, 0xDB, 0x16, 0x77, 0xA3, 0x43, 0xEE, 0x61, 0x5C, 0x7F, 0xBA, 0x35,
+ 0x78, 0xD2, 0x3C, 0x79, 0x61, 0x9E, 0xFC, 0xB1, 0x7B, 0x2E, 0x1C, 0x45, 0xF9, 0xDA, 0xE2, 0x98,
+ 0xF6, 0x10, 0x58, 0xBB, 0x6D, 0x2F, 0x7D, 0x18, 0x20, 0xD2, 0x83, 0xCB, 0x00, 0xF4, 0x63, 0x58,
+ 0xFF, 0x4A, 0xEE, 0x88, 0x7A, 0x09, 0xAA, 0xA2, 0xAD, 0x73, 0x54, 0xD8, 0xEE, 0xFD, 0x81, 0xA3,
+ 0xF2, 0xCE, 0x65, 0x18, 0x48, 0x97, 0xC3, 0x92, 0x37, 0x8B, 0x75, 0xC1, 0x61, 0x19, 0x31, 0x64,
+ 0x6C, 0x00, 0xE3, 0xCD, 0x5D, 0x49, 0x13, 0xD5, 0x1C, 0xB4, 0xF0, 0x1B, 0x08, 0x8A, 0x4F, 0x39,
+ 0xCE, 0x9A, 0x38, 0xAD, 0x62, 0x72, 0xC5, 0x23, 0xC8, 0x4A, 0x67, 0x89, 0xC0, 0x6E, 0x10, 0x0D,
+ 0x0D, 0x7C, 0x64, 0x9A, 0xA1, 0xB6, 0x1D, 0x3E, 0x37, 0xD7, 0xBC, 0xD9, 0x54, 0xFA, 0x4B, 0x62,
+ 0x79, 0xD5, 0xB0, 0x8B, 0x1C, 0x56, 0xCC, 0x75, 0x7D, 0x1F, 0xF4, 0xA3, 0x4E, 0x29, 0xAF, 0x48,
+ 0xA4, 0x53, 0xD1, 0x83, 0xC4, 0x86, 0xA2, 0x41, 0xBE, 0x91, 0x40, 0x44, 0x72, 0x4A, 0x33, 0x5D,
+ 0xC7, 0xCA, 0xD2, 0x0B, 0x28, 0x49, 0x7A, 0xB2, 0x73, 0x95, 0x49, 0x6B, 0x25, 0x06, 0xFE, 0xC8,
+ 0xD7, 0xF0, 0xC7, 0xA1, 0xD0, 0xA3, 0x83, 0x9B, 0x49, 0x2B, 0x83, 0xA4, 0x23, 0x64, 0x83, 0xA9,
+ 0x37, 0xE4, 0xBB, 0xA8, 0x2D, 0x2F, 0xCB, 0xB4, 0x16, 0x50, 0x70, 0x71, 0x83, 0xBB, 0x11, 0x30,
+ 0x52, 0x5A, 0xC4, 0x9E, 0x94, 0xA8, 0xC7, 0x8F, 0x10, 0x1F, 0x53, 0x4A, 0x20, 0x06, 0x20, 0xA6,
+ 0x40, 0xD0, 0xA7, 0x42, 0x8A, 0x54, 0xE6, 0x92, 0x53, 0x2A, 0x20, 0xCA, 0x48, 0xCD, 0xE2, 0xC1,
+ 0x85, 0x78, 0xD4, 0x46, 0xD6, 0x80, 0xFD, 0xDC, 0xBD, 0x73, 0x33, 0xDE, 0x90, 0x68, 0x09, 0x56,
+ 0x36, 0x3D, 0x9A, 0xA6, 0x52, 0x5C, 0x54, 0xC7, 0x19, 0xF8, 0xA8, 0xA1, 0x03, 0x5A, 0x23, 0x84,
+ 0x11, 0x1E, 0x84, 0x8A, 0x01, 0x40, 0x7F, 0x42, 0xC3, 0x1C, 0x22, 0x70, 0x08, 0x20, 0x82, 0xA0,
+ 0x7F, 0x49, 0x0D, 0xF7, 0x64, 0x05, 0xC9, 0xF8, 0xD8, 0x6D, 0x35, 0xF0, 0x9D, 0x66, 0x95, 0xEC,
+ 0x20, 0xA5, 0xBD, 0x68, 0x24, 0xFA, 0x64, 0x98, 0x1A, 0x50, 0x00, 0xAC, 0xD9, 0x01, 0xA0, 0x1E,
+ 0x24, 0x5E, 0x63, 0x2B, 0x3F, 0xEF, 0x04, 0x2A, 0xBB, 0x00, 0xAB, 0xBB, 0x8E, 0x87, 0x5F, 0x39,
+ 0x4F, 0x19, 0xA7, 0x39, 0x26, 0x00, 0x7B, 0x93, 0x68, 0x7A, 0x99, 0x30, 0x2E, 0xCE, 0x64, 0x1B,
+ 0x6A, 0x6C, 0xB4, 0xE4, 0xF5, 0xA9, 0x87, 0x15, 0x79, 0x3F, 0xC5, 0x8B, 0xCB, 0x0C, 0xF3, 0xBA,
+ 0x53, 0x79, 0x77, 0xB1, 0x86, 0x70, 0x21, 0x50, 0x66, 0x38, 0xB3, 0x29, 0x74, 0xB0, 0xFA, 0xA1,
+ 0x48, 0x82, 0x7A, 0x4F, 0xB7, 0x42, 0xE2, 0xC1, 0x44, 0xED, 0x81, 0xF9, 0xDC, 0xC2, 0xD8, 0xE1,
+ 0x94, 0x83, 0x5A, 0x0A, 0xB5, 0x02, 0x45, 0xC6, 0x95, 0xCD, 0x98, 0x35, 0x1D, 0x6A, 0x58, 0x88,
+ 0x61, 0xE0, 0xAF, 0xFE, 0x05, 0x0F, 0x1E, 0x1C, 0xC8, 0x55, 0x3F, 0xE1, 0x23, 0xE3, 0x7E, 0xF4,
+ 0x23, 0x3E, 0x3E, 0xAF, 0xF0, 0xF1, 0x79, 0x1D, 0x1F, 0xB4, 0xAA, 0x3C, 0x98, 0x0C, 0x80, 0xEC,
+ 0x19, 0xE1, 0x64, 0x4C, 0x13, 0x58, 0xC0, 0x43, 0x50, 0x25, 0x7F, 0x8B, 0xB3, 0x84, 0xFE, 0x98,
+ 0xB3, 0xDE, 0x84, 0x8D, 0xC4, 0x23, 0xFE, 0x8A, 0xD5, 0xFF, 0x82, 0x4B, 0x3C, 0x70, 0x3D, 0x97,
+ 0x79, 0x6D, 0x5A, 0x49, 0x28, 0x3F, 0x7E, 0x2B, 0x91, 0x7E, 0xE4, 0x42, 0x78, 0xA9, 0x38, 0xC8,
+ 0xDF, 0xB7, 0xF4, 0x00, 0xBC, 0x11, 0xF8, 0x29, 0x35, 0x75, 0xBC, 0x0B, 0xA5, 0xFC, 0x29, 0x30,
+ 0x64, 0xA8, 0xC0, 0x47, 0xDD, 0xD9, 0xDC, 0x12, 0xAE, 0x01, 0x8A, 0xF1, 0xA3, 0x29, 0xB0, 0xEA,
+ 0xC9, 0x02, 0xD7, 0x9E, 0x40, 0x26, 0x04, 0x91, 0xE0, 0x48, 0xC8, 0xA7, 0x8D, 0x2F, 0x07, 0x9B,
+ 0x37, 0x35, 0xC8, 0x43, 0x2E, 0xFC, 0x98, 0x2E, 0x0C, 0x36, 0x6F, 0xFE, 0x6D, 0x36, 0xC6, 0xCC,
+ 0x5A, 0x76, 0xA4, 0x96, 0x4C, 0xF6, 0xF4, 0x0B, 0xBF, 0x71, 0x09, 0x48, 0x5D, 0x49, 0x78, 0x45,
+ 0x34, 0x03, 0x6B, 0x43, 0x61, 0xE1, 0x07, 0xFF, 0x47, 0x09, 0xF8, 0x91, 0x9E, 0x07, 0xCE, 0xBD,
+ 0xE6, 0x3D, 0x5E, 0x2F, 0x3E, 0x85, 0xE9, 0x56, 0xE9, 0xC1, 0x4A, 0xC7, 0xEF, 0x53, 0x3A, 0x76,
+ 0x59, 0xA2, 0x14, 0x4A, 0x14, 0x59, 0x88, 0x1A, 0x6A, 0x50, 0x0E, 0x51, 0x98, 0x89, 0x17, 0xCD,
+ 0x81, 0x02, 0x9B, 0x73, 0x34, 0x5B, 0x3A, 0x02, 0x0F, 0xF4, 0xF5, 0x45, 0xEE, 0xFC, 0x74, 0x76,
+ 0x7A, 0x22, 0x44, 0x7C, 0xA5, 0x62, 0x22, 0xD0, 0xAA, 0x2E, 0x2C, 0x2F, 0xCF, 0x9C, 0x89, 0xE4,
+ 0xA1, 0x28, 0x75, 0x30, 0x31, 0x28, 0x87, 0xFE, 0x74, 0x31, 0xFC, 0x0A, 0x71, 0xD6, 0xD0, 0xCF,
+ 0x52, 0x48, 0x58, 0x5B, 0x36, 0xA2, 0xF7, 0xFB, 0x97, 0xF6, 0xAE, 0xDD, 0x84, 0xBA, 0x00, 0xB4,
+ 0x0A, 0x69, 0x19, 0xEE, 0x7D, 0xFE, 0xB7, 0x90, 0xB7, 0xFF, 0x1E, 0x32, 0x83, 0xA8, 0x95, 0x42,
+ 0x58, 0x2A, 0xF0, 0xAB, 0xB8, 0x93, 0x24, 0x9A, 0x4A, 0xB4, 0xE3, 0x24, 0xC1, 0x4B, 0xE9, 0x43,
+ 0x85, 0xA2, 0x0D, 0x61, 0x31, 0xA5, 0x89, 0xE6, 0x47, 0x34, 0xD5, 0x78, 0x24, 0xB4, 0x34, 0x8B,
+ 0x63, 0x68, 0x5C, 0x56, 0xF4, 0x61, 0xEB, 0xC5, 0xEB, 0xCB, 0xFB, 0x8C, 0x66, 0xD4, 0xCF, 0x97,
+ 0x69, 0x52, 0xD1, 0x0B, 0x56, 0x50, 0xDF, 0x10, 0xEE, 0x7E, 0xB9, 0xC9, 0xEB, 0xA9, 0x8C, 0x73,
+ 0x8C, 0xA2, 0x1B, 0x2D, 0x35, 0x07, 0xE9, 0x26, 0x40, 0xD5, 0xE5, 0x59, 0x10, 0xCC, 0xDB, 0x2B,
+ 0xB4, 0xA0, 0xF1, 0x8A, 0x44, 0x24, 0x9F, 0xCB, 0x67, 0x7F, 0xE4, 0xC9, 0xA9, 0xE2, 0x82, 0x50,
+ 0xF2, 0x54, 0xA9, 0x36, 0xAD, 0x0D, 0x63, 0x83, 0x6A, 0x8C, 0xA7, 0x82, 0x70, 0x0F, 0xAF, 0x51,
+ 0xE9, 0xC2, 0x2C, 0x6A, 0x29, 0xDC, 0xDE, 0x46, 0x5F, 0xCB, 0x6D, 0xE9, 0x89, 0x7C, 0x2A, 0x25,
+ 0xE3, 0xAE, 0xAE, 0x63, 0x55, 0x45, 0xB1, 0x3E, 0x25, 0x61, 0x5A, 0x26, 0x5B, 0x54, 0x06, 0x26,
+ 0x77, 0x0B, 0x70, 0x9B, 0x06, 0x29, 0x1C, 0xBD, 0x7E, 0x7F, 0xCE, 0x46, 0xD1, 0xCE, 0x11, 0x80,
+ 0x69, 0xC5, 0x3E, 0x93, 0xD7, 0xE0, 0x24, 0xCC, 0x73, 0x07, 0x32, 0xE9, 0x4A, 0x03, 0x0E, 0xA9,
+ 0x98, 0x44, 0xFE, 0x81, 0x7E, 0xA0, 0x3B, 0x3A, 0xFC, 0xBB, 0x09, 0x35, 0x47, 0xCD, 0xA5, 0xD0,
+ 0xA4, 0xFA, 0x74, 0x70, 0xF5, 0x06, 0xC2, 0x53, 0x0C, 0xA5, 0x01, 0x17, 0x50, 0x34, 0xD7, 0x74,
+ 0x7C, 0x7A, 0x7D, 0x0C, 0x29, 0xC8, 0x7F, 0x21, 0x37, 0x66, 0xBB, 0xAA, 0x6C, 0xB8, 0xF3, 0xEA,
+ 0x75, 0x56, 0x2E, 0x03, 0x7A, 0x61, 0x8C, 0x58, 0x0F, 0x29, 0x7E, 0xFB, 0x7B, 0xF4, 0x9E, 0x8D,
+ 0x15, 0xD2, 0x6A, 0x5D, 0x6F, 0xCE, 0x76, 0x90, 0x67, 0x89, 0xD5, 0x43, 0x2C, 0x70, 0x97, 0x1F,
+ 0x29, 0x59, 0x95, 0x35, 0xDC, 0xF6, 0x48, 0x10, 0xE0, 0xC7, 0x5A, 0x03, 0x1B, 0x6A, 0x22, 0xB2,
+ 0xD4, 0x42, 0x22, 0x29, 0x08, 0x90, 0xD2, 0x3E, 0x84, 0x39, 0xD3, 0x92, 0x65, 0x86, 0xB2, 0xA1,
+ 0xBC, 0xFF, 0xC5, 0x9A, 0xA3, 0x64, 0x46, 0xE8, 0xCE, 0xF9, 0x6C, 0x73, 0x53, 0xD8, 0x85, 0x99,
+ 0x18, 0x05, 0x52, 0x8A, 0x01, 0x1C, 0x9A, 0x7D, 0x68, 0x2D, 0x8C, 0xB2, 0x90, 0x58, 0xAB, 0x3D,
+ 0xD2, 0xB6, 0x51, 0x55, 0x03, 0x54, 0x7C, 0x46, 0x01, 0x03, 0xCE, 0xB2, 0x24, 0x80, 0xA8, 0x8B,
+ 0x39, 0xBA, 0xB2, 0x2D, 0xC5, 0xBA, 0xD0, 0x84, 0x0E, 0xEC, 0x67, 0xC8, 0x12, 0x95, 0x97, 0xAD,
+ 0xA2, 0x27, 0x12, 0xC5, 0x77, 0x95, 0x9E, 0xC8, 0x6F, 0xE5, 0x84, 0xAA, 0xC8, 0x77, 0x88, 0x2F,
+ 0x13, 0x5C, 0xD4, 0xD1, 0x13, 0xA0, 0x24, 0x83, 0x52, 0x34, 0x60, 0x2A, 0x2C, 0x37, 0xEE, 0xEB,
+ 0xD3, 0xE9, 0xB4, 0x8E, 0xDF, 0x6A, 0xEB, 0x70, 0x82, 0xB2, 0x02, 0x5F, 0x5F, 0xC7, 0x21, 0x47,
+ 0x15, 0x58, 0xF8, 0x6E, 0xE1, 0xAC, 0xBA, 0xE8, 0x42, 0x7F, 0x2B, 0xDE, 0xD4, 0xAA, 0xD2, 0x59,
+ 0xE1, 0x73, 0x79, 0xDB, 0x7B, 0x3B, 0x2B, 0x20, 0x32, 0xC4, 0xAF, 0xB2, 0x90, 0x69, 0x20, 0x0D,
+ 0x3B, 0xE5, 0x46, 0x56, 0x25, 0x85, 0x65, 0x5C, 0xB0, 0xE3, 0x2C, 0x9D, 0x18, 0x33, 0x60, 0xDD,
+ 0x11, 0x96, 0xD2, 0x95, 0x43, 0x2D, 0x65, 0xB7, 0x0E, 0xB7, 0x0A, 0xFB, 0x70, 0x30, 0x83, 0x94,
+ 0x79, 0xFB, 0xF3, 0x4F, 0x39, 0x5B, 0xDE, 0xF6, 0x92, 0x62, 0x71, 0xE1, 0xF3, 0xFC, 0xA9, 0x35,
+ 0xAF, 0x69, 0xA5, 0xD1, 0xAF, 0xC4, 0x97, 0xBD, 0x46, 0xFE, 0x19, 0x3B, 0xFF, 0x9C, 0xAD, 0x81,
+ 0xB1, 0x43, 0x23, 0x2A, 0xDC, 0x4C, 0x8C, 0xEA, 0x2F, 0x34, 0xE6, 0x63, 0x79, 0x29, 0xBF, 0x2D,
+ 0xA0, 0x54, 0xA9, 0xD3, 0x68, 0x78, 0x3E, 0xFF, 0x9A, 0x42, 0x19, 0x1D, 0x65, 0xFE, 0x28, 0x20,
+ 0x09, 0xC5, 0x82, 0xA3, 0x41, 0xBE, 0x92, 0xFB, 0x46, 0xC0, 0x86, 0x69, 0x03, 0x93, 0x6D, 0xCB,
+ 0xDE, 0xB2, 0x77, 0x71, 0x64, 0x7F, 0x4D, 0xF7, 0x57, 0x4F, 0xD8, 0x5F, 0x34, 0x69, 0x58, 0x0B,
+ 0xE7, 0xB5, 0xAB, 0x8A, 0x4D, 0x6A, 0x83, 0xFB, 0xC4, 0xA7, 0x70, 0x3D, 0x6F, 0xB3, 0xCC, 0xB6,
+ 0x1A, 0xE4, 0x5F, 0x60, 0xD4, 0x31, 0xBA, 0x95, 0x2F, 0x92, 0xF4, 0x81, 0x7B, 0x18, 0x5B, 0x17,
+ 0x54, 0x26, 0x70, 0x49, 0xD5, 0x87, 0x34, 0xB9, 0xD3, 0x9C, 0x2F, 0x39, 0xC3, 0xB7, 0x3C, 0xA8,
+ 0x03, 0xE4, 0x37, 0x9C, 0x72, 0x39, 0xB0, 0xBF, 0x07, 0x5D, 0x33, 0x2A, 0x41, 0x79, 0xB1, 0x26,
+ 0x9B, 0xE6, 0x7C, 0x02, 0x82, 0x01, 0x70, 0xB1, 0xA3, 0x48, 0xCD, 0x2B, 0xCB, 0x98, 0x9B, 0x57,
+ 0x96, 0x54, 0xE2, 0x5F, 0x59, 0xCC, 0xDB, 0x9F, 0xFC, 0xDB, 0x4C, 0xF9, 0x7F, 0x5B, 0x28, 0x36,
+ 0x32, 0xF9, 0xE1, 0x09, 0xF7, 0x56, 0x3F, 0x45, 0xAD, 0x47, 0x51, 0xBB, 0xF7, 0xFF, 0x17, 0x53,
+ 0xE8, 0x9D, 0x36, 0x92, 0x29, 0x00, 0x00
+};
+
+#define SPIFFS_MAXLENGTH_FILEPATH 32
+const char *excludeListFile = "/.exclude.files";
+
+typedef struct ExcludeListS {
+    char *item;
+    ExcludeListS *next;
+} ExcludeList;
+
+static ExcludeList *excludes = NULL;
+
+static bool matchWild(const char *pattern, const char *testee) {
+  const char *nxPat = NULL, *nxTst = NULL;
+
+  while (*testee) {
+    if (( *pattern == '?' ) || (*pattern == *testee)){
+      pattern++;testee++;
+      continue;
+    }
+    if (*pattern=='*'){
+      nxPat=pattern++; nxTst=testee;
+      continue;
+    }
+    if (nxPat){ 
+      pattern = nxPat+1; testee=++nxTst;
+      continue;
+    }
+    return false;
+  }
+  while (*pattern=='*'){pattern++;}  
+  return (*pattern == 0);
+}
+
+static bool addExclude(const char *item){
+    size_t len = strlen(item);
+    if(!len){
+        return false;
+    }
+    ExcludeList *e = (ExcludeList *)malloc(sizeof(ExcludeList));
+    if(!e){
+        return false;
+    }
+    e->item = (char *)malloc(len+1);
+    if(!e->item){
+        free(e);
+        return false;
+    }
+    memcpy(e->item, item, len+1);
+    e->next = excludes;
+    excludes = e;
+    return true;
+}
+
+static void loadExcludeList(fs::FS &_fs, const char *filename){
+    static char linebuf[SPIFFS_MAXLENGTH_FILEPATH];
+    fs::File excludeFile=_fs.open(filename, "r");
+    if(!excludeFile){
+        //addExclude("/*.js.gz");
+        return;
+    }
+#ifdef ESP32
+    if(excludeFile.isDirectory()){
+      excludeFile.close();
+      return;
+    }
+#endif
+    if (excludeFile.size() > 0){
+      uint8_t idx;
+      bool isOverflowed = false;
+      while (excludeFile.available()){
+        linebuf[0] = '\0';
+        idx = 0;
+        int lastChar;
+        do {
+          lastChar = excludeFile.read();
+          if(lastChar != '\r'){
+            linebuf[idx++] = (char) lastChar;
+          }
+        } while ((lastChar >= 0) && (lastChar != '\n') && (idx < SPIFFS_MAXLENGTH_FILEPATH));
+
+        if(isOverflowed){
+          isOverflowed = (lastChar != '\n');
+          continue;
+        }
+        isOverflowed = (idx >= SPIFFS_MAXLENGTH_FILEPATH);
+        linebuf[idx-1] = '\0';
+        if(!addExclude(linebuf)){
+            excludeFile.close();
+            return;
+        }
+      }
+    }
+    excludeFile.close();
+}
+
+static bool isExcluded(fs::FS &_fs, const char *filename) {
+  if(excludes == NULL){
+      loadExcludeList(_fs, excludeListFile);
+  }
+  ExcludeList *e = excludes;
+  while(e){
+    if (matchWild(e->item, filename)){
+      return true;
+    }
+    e = e->next;
+  }
+  return false;
+}
+
+// WEB HANDLER IMPLEMENTATION
+
+#ifdef ESP32
+SPIFFSEditor::SPIFFSEditor(const fs::FS& fs, const String& username, const String& password)
+#else
+SPIFFSEditor::SPIFFSEditor(const String& username, const String& password, const fs::FS& fs)
+#endif
+:_fs(fs)
+,_username(username)
+,_password(password)
+,_authenticated(false)
+,_startTime(0)
+{}
+
+bool SPIFFSEditor::canHandle(AsyncWebServerRequest *request){
+  if(request->url().equalsIgnoreCase("/edit")){
+    if(request->method() == HTTP_GET){
+      if(request->hasParam("list"))
+        return true;
+      if(request->hasParam("edit")){
+        request->_tempFile = _fs.open(request->arg("edit"), "r");
+        if(!request->_tempFile){
+          return false;
+        }
+#ifdef ESP32
+        if(request->_tempFile.isDirectory()){
+          request->_tempFile.close();
+          return false;
+        }
+#endif
+      }
+      if(request->hasParam("download")){
+        request->_tempFile = _fs.open(request->arg("download"), "r");
+        if(!request->_tempFile){
+          return false;
+        }
+#ifdef ESP32
+        if(request->_tempFile.isDirectory()){
+          request->_tempFile.close();
+          return false;
+        }
+#endif
+      }
+      request->addInterestingHeader("If-Modified-Since");
+      return true;
+    }
+    else if(request->method() == HTTP_POST)
+      return true;
+    else if(request->method() == HTTP_DELETE)
+      return true;
+    else if(request->method() == HTTP_PUT)
+      return true;
+
+  }
+  return false;
+}
+
+
+void SPIFFSEditor::handleRequest(AsyncWebServerRequest *request){
+  if(_username.length() && _password.length() && !request->authenticate(_username.c_str(), _password.c_str()))
+    return request->requestAuthentication();
+
+  if(request->method() == HTTP_GET){
+    if(request->hasParam("list")){
+      String path = request->getParam("list")->value();
+#ifdef ESP32
+      File dir = _fs.open(path);
+#else
+      Dir dir = _fs.openDir(path);
+#endif
+      path = String();
+      String output = "[";
+#ifdef ESP32
+      File entry = dir.openNextFile();
+      while(entry){
+#else
+      while(dir.next()){
+        fs::File entry = dir.openFile("r");
+#endif
+        if (isExcluded(_fs, entry.name())) {
+#ifdef ESP32
+            entry = dir.openNextFile();
+#endif
+            continue;
+        }
+        if (output != "[") output += ',';
+        output += "{\"type\":\"";
+        output += "file";
+        output += "\",\"name\":\"";
+        output += String(entry.name());
+        output += "\",\"size\":";
+        output += String(entry.size());
+        output += "}";
+#ifdef ESP32
+        entry = dir.openNextFile();
+#else
+        entry.close();
+#endif
+      }
+#ifdef ESP32
+      dir.close();
+#endif
+      output += "]";
+      request->send(200, "application/json", output);
+      output = String();
+    }
+    else if(request->hasParam("edit") || request->hasParam("download")){
+      request->send(request->_tempFile, request->_tempFile.name(), String(), request->hasParam("download"));
+    }
+    else {
+      const char * buildTime = __DATE__ " " __TIME__ " GMT";
+      if (request->header("If-Modified-Since").equals(buildTime)) {
+        request->send(304);
+      } else {
+        AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", edit_htm_gz, edit_htm_gz_len);
+        response->addHeader("Content-Encoding", "gzip");
+        response->addHeader("Last-Modified", buildTime);
+        request->send(response);
+      }
+    }
+  } else if(request->method() == HTTP_DELETE){
+    if(request->hasParam("path", true)){
+        _fs.remove(request->getParam("path", true)->value());
+      request->send(200, "", "DELETE: "+request->getParam("path", true)->value());
+    } else
+      request->send(404);
+  } else if(request->method() == HTTP_POST){
+    if(request->hasParam("data", true, true) && _fs.exists(request->getParam("data", true, true)->value()))
+      request->send(200, "", "UPLOADED: "+request->getParam("data", true, true)->value());
+    else
+      request->send(500);
+  } else if(request->method() == HTTP_PUT){
+    if(request->hasParam("path", true)){
+      String filename = request->getParam("path", true)->value();
+      if(_fs.exists(filename)){
+        request->send(200);
+      } else {
+        fs::File f = _fs.open(filename, "w");
+        if(f){
+          f.write((uint8_t)0x00);
+          f.close();
+          request->send(200, "", "CREATE: "+filename);
+        } else {
+          request->send(500);
+        }
+      }
+    } else
+      request->send(400);
+  }
+}
+
+void SPIFFSEditor::handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final){
+  if(!index){
+    if(!_username.length() || request->authenticate(_username.c_str(),_password.c_str())){
+      _authenticated = true;
+      request->_tempFile = _fs.open(filename, "w");
+      _startTime = millis();
+    }
+  }
+  if(_authenticated && request->_tempFile){
+    if(len){
+      request->_tempFile.write(data,len);
+    }
+    if(final){
+      request->_tempFile.close();
+    }
+  }
+}

lib/ESPAsyncWebServer/src/SPIFFSEditor.h

@@ -0,0 +1,29 @@
+#ifndef SPIFFSEditor_H_
+#define SPIFFSEditor_H_
+#include <ESPAsyncWebServer.h>
+
+#ifdef ESP8266
+#include <LittleFS.h>
+#endif
+
+class SPIFFSEditor : public AsyncWebHandler {
+   private:
+    fs::FS _fs;
+    String _username;
+    String _password;
+    bool _authenticated;
+    uint32_t _startTime;
+
+   public:
+#ifdef ESP32
+    SPIFFSEditor(const fs::FS& fs, const String& username = String(), const String& password = String());
+#else
+    SPIFFSEditor(const String& username = String(), const String& password = String(), const fs::FS& fs = LittleFS);
+#endif
+    virtual bool canHandle(AsyncWebServerRequest* request) override final;
+    virtual void handleRequest(AsyncWebServerRequest* request) override final;
+    virtual void handleUpload(AsyncWebServerRequest* request, const String& filename, size_t index, uint8_t* data, size_t len, bool final) override final;
+    virtual bool isRequestHandlerTrivial() override final { return false; }
+};
+
+#endif

lib/ESPAsyncWebServer/src/StringArray.h

@@ -0,0 +1,193 @@
+/*
+  Asynchronous WebServer 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 STRINGARRAY_H_
+#define STRINGARRAY_H_
+
+#include "stddef.h"
+#include "WString.h"
+
+template <typename T>
+class LinkedListNode {
+    T _value;
+  public:
+    LinkedListNode<T>* next;
+    LinkedListNode(const T val): _value(val), next(nullptr) {}
+    ~LinkedListNode(){}
+    const T& value() const { return _value; };
+    T& value(){ return _value; }
+};
+
+template <typename T, template<typename> class Item = LinkedListNode>
+class LinkedList {
+  public:
+    typedef Item<T> ItemType;
+    typedef std::function<void(const T&)> OnRemove;
+    typedef std::function<bool(const T&)> Predicate;
+  private:
+    ItemType* _root;
+    OnRemove _onRemove;
+
+    class Iterator {
+      ItemType* _node;
+    public:
+      Iterator(ItemType* current = nullptr) : _node(current) {}
+      Iterator(const Iterator& i) : _node(i._node) {}
+      Iterator& operator ++() { _node = _node->next; return *this; }
+      bool operator != (const Iterator& i) const { return _node != i._node; }
+      const T& operator * () const { return _node->value(); }
+      const T* operator -> () const { return &_node->value(); }
+    };
+    
+  public:
+    typedef const Iterator ConstIterator;
+    ConstIterator begin() const { return ConstIterator(_root); }
+    ConstIterator end() const { return ConstIterator(nullptr); }
+
+    LinkedList(OnRemove onRemove) : _root(nullptr), _onRemove(onRemove) {}
+    ~LinkedList(){}
+    void add(const T& t){
+      auto it = new ItemType(t);
+      if(!_root){
+        _root = it;
+      } else {
+        auto i = _root;
+        while(i->next) i = i->next;
+        i->next = it;
+      }
+    }
+    T& front() const {
+      return _root->value();
+    }
+    
+    bool isEmpty() const {
+      return _root == nullptr;
+    }
+    size_t length() const {
+      size_t i = 0;
+      auto it = _root;
+      while(it){
+        i++;
+        it = it->next;
+      }
+      return i;
+    }
+    size_t count_if(Predicate predicate) const {
+      size_t i = 0;
+      auto it = _root;
+      while(it){
+        if (!predicate){
+          i++;
+        }
+        else if (predicate(it->value())) {
+          i++;
+        }
+        it = it->next;
+      }
+      return i;
+    }
+    const T* nth(size_t N) const {
+      size_t i = 0;
+      auto it = _root;
+      while(it){
+        if(i++ == N)
+          return &(it->value());
+        it = it->next;
+      }
+      return nullptr;
+    }
+    bool remove(const T& t){
+      auto it = _root;
+      auto pit = _root;
+      while(it){
+        if(it->value() == t){
+          if(it == _root){
+            _root = _root->next;
+          } else {
+            pit->next = it->next;
+          }
+          
+          if (_onRemove) {
+            _onRemove(it->value());
+          }
+          
+          delete it;
+          return true;
+        }
+        pit = it;
+        it = it->next;
+      }
+      return false;
+    }
+    bool remove_first(Predicate predicate){
+      auto it = _root;
+      auto pit = _root;
+      while(it){
+        if(predicate(it->value())){
+          if(it == _root){
+            _root = _root->next;
+          } else {
+            pit->next = it->next;
+          }
+          if (_onRemove) {
+            _onRemove(it->value());
+          }
+          delete it;
+          return true;
+        }
+        pit = it;
+        it = it->next;
+      }
+      return false;
+    }
+    
+    void free(){
+      while(_root != nullptr){
+        auto it = _root;
+        _root = _root->next;
+        if (_onRemove) {
+          _onRemove(it->value());
+        }
+        delete it;
+      }
+      _root = nullptr;
+    }
+};
+
+
+class StringArray : public LinkedList<String> {
+public:
+  
+  StringArray() : LinkedList(nullptr) {}
+  
+  bool containsIgnoreCase(const String& str){
+    for (const auto& s : *this) {
+      if (str.equalsIgnoreCase(s)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+
+
+
+#endif /* STRINGARRAY_H_ */

lib/ESPAsyncWebServer/src/WebAuthentication.cpp

@@ -0,0 +1,235 @@
+/*
+  Asynchronous WebServer 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 "WebAuthentication.h"
+#include <libb64/cencode.h>
+#ifdef ESP32
+#include "mbedtls/md5.h"
+#else
+#include "md5.h"
+#endif
+
+
+// Basic Auth hash = base64("username:password")
+
+bool checkBasicAuthentication(const char * hash, const char * username, const char * password){
+  if(username == NULL || password == NULL || hash == NULL)
+    return false;
+
+  size_t toencodeLen = strlen(username)+strlen(password)+1;
+  size_t encodedLen = base64_encode_expected_len(toencodeLen);
+  if(strlen(hash) != encodedLen)
+    return false;
+
+  char *toencode = new char[toencodeLen+1];
+  if(toencode == NULL){
+    return false;
+  }
+  char *encoded = new char[base64_encode_expected_len(toencodeLen)+1];
+  if(encoded == NULL){
+    delete[] toencode;
+    return false;
+  }
+  sprintf(toencode, "%s:%s", username, password);
+  if(base64_encode_chars(toencode, toencodeLen, encoded) > 0 && memcmp(hash, encoded, encodedLen) == 0){
+    delete[] toencode;
+    delete[] encoded;
+    return true;
+  }
+  delete[] toencode;
+  delete[] encoded;
+  return false;
+}
+
+static bool getMD5(uint8_t * data, uint16_t len, char * output){//33 bytes or more
+#ifdef ESP32
+    mbedtls_md5_context _ctx;
+#else
+    md5_context_t _ctx;
+#endif
+  uint8_t i;
+  uint8_t * _buf = (uint8_t*)malloc(16);
+  if(_buf == NULL)
+    return false;
+  memset(_buf, 0x00, 16);
+#ifdef ESP32
+  mbedtls_md5_init(&_ctx);
+  mbedtls_md5_starts(&_ctx);
+  mbedtls_md5_update(&_ctx, data, len);
+  mbedtls_md5_finish(&_ctx, _buf);
+#else
+  MD5Init(&_ctx);
+  MD5Update(&_ctx, data, len);
+  MD5Final(_buf, &_ctx);
+#endif
+  for(i = 0; i < 16; i++) {
+    sprintf(output + (i * 2), "%02x", _buf[i]);
+  }
+  free(_buf);
+  return true;
+}
+
+static String genRandomMD5(){
+#ifdef ESP8266
+  uint32_t r = RANDOM_REG32;
+#else
+  uint32_t r = rand();
+#endif
+  char * out = (char*)malloc(33);
+  if(out == NULL || !getMD5((uint8_t*)(&r), 4, out))
+    return "";
+  String res = String(out);
+  free(out);
+  return res;
+}
+
+static String stringMD5(const String& in){
+  char * out = (char*)malloc(33);
+  if(out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out))
+    return "";
+  String res = String(out);
+  free(out);
+  return res;
+}
+
+String generateDigestHash(const char * username, const char * password, const char * realm){
+  if(username == NULL || password == NULL || realm == NULL){
+    return "";
+  }
+  char * out = (char*)malloc(33);
+  String res = String(username);
+  res.concat(":");
+  res.concat(realm);
+  res.concat(":");
+  String in = res;
+  in.concat(password);
+  if(out == NULL || !getMD5((uint8_t*)(in.c_str()), in.length(), out))
+    return "";
+  res.concat(out);
+  free(out);
+  return res;
+}
+
+String requestDigestAuthentication(const char * realm){
+  String header = "realm=\"";
+  if(realm == NULL)
+    header.concat("asyncesp");
+  else
+    header.concat(realm);
+  header.concat( "\", qop=\"auth\", nonce=\"");
+  header.concat(genRandomMD5());
+  header.concat("\", opaque=\"");
+  header.concat(genRandomMD5());
+  header.concat("\"");
+  return header;
+}
+
+bool checkDigestAuthentication(const char * header, const char * method, const char * username, const char * password, const char * realm, bool passwordIsHash, const char * nonce, const char * opaque, const char * uri){
+  if(username == NULL || password == NULL || header == NULL || method == NULL){
+    //os_printf("AUTH FAIL: missing requred fields\n");
+    return false;
+  }
+
+  String myHeader = String(header);
+  int nextBreak = myHeader.indexOf(",");
+  if(nextBreak < 0){
+    //os_printf("AUTH FAIL: no variables\n");
+    return false;
+  }
+
+  String myUsername = String();
+  String myRealm = String();
+  String myNonce = String();
+  String myUri = String();
+  String myResponse = String();
+  String myQop = String();
+  String myNc = String();
+  String myCnonce = String();
+
+  myHeader += ", ";
+  do {
+    String avLine = myHeader.substring(0, nextBreak);
+    avLine.trim();
+    myHeader = myHeader.substring(nextBreak+1);
+    nextBreak = myHeader.indexOf(",");
+
+    int eqSign = avLine.indexOf("=");
+    if(eqSign < 0){
+      //os_printf("AUTH FAIL: no = sign\n");
+      return false;
+    }
+    String varName = avLine.substring(0, eqSign);
+    avLine = avLine.substring(eqSign + 1);
+    if(avLine.startsWith("\"")){
+      avLine = avLine.substring(1, avLine.length() - 1);
+    }
+
+    if(varName.equals("username")){
+      if(!avLine.equals(username)){
+        //os_printf("AUTH FAIL: username\n");
+        return false;
+      }
+      myUsername = avLine;
+    } else if(varName.equals("realm")){
+      if(realm != NULL && !avLine.equals(realm)){
+        //os_printf("AUTH FAIL: realm\n");
+        return false;
+      }
+      myRealm = avLine;
+    } else if(varName.equals("nonce")){
+      if(nonce != NULL && !avLine.equals(nonce)){
+        //os_printf("AUTH FAIL: nonce\n");
+        return false;
+      }
+      myNonce = avLine;
+    } else if(varName.equals("opaque")){
+      if(opaque != NULL && !avLine.equals(opaque)){
+        //os_printf("AUTH FAIL: opaque\n");
+        return false;
+      }
+    } else if(varName.equals("uri")){
+      if(uri != NULL && !avLine.equals(uri)){
+        //os_printf("AUTH FAIL: uri\n");
+        return false;
+      }
+      myUri = avLine;
+    } else if(varName.equals("response")){
+      myResponse = avLine;
+    } else if(varName.equals("qop")){
+      myQop = avLine;
+    } else if(varName.equals("nc")){
+      myNc = avLine;
+    } else if(varName.equals("cnonce")){
+      myCnonce = avLine;
+    }
+  } while(nextBreak > 0);
+
+  String ha1 = (passwordIsHash) ? String(password) : stringMD5(myUsername + ":" + myRealm + ":" + String(password));
+  String ha2 = String(method) + ":" + myUri;
+  String response = ha1 + ":" + myNonce + ":" + myNc + ":" + myCnonce + ":" + myQop + ":" + stringMD5(ha2);
+
+  if(myResponse.equals(stringMD5(response))){
+    //os_printf("AUTH SUCCESS\n");
+    return true;
+  }
+
+  //os_printf("AUTH FAIL: password\n");
+  return false;
+}

lib/ESPAsyncWebServer/src/WebAuthentication.h

@@ -0,0 +1,34 @@
+/*
+  Asynchronous WebServer 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 WEB_AUTHENTICATION_H_
+#define WEB_AUTHENTICATION_H_
+
+#include "Arduino.h"
+
+bool checkBasicAuthentication(const char * header, const char * username, const char * password);
+String requestDigestAuthentication(const char * realm);
+bool checkDigestAuthentication(const char * header, const char * method, const char * username, const char * password, const char * realm, bool passwordIsHash, const char * nonce, const char * opaque, const char * uri);
+
+//for storing hashed versions on the device that can be authenticated against
+String generateDigestHash(const char * username, const char * password, const char * realm);
+
+#endif

lib/ESPAsyncWebServer/src/WebHandlerImpl.h

@@ -0,0 +1,138 @@
+/*
+  Asynchronous WebServer 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 ASYNCWEBSERVERHANDLERIMPL_H_
+#define ASYNCWEBSERVERHANDLERIMPL_H_
+
+#include <string>
+#ifdef ASYNCWEBSERVER_REGEX
+#include <regex>
+#endif
+
+#include "stddef.h"
+#include <time.h>
+
+class AsyncStaticWebHandler: public AsyncWebHandler {
+   using File = fs::File;
+   using FS = fs::FS;
+  private:
+    bool _getFile(AsyncWebServerRequest *request);
+    bool _fileExists(AsyncWebServerRequest *request, const String& path);
+    uint8_t _countBits(const uint8_t value) const;
+  protected:
+    FS _fs;
+    String _uri;
+    String _path;
+    String _default_file;
+    String _cache_control;
+    String _last_modified;
+    AwsTemplateProcessor _callback;
+    bool _isDir;
+    bool _gzipFirst;
+    uint8_t _gzipStats;
+  public:
+    AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control);
+    virtual bool canHandle(AsyncWebServerRequest *request) override final;
+    virtual void handleRequest(AsyncWebServerRequest *request) override final;
+    AsyncStaticWebHandler& setIsDir(bool isDir);
+    AsyncStaticWebHandler& setDefaultFile(const char* filename);
+    AsyncStaticWebHandler& setCacheControl(const char* cache_control);
+    AsyncStaticWebHandler& setLastModified(const char* last_modified);
+    AsyncStaticWebHandler& setLastModified(struct tm* last_modified);
+  #ifdef ESP8266
+    AsyncStaticWebHandler& setLastModified(time_t last_modified);
+    AsyncStaticWebHandler& setLastModified(); //sets to current time. Make sure sntp is runing and time is updated
+  #endif
+    AsyncStaticWebHandler& setTemplateProcessor(AwsTemplateProcessor newCallback) {_callback = newCallback; return *this;}
+};
+
+class AsyncCallbackWebHandler: public AsyncWebHandler {
+  private:
+  protected:
+    String _uri;
+    WebRequestMethodComposite _method;
+    ArRequestHandlerFunction _onRequest;
+    ArUploadHandlerFunction _onUpload;
+    ArBodyHandlerFunction _onBody;
+    bool _isRegex;
+  public:
+    AsyncCallbackWebHandler() : _uri(), _method(HTTP_ANY), _onRequest(NULL), _onUpload(NULL), _onBody(NULL), _isRegex(false) {}
+    void setUri(const String& uri){ 
+      _uri = uri; 
+      _isRegex = uri.startsWith("^") && uri.endsWith("$");
+    }
+    void setMethod(WebRequestMethodComposite method){ _method = method; }
+    void onRequest(ArRequestHandlerFunction fn){ _onRequest = fn; }
+    void onUpload(ArUploadHandlerFunction fn){ _onUpload = fn; }
+    void onBody(ArBodyHandlerFunction fn){ _onBody = fn; }
+
+    virtual bool canHandle(AsyncWebServerRequest *request) override final{
+
+      if(!_onRequest)
+        return false;
+
+      if(!(_method & request->method()))
+        return false;
+
+#ifdef ASYNCWEBSERVER_REGEX
+      if (_isRegex) {
+        std::regex pattern(_uri.c_str());
+        std::smatch matches;
+        std::string s(request->url().c_str());
+        if(std::regex_search(s, matches, pattern)) {
+          for (size_t i = 1; i < matches.size(); ++i) { // start from 1
+            request->_addPathParam(matches[i].str().c_str());
+          }
+        } else {
+          return false;
+        }
+      } else 
+#endif
+      if (_uri.length() && _uri.endsWith("*")) {
+        String uriTemplate = String(_uri);
+	uriTemplate = uriTemplate.substring(0, uriTemplate.length() - 1);
+        if (!request->url().startsWith(uriTemplate))
+          return false;
+      }
+      else if(_uri.length() && (_uri != request->url() && !request->url().startsWith(_uri+"/")))
+        return false;
+
+      request->addInterestingHeader("ANY");
+      return true;
+    }
+  
+    virtual void handleRequest(AsyncWebServerRequest *request) override final {
+      if(_onRequest)
+        _onRequest(request);
+      else
+        request->send(500);
+    }
+    virtual void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final) override final {
+      if(_onUpload)
+        _onUpload(request, filename, index, data, len, final);
+    }
+    virtual void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final {
+      if(_onBody)
+        _onBody(request, data, len, index, total);
+    }
+    virtual bool isRequestHandlerTrivial() override final {return _onRequest ? false : true;}
+};
+
+#endif /* ASYNCWEBSERVERHANDLERIMPL_H_ */

lib/ESPAsyncWebServer/src/WebHandlers.cpp

@@ -0,0 +1,220 @@
+/*
+  Asynchronous WebServer 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 "ESPAsyncWebServer.h"
+#include "WebHandlerImpl.h"
+
+AsyncStaticWebHandler::AsyncStaticWebHandler(const char* uri, FS& fs, const char* path, const char* cache_control)
+  : _fs(fs), _uri(uri), _path(path), _default_file("index.htm"), _cache_control(cache_control), _last_modified(""), _callback(nullptr)
+{
+  // Ensure leading '/'
+  if (_uri.length() == 0 || _uri[0] != '/') _uri = "/" + _uri;
+  if (_path.length() == 0 || _path[0] != '/') _path = "/" + _path;
+
+  // If path ends with '/' we assume a hint that this is a directory to improve performance.
+  // However - if it does not end with '/' we, can't assume a file, path can still be a directory.
+  _isDir = _path[_path.length()-1] == '/';
+
+  // Remove the trailing '/' so we can handle default file
+  // Notice that root will be "" not "/"
+  if (_uri[_uri.length()-1] == '/') _uri = _uri.substring(0, _uri.length()-1);
+  if (_path[_path.length()-1] == '/') _path = _path.substring(0, _path.length()-1);
+
+  // Reset stats
+  _gzipFirst = false;
+  _gzipStats = 0xF8;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setIsDir(bool isDir){
+  _isDir = isDir;
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setDefaultFile(const char* filename){
+  _default_file = String(filename);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setCacheControl(const char* cache_control){
+  _cache_control = String(cache_control);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(const char* last_modified){
+  _last_modified = String(last_modified);
+  return *this;
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(struct tm* last_modified){
+  char result[30];
+  strftime (result,30,"%a, %d %b %Y %H:%M:%S %Z", last_modified);
+  return setLastModified((const char *)result);
+}
+
+#ifdef ESP8266
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(time_t last_modified){
+  return setLastModified((struct tm *)gmtime(&last_modified));
+}
+
+AsyncStaticWebHandler& AsyncStaticWebHandler::setLastModified(){
+  time_t last_modified;
+  if(time(&last_modified) == 0) //time is not yet set
+    return *this;
+  return setLastModified(last_modified);
+}
+#endif
+bool AsyncStaticWebHandler::canHandle(AsyncWebServerRequest *request){
+  if(request->method() != HTTP_GET 
+    || !request->url().startsWith(_uri) 
+    || !request->isExpectedRequestedConnType(RCT_DEFAULT, RCT_HTTP)
+  ){
+    return false;
+  }
+  if (_getFile(request)) {
+    // We interested in "If-Modified-Since" header to check if file was modified
+    if (_last_modified.length())
+      request->addInterestingHeader("If-Modified-Since");
+
+    if(_cache_control.length())
+      request->addInterestingHeader("If-None-Match");
+
+    DEBUGF("[AsyncStaticWebHandler::canHandle] TRUE\n");
+    return true;
+  }
+
+  return false;
+}
+
+bool AsyncStaticWebHandler::_getFile(AsyncWebServerRequest *request)
+{
+  // Remove the found uri
+  String path = request->url().substring(_uri.length());
+
+  // We can skip the file check and look for default if request is to the root of a directory or that request path ends with '/'
+  bool canSkipFileCheck = (_isDir && path.length() == 0) || (path.length() && path[path.length()-1] == '/');
+
+  path = _path + path;
+
+  // Do we have a file or .gz file
+  if (!canSkipFileCheck && _fileExists(request, path))
+    return true;
+
+  // Can't handle if not default file
+  if (_default_file.length() == 0)
+    return false;
+
+  // Try to add default file, ensure there is a trailing '/' ot the path.
+  if (path.length() == 0 || path[path.length()-1] != '/')
+    path += "/";
+  path += _default_file;
+
+  return _fileExists(request, path);
+}
+
+#ifdef ESP32
+#define FILE_IS_REAL(f) (f == true && !f.isDirectory())
+#else
+#define FILE_IS_REAL(f) (f == true)
+#endif
+
+bool AsyncStaticWebHandler::_fileExists(AsyncWebServerRequest *request, const String& path)
+{
+  bool fileFound = false;
+  bool gzipFound = false;
+
+  String gzip = path + ".gz";
+
+  if (_gzipFirst) {
+    request->_tempFile = _fs.open(gzip, "r");
+    gzipFound = FILE_IS_REAL(request->_tempFile);
+    if (!gzipFound){
+      request->_tempFile = _fs.open(path, "r");
+      fileFound = FILE_IS_REAL(request->_tempFile);
+    }
+  } else {
+    request->_tempFile = _fs.open(path, "r");
+    fileFound = FILE_IS_REAL(request->_tempFile);
+    if (!fileFound){
+      request->_tempFile = _fs.open(gzip, "r");
+      gzipFound = FILE_IS_REAL(request->_tempFile);
+    }
+  }
+
+  bool found = fileFound || gzipFound;
+
+  if (found) {
+    // Extract the file name from the path and keep it in _tempObject
+    size_t pathLen = path.length();
+    char * _tempPath = (char*)malloc(pathLen+1);
+    snprintf(_tempPath, pathLen+1, "%s", path.c_str());
+    request->_tempObject = (void*)_tempPath;
+
+    // Calculate gzip statistic
+    _gzipStats = (_gzipStats << 1) + (gzipFound ? 1 : 0);
+    if (_gzipStats == 0x00) _gzipFirst = false; // All files are not gzip
+    else if (_gzipStats == 0xFF) _gzipFirst = true; // All files are gzip
+    else _gzipFirst = _countBits(_gzipStats) > 4; // IF we have more gzip files - try gzip first
+  }
+
+  return found;
+}
+
+uint8_t AsyncStaticWebHandler::_countBits(const uint8_t value) const
+{
+  uint8_t w = value;
+  uint8_t n;
+  for (n=0; w!=0; n++) w&=w-1;
+  return n;
+}
+
+void AsyncStaticWebHandler::handleRequest(AsyncWebServerRequest *request)
+{
+  // Get the filename from request->_tempObject and free it
+  String filename = String((char*)request->_tempObject);
+  free(request->_tempObject);
+  request->_tempObject = NULL;
+  if((_username != "" && _password != "") && !request->authenticate(_username.c_str(), _password.c_str()))
+      return request->requestAuthentication();
+
+  if (request->_tempFile == true) {
+    String etag = String(request->_tempFile.size());
+    if (_last_modified.length() && _last_modified == request->header("If-Modified-Since")) {
+      request->_tempFile.close();
+      request->send(304); // Not modified
+    } else if (_cache_control.length() && request->hasHeader("If-None-Match") && request->header("If-None-Match").equals(etag)) {
+      request->_tempFile.close();
+      AsyncWebServerResponse * response = new AsyncBasicResponse(304); // Not modified
+      response->addHeader("Cache-Control", _cache_control);
+      response->addHeader("ETag", etag);
+      request->send(response);
+    } else {
+      AsyncWebServerResponse * response = new AsyncFileResponse(request->_tempFile, filename, String(), false, _callback);
+      if (_last_modified.length())
+        response->addHeader("Last-Modified", _last_modified);
+      if (_cache_control.length()){
+        response->addHeader("Cache-Control", _cache_control);
+        response->addHeader("ETag", etag);
+      }
+      request->send(response);
+    }
+  } else {
+    request->send(404);
+  }
+}

lib/ESPAsyncWebServer/src/WebResponseImpl.h

@@ -0,0 +1,136 @@
+/*
+  Asynchronous WebServer 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 ASYNCWEBSERVERRESPONSEIMPL_H_
+#define ASYNCWEBSERVERRESPONSEIMPL_H_
+
+#ifdef Arduino_h
+// arduino is not compatible with std::vector
+#undef min
+#undef max
+#endif
+#include <vector>
+// It is possible to restore these defines, but one can use _min and _max instead. Or std::min, std::max.
+
+class AsyncBasicResponse: public AsyncWebServerResponse {
+  private:
+    String _content;
+  public:
+    AsyncBasicResponse(int code, const String& contentType=String(), const String& content=String());
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return true; }
+};
+
+class AsyncAbstractResponse: public AsyncWebServerResponse {
+  private:
+    String _head;
+    // Data is inserted into cache at begin(). 
+    // This is inefficient with vector, but if we use some other container, 
+    // we won't be able to access it as contiguous array of bytes when reading from it,
+    // so by gaining performance in one place, we'll lose it in another.
+    std::vector<uint8_t> _cache;
+    size_t _readDataFromCacheOrContent(uint8_t* data, const size_t len);
+    size_t _fillBufferAndProcessTemplates(uint8_t* buf, size_t maxLen);
+  protected:
+    AwsTemplateProcessor _callback;
+  public:
+    AsyncAbstractResponse(AwsTemplateProcessor callback=nullptr);
+    void _respond(AsyncWebServerRequest *request);
+    size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
+    bool _sourceValid() const { return false; }
+    virtual size_t _fillBuffer(uint8_t *buf __attribute__((unused)), size_t maxLen __attribute__((unused))) { return 0; }
+};
+
+#ifndef TEMPLATE_PLACEHOLDER
+#define TEMPLATE_PLACEHOLDER '%'
+#endif
+
+#define TEMPLATE_PARAM_NAME_LENGTH 32
+class AsyncFileResponse: public AsyncAbstractResponse {
+  using File = fs::File;
+  using FS = fs::FS;
+  private:
+    File _content;
+    String _path;
+    void _setContentType(const String& path);
+  public:
+    AsyncFileResponse(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
+    AsyncFileResponse(File content, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
+    ~AsyncFileResponse();
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncStreamResponse: public AsyncAbstractResponse {
+  private:
+    Stream *_content;
+  public:
+    AsyncStreamResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr);
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncCallbackResponse: public AsyncAbstractResponse {
+  private:
+    AwsResponseFiller _content;
+    size_t _filledLength;
+  public:
+    AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncChunkedResponse: public AsyncAbstractResponse {
+  private:
+    AwsResponseFiller _content;
+    size_t _filledLength;
+  public:
+    AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
+    bool _sourceValid() const { return !!(_content); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class AsyncProgmemResponse: public AsyncAbstractResponse {
+  private:
+    const uint8_t * _content;
+    size_t _readLength;
+  public:
+    AsyncProgmemResponse(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
+    bool _sourceValid() const { return true; }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+};
+
+class cbuf;
+
+class AsyncResponseStream: public AsyncAbstractResponse, public Print {
+  private:
+    cbuf *_content;
+  public:
+    AsyncResponseStream(const String& contentType, size_t bufferSize);
+    ~AsyncResponseStream();
+    bool _sourceValid() const { return (_state < RESPONSE_END); }
+    virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+    using Print::write;
+};
+
+#endif /* ASYNCWEBSERVERRESPONSEIMPL_H_ */

lib/ESPAsyncWebServer/src/WebResponses.cpp

@@ -0,0 +1,699 @@
+/*
+  Asynchronous WebServer 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 "ESPAsyncWebServer.h"
+#include "WebResponseImpl.h"
+#include "cbuf.h"
+
+// Since ESP8266 does not link memchr by default, here's its implementation.
+void* memchr(void* ptr, int ch, size_t count)
+{
+  unsigned char* p = static_cast<unsigned char*>(ptr);
+  while(count--)
+    if(*p++ == static_cast<unsigned char>(ch))
+      return --p;
+  return nullptr;
+}
+
+
+/*
+ * Abstract Response
+ * */
+const char* AsyncWebServerResponse::_responseCodeToString(int code) {
+  switch (code) {
+    case 100: return "Continue";
+    case 101: return "Switching Protocols";
+    case 200: return "OK";
+    case 201: return "Created";
+    case 202: return "Accepted";
+    case 203: return "Non-Authoritative Information";
+    case 204: return "No Content";
+    case 205: return "Reset Content";
+    case 206: return "Partial Content";
+    case 300: return "Multiple Choices";
+    case 301: return "Moved Permanently";
+    case 302: return "Found";
+    case 303: return "See Other";
+    case 304: return "Not Modified";
+    case 305: return "Use Proxy";
+    case 307: return "Temporary Redirect";
+    case 400: return "Bad Request";
+    case 401: return "Unauthorized";
+    case 402: return "Payment Required";
+    case 403: return "Forbidden";
+    case 404: return "Not Found";
+    case 405: return "Method Not Allowed";
+    case 406: return "Not Acceptable";
+    case 407: return "Proxy Authentication Required";
+    case 408: return "Request Time-out";
+    case 409: return "Conflict";
+    case 410: return "Gone";
+    case 411: return "Length Required";
+    case 412: return "Precondition Failed";
+    case 413: return "Request Entity Too Large";
+    case 414: return "Request-URI Too Large";
+    case 415: return "Unsupported Media Type";
+    case 416: return "Requested range not satisfiable";
+    case 417: return "Expectation Failed";
+    case 500: return "Internal Server Error";
+    case 501: return "Not Implemented";
+    case 502: return "Bad Gateway";
+    case 503: return "Service Unavailable";
+    case 504: return "Gateway Time-out";
+    case 505: return "HTTP Version not supported";
+    default:  return "";
+  }
+}
+
+AsyncWebServerResponse::AsyncWebServerResponse()
+  : _code(0)
+  , _headers(LinkedList<AsyncWebHeader *>([](AsyncWebHeader *h){ delete h; }))
+  , _contentType()
+  , _contentLength(0)
+  , _sendContentLength(true)
+  , _chunked(false)
+  , _headLength(0)
+  , _sentLength(0)
+  , _ackedLength(0)
+  , _writtenLength(0)
+  , _state(RESPONSE_SETUP)
+{
+  for(auto header: DefaultHeaders::Instance()) {
+    _headers.add(new AsyncWebHeader(header->name(), header->value()));
+  }
+}
+
+AsyncWebServerResponse::~AsyncWebServerResponse(){
+  _headers.free();
+}
+
+void AsyncWebServerResponse::setCode(int code){
+  if(_state == RESPONSE_SETUP)
+    _code = code;
+}
+
+void AsyncWebServerResponse::setContentLength(size_t len){
+  if(_state == RESPONSE_SETUP)
+    _contentLength = len;
+}
+
+void AsyncWebServerResponse::setContentType(const String& type){
+  if(_state == RESPONSE_SETUP)
+    _contentType = type;
+}
+
+void AsyncWebServerResponse::addHeader(const String& name, const String& value){
+  _headers.add(new AsyncWebHeader(name, value));
+}
+
+String AsyncWebServerResponse::_assembleHead(uint8_t version){
+  if(version){
+    addHeader("Accept-Ranges","none");
+    if(_chunked)
+      addHeader("Transfer-Encoding","chunked");
+  }
+  String out = String();
+  int bufSize = 300;
+  char buf[bufSize];
+
+  snprintf(buf, bufSize, "HTTP/1.%d %d %s\r\n", version, _code, _responseCodeToString(_code));
+  out.concat(buf);
+
+  if(_sendContentLength) {
+    snprintf(buf, bufSize, "Content-Length: %d\r\n", _contentLength);
+    out.concat(buf);
+  }
+  if(_contentType.length()) {
+    snprintf(buf, bufSize, "Content-Type: %s\r\n", _contentType.c_str());
+    out.concat(buf);
+  }
+
+  for(const auto& header: _headers){
+    snprintf(buf, bufSize, "%s: %s\r\n", header->name().c_str(), header->value().c_str());
+    out.concat(buf);
+  }
+  _headers.free();
+
+  out.concat("\r\n");
+  _headLength = out.length();
+  return out;
+}
+
+bool AsyncWebServerResponse::_started() const { return _state > RESPONSE_SETUP; }
+bool AsyncWebServerResponse::_finished() const { return _state > RESPONSE_WAIT_ACK; }
+bool AsyncWebServerResponse::_failed() const { return _state == RESPONSE_FAILED; }
+bool AsyncWebServerResponse::_sourceValid() const { return false; }
+void AsyncWebServerResponse::_respond(AsyncWebServerRequest *request){ _state = RESPONSE_END; request->client()->close(); }
+size_t AsyncWebServerResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){ (void)request; (void)len; (void)time; return 0; }
+
+/*
+ * String/Code Response
+ * */
+AsyncBasicResponse::AsyncBasicResponse(int code, const String& contentType, const String& content){
+  _code = code;
+  _content = content;
+  _contentType = contentType;
+  if(_content.length()){
+    _contentLength = _content.length();
+    if(!_contentType.length())
+      _contentType = "text/plain";
+  }
+  addHeader("Connection","close");
+}
+
+void AsyncBasicResponse::_respond(AsyncWebServerRequest *request){
+  _state = RESPONSE_HEADERS;
+  String out = _assembleHead(request->version());
+  size_t outLen = out.length();
+  size_t space = request->client()->space();
+  if(!_contentLength && space >= outLen){
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_WAIT_ACK;
+  } else if(_contentLength && space >= outLen + _contentLength){
+    out += _content;
+    outLen += _contentLength;
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_WAIT_ACK;
+  } else if(space && space < outLen){
+    String partial = out.substring(0, space);
+    _content = out.substring(space) + _content;
+    _contentLength += outLen - space;
+    _writtenLength += request->client()->write(partial.c_str(), partial.length());
+    _state = RESPONSE_CONTENT;
+  } else if(space > outLen && space < (outLen + _contentLength)){
+    size_t shift = space - outLen;
+    outLen += shift;
+    _sentLength += shift;
+    out += _content.substring(0, shift);
+    _content = _content.substring(shift);
+    _writtenLength += request->client()->write(out.c_str(), outLen);
+    _state = RESPONSE_CONTENT;
+  } else {
+    _content = out + _content;
+    _contentLength += outLen;
+    _state = RESPONSE_CONTENT;
+  }
+}
+
+size_t AsyncBasicResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){
+  (void)time;
+  _ackedLength += len;
+  if(_state == RESPONSE_CONTENT){
+    size_t available = _contentLength - _sentLength;
+    size_t space = request->client()->space();
+    //we can fit in this packet
+    if(space > available){
+      _writtenLength += request->client()->write(_content.c_str(), available);
+      _content = String();
+      _state = RESPONSE_WAIT_ACK;
+      return available;
+    }
+    //send some data, the rest on ack
+    String out = _content.substring(0, space);
+    _content = _content.substring(space);
+    _sentLength += space;
+    _writtenLength += request->client()->write(out.c_str(), space);
+    return space;
+  } else if(_state == RESPONSE_WAIT_ACK){
+    if(_ackedLength >= _writtenLength){
+      _state = RESPONSE_END;
+    }
+  }
+  return 0;
+}
+
+
+/*
+ * Abstract Response
+ * */
+
+AsyncAbstractResponse::AsyncAbstractResponse(AwsTemplateProcessor callback): _callback(callback)
+{
+  // In case of template processing, we're unable to determine real response size
+  if(callback) {
+    _contentLength = 0;
+    _sendContentLength = false;
+    _chunked = true;
+  }
+}
+
+void AsyncAbstractResponse::_respond(AsyncWebServerRequest *request){
+  addHeader("Connection","close");
+  _head = _assembleHead(request->version());
+  _state = RESPONSE_HEADERS;
+  _ack(request, 0, 0);
+}
+
+size_t AsyncAbstractResponse::_ack(AsyncWebServerRequest *request, size_t len, uint32_t time){
+  (void)time;
+  if(!_sourceValid()){
+    _state = RESPONSE_FAILED;
+    request->client()->close();
+    return 0;
+  }
+  _ackedLength += len;
+  size_t space = request->client()->space();
+
+  size_t headLen = _head.length();
+  if(_state == RESPONSE_HEADERS){
+    if(space >= headLen){
+      _state = RESPONSE_CONTENT;
+      space -= headLen;
+    } else {
+      String out = _head.substring(0, space);
+      _head = _head.substring(space);
+      _writtenLength += request->client()->write(out.c_str(), out.length());
+      return out.length();
+    }
+  }
+
+  if(_state == RESPONSE_CONTENT){
+    size_t outLen;
+    if(_chunked){
+      if(space <= 8){
+        return 0;
+      }
+      outLen = space;
+    } else if(!_sendContentLength){
+      outLen = space;
+    } else {
+      outLen = ((_contentLength - _sentLength) > space)?space:(_contentLength - _sentLength);
+    }
+
+    uint8_t *buf = (uint8_t *)malloc(outLen+headLen);
+    if (!buf) {
+      // os_printf("_ack malloc %d failed\n", outLen+headLen);
+      return 0;
+    }
+
+    if(headLen){
+      memcpy(buf, _head.c_str(), _head.length());
+    }
+
+    size_t readLen = 0;
+
+    if(_chunked){
+      // HTTP 1.1 allows leading zeros in chunk length. Or spaces may be added.
+      // See RFC2616 sections 2, 3.6.1.
+      readLen = _fillBufferAndProcessTemplates(buf+headLen+6, outLen - 8);
+      if(readLen == RESPONSE_TRY_AGAIN){
+          free(buf);
+          return 0;
+      }
+      outLen = sprintf((char*)buf+headLen, "%x", readLen) + headLen;
+      while(outLen < headLen + 4) buf[outLen++] = ' ';
+      buf[outLen++] = '\r';
+      buf[outLen++] = '\n';
+      outLen += readLen;
+      buf[outLen++] = '\r';
+      buf[outLen++] = '\n';
+    } else {
+      readLen = _fillBufferAndProcessTemplates(buf+headLen, outLen);
+      if(readLen == RESPONSE_TRY_AGAIN){
+          free(buf);
+          return 0;
+      }
+      outLen = readLen + headLen;
+    }
+
+    if(headLen){
+        _head = String();
+    }
+
+    if(outLen){
+        _writtenLength += request->client()->write((const char*)buf, outLen);
+    }
+
+    if(_chunked){
+        _sentLength += readLen;
+    } else {
+        _sentLength += outLen - headLen;
+    }
+
+    free(buf);
+
+    if((_chunked && readLen == 0) || (!_sendContentLength && outLen == 0) || (!_chunked && _sentLength == _contentLength)){
+      _state = RESPONSE_WAIT_ACK;
+    }
+    return outLen;
+
+  } else if(_state == RESPONSE_WAIT_ACK){
+    if(!_sendContentLength || _ackedLength >= _writtenLength){
+      _state = RESPONSE_END;
+      if(!_chunked && !_sendContentLength)
+        request->client()->close(true);
+    }
+  }
+  return 0;
+}
+
+size_t AsyncAbstractResponse::_readDataFromCacheOrContent(uint8_t* data, const size_t len)
+{
+    // If we have something in cache, copy it to buffer
+    const size_t readFromCache = std::min(len, _cache.size());
+    if(readFromCache) {
+      memcpy(data, _cache.data(), readFromCache);
+      _cache.erase(_cache.begin(), _cache.begin() + readFromCache);
+    }
+    // If we need to read more...
+    const size_t needFromFile = len - readFromCache;
+    const size_t readFromContent = _fillBuffer(data + readFromCache, needFromFile);
+    return readFromCache + readFromContent;
+}
+
+size_t AsyncAbstractResponse::_fillBufferAndProcessTemplates(uint8_t* data, size_t len)
+{
+  if(!_callback)
+    return _fillBuffer(data, len);
+
+  const size_t originalLen = len;
+  len = _readDataFromCacheOrContent(data, len);
+  // Now we've read 'len' bytes, either from cache or from file
+  // Search for template placeholders
+  uint8_t* pTemplateStart = data;
+  while((pTemplateStart < &data[len]) && (pTemplateStart = (uint8_t*)memchr(pTemplateStart, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart + 1))) { // data[0] ... data[len - 1]
+    uint8_t* pTemplateEnd = (pTemplateStart < &data[len - 1]) ? (uint8_t*)memchr(pTemplateStart + 1, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart) : nullptr;
+    // temporary buffer to hold parameter name
+    uint8_t buf[TEMPLATE_PARAM_NAME_LENGTH + 1];
+    String paramName;
+    // If closing placeholder is found:
+    if(pTemplateEnd) {
+      // prepare argument to callback
+      const size_t paramNameLength = std::min(sizeof(buf) - 1, (unsigned int)(pTemplateEnd - pTemplateStart - 1));
+      if(paramNameLength) {
+        memcpy(buf, pTemplateStart + 1, paramNameLength);
+        buf[paramNameLength] = 0;
+        paramName = String(reinterpret_cast<char*>(buf));
+      } else { // double percent sign encountered, this is single percent sign escaped.
+        // remove the 2nd percent sign
+        memmove(pTemplateEnd, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);
+        len += _readDataFromCacheOrContent(&data[len - 1], 1) - 1;
+        ++pTemplateStart;
+      }
+    } else if(&data[len - 1] - pTemplateStart + 1 < TEMPLATE_PARAM_NAME_LENGTH + 2) { // closing placeholder not found, check if it's in the remaining file data
+      memcpy(buf, pTemplateStart + 1, &data[len - 1] - pTemplateStart);
+      const size_t readFromCacheOrContent = _readDataFromCacheOrContent(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PARAM_NAME_LENGTH + 2 - (&data[len - 1] - pTemplateStart + 1));
+      if(readFromCacheOrContent) {
+        pTemplateEnd = (uint8_t*)memchr(buf + (&data[len - 1] - pTemplateStart), TEMPLATE_PLACEHOLDER, readFromCacheOrContent);
+        if(pTemplateEnd) {
+          // prepare argument to callback
+          *pTemplateEnd = 0;
+          paramName = String(reinterpret_cast<char*>(buf));
+          // Copy remaining read-ahead data into cache
+          _cache.insert(_cache.begin(), pTemplateEnd + 1, buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);
+          pTemplateEnd = &data[len - 1];
+        }
+        else // closing placeholder not found in file data, store found percent symbol as is and advance to the next position
+        {
+          // but first, store read file data in cache
+          _cache.insert(_cache.begin(), buf + (&data[len - 1] - pTemplateStart), buf + (&data[len - 1] - pTemplateStart) + readFromCacheOrContent);
+          ++pTemplateStart;
+        }
+      }
+      else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position
+        ++pTemplateStart;
+    }
+    else // closing placeholder not found in content data, store found percent symbol as is and advance to the next position
+      ++pTemplateStart;
+    if(paramName.length()) {
+      // call callback and replace with result.
+      // Everything in range [pTemplateStart, pTemplateEnd] can be safely replaced with parameter value.
+      // Data after pTemplateEnd may need to be moved.
+      // The first byte of data after placeholder is located at pTemplateEnd + 1.
+      // It should be located at pTemplateStart + numBytesCopied (to begin right after inserted parameter value).
+      const String paramValue(_callback(paramName));
+      const char* pvstr = paramValue.c_str();
+      const unsigned int pvlen = paramValue.length();
+      const size_t numBytesCopied = std::min(pvlen, static_cast<unsigned int>(&data[originalLen - 1] - pTemplateStart + 1));
+      // make room for param value
+      // 1. move extra data to cache if parameter value is longer than placeholder AND if there is no room to store
+      if((pTemplateEnd + 1 < pTemplateStart + numBytesCopied) && (originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1) < len)) {
+        _cache.insert(_cache.begin(), &data[originalLen - (pTemplateStart + numBytesCopied - pTemplateEnd - 1)], &data[len]);
+        //2. parameter value is longer than placeholder text, push the data after placeholder which not saved into cache further to the end
+        memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[originalLen] - pTemplateStart - numBytesCopied);
+        len = originalLen; // fix issue with truncated data, not sure if it has any side effects
+      } else if(pTemplateEnd + 1 != pTemplateStart + numBytesCopied)
+        //2. Either parameter value is shorter than placeholder text OR there is enough free space in buffer to fit.
+        //   Move the entire data after the placeholder
+        memmove(pTemplateStart + numBytesCopied, pTemplateEnd + 1, &data[len] - pTemplateEnd - 1);
+      // 3. replace placeholder with actual value
+      memcpy(pTemplateStart, pvstr, numBytesCopied);
+      // If result is longer than buffer, copy the remainder into cache (this could happen only if placeholder text itself did not fit entirely in buffer)
+      if(numBytesCopied < pvlen) {
+        _cache.insert(_cache.begin(), pvstr + numBytesCopied, pvstr + pvlen);
+      } else if(pTemplateStart + numBytesCopied < pTemplateEnd + 1) { // result is copied fully; if result is shorter than placeholder text...
+        // there is some free room, fill it from cache
+        const size_t roomFreed = pTemplateEnd + 1 - pTemplateStart - numBytesCopied;
+        const size_t totalFreeRoom = originalLen - len + roomFreed;
+        len += _readDataFromCacheOrContent(&data[len - roomFreed], totalFreeRoom) - roomFreed;
+      } else { // result is copied fully; it is longer than placeholder text
+        const size_t roomTaken = pTemplateStart + numBytesCopied - pTemplateEnd - 1;
+        len = std::min(len + roomTaken, originalLen);
+      }
+    }
+  } // while(pTemplateStart)
+  return len;
+}
+
+
+/*
+ * File Response
+ * */
+
+AsyncFileResponse::~AsyncFileResponse(){
+  if(_content)
+    _content.close();
+}
+
+void AsyncFileResponse::_setContentType(const String& path){
+  if (path.endsWith(".html")) _contentType = "text/html";
+  else if (path.endsWith(".htm")) _contentType = "text/html";
+  else if (path.endsWith(".css")) _contentType = "text/css";
+  else if (path.endsWith(".json")) _contentType = "application/json";
+  else if (path.endsWith(".js")) _contentType = "application/javascript";
+  else if (path.endsWith(".png")) _contentType = "image/png";
+  else if (path.endsWith(".gif")) _contentType = "image/gif";
+  else if (path.endsWith(".jpg")) _contentType = "image/jpeg";
+  else if (path.endsWith(".ico")) _contentType = "image/x-icon";
+  else if (path.endsWith(".svg")) _contentType = "image/svg+xml";
+  else if (path.endsWith(".eot")) _contentType = "font/eot";
+  else if (path.endsWith(".woff")) _contentType = "font/woff";
+  else if (path.endsWith(".woff2")) _contentType = "font/woff2";
+  else if (path.endsWith(".ttf")) _contentType = "font/ttf";
+  else if (path.endsWith(".xml")) _contentType = "text/xml";
+  else if (path.endsWith(".pdf")) _contentType = "application/pdf";
+  else if (path.endsWith(".zip")) _contentType = "application/zip";
+  else if(path.endsWith(".gz")) _contentType = "application/x-gzip";
+  else _contentType = "text/plain";
+}
+
+AsyncFileResponse::AsyncFileResponse(FS &fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback){
+  _code = 200;
+  _path = path;
+
+  if(!download && !fs.exists(_path) && fs.exists(_path+".gz")){
+    _path = _path+".gz";
+    addHeader("Content-Encoding", "gzip");
+    _callback = nullptr; // Unable to process zipped templates
+    _sendContentLength = true;
+    _chunked = false;
+  }
+
+  _content = fs.open(_path, "r");
+  _contentLength = _content.size();
+
+  if(contentType == "")
+    _setContentType(path);
+  else
+    _contentType = contentType;
+
+  int filenameStart = path.lastIndexOf('/') + 1;
+  char buf[26+path.length()-filenameStart];
+  char* filename = (char*)path.c_str() + filenameStart;
+
+  if(download) {
+    // set filename and force download
+    snprintf(buf, sizeof (buf), "attachment; filename=\"%s\"", filename);
+  } else {
+    // set filename and force rendering
+    snprintf(buf, sizeof (buf), "inline; filename=\"%s\"", filename);
+  }
+  addHeader("Content-Disposition", buf);
+}
+
+AsyncFileResponse::AsyncFileResponse(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback): AsyncAbstractResponse(callback){
+  _code = 200;
+  _path = path;
+
+  if(!download && String(content.name()).endsWith(".gz") && !path.endsWith(".gz")){
+    addHeader("Content-Encoding", "gzip");
+    _callback = nullptr; // Unable to process gzipped templates
+    _sendContentLength = true;
+    _chunked = false;
+  }
+
+  _content = content;
+  _contentLength = _content.size();
+
+  if(contentType == "")
+    _setContentType(path);
+  else
+    _contentType = contentType;
+
+  int filenameStart = path.lastIndexOf('/') + 1;
+  char buf[26+path.length()-filenameStart];
+  char* filename = (char*)path.c_str() + filenameStart;
+
+  if(download) {
+    snprintf(buf, sizeof (buf), "attachment; filename=\"%s\"", filename);
+  } else {
+    snprintf(buf, sizeof (buf), "inline; filename=\"%s\"", filename);
+  }
+  addHeader("Content-Disposition", buf);
+}
+
+size_t AsyncFileResponse::_fillBuffer(uint8_t *data, size_t len){
+  return _content.read(data, len);
+}
+
+/*
+ * Stream Response
+ * */
+
+AsyncStreamResponse::AsyncStreamResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) {
+  _code = 200;
+  _content = &stream;
+  _contentLength = len;
+  _contentType = contentType;
+}
+
+size_t AsyncStreamResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t available = _content->available();
+  size_t outLen = (available > len)?len:available;
+  size_t i;
+  for(i=0;i<outLen;i++)
+    data[i] = _content->read();
+  return outLen;
+}
+
+/*
+ * Callback Response
+ * */
+
+AsyncCallbackResponse::AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback): AsyncAbstractResponse(templateCallback) {
+  _code = 200;
+  _content = callback;
+  _contentLength = len;
+  if(!len)
+    _sendContentLength = false;
+  _contentType = contentType;
+  _filledLength = 0;
+}
+
+size_t AsyncCallbackResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t ret = _content(data, len, _filledLength);
+  if(ret != RESPONSE_TRY_AGAIN){
+      _filledLength += ret;
+  }
+  return ret;
+}
+
+/*
+ * Chunked Response
+ * */
+
+AsyncChunkedResponse::AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor processorCallback): AsyncAbstractResponse(processorCallback) {
+  _code = 200;
+  _content = callback;
+  _contentLength = 0;
+  _contentType = contentType;
+  _sendContentLength = false;
+  _chunked = true;
+  _filledLength = 0;
+}
+
+size_t AsyncChunkedResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t ret = _content(data, len, _filledLength);
+  if(ret != RESPONSE_TRY_AGAIN){
+      _filledLength += ret;
+  }
+  return ret;
+}
+
+/*
+ * Progmem Response
+ * */
+
+AsyncProgmemResponse::AsyncProgmemResponse(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback): AsyncAbstractResponse(callback) {
+  _code = code;
+  _content = content;
+  _contentType = contentType;
+  _contentLength = len;
+  _readLength = 0;
+}
+
+size_t AsyncProgmemResponse::_fillBuffer(uint8_t *data, size_t len){
+  size_t left = _contentLength - _readLength;
+  if (left > len) {
+    memcpy_P(data, _content + _readLength, len);
+    _readLength += len;
+    return len;
+  }
+  memcpy_P(data, _content + _readLength, left);
+  _readLength += left;
+  return left;
+}
+
+
+/*
+ * Response Stream (You can print/write/printf to it, up to the contentLen bytes)
+ * */
+
+AsyncResponseStream::AsyncResponseStream(const String& contentType, size_t bufferSize){
+  _code = 200;
+  _contentLength = 0;
+  _contentType = contentType;
+  _content = new cbuf(bufferSize);
+}
+
+AsyncResponseStream::~AsyncResponseStream(){
+  delete _content;
+}
+
+size_t AsyncResponseStream::_fillBuffer(uint8_t *buf, size_t maxLen){
+  return _content->read((char*)buf, maxLen);
+}
+
+size_t AsyncResponseStream::write(const uint8_t *data, size_t len){
+  if(_started())
+    return 0;
+
+  if(len > _content->room()){
+    size_t needed = len - _content->room();
+    _content->resizeAdd(needed);
+  }
+  size_t written = _content->write((const char*)data, len);
+  _contentLength += written;
+  return written;
+}
+
+size_t AsyncResponseStream::write(uint8_t data){
+  return write(&data, 1);
+}

lib/ESPAsyncWebServer/src/WebServer.cpp

@@ -0,0 +1,193 @@
+/*
+  Asynchronous WebServer 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 "ESPAsyncWebServer.h"
+#include "WebHandlerImpl.h"
+
+bool ON_STA_FILTER(AsyncWebServerRequest *request) {
+  return WiFi.localIP() == request->client()->localIP();
+}
+
+bool ON_AP_FILTER(AsyncWebServerRequest *request) {
+  return WiFi.localIP() != request->client()->localIP();
+}
+
+
+AsyncWebServer::AsyncWebServer(uint16_t port)
+  : _server(port)
+  , _rewrites(LinkedList<AsyncWebRewrite*>([](AsyncWebRewrite* r){ delete r; }))
+  , _handlers(LinkedList<AsyncWebHandler*>([](AsyncWebHandler* h){ delete h; }))
+{
+  _catchAllHandler = new AsyncCallbackWebHandler();
+  if(_catchAllHandler == NULL)
+    return;
+  _server.onClient([](void *s, AsyncClient* c){
+    if(c == NULL)
+      return;
+    c->setRxTimeout(3);
+    AsyncWebServerRequest *r = new AsyncWebServerRequest((AsyncWebServer*)s, c);
+    if(r == NULL){
+      c->close(true);
+      c->free();
+      delete c;
+    }
+  }, this);
+}
+
+AsyncWebServer::~AsyncWebServer(){
+  reset();  
+  end();
+  if(_catchAllHandler) delete _catchAllHandler;
+}
+
+AsyncWebRewrite& AsyncWebServer::addRewrite(AsyncWebRewrite* rewrite){
+  _rewrites.add(rewrite);
+  return *rewrite;
+}
+
+bool AsyncWebServer::removeRewrite(AsyncWebRewrite *rewrite){
+  return _rewrites.remove(rewrite);
+}
+
+AsyncWebRewrite& AsyncWebServer::rewrite(const char* from, const char* to){
+  return addRewrite(new AsyncWebRewrite(from, to));
+}
+
+AsyncWebHandler& AsyncWebServer::addHandler(AsyncWebHandler* handler){
+  _handlers.add(handler);
+  return *handler;
+}
+
+bool AsyncWebServer::removeHandler(AsyncWebHandler *handler){
+  return _handlers.remove(handler);
+}
+
+void AsyncWebServer::begin(){
+  _server.setNoDelay(true);
+  _server.begin();
+}
+
+void AsyncWebServer::end(){
+  _server.end();
+}
+
+#if ASYNC_TCP_SSL_ENABLED
+void AsyncWebServer::onSslFileRequest(AcSSlFileHandler cb, void* arg){
+  _server.onSslFileRequest(cb, arg);
+}
+
+void AsyncWebServer::beginSecure(const char *cert, const char *key, const char *password){
+  _server.beginSecure(cert, key, password);
+}
+#endif
+
+void AsyncWebServer::_handleDisconnect(AsyncWebServerRequest *request){
+  delete request;
+}
+
+void AsyncWebServer::_rewriteRequest(AsyncWebServerRequest *request){
+  for(const auto& r: _rewrites){
+    if (r->match(request)){
+      request->_url = r->toUrl();
+      request->_addGetParams(r->params());
+    }
+  }
+}
+
+void AsyncWebServer::_attachHandler(AsyncWebServerRequest *request){
+  for(const auto& h: _handlers){
+    if (h->filter(request) && h->canHandle(request)){
+      request->setHandler(h);
+      return;
+    }
+  }
+  
+  request->addInterestingHeader("ANY");
+  request->setHandler(_catchAllHandler);
+}
+
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  handler->onUpload(onUpload);
+  handler->onBody(onBody);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  handler->onUpload(onUpload);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->setMethod(method);
+  handler->onRequest(onRequest);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncCallbackWebHandler& AsyncWebServer::on(const char* uri, ArRequestHandlerFunction onRequest){
+  AsyncCallbackWebHandler* handler = new AsyncCallbackWebHandler();
+  handler->setUri(uri);
+  handler->onRequest(onRequest);
+  addHandler(handler);
+  return *handler;
+}
+
+AsyncStaticWebHandler& AsyncWebServer::serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control){
+  AsyncStaticWebHandler* handler = new AsyncStaticWebHandler(uri, fs, path, cache_control);
+  addHandler(handler);
+  return *handler;
+}
+
+void AsyncWebServer::onNotFound(ArRequestHandlerFunction fn){
+  _catchAllHandler->onRequest(fn);
+}
+
+void AsyncWebServer::onFileUpload(ArUploadHandlerFunction fn){
+  _catchAllHandler->onUpload(fn);
+}
+
+void AsyncWebServer::onRequestBody(ArBodyHandlerFunction fn){
+  _catchAllHandler->onBody(fn);
+}
+
+void AsyncWebServer::reset(){
+  _rewrites.free();
+  _handlers.free();
+  
+  if (_catchAllHandler != NULL){
+    _catchAllHandler->onRequest(NULL);
+    _catchAllHandler->onUpload(NULL);
+    _catchAllHandler->onBody(NULL);
+  }
+}
+

lib/ESPAsyncWebServer/src/edit.htm

@@ -0,0 +1,627 @@
+<!--This is the plain html source of the hex encoded Editor-Page embedded in SPIFFSEditor.cpp -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<title>ESP Editor</title>
+<style type="text/css" media="screen">
+.cm {
+  z-index: 300;
+  position: absolute;
+  left: 5px;
+  border: 1px solid #444;
+  background-color: #F5F5F5;
+  display: none;
+  box-shadow: 0 0 10px rgba( 0, 0, 0, .4 );
+  font-size: 12px;
+  font-family: sans-serif;
+  font-weight:bold;
+}
+.cm ul {
+  list-style: none;
+  top: 0;
+  left: 0;
+  margin: 0;
+  padding: 0;
+}
+.cm li {
+  position: relative;
+  min-width: 60px;
+  cursor: pointer;
+}
+.cm span {
+  color: #444;
+  display: inline-block;
+  padding: 6px;
+}
+.cm li:hover { background: #444; }
+.cm li:hover span { color: #EEE; }
+.tvu ul, .tvu li {
+  padding: 0;
+  margin: 0;
+  list-style: none;
+}
+.tvu input {
+  position: absolute;
+  opacity: 0;
+}
+.tvu {
+  font: normal 12px Verdana, Arial, Sans-serif;
+  -moz-user-select: none;
+  -webkit-user-select: none;
+  user-select: none;
+  color: #444;
+  line-height: 16px;
+}
+.tvu span {
+  margin-bottom:5px;
+  padding: 0 0 0 18px;
+  cursor: pointer;
+  display: inline-block;
+  height: 16px;
+  vertical-align: middle;
+  background: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAADoSURBVBgZBcExblNBGAbA2ceegTRBuIKOgiihSZNTcC5LUHAihNJR0kGKCDcYJY6D3/77MdOinTvzAgCw8ysThIvn/VojIyMjIyPP+bS1sUQIV2s95pBDDvmbP/mdkft83tpYguZq5Jh/OeaYh+yzy8hTHvNlaxNNczm+la9OTlar1UdA/+C2A4trRCnD3jS8BB1obq2Gk6GU6QbQAS4BUaYSQAf4bhhKKTFdAzrAOwAxEUAH+KEM01SY3gM6wBsEAQB0gJ+maZoC3gI6iPYaAIBJsiRmHU0AALOeFC3aK2cWAACUXe7+AwO0lc9eTHYTAAAAAElFTkSuQmCC') no-repeat;
+  background-position: 0px 0px;
+}
+.tvu span:hover {
+  text-decoration: underline;
+}
+@media screen and (-webkit-min-device-pixel-ratio:0){
+  .tvu{
+    -webkit-animation: webkit-adjacent-element-selector-bugfix infinite 1s;
+  }
+
+  @-webkit-keyframes webkit-adjacent-element-selector-bugfix {
+    from { 
+      padding: 0;
+    } 
+    to { 
+      padding: 0;
+    }
+  }
+}
+#uploader { 
+  position: absolute;
+  top: 0;
+  right: 0;
+  left: 0;
+  height:28px;
+  line-height: 24px;
+  padding-left: 10px;
+  background-color: #444;
+  color:#EEE;
+}
+#tree { 
+  position: absolute;
+  top: 28px;
+  bottom: 0;
+  left: 0;
+  width:160px;
+  padding: 8px;
+}
+#editor, #preview { 
+  position: absolute;
+  top: 28px;
+  right: 0;
+  bottom: 0;
+  left: 160px;
+  border-left:1px solid #EEE;
+}
+#preview {
+  background-color: #EEE;
+  padding:5px;
+}
+#loader { 
+  position: absolute;
+  top: 36%;
+  right: 40%;
+}
+.loader {
+    z-index: 10000;
+    border: 8px solid #b5b5b5; /* Grey */
+    border-top: 8px solid #3498db; /* Blue */
+    border-bottom: 8px solid #3498db; /* Blue */
+    border-radius: 50%;
+    width: 240px;
+    height: 240px;
+    animation: spin 2s linear infinite;
+    display:none;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+</style>
+<script>
+if (typeof XMLHttpRequest === "undefined") {
+  XMLHttpRequest = function () {
+    try { return new ActiveXObject("Msxml2.XMLHTTP.6.0"); } catch (e) {}
+    try { return new ActiveXObject("Msxml2.XMLHTTP.3.0"); } catch (e) {}
+    try { return new ActiveXObject("Microsoft.XMLHTTP"); } catch (e) {}
+    throw new Error("This browser does not support XMLHttpRequest.");
+  };
+}
+
+function ge(a){
+  return document.getElementById(a);
+}
+function ce(a){
+  return document.createElement(a);
+}
+
+function sortByKey(array, key) {
+  return array.sort(function(a, b) {
+    var x = a[key]; var y = b[key];
+    return ((x < y) ? -1 : ((x > y) ? 1 : 0));
+  });
+}
+
+
+var QueuedRequester = function () {
+  this.queue = [];
+  this.running = false;
+  this.xmlhttp = null;
+}
+QueuedRequester.prototype = {
+  _request: function(req){
+    this.running = true;
+    if(!req instanceof Object) return;
+    var that = this;
+    
+    function ajaxCb(x,d){ return function(){
+      if (x.readyState == 4){
+        ge("loader").style.display = "none";
+        d.callback(x.status, x.responseText);
+        if(that.queue.length === 0) that.running = false;
+        if(that.running) that._request(that.queue.shift());
+      }
+    }}
+    
+    ge("loader").style.display = "block";
+    
+    var p = "";
+    if(req.params instanceof FormData){
+      p = req.params;
+    } else if(req.params instanceof Object){
+      for (var key in req.params) {
+        if(p === "")
+          p += (req.method === "GET")?"?":"";
+        else
+          p += "&";
+        p += encodeURIComponent(key)+"="+encodeURIComponent(req.params[key]);
+      };
+    }
+    
+    this.xmlhttp = new XMLHttpRequest();
+    this.xmlhttp.onreadystatechange = ajaxCb(this.xmlhttp, req);
+    if(req.method === "GET"){
+      this.xmlhttp.open(req.method, req.url+p, true);
+      this.xmlhttp.send();
+    } else {
+      this.xmlhttp.open(req.method, req.url, true);
+      if(p instanceof String)
+        this.xmlhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
+      this.xmlhttp.send(p);
+    }
+  },
+  stop: function(){
+    if(this.running) this.running = false;
+    if(this.xmlhttp && this.xmlhttp.readyState < 4){
+      this.xmlhttp.abort();
+    }
+  },
+  add: function(method, url, params, callback){
+    this.queue.push({url:url,method:method,params:params,callback:callback});
+    if(!this.running){
+      this._request(this.queue.shift());
+    }
+  }
+}
+
+var requests = new QueuedRequester();
+
+function createFileUploader(element, tree, editor){
+  var xmlHttp;
+  
+  var refresh = ce("button");
+  refresh.innerHTML = 'Refresh List';
+  ge(element).appendChild(refresh);
+
+  var input = ce("input");
+  input.type = "file";
+  input.multiple = false;
+  input.name = "data";
+  input.id="upload-select";
+  ge(element).appendChild(input);
+  
+  var path = ce("input");
+  path.id = "upload-path";
+  path.type = "text";
+  path.name = "path";
+  path.defaultValue = "/";
+  ge(element).appendChild(path);
+  
+  var button = ce("button");
+  button.innerHTML = 'Upload';
+  ge(element).appendChild(button);
+  
+  var mkfile = ce("button");
+  mkfile.innerHTML = 'Create';
+  ge(element).appendChild(mkfile);
+
+  var filename     = ce("input");
+  filename.id      = "editor-filename";
+  filename.type    = "text";
+  filename.disabled= true;
+  filename.size    = 20;
+  ge(element).appendChild(filename);
+
+  var savefile = ce("button");
+  savefile.innerHTML = ' Save ' ;
+  ge(element).appendChild(savefile);
+
+  function httpPostProcessRequest(status, responseText){
+    if(status != 200)
+      alert("ERROR["+status+"]: "+responseText);
+    else
+      tree.refreshPath(path.value);
+  }
+  function createPath(p){
+    var formData = new FormData();
+    formData.append("path", p);
+    requests.add("PUT", "/edit", formData, httpPostProcessRequest);
+  }
+  
+  mkfile.onclick = function(e){
+    createPath(path.value);
+    editor.loadUrl(path.value);
+    path.value="/";
+  };
+
+  savefile.onclick = function(e){
+    editor.execCommand('saveCommand');
+  };
+  
+  refresh.onclick = function(e){
+    tree.refreshPath(path.value);
+  };
+  
+  button.onclick = function(e){
+    if(input.files.length === 0){
+      return;
+    }
+    var formData = new FormData();
+    formData.append("data", input.files[0], path.value);
+    requests.add("POST", "/edit", formData, httpPostProcessRequest);
+    var uploadPath= ge("upload-path");
+    uploadPath.value="/";
+    var uploadSelect= ge("upload-select");
+    uploadSelect.value="";
+  };
+  input.onchange = function(e){
+    if(input.files.length === 0) return;
+    var filename = input.files[0].name;
+    var ext = /(?:\.([^.]+))?$/.exec(filename)[1];
+    var name = /(.*)\.[^.]+$/.exec(filename)[1];
+    if(typeof name !== undefined){
+      filename = name;
+    }
+    path.value = "/"+filename+"."+ext;
+  };
+}
+
+function createTree(element, editor){
+  var preview = ge("preview");
+  var treeRoot = ce("div");
+  treeRoot.className = "tvu";
+  ge(element).appendChild(treeRoot);
+
+  function loadDownload(path){
+    ge('download-frame').src = "/edit?download="+path;
+  }
+
+  function loadPreview(path){
+    var edfname = ge("editor-filename");
+    edfname.value=path;
+    ge("editor").style.display = "none";
+    preview.style.display = "block";
+    preview.innerHTML = '<img src="/edit?edit='+path+'&_cb='+Date.now()+'" style="max-width:100%; max-height:100%; margin:auto; display:block;" />';
+  }
+
+  function fillFileMenu(el, path){
+    var list = ce("ul");
+    el.appendChild(list);
+    var action = ce("li");
+    list.appendChild(action);
+    if(isImageFile(path)){
+      action.innerHTML = "<span>Preview</span>";
+      action.onclick = function(e){
+        loadPreview(path);
+        if(document.body.getElementsByClassName('cm').length > 0) document.body.removeChild(el);
+      };
+    } else if(isTextFile(path)){
+      action.innerHTML = "<span>Edit</span>";
+      action.onclick = function(e){
+        editor.loadUrl(path);
+        if(document.body.getElementsByClassName('cm').length > 0) document.body.removeChild(el);
+      };
+    }
+    var download = ce("li");
+    list.appendChild(download);
+    download.innerHTML = "<span>Download</span>";
+    download.onclick = function(e){
+      loadDownload(path);
+      if(document.body.getElementsByClassName('cm').length > 0) document.body.removeChild(el);
+    };
+    var delFile = ce("li");
+    list.appendChild(delFile);
+    delFile.innerHTML = "<span>Delete</span>";
+    delFile.onclick = function(e){
+      httpDelete(path);
+      if(document.body.getElementsByClassName('cm').length > 0) document.body.removeChild(el);
+    };
+  }
+
+  function showContextMenu(event, path, isfile){
+    var divContext = ce("div");
+    var scrollTop = document.body.scrollTop ? document.body.scrollTop : document.documentElement.scrollTop;
+    var scrollLeft = document.body.scrollLeft ? document.body.scrollLeft : document.documentElement.scrollLeft;
+    var left = event.clientX + scrollLeft;
+    var top = event.clientY + scrollTop;
+    divContext.className = 'cm';
+    divContext.style.display = 'block';
+    divContext.style.left = left + 'px';
+    divContext.style.top = top + 'px';
+    fillFileMenu(divContext, path);
+    document.body.appendChild(divContext);
+    var width = divContext.offsetWidth;
+    var height = divContext.offsetHeight;
+    divContext.onmouseout = function(e){
+      if(e.clientX < left || e.clientX > (left + width) || e.clientY < top || e.clientY > (top + height)){
+        if(document.body.getElementsByClassName('cm').length > 0) document.body.removeChild(divContext);
+      }
+    };
+  }
+
+  function createTreeLeaf(path, name, size){
+    var leaf = ce("li");
+    leaf.id = name;
+    var label = ce("span");
+    label.innerHTML = name;
+    leaf.appendChild(label);
+    leaf.onclick = function(e){
+      if(isTextFile(leaf.id.toLowerCase())){
+        editor.loadUrl(leaf.id);
+      } else if(isImageFile(leaf.id.toLowerCase())){
+        loadPreview(leaf.id);
+      }
+    };
+    leaf.oncontextmenu = function(e){
+      e.preventDefault();
+      e.stopPropagation();
+      showContextMenu(e, leaf.id, true);
+    };
+    return leaf;
+  }
+
+  function addList(parent, path, items){
+    sortByKey(items, 'name');
+    var list = ce("ul");
+    parent.appendChild(list);
+    var ll = items.length;
+    for(var i = 0; i < ll; i++){
+      if(items[i].type === "file")
+        list.appendChild(createTreeLeaf(path, items[i].name, items[i].size));
+    }
+
+  }
+
+  function isTextFile(path){
+    var ext = /(?:\.([^.]+))?$/.exec(path)[1];
+    if(typeof ext !== undefined){
+      switch(ext){
+        case "txt":
+        case "htm":
+        case "html":
+        case "js":
+        case "css":
+        case "xml":
+        case "json":
+        case "conf":
+        case "ini":
+        case "h":
+        case "c":
+        case "cpp":
+        case "php":
+        case "hex":
+        case "ino":
+        case "pde":
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function isImageFile(path){
+    var ext = /(?:\.([^.]+))?$/.exec(path)[1];
+    if(typeof ext !== undefined){
+      switch(ext){
+        case "png":
+        case "jpg":
+        case "gif":
+        case "bmp":
+        return true;
+      }
+    }
+    return false;
+  }
+
+  this.refreshPath = function(path){
+    treeRoot.removeChild(treeRoot.childNodes[0]);
+    httpGet(treeRoot, "/");
+  };
+
+  function delCb(path){
+    return function(status, responseText){
+      if(status != 200){
+        alert("ERROR["+status+"]: "+responseText);
+      } else {
+        treeRoot.removeChild(treeRoot.childNodes[0]);
+        httpGet(treeRoot, "/");
+      }
+    }
+  }
+
+  function httpDelete(filename){
+    var formData = new FormData();
+    formData.append("path", filename);
+    requests.add("DELETE", "/edit", formData, delCb(filename));
+  }
+
+  function getCb(parent, path){
+    return function(status, responseText){
+      if(status == 200)
+        addList(parent, path, JSON.parse(responseText));
+    }
+  }
+
+  function httpGet(parent, path){
+    requests.add("GET", "/edit", { list: path }, getCb(parent, path));
+  }
+
+  httpGet(treeRoot, "/");
+  return this;
+}
+
+function createEditor(element, file, lang, theme, type){
+  function getLangFromFilename(filename){
+    var lang = "plain";
+    var ext = /(?:\.([^.]+))?$/.exec(filename)[1];
+    if(typeof ext !== undefined){
+      switch(ext){
+        case "txt": lang = "plain"; break;
+        case "hex": lang = "plain"; break;
+        case "conf": lang = "plain"; break;
+        case "htm": lang = "html"; break;
+        case "js": lang = "javascript"; break;
+        case "h": lang = "c_cpp"; break;
+        case "c": lang = "c_cpp"; break;
+        case "cpp": lang = "c_cpp"; break;
+        case "css":
+        case "scss":
+        case "php":
+        case "html":
+        case "json":
+        case "xml":
+        case "ini":  lang = ext;
+      }
+    }
+    return lang;
+  }
+
+  if(typeof file === "undefined") file = "/index.html";
+
+  if(typeof lang === "undefined"){
+    lang = getLangFromFilename(file);
+  }
+
+  if(typeof theme === "undefined") theme = "textmate";
+
+  if(typeof type === "undefined"){
+    type = "text/"+lang;
+    if(lang === "c_cpp") type = "text/plain";
+  }
+
+  var editor = ace.edit(element);
+  function httpPostProcessRequest(status, responseText){
+    if(status != 200) alert("ERROR["+status+"]: "+responseText);
+  }
+  function httpPost(filename, data, type){
+    var formData = new FormData();
+    formData.append("data", new Blob([data], { type: type }), filename);
+    requests.add("POST", "/edit", formData, httpPostProcessRequest);
+  }
+  function httpGetProcessRequest(status, responseText){
+      ge("preview").style.display = "none";
+      ge("editor").style.display = "block";
+      if(status == 200)
+        editor.setValue(responseText);
+      else
+        editor.setValue("");
+      editor.clearSelection();
+  }
+  function httpGet(theUrl){
+      requests.add("GET", "/edit", { edit: theUrl }, httpGetProcessRequest);
+  }
+
+  if(lang !== "plain") editor.getSession().setMode("ace/mode/"+lang);
+  editor.setTheme("ace/theme/"+theme);
+  editor.$blockScrolling = Infinity;
+  editor.getSession().setUseSoftTabs(true);
+  editor.getSession().setTabSize(2);
+  editor.setHighlightActiveLine(true);
+  editor.setShowPrintMargin(false);
+  editor.commands.addCommand({
+      name: 'saveCommand',
+      bindKey: {win: 'Ctrl-S',  mac: 'Command-S'},
+      exec: function(editor) {
+        httpPost(file, editor.getValue()+"", type);
+      },
+      readOnly: false
+  });
+  editor.commands.addCommand({
+      name: 'undoCommand',
+      bindKey: {win: 'Ctrl-Z',  mac: 'Command-Z'},
+      exec: function(editor) {
+        editor.getSession().getUndoManager().undo(false);
+      },
+      readOnly: false
+  });
+  editor.commands.addCommand({
+      name: 'redoCommand',
+      bindKey: {win: 'Ctrl-Shift-Z',  mac: 'Command-Shift-Z'},
+      exec: function(editor) {
+        editor.getSession().getUndoManager().redo(false);
+      },
+      readOnly: false
+  });
+  editor.loadUrl = function(filename){
+    var edfname = ge("editor-filename");
+    edfname.value=filename;
+    file = filename;
+    lang = getLangFromFilename(file);
+    type = "text/"+lang;
+    if(lang !== "plain") editor.getSession().setMode("ace/mode/"+lang);
+    httpGet(file);
+  };
+  return editor;
+}
+function onBodyLoad(){
+  var vars = {};
+  var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) { vars[key] = value; });
+  var editor = createEditor("editor", vars.file, vars.lang, vars.theme);
+  var tree = createTree("tree", editor);
+  createFileUploader("uploader", tree, editor);
+  if(typeof vars.file === "undefined") vars.file = "/index.htm";
+  editor.loadUrl(vars.file);
+};
+</script>
+<script id='ace' src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.2.6/ace.js" type="text/javascript" charset="utf-8"></script>
+<script>
+  if  (typeof ace.edit == "undefined") {
+    var script = document.createElement('script');
+    script.src = "/ace.js";
+    script.async = false;
+    document.head.appendChild(script);
+  }
+</script>
+</head>
+<body onload="onBodyLoad();">
+  <div id="loader" class="loader"></div>
+  <div id="uploader"></div>
+  <div id="tree"></div>
+  <div id="editor"></div>
+  <div id="preview" style="display:none;"></div>
+  <iframe id=download-frame style='display:none;'></iframe>
+</body>
+</html>

lib/GyverFilters/examples/GFilterRA/GFilterRA.ino

@@ -0,0 +1,16 @@
+#include "GyverFilters.h"
+GFilterRA analog0;    // фильтр назовём analog0
+
+void setup() {
+  Serial.begin(9600);
+
+  // установка коэффициента фильтрации (0.0... 1.0). Чем меньше, тем плавнее фильтр
+  analog0.setCoef(0.01);
+
+  // установка шага фильтрации (мс). Чем меньше, тем резче фильтр
+  analog0.setStep(10);
+}
+
+void loop() {
+  Serial.println(analog0.filteredTime(analogRead(0)));
+}

lib/GyverFilters/examples/GLinear_arrays/GLinear_arrays.ino

@@ -0,0 +1,32 @@
+/*
+  Пример линейной аппроксимации методом наименьших квадратов
+  Два массива: по оси Х и по оси У
+  Линейная аппроксимация повозоляет получить уравнение прямой,
+  равноудалённой от точек на плоскости ХУ. Удобно для расчёта
+  роста изменяющейся шумящей величины. Уравнение вида у = A*x + B
+  В папке с данным примером есть скриншот из excel,
+  иллюстрирующий работу аппроксимации с такими же исходными
+*/
+
+// два массива с данными (одинаковой размероности и размера)
+int x_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+int y_array[] = {1, 5, 2, 8, 3, 9, 10, 5, 15, 12};
+
+#include <GyverFilters.h>
+GLinear<int> test;    // указываем тип данных в <>
+
+void setup() {
+  Serial.begin(9600);
+
+  // передаём массивы и размер одного из них
+  test.compute((int*)x_array, (int*)y_array, sizeof(x_array));
+
+  // Уравнение вида у = A*x + B
+  Serial.println(test.getA());  // получить коэффициент А
+  Serial.println(test.getB());  // получить коэффициент В
+  Serial.println(test.getDelta());  // получить изменение (аппроксимированное)
+}
+
+void loop() {
+
+}

lib/GyverFilters/examples/GLinear_running/GLinear_running.ino

@@ -0,0 +1,34 @@
+/*
+  Пример линейной аппроксимации методом наименьших квадратов
+  Два массива: по оси Х и по оси У
+  Наполнение массивов осуществляется динамически: сдвигом и записью в крайнюю ячейку,
+  то есть аппроксимация по последним ARRAY_SIZE изменениям!!
+*/
+#define ARRAY_SIZE 10   // размер пространства для аппроксимации
+
+// два массива с данными (одинаковой размероности и размера)
+int x_array[ARRAY_SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  // ось x от 1 до 10, допустим СЕКУНД
+int y_array[ARRAY_SIZE];    // значения по оси У будем брать с датчика
+
+#include <GyverFilters.h>
+GLinear<int> test;    // указываем тип данных в <>
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  for (byte i = 0; i < ARRAY_SIZE - 1; i++) {    // счётчик от 0 до ARRAY_SIZE
+    y_array[i] = y_array[i + 1];    // сдвинуть массив давлений КРОМЕ ПОСЛЕДНЕЙ ЯЧЕЙКИ на шаг назад
+  }
+  // последний элемент массива теперь - новое значение (просто с аналог. датчика)
+  y_array[ARRAY_SIZE - 1] = analogRead(0);
+
+  // передаём массивы и размер одного из них
+  test.compute((int*)x_array, (int*)y_array, sizeof(x_array));
+
+  // по нашим исходным данным это будет производная, т.е. "изменение единиц в секунду"
+  Serial.println(test.getDelta());  // получить изменение (аппроксимированное)
+
+  delay(1000);  // секундная задержка
+}

lib/GyverFilters/examples/alphabeta_example/alphabeta_example.ino

@@ -0,0 +1,24 @@
+/*
+   Пример альфа-бета фильтра
+*/
+
+#include "GyverFilters.h"
+
+// параметры: период дискретизации (измерений), process variation, noise variation
+GABfilter testFilter(0.08, 40, 1);
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  delay(80);
+  int value = analogRead(0);
+  value += random(2) * random(-1, 2) * random(10, 70);
+  Serial.print("$");
+  Serial.print(value);
+  Serial.print(" ");
+  value = testFilter.filtered((int)value);
+  Serial.print(value);
+  Serial.println(";");
+}

lib/GyverFilters/examples/filters_comparsion/filters_comparsion.ino

@@ -0,0 +1,30 @@
+/*
+   Сравнение калмана и бегущего среднего
+*/
+#include "GyverFilters.h"
+
+// параметры: разброс измерения, разброс оценки, скорость изменения значений
+// разброс измерения: шум измерений
+// разброс оценки: подстраивается сам, можно поставить таким же как разброс измерения
+// скорость изменения значений: 0.001-1, варьировать самому
+
+GKalman kalman(90, 90, 0.5);
+GFilterRA average(0.5, 80);
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {  
+  int value = analogRead(0);
+  value += random(2) * random(-1, 2) * random(50, 100);
+  Serial.print("$");
+  Serial.print(value);
+  Serial.print(" ");  
+  
+  Serial.print((int)kalman.filtered(value));
+  Serial.print(" ");
+  Serial.print((int)average.filtered(value));
+  Serial.println(";");
+  delay(80);
+}

lib/GyverFilters/examples/kalman_example/kalman_example.ino

@@ -0,0 +1,31 @@
+/*
+   Пример простого одномерного фильтра
+*/
+
+#include "GyverFilters.h"
+
+// параметры: разброс измерения, разброс оценки, скорость изменения значений
+// разброс измерения: шум измерений
+// разброс оценки: подстраивается сам, можно поставить таким же как разброс измерения
+// скорость изменения значений: 0.001-1, варьировать самому
+
+GKalman testFilter(40, 40, 0.5);
+
+// также может быть объявлен как (разброс измерения, скорость изменения значений)
+// GKalman testFilter(40, 0.5);
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  delay(80);
+  int value = analogRead(0);
+  value += random(2) * random(-1, 2) * random(10, 70);
+  Serial.print("$");
+  Serial.print(value);
+  Serial.print(" ");
+  value = testFilter.filtered((int)value);
+  Serial.print(value);
+  Serial.println(";");
+}

lib/GyverFilters/examples/median3_example/median3_example.ino

@@ -0,0 +1,21 @@
+/*
+	Пример использования быстрого медианного фильтра 3 порядка
+*/
+
+#include "GyverFilters.h"
+GMedian3<int> testFilter; 		// указываем тип данных в <>
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {    
+  int value = analogRead(0);
+  // добавляем шум "выбросы"
+  value += random(2) * random(2) * random(-1, 2) * random(50, 250);
+  Serial.print(value);
+  Serial.print(',');  
+  value = testFilter.filtered(value);
+  Serial.println(value);
+  delay(80);
+}

lib/GyverFilters/examples/median_example/median_example.ino

@@ -0,0 +1,23 @@
+/*
+	Пример использования медианного фильтра.
+*/
+
+#include "GyverFilters.h"
+
+// указываем размер окна и тип данных в <>
+GMedian<10, int> testFilter;    
+
+void setup() {
+  Serial.begin(9600);
+}
+
+void loop() {
+  delay(80);
+  int value = analogRead(0);
+  // добавляем шум "выбросы"
+  value += random(2) * random(2) * random(-1, 2) * random(50, 250);
+  Serial.print(value);
+  Serial.print(',');  
+  value = testFilter.filtered(value);
+  Serial.println(value);
+}

lib/GyverFilters/keywords.txt

@@ -0,0 +1,28 @@
+#######################################
+# Syntax Coloring Map For GyverFilters
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+GyverFilters	KEYWORD1
+GFilterRA	KEYWORD1
+GMedian3	KEYWORD1
+GMedian	KEYWORD1
+GABfilter	KEYWORD1
+GKalman	KEYWORD1
+GLinear	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+setCoef	KEYWORD2
+setStep	KEYWORD2
+filteredTime	KEYWORD2
+filtered	KEYWORD2
+setParameters	KEYWORD2
+getA	KEYWORD2
+getB	KEYWORD2
+getDelta	KEYWORD2

lib/GyverFilters/library.properties

@@ -0,0 +1,9 @@
+name=GyverFilters
+version=2.0
+author=AlexGyver <beragumbo@ya.ru>
+maintainer=AlexGyver <beragumbo@ya.ru>
+sentence=Library with few filters for data.
+paragraph=Includes median, running average, AB, simplified Kalman and linear approximation filtering algorithms.
+category=Data Processing
+url=https://github.com/AlexGyver/GyverLibs
+architectures=*

lib/GyverFilters/src/GyverFilters.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <filters/alfaBeta.h>
+#include <filters/kalman.h>
+#include <filters/linear.h>
+#include <filters/median.h>
+#include <filters/median3.h>
+#include <filters/runningAverage.h>
+
+/*
+	GyverFilters - библиотека с некоторыми удобными фильтрами:
+	- GFilterRA - компактная альтернатива фильтра экспоненциальное бегущее среднее (Running Average)			
+	- GMedian3 - быстрый медианный фильтр 3-го порядка (отсекает выбросы)
+	- GMedian - медианный фильтр N-го порядка. Порядок настраивается в GyverFilters.h - MEDIAN_FILTER_SIZE
+	- GABfilter - альфа-бета фильтр (разновидность Калмана для одномерного случая)
+	- GKalman - упрощённый Калман для одномерного случая (на мой взгляд лучший из фильтров)
+	- GLinear - линейная аппроксимация методом наименьших квадратов для двух массивов
+	
+	Версии
+	- 1.6 от 12.11.2019
+	- 1.7: исправлен GLinear
+	- 1.8: небольшие улучшения
+	- 2.0:
+		- Улучшен и исправлен median и median3
+		- Улучшен linear
+		- Смотрите примеры! Использование этих фильтров чуть изменилось
+*/

lib/GyverFilters/src/filters/alfaBeta.h

@@ -0,0 +1,37 @@
+#pragma once
+#include <math.h>
+
+// альфа-бета фильтр
+class GABfilter {
+public:
+	// период дискретизации (измерений), process variation, noise variation
+	GABfilter(float delta, float sigma_process, float sigma_noise) {setParameters(delta, sigma_process, sigma_noise);}
+	
+	// период дискретизации (измерений), process variation, noise variation
+	void setParameters(float delta, float sigma_process, float sigma_noise) {
+		dt = delta;
+		float lambda = (float)sigma_process * dt * dt / sigma_noise;
+		float r = (4 + lambda - (float)sqrt(8 * lambda + lambda * lambda)) / 4;
+		a = (float)1 - r * r;
+		b = (float)2 * (2 - a) - 4 * (float)sqrt(1 - a);
+	}
+	
+	// возвращает фильтрованное значение
+	float filtered(float value) {				
+		xm = value;
+		xk = xk_1 + ((float) vk_1 * dt );
+		vk = vk_1;
+		rk = xm - xk;
+		xk += (float)a * rk;
+		vk += (float)( b * rk ) / dt;
+		xk_1 = xk;
+		vk_1 = vk;
+		return xk_1;
+	}
+	
+private:
+	float dt;
+	float xk_1, vk_1, a, b;
+	float xk, vk, rk;
+	float xm;
+};

lib/GyverFilters/src/filters/kalman.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <math.h>
+
+// упрощённый Калман для одномерного случая
+class GKalman {
+public:
+	// разброс измерения, разброс оценки, скорость изменения значений
+	GKalman(float mea_e, float est_e, float q) { setParameters(mea_e, est_e, q); }
+	
+	// разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
+	GKalman(float mea_e, float q) {GKalman::setParameters(mea_e, mea_e, q);}
+	
+	// разброс измерения, разброс оценки, скорость изменения значений
+	void setParameters(float mea_e, float est_e, float q) {
+		_err_measure = mea_e;
+		_err_estimate = est_e;
+		_q = q;
+	}
+	
+	// разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
+	void setParameters(float mea_e, float q) {setParameters(mea_e, mea_e, q);}
+	
+	// возвращает фильтрованное значение
+	float filtered(float value) {		
+		float _kalman_gain, _current_estimate;
+		_kalman_gain = _err_estimate / (_err_estimate + _err_measure);
+		_current_estimate = _last_estimate + _kalman_gain * (value - _last_estimate);
+		_err_estimate =  (1.0 - _kalman_gain)*_err_estimate + fabs(_last_estimate-_current_estimate)*_q;
+		_last_estimate=_current_estimate;
+		return _current_estimate;
+	}
+
+private:
+	float _err_measure = 0.0;
+	float _err_estimate = 0.0;
+	float _q = 0.0;
+	float _last_estimate = 0.0;
+};

lib/GyverFilters/src/filters/linear.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <Arduino.h>
+
+// линейная аппроксимация методом наименьших квадратов
+template < typename TYPE >
+class GLinear {
+public:
+	GLinear(){};
+	void compute(TYPE *x_array, TYPE *y_array, int arrSize) {		// аппроксимировать
+		int32_t sumX = 0, sumY = 0, sumX2 = 0, sumXY = 0;	
+		arrSize /= sizeof(int);
+		for (int i = 0; i < arrSize; i++) {		// для всех элементов массива
+			sumX += x_array[i];
+			sumY += (long)y_array[i];
+			sumX2 += x_array[i] * x_array[i];
+			sumXY += (long)y_array[i] * x_array[i];
+		}
+		a = (long)arrSize * sumXY;             // расчёт коэффициента наклона приямой
+		a = a - (long)sumX * sumY;
+		a = (float)a / (arrSize * sumX2 - sumX * sumX);
+		b = (float)(sumY - (float)a * sumX) / arrSize;
+		delta = a * arrSize;					// расчёт изменения
+	}
+	float getA() {return a;}			// получить коэффициент А
+	float getB() {return b;}			// получить коэффициент В
+	float getDelta() {return delta;}	// получить аппроксимированное изменение
+	
+private:	
+	float a, b, delta;
+};

lib/GyverFilters/src/filters/median.h

@@ -0,0 +1,35 @@
+#pragma once
+
+// медианный фильтр N-го порядка
+template < int SIZE, typename TYPE >
+class GMedian {
+public:
+	TYPE filtered(TYPE newVal) {
+		buffer[_count] = newVal;
+		if ((_count < _numRead - 1) && (buffer[_count] > buffer[_count + 1])) {
+			for (int i = _count; i < _numRead - 1; i++) {
+				if (buffer[i] > buffer[i + 1]) {
+					float buff = buffer[i];
+					buffer[i] = buffer[i + 1];
+					buffer[i + 1] = buff;
+				}
+			}
+		} else {
+			if ((_count > 0) and (buffer[_count - 1] > buffer[_count])) {
+				for (int i = _count; i > 0; i--) {
+					if (buffer[i] < buffer[i - 1]) {
+						float buff = buffer[i];
+						buffer[i] = buffer[i - 1];
+						buffer[i - 1] = buff;
+					}
+				}
+			}
+		}
+		if (++_count >= _numRead) _count = 0;
+		return buffer[(int)_numRead / 2];
+	}
+private:
+	TYPE buffer[SIZE];
+	byte _count = 0;
+	byte _numRead = SIZE;
+};

lib/GyverFilters/src/filters/median3.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// быстрый медианный фильтр 3-го порядка
+template < typename TYPE >
+class GMedian3 {
+public:
+	TYPE filtered(TYPE value) {	// возвращает фильтрованное значение
+		buffer[_counter] = value;
+		if (++_counter > 2) _counter = 0;
+		
+		TYPE middle;	
+		
+		if ((buffer[0] <= buffer[1]) && (buffer[0] <= buffer[2])) {
+			middle = (buffer[1] <= buffer[2]) ? buffer[1] : buffer[2];
+		}
+		else {
+			if ((buffer[1] <= buffer[0]) && (buffer[1] <= buffer[2])) {
+				middle = (buffer[0] <= buffer[2]) ? buffer[0] : buffer[2];
+			}
+			else {
+				middle = (buffer[0] <= buffer[1]) ? buffer[0] : buffer[1];
+			}
+		}
+		return middle;
+	}
+	
+private:
+	TYPE buffer[3];
+	uint8_t _counter = 0;
+};

lib/GyverFilters/src/filters/runningAverage.cpp

@@ -0,0 +1,43 @@
+#include <filters/runningAverage.h>
+
+GFilterRA::GFilterRA() {}
+
+GFilterRA::GFilterRA(float coef, uint16_t interval) {
+	_coef = coef;
+	_filterInterval = interval;
+}
+
+GFilterRA::GFilterRA(float coef) {
+	_coef = coef;
+}
+
+void GFilterRA::setCoef(float coef) {
+	_coef = coef;
+}
+void GFilterRA::setStep(uint16_t interval) {
+	_filterInterval = interval;
+}
+
+float GFilterRA::filteredTime(int16_t value) {
+	if (millis() - _filterTimer >= _filterInterval) {
+		_filterTimer = millis();
+		return GFilterRA::filtered(value);
+	}
+}
+
+float GFilterRA::filteredTime(float value) {
+	if (millis() - _filterTimer >= _filterInterval) {
+		_filterTimer = millis();
+		return GFilterRA::filtered(value);
+	}
+}
+
+float GFilterRA::filtered(int16_t value) {
+	_lastValue += (float)(value - _lastValue) * _coef;
+	return _lastValue;
+}
+
+float GFilterRA::filtered(float value) {
+	_lastValue += (float)(value - _lastValue) * _coef;
+	return _lastValue;
+}

lib/GyverFilters/src/filters/runningAverage.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <Arduino.h>
+
+// экспоненциальное бегущее среднее
+class GFilterRA
+{
+public:
+	GFilterRA();								// инициализация фильтра
+	GFilterRA(float coef);						// расширенная инициализация фильтра (коэффициент)
+	GFilterRA(float coef, uint16_t interval);	// расширенная инициализация фильтра (коэффициент, шаг фильтрации)
+	void setCoef(float coef);	    			// настройка коэффициента фильтрации (0.00 - 1.00). Чем меньше, тем плавнее
+	void setStep(uint16_t interval);			// установка шага фильтрации (мс). Чем меньше, тем резче фильтр
+	
+	float filteredTime(int16_t value);			// возвращает фильтрованное значение с опорой на встроенный таймер	
+	float filtered(int16_t value);				// возвращает фильтрованное значение
+	
+	float filteredTime(float value);			// возвращает фильтрованное значение с опорой на встроенный таймер	
+	float filtered(float value);				// возвращает фильтрованное значение
+	
+private:
+	float _coef = 0.0, _lastValue = 0.0;
+	uint32_t _filterTimer = 0;
+	uint16_t _filterInterval = 0;
+};

lib/LITTLEFS/LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the 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 Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

lib/LITTLEFS/README.md

@@ -0,0 +1,59 @@
+# LITTLEFS
+## LittleFS library for arduino-esp32
+
+#### Warning: Tested only with git arduino-esp32 #b92c58d core, which is for ESP-IDF 3.3! </br> With other versions/releases of the core including release 1.0.4, especially against different IDF this will NOT not work.
+
+- A LittleFS wrapper for Arduino ESP32 of [Mbed LittleFS](https://github.com/ARMmbed/littlefs)
+- Based on [ESP-IDF port of joltwallet/esp_littlefs](https://github.com/joltwallet/esp_littlefs) , thank you Brian!
+- Functionality is the same and SPIFFS partition scheme and data folder meaning are kept
+- You can use either LITTLEFS or SPIFFS but not both simultaneously on given Arduino project
+- A PR to embed it to esp32 core is made too. See the [PR status here](https://github.com/espressif/arduino-esp32/pull/4096) 
+
+### Installation
+
+- Copy <b>LITTLEFS</b> folder to Arduino IDE embedded libraries place
+- For Win, the default place of arduino-esp32 core libraries is somewhere like: 
+```C:\Users\<username>\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.4\libraries ```
+- Alternatively, you can put it to your usual libraries place
+
+### Usage
+
+- In your existing code, replace SPIFFS like this 
+``` 
+#define USE_LittleFS
+
+#include <FS.h>
+#ifdef USE_LittleFS
+  #define SPIFFS LITTLEFS
+  #include <LITTLEFS.h> 
+#else
+  #include <SPIFFS.h>
+#endif 
+ ```
+### Differences with SPIFFS (and in this implementation)
+
+- LittleFS has folders, you my need to tweak your code to iterate files in folders
+- Root: /someting  = something, so attention to /
+- Lower level littlefs library cannot mount on NULL as partition_label name, while SPIFFS can
+- Lower level littlefs library does not need maxOpenFiles parameter
+- Speed (LITTLEFS_Test.ino) 1048576 bytes written in 16238 ms / 1048576 bytes read in 918 ms
+- Speed (SPIFFS_Test.ino)   1048576 bytes written in 65971 ms / 1048576 bytes read in 680 ms
+
+
+### Arduino ESP32 LittleFS filesystem upload tool 
+
+- Download the tool archive from [here](https://github.com/lorol/arduino-esp32littlefs-plugin/raw/master/src/bin/esp32littlefs.jar)
+- In your Arduino sketchbook directory, create tools directory if it doesn't exist yet.
+- Unpack the tool into tools directory (the path will look like ```<home_dir>/Arduino/tools/ESP32LittleFS/tool/esp32littlefs.jar```).
+- You need the [mklittlefs tool](https://github.com/earlephilhower/mklittlefs)  Download the [release](https://github.com/earlephilhower/mklittlefs/releases) and copy it to 
+packages\esp32\tools\mkspiffs\<mklittlefs rev. x.x.x>\ or on checkout (dev) environment to: packages\esp32\hardware\esp32\<release>\tools\mklittlefs\
+- Restart Arduino IDE. 
+
+## Credits and license
+
+- This work is based on [Mbed LittleFS](https://github.com/ARMmbed/littlefs) , [ESP-IDF port of joltwallet/esp_littlefs](https://github.com/joltwallet/esp_littlefs) , [Espressif Arduino core for the ESP32, the ESP-IDF - SPIFFS Library](https://github.com/espressif/arduino-esp32/tree/master/libraries/SPIFFS)
+- Licensed under GPL v2 ([text](LICENSE))
+
+## To Do
+
+- Supporting different IDF versions 

lib/LITTLEFS/examples/LittleFS_test/LittleFS_test.ino

@@ -0,0 +1,182 @@
+#include <Arduino.h>
+#include "FS.h"
+#include <LITTLEFS.h>
+
+/* You only need to format SPIFFS the first time you run a
+   test or else use the LITTLEFS plugin to create a partition
+   https://github.com/me-no-dev/arduino-esp32fs-plugin */
+#define FORMAT_LITTLEFS_IF_FAILED true
+
+void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
+    Serial.printf("Listing directory: %s\r\n", dirname);
+
+    File root = fs.open(dirname);
+    if(!root){
+        Serial.println("- failed to open directory");
+        return;
+    }
+    if(!root.isDirectory()){
+        Serial.println(" - not a directory");
+        return;
+    }
+
+    File file = root.openNextFile();
+    while(file){
+        if(file.isDirectory()){
+            Serial.print("  DIR : ");
+            Serial.println(file.name());
+            if(levels){
+                listDir(fs, file.name(), levels -1);
+            }
+        } else {
+            Serial.print("  FILE: ");
+            Serial.print(file.name());
+            Serial.print("\tSIZE: ");
+            Serial.println(file.size());
+        }
+        file = root.openNextFile();
+    }
+}
+
+void readFile(fs::FS &fs, const char * path){
+    Serial.printf("Reading file: %s\r\n", path);
+
+    File file = fs.open(path);
+    if(!file || file.isDirectory()){
+        Serial.println("- failed to open file for reading");
+        return;
+    }
+
+    Serial.println("- read from file:");
+    while(file.available()){
+        Serial.write(file.read());
+    }
+    file.close();
+}
+
+void writeFile(fs::FS &fs, const char * path, const char * message){
+    Serial.printf("Writing file: %s\r\n", path);
+
+    File file = fs.open(path, FILE_WRITE);
+    if(!file){
+        Serial.println("- failed to open file for writing");
+        return;
+    }
+    if(file.print(message)){
+        Serial.println("- file written");
+    } else {
+        Serial.println("- write failed");
+    }
+    file.close();
+}
+
+void appendFile(fs::FS &fs, const char * path, const char * message){
+    Serial.printf("Appending to file: %s\r\n", path);
+
+    File file = fs.open(path, FILE_APPEND);
+    if(!file){
+        Serial.println("- failed to open file for appending");
+        return;
+    }
+    if(file.print(message)){
+        Serial.println("- message appended");
+    } else {
+        Serial.println("- append failed");
+    }
+    file.close();
+}
+
+void renameFile(fs::FS &fs, const char * path1, const char * path2){
+    Serial.printf("Renaming file %s to %s\r\n", path1, path2);
+    if (fs.rename(path1, path2)) {
+        Serial.println("- file renamed");
+    } else {
+        Serial.println("- rename failed");
+    }
+}
+
+void deleteFile(fs::FS &fs, const char * path){
+    Serial.printf("Deleting file: %s\r\n", path);
+    if(fs.remove(path)){
+        Serial.println("- file deleted");
+    } else {
+        Serial.println("- delete failed");
+    }
+}
+
+void testFileIO(fs::FS &fs, const char * path){
+    Serial.printf("Testing file I/O with %s\r\n", path);
+
+    static uint8_t buf[512];
+    size_t len = 0;
+    File file = fs.open(path, FILE_WRITE);
+    if(!file){
+        Serial.println("- failed to open file for writing");
+        return;
+    }
+
+    size_t i;
+    Serial.print("- writing" );
+    uint32_t start = millis();
+    for(i=0; i<2048; i++){
+        if ((i & 0x001F) == 0x001F){
+          Serial.print(".");
+        }
+        file.write(buf, 512);
+    }
+    Serial.println("");
+    uint32_t end = millis() - start;
+    Serial.printf(" - %u bytes written in %u ms\r\n", 2048 * 512, end);
+    file.close();
+
+    file = fs.open(path);
+    start = millis();
+    end = start;
+    i = 0;
+    if(file && !file.isDirectory()){
+        len = file.size();
+        size_t flen = len;
+        start = millis();
+        Serial.print("- reading" );
+        while(len){
+            size_t toRead = len;
+            if(toRead > 512){
+                toRead = 512;
+            }
+            file.read(buf, toRead);
+            if ((i++ & 0x001F) == 0x001F){
+              Serial.print(".");
+            }
+            len -= toRead;
+        }
+        Serial.println("");
+        end = millis() - start;
+        Serial.printf("- %u bytes read in %u ms\r\n", flen, end);
+        file.close();
+    } else {
+        Serial.println("- failed to open file for reading");
+    }
+}
+
+void setup(){
+    Serial.begin(115200);
+    if(!LITTLEFS.begin(FORMAT_LITTLEFS_IF_FAILED)){
+        Serial.println("LITTLEFS Mount Failed");
+        return;
+    }
+    
+    listDir(LITTLEFS, "/", 0);
+    writeFile(LITTLEFS, "/hello.txt", "Hello ");
+    appendFile(LITTLEFS, "/hello.txt", "World!\r\n");
+    readFile(LITTLEFS, "/hello.txt");
+    renameFile(LITTLEFS, "/hello.txt", "/foo.txt");
+    readFile(LITTLEFS, "/foo.txt");
+    deleteFile(LITTLEFS, "/foo.txt");
+    testFileIO(LITTLEFS, "/test.txt");
+    deleteFile(LITTLEFS, "/test.txt");
+    Serial.println( "Test complete" );
+}
+
+void loop(){
+
+}

lib/LITTLEFS/library.json

@@ -0,0 +1,22 @@
+{
+  "name":"LITTLEFS",
+  "description":"LITTLEFS File System Library for ESP32",
+  "keywords":"littlefs, spiffs",
+  "authors":
+  {
+    "name": "LL",
+    "maintainer": true
+  },
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/lorol/LITTLEFS.git"
+  },
+  "version": "1.0",
+  "license": "LGPL-2.0",
+  "frameworks": "arduino",
+  "platforms": "espressif32",
+  "build": {
+    "libCompatMode": 2
+  }  
+}

lib/LITTLEFS/library.properties

@@ -0,0 +1,9 @@
+name=LITTLEFS
+version=1.0
+author=LL
+maintainer=LL
+sentence=ESP32 LITTLEFS File System
+paragraph=
+category=Data Storage
+url=
+architectures=esp32

lib/LITTLEFS/src/LITTLEFS.cpp

@@ -0,0 +1,106 @@
+// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+static constexpr const char LFS_NAME[] = "spiffs";
+
+#include "vfs_api.h"
+
+extern "C" {
+#include <sys/unistd.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include "esp_littlefs.h"
+}
+
+#include "LITTLEFS.h"
+
+using namespace fs;
+
+LITTLEFSFS::LITTLEFSFS() : FS(FSImplPtr(new VFSImpl()))
+{
+
+}
+
+bool LITTLEFSFS::begin(bool formatOnFail, const char * basePath, uint8_t maxOpenFiles)
+{
+    if(esp_littlefs_mounted(LFS_NAME)){
+        log_w("LITTLEFS Already Mounted!");
+        return true;
+    }
+
+    esp_vfs_littlefs_conf_t conf = {
+      .base_path = basePath,
+      .partition_label = LFS_NAME,
+      //.max_files = maxOpenFiles,
+      .format_if_mount_failed = false
+    };
+
+    esp_err_t err = esp_vfs_littlefs_register(&conf);
+    if(err == ESP_FAIL && formatOnFail){
+        if(format()){
+            err = esp_vfs_littlefs_register(&conf);
+        }
+    }
+    if(err != ESP_OK){
+        log_e("Mounting LITTLEFS failed! Error: %d", err);
+        return false;
+    }
+    _impl->mountpoint(basePath);
+    return true;
+}
+
+void LITTLEFSFS::end()
+{
+    if(esp_littlefs_mounted(LFS_NAME)){
+        esp_err_t err = esp_vfs_littlefs_unregister(LFS_NAME);
+        if(err){
+            log_e("Unmounting LITTLEFS failed! Error: %d", err);
+            return;
+        }
+        _impl->mountpoint(NULL);
+    }
+}
+
+bool LITTLEFSFS::format()
+{
+    disableCore0WDT();
+    esp_err_t err = esp_littlefs_format(LFS_NAME);
+    enableCore0WDT();
+    if(err){
+        log_e("Formatting LITTLEFS failed! Error: %d", err);
+        return false;
+    }
+    return true;
+}
+
+size_t LITTLEFSFS::totalBytes()
+{
+    size_t total,used;
+    if(esp_littlefs_info(LFS_NAME, &total, &used)){
+        return 0;
+    }
+    return total;
+}
+
+size_t LITTLEFSFS::usedBytes()
+{
+    size_t total,used;
+    if(esp_littlefs_info(LFS_NAME, &total, &used)){
+        return 0;
+    }
+    return used;
+}
+
+LITTLEFSFS LITTLEFS;
+

lib/LITTLEFS/src/LITTLEFS.h

@@ -0,0 +1,38 @@
+// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef _LITTLEFS_H_
+#define _LITTLEFS_H_
+
+#include "FS.h"
+
+namespace fs
+{
+
+class LITTLEFSFS : public FS
+{
+public:
+    LITTLEFSFS();
+    bool begin(bool formatOnFail=false, const char * basePath="/littlefs", uint8_t maxOpenFiles=5);
+    bool format();
+    size_t totalBytes();
+    size_t usedBytes();
+    void end();
+};
+
+}
+
+extern fs::LITTLEFSFS LITTLEFS;
+
+
+#endif

lib/LITTLEFS/src/esp_littlefs.h

@@ -0,0 +1,114 @@
+#ifndef ESP_LITTLEFS_H__
+#define ESP_LITTLEFS_H__
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <utime.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include "esp_err.h"
+#include <sys/types.h>
+#include <sys/reent.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/termios.h>
+#include <sys/poll.h>
+#include <dirent.h>
+#include <string.h>
+#include "sdkconfig.h"
+
+#include "lfs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    LITTLEFS_ATTR_MTIME,   /**< Last Modified - time (seconds) */
+    LITTLEFS_ATTR_MAX
+};
+
+/**
+ *Configuration structure for esp_vfs_littlefs_register.
+ */
+typedef struct {
+    const char *base_path;            /**< Mounting point. */
+    const char *partition_label;      /**< Label of partition to use. */
+    uint8_t format_if_mount_failed:1; /**< Format the file system if it fails to mount. */
+    uint8_t dont_mount:1;             /**< Don't attempt to mount or format. Overrides format_if_mount_failed */
+} esp_vfs_littlefs_conf_t;
+
+/**
+ * Register and mount littlefs to VFS with given path prefix.
+ *
+ * @param   conf                      Pointer to esp_vfs_littlefs_conf_t configuration structure
+ *
+ * @return  
+ *          - ESP_OK                  if success
+ *          - ESP_ERR_NO_MEM          if objects could not be allocated
+ *          - ESP_ERR_INVALID_STATE   if already mounted or partition is encrypted
+ *          - ESP_ERR_NOT_FOUND       if partition for littlefs was not found
+ *          - ESP_FAIL                if mount or format fails
+ */
+esp_err_t esp_vfs_littlefs_register(const esp_vfs_littlefs_conf_t * conf);
+
+/**
+ * Unregister and unmount littlefs from VFS
+ *
+ * @param partition_label  Label of the partition to unregister.
+ *
+ * @return  
+ *          - ESP_OK if successful
+ *          - ESP_ERR_INVALID_STATE already unregistered
+ */
+esp_err_t esp_vfs_littlefs_unregister(const char* partition_label);
+
+/**
+ * Check if littlefs is mounted
+ *
+ * @param partition_label  Label of the partition to check.
+ *
+ * @return  
+ *          - true    if mounted
+ *          - false   if not mounted
+ */
+bool esp_littlefs_mounted(const char* partition_label);
+
+/**
+ * Format the littlefs partition
+ *
+ * @param partition_label  Label of the partition to format.
+ * @return  
+ *          - ESP_OK      if successful
+ *          - ESP_FAIL    on error
+ */
+esp_err_t esp_littlefs_format(const char* partition_label);
+
+/**
+ * Get information for littlefs
+ *
+ * @param partition_label           Optional, label of the partition to get info for.
+ * @param[out] total_bytes          Size of the file system
+ * @param[out] used_bytes           Current used bytes in the file system
+ *
+ * @return  
+ *          - ESP_OK                  if success
+ *          - ESP_ERR_INVALID_STATE   if not mounted
+ */
+esp_err_t esp_littlefs_info(const char* partition_label, size_t *total_bytes, size_t *used_bytes);
+
+#if CONFIG_LITTLEFS_HUMAN_READABLE
+/**
+ * @brief converts an enumerated lfs error into a string.
+ * @param lfs_errno The enumerated littlefs error.
+ */
+const char * esp_littlefs_errno(enum lfs_error lfs_errno);
+#endif
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

lib/LITTLEFS/src/lfs.h

@@ -0,0 +1,655 @@
+/*
+ * The little filesystem
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS_H
+#define LFS_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/// Version info ///
+
+// Software library version
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS_VERSION 0x00020002
+#define LFS_VERSION_MAJOR (0xffff & (LFS_VERSION >> 16))
+#define LFS_VERSION_MINOR (0xffff & (LFS_VERSION >>  0))
+
+// Version of On-disk data structures
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS_DISK_VERSION 0x00020000
+#define LFS_DISK_VERSION_MAJOR (0xffff & (LFS_DISK_VERSION >> 16))
+#define LFS_DISK_VERSION_MINOR (0xffff & (LFS_DISK_VERSION >>  0))
+
+
+/// Definitions ///
+
+// Type definitions
+typedef uint32_t lfs_size_t;
+typedef uint32_t lfs_off_t;
+
+typedef int32_t  lfs_ssize_t;
+typedef int32_t  lfs_soff_t;
+
+typedef uint32_t lfs_block_t;
+
+// Maximum name size in bytes, may be redefined to reduce the size of the
+// info struct. Limited to <= 1022. Stored in superblock and must be
+// respected by other littlefs drivers.
+#ifndef LFS_NAME_MAX
+#define LFS_NAME_MAX 255
+#endif
+
+// Maximum size of a file in bytes, may be redefined to limit to support other
+// drivers. Limited on disk to <= 4294967296. However, above 2147483647 the
+// functions lfs_file_seek, lfs_file_size, and lfs_file_tell will return
+// incorrect values due to using signed integers. Stored in superblock and
+// must be respected by other littlefs drivers.
+#ifndef LFS_FILE_MAX
+#define LFS_FILE_MAX 2147483647
+#endif
+
+// Maximum size of custom attributes in bytes, may be redefined, but there is
+// no real benefit to using a smaller LFS_ATTR_MAX. Limited to <= 1022.
+#ifndef LFS_ATTR_MAX
+#define LFS_ATTR_MAX 1022
+#endif
+
+// Possible error codes, these are negative to allow
+// valid positive return values
+enum lfs_error {
+    LFS_ERR_OK          = 0,    // No error
+    LFS_ERR_IO          = -5,   // Error during device operation
+    LFS_ERR_CORRUPT     = -84,  // Corrupted
+    LFS_ERR_NOENT       = -2,   // No directory entry
+    LFS_ERR_EXIST       = -17,  // Entry already exists
+    LFS_ERR_NOTDIR      = -20,  // Entry is not a dir
+    LFS_ERR_ISDIR       = -21,  // Entry is a dir
+    LFS_ERR_NOTEMPTY    = -39,  // Dir is not empty
+    LFS_ERR_BADF        = -9,   // Bad file number
+    LFS_ERR_FBIG        = -27,  // File too large
+    LFS_ERR_INVAL       = -22,  // Invalid parameter
+    LFS_ERR_NOSPC       = -28,  // No space left on device
+    LFS_ERR_NOMEM       = -12,  // No more memory available
+    LFS_ERR_NOATTR      = -61,  // No data/attr available
+    LFS_ERR_NAMETOOLONG = -36,  // File name too long
+};
+
+// File types
+enum lfs_type {
+    // file types
+    LFS_TYPE_REG            = 0x001,
+    LFS_TYPE_DIR            = 0x002,
+
+    // internally used types
+    LFS_TYPE_SPLICE         = 0x400,
+    LFS_TYPE_NAME           = 0x000,
+    LFS_TYPE_STRUCT         = 0x200,
+    LFS_TYPE_USERATTR       = 0x300,
+    LFS_TYPE_FROM           = 0x100,
+    LFS_TYPE_TAIL           = 0x600,
+    LFS_TYPE_GLOBALS        = 0x700,
+    LFS_TYPE_CRC            = 0x500,
+
+    // internally used type specializations
+    LFS_TYPE_CREATE         = 0x401,
+    LFS_TYPE_DELETE         = 0x4ff,
+    LFS_TYPE_SUPERBLOCK     = 0x0ff,
+    LFS_TYPE_DIRSTRUCT      = 0x200,
+    LFS_TYPE_CTZSTRUCT      = 0x202,
+    LFS_TYPE_INLINESTRUCT   = 0x201,
+    LFS_TYPE_SOFTTAIL       = 0x600,
+    LFS_TYPE_HARDTAIL       = 0x601,
+    LFS_TYPE_MOVESTATE      = 0x7ff,
+
+    // internal chip sources
+    LFS_FROM_NOOP           = 0x000,
+    LFS_FROM_MOVE           = 0x101,
+    LFS_FROM_USERATTRS      = 0x102,
+};
+
+// File open flags
+enum lfs_open_flags {
+    // open flags
+    LFS_O_RDONLY = 1,         // Open a file as read only
+    LFS_O_WRONLY = 2,         // Open a file as write only
+    LFS_O_RDWR   = 3,         // Open a file as read and write
+    LFS_O_CREAT  = 0x0100,    // Create a file if it does not exist
+    LFS_O_EXCL   = 0x0200,    // Fail if a file already exists
+    LFS_O_TRUNC  = 0x0400,    // Truncate the existing file to zero size
+    LFS_O_APPEND = 0x0800,    // Move to end of file on every write
+
+    // internally used flags
+    LFS_F_DIRTY   = 0x010000, // File does not match storage
+    LFS_F_WRITING = 0x020000, // File has been written since last flush
+    LFS_F_READING = 0x040000, // File has been read since last flush
+    LFS_F_ERRED   = 0x080000, // An error occured during write
+    LFS_F_INLINE  = 0x100000, // Currently inlined in directory entry
+    LFS_F_OPENED  = 0x200000, // File has been opened
+};
+
+// File seek flags
+enum lfs_whence_flags {
+    LFS_SEEK_SET = 0,   // Seek relative to an absolute position
+    LFS_SEEK_CUR = 1,   // Seek relative to the current file position
+    LFS_SEEK_END = 2,   // Seek relative to the end of the file
+};
+
+
+// Configuration provided during initialization of the littlefs
+struct lfs_config {
+    // Opaque user provided context that can be used to pass
+    // information to the block device operations
+    void *context;
+
+    // Read a region in a block. Negative error codes are propogated
+    // to the user.
+    int (*read)(const struct lfs_config *c, lfs_block_t block,
+            lfs_off_t off, void *buffer, lfs_size_t size);
+
+    // Program a region in a block. The block must have previously
+    // been erased. Negative error codes are propogated to the user.
+    // May return LFS_ERR_CORRUPT if the block should be considered bad.
+    int (*prog)(const struct lfs_config *c, lfs_block_t block,
+            lfs_off_t off, const void *buffer, lfs_size_t size);
+
+    // Erase a block. A block must be erased before being programmed.
+    // The state of an erased block is undefined. Negative error codes
+    // are propogated to the user.
+    // May return LFS_ERR_CORRUPT if the block should be considered bad.
+    int (*erase)(const struct lfs_config *c, lfs_block_t block);
+
+    // Sync the state of the underlying block device. Negative error codes
+    // are propogated to the user.
+    int (*sync)(const struct lfs_config *c);
+
+    // Minimum size of a block read. All read operations will be a
+    // multiple of this value.
+    lfs_size_t read_size;
+
+    // Minimum size of a block program. All program operations will be a
+    // multiple of this value.
+    lfs_size_t prog_size;
+
+    // Size of an erasable block. This does not impact ram consumption and
+    // may be larger than the physical erase size. However, non-inlined files
+    // take up at minimum one block. Must be a multiple of the read
+    // and program sizes.
+    lfs_size_t block_size;
+
+    // Number of erasable blocks on the device.
+    lfs_size_t block_count;
+
+    // Number of erase cycles before littlefs evicts metadata logs and moves 
+    // the metadata to another block. Suggested values are in the
+    // range 100-1000, with large values having better performance at the cost
+    // of less consistent wear distribution.
+    //
+    // Set to -1 to disable block-level wear-leveling.
+    int32_t block_cycles;
+
+    // Size of block caches. Each cache buffers a portion of a block in RAM.
+    // The littlefs needs a read cache, a program cache, and one additional
+    // cache per file. Larger caches can improve performance by storing more
+    // data and reducing the number of disk accesses. Must be a multiple of
+    // the read and program sizes, and a factor of the block size.
+    lfs_size_t cache_size;
+
+    // Size of the lookahead buffer in bytes. A larger lookahead buffer
+    // increases the number of blocks found during an allocation pass. The
+    // lookahead buffer is stored as a compact bitmap, so each byte of RAM
+    // can track 8 blocks. Must be a multiple of 8.
+    lfs_size_t lookahead_size;
+
+    // Optional statically allocated read buffer. Must be cache_size.
+    // By default lfs_malloc is used to allocate this buffer.
+    void *read_buffer;
+
+    // Optional statically allocated program buffer. Must be cache_size.
+    // By default lfs_malloc is used to allocate this buffer.
+    void *prog_buffer;
+
+    // Optional statically allocated lookahead buffer. Must be lookahead_size
+    // and aligned to a 32-bit boundary. By default lfs_malloc is used to
+    // allocate this buffer.
+    void *lookahead_buffer;
+
+    // Optional upper limit on length of file names in bytes. No downside for
+    // larger names except the size of the info struct which is controlled by
+    // the LFS_NAME_MAX define. Defaults to LFS_NAME_MAX when zero. Stored in
+    // superblock and must be respected by other littlefs drivers.
+    lfs_size_t name_max;
+
+    // Optional upper limit on files in bytes. No downside for larger files
+    // but must be <= LFS_FILE_MAX. Defaults to LFS_FILE_MAX when zero. Stored
+    // in superblock and must be respected by other littlefs drivers.
+    lfs_size_t file_max;
+
+    // Optional upper limit on custom attributes in bytes. No downside for
+    // larger attributes size but must be <= LFS_ATTR_MAX. Defaults to
+    // LFS_ATTR_MAX when zero.
+    lfs_size_t attr_max;
+};
+
+// File info structure
+struct lfs_info {
+    // Type of the file, either LFS_TYPE_REG or LFS_TYPE_DIR
+    uint8_t type;
+
+    // Size of the file, only valid for REG files. Limited to 32-bits.
+    lfs_size_t size;
+
+    // Name of the file stored as a null-terminated string. Limited to
+    // LFS_NAME_MAX+1, which can be changed by redefining LFS_NAME_MAX to
+    // reduce RAM. LFS_NAME_MAX is stored in superblock and must be
+    // respected by other littlefs drivers.
+    char name[LFS_NAME_MAX+1];
+};
+
+// Custom attribute structure, used to describe custom attributes
+// committed atomically during file writes.
+struct lfs_attr {
+    // 8-bit type of attribute, provided by user and used to
+    // identify the attribute
+    uint8_t type;
+
+    // Pointer to buffer containing the attribute
+    void *buffer;
+
+    // Size of attribute in bytes, limited to LFS_ATTR_MAX
+    lfs_size_t size;
+};
+
+// Optional configuration provided during lfs_file_opencfg
+struct lfs_file_config {
+    // Optional statically allocated file buffer. Must be cache_size.
+    // By default lfs_malloc is used to allocate this buffer.
+    void *buffer;
+
+    // Optional list of custom attributes related to the file. If the file
+    // is opened with read access, these attributes will be read from disk
+    // during the open call. If the file is opened with write access, the
+    // attributes will be written to disk every file sync or close. This
+    // write occurs atomically with update to the file's contents.
+    //
+    // Custom attributes are uniquely identified by an 8-bit type and limited
+    // to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller
+    // than the buffer, it will be padded with zeros. If the stored attribute
+    // is larger, then it will be silently truncated. If the attribute is not
+    // found, it will be created implicitly.
+    struct lfs_attr *attrs;
+
+    // Number of custom attributes in the list
+    lfs_size_t attr_count;
+};
+
+
+/// internal littlefs data structures ///
+typedef struct lfs_cache {
+    lfs_block_t block;
+    lfs_off_t off;
+    lfs_size_t size;
+    uint8_t *buffer;
+} lfs_cache_t;
+
+typedef struct lfs_mdir {
+    lfs_block_t pair[2];
+    uint32_t rev;
+    lfs_off_t off;
+    uint32_t etag;
+    uint16_t count;
+    bool erased;
+    bool split;
+    lfs_block_t tail[2];
+} lfs_mdir_t;
+
+// littlefs directory type
+typedef struct lfs_dir {
+    struct lfs_dir *next;
+    uint16_t id;
+    uint8_t type;
+    lfs_mdir_t m;
+
+    lfs_off_t pos;
+    lfs_block_t head[2];
+} lfs_dir_t;
+
+// littlefs file type
+typedef struct lfs_file {
+    struct lfs_file *next;
+    uint16_t id;
+    uint8_t type;
+    lfs_mdir_t m;
+
+    struct lfs_ctz {
+        lfs_block_t head;
+        lfs_size_t size;
+    } ctz;
+
+    uint32_t flags;
+    lfs_off_t pos;
+    lfs_block_t block;
+    lfs_off_t off;
+    lfs_cache_t cache;
+
+    const struct lfs_file_config *cfg;
+} lfs_file_t;
+
+typedef struct lfs_superblock {
+    uint32_t version;
+    lfs_size_t block_size;
+    lfs_size_t block_count;
+    lfs_size_t name_max;
+    lfs_size_t file_max;
+    lfs_size_t attr_max;
+} lfs_superblock_t;
+
+typedef struct lfs_gstate {
+    uint32_t tag;
+    lfs_block_t pair[2];
+} lfs_gstate_t;
+
+// The littlefs filesystem type
+typedef struct lfs {
+    lfs_cache_t rcache;
+    lfs_cache_t pcache;
+
+    lfs_block_t root[2];
+    struct lfs_mlist {
+        struct lfs_mlist *next;
+        uint16_t id;
+        uint8_t type;
+        lfs_mdir_t m;
+    } *mlist;
+    uint32_t seed;
+
+    lfs_gstate_t gstate;
+    lfs_gstate_t gdisk;
+    lfs_gstate_t gdelta;
+
+    struct lfs_free {
+        lfs_block_t off;
+        lfs_block_t size;
+        lfs_block_t i;
+        lfs_block_t ack;
+        uint32_t *buffer;
+    } free;
+
+    const struct lfs_config *cfg;
+    lfs_size_t name_max;
+    lfs_size_t file_max;
+    lfs_size_t attr_max;
+
+#ifdef LFS_MIGRATE
+    struct lfs1 *lfs1;
+#endif
+} lfs_t;
+
+
+/// Filesystem functions ///
+
+// Format a block device with the littlefs
+//
+// Requires a littlefs object and config struct. This clobbers the littlefs
+// object, and does not leave the filesystem mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs_format(lfs_t *lfs, const struct lfs_config *config);
+
+// Mounts a littlefs
+//
+// Requires a littlefs object and config struct. Multiple filesystems
+// may be mounted simultaneously with multiple littlefs objects. Both
+// lfs and config must be allocated while mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs_mount(lfs_t *lfs, const struct lfs_config *config);
+
+// Unmounts a littlefs
+//
+// Does nothing besides releasing any allocated resources.
+// Returns a negative error code on failure.
+int lfs_unmount(lfs_t *lfs);
+
+/// General operations ///
+
+// Removes a file or directory
+//
+// If removing a directory, the directory must be empty.
+// Returns a negative error code on failure.
+int lfs_remove(lfs_t *lfs, const char *path);
+
+// Rename or move a file or directory
+//
+// If the destination exists, it must match the source in type.
+// If the destination is a directory, the directory must be empty.
+//
+// Returns a negative error code on failure.
+int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath);
+
+// Find info about a file or directory
+//
+// Fills out the info structure, based on the specified file or directory.
+// Returns a negative error code on failure.
+int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
+
+// Get a custom attribute
+//
+// Custom attributes are uniquely identified by an 8-bit type and limited
+// to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller than
+// the buffer, it will be padded with zeros. If the stored attribute is larger,
+// then it will be silently truncated. If no attribute is found, the error
+// LFS_ERR_NOATTR is returned and the buffer is filled with zeros.
+//
+// Returns the size of the attribute, or a negative error code on failure.
+// Note, the returned size is the size of the attribute on disk, irrespective
+// of the size of the buffer. This can be used to dynamically allocate a buffer
+// or check for existance.
+lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path,
+        uint8_t type, void *buffer, lfs_size_t size);
+
+// Set custom attributes
+//
+// Custom attributes are uniquely identified by an 8-bit type and limited
+// to LFS_ATTR_MAX bytes. If an attribute is not found, it will be
+// implicitly created.
+//
+// Returns a negative error code on failure.
+int lfs_setattr(lfs_t *lfs, const char *path,
+        uint8_t type, const void *buffer, lfs_size_t size);
+
+// Removes a custom attribute
+//
+// If an attribute is not found, nothing happens.
+//
+// Returns a negative error code on failure.
+int lfs_removeattr(lfs_t *lfs, const char *path, uint8_t type);
+
+
+/// File operations ///
+
+// Open a file
+//
+// The mode that the file is opened in is determined by the flags, which
+// are values from the enum lfs_open_flags that are bitwise-ored together.
+//
+// Returns a negative error code on failure.
+int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
+        const char *path, int flags);
+
+// Open a file with extra configuration
+//
+// The mode that the file is opened in is determined by the flags, which
+// are values from the enum lfs_open_flags that are bitwise-ored together.
+//
+// The config struct provides additional config options per file as described
+// above. The config struct must be allocated while the file is open, and the
+// config struct must be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file,
+        const char *path, int flags,
+        const struct lfs_file_config *config);
+
+// Close a file
+//
+// Any pending writes are written out to storage as though
+// sync had been called and releases any allocated resources.
+//
+// Returns a negative error code on failure.
+int lfs_file_close(lfs_t *lfs, lfs_file_t *file);
+
+// Synchronize a file on storage
+//
+// Any pending writes are written out to storage.
+// Returns a negative error code on failure.
+int lfs_file_sync(lfs_t *lfs, lfs_file_t *file);
+
+// Read data from file
+//
+// Takes a buffer and size indicating where to store the read data.
+// Returns the number of bytes read, or a negative error code on failure.
+lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
+        void *buffer, lfs_size_t size);
+
+// Write data to file
+//
+// Takes a buffer and size indicating the data to write. The file will not
+// actually be updated on the storage until either sync or close is called.
+//
+// Returns the number of bytes written, or a negative error code on failure.
+lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
+        const void *buffer, lfs_size_t size);
+
+// Change the position of the file
+//
+// The change in position is determined by the offset and whence flag.
+// Returns the new position of the file, or a negative error code on failure.
+lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
+        lfs_soff_t off, int whence);
+
+// Truncates the size of the file to the specified size
+//
+// Returns a negative error code on failure.
+int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size);
+
+// Return the position of the file
+//
+// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_CUR)
+// Returns the position of the file, or a negative error code on failure.
+lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file);
+
+// Change the position of the file to the beginning of the file
+//
+// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_SET)
+// Returns a negative error code on failure.
+int lfs_file_rewind(lfs_t *lfs, lfs_file_t *file);
+
+// Return the size of the file
+//
+// Similar to lfs_file_seek(lfs, file, 0, LFS_SEEK_END)
+// Returns the size of the file, or a negative error code on failure.
+lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file);
+
+
+/// Directory operations ///
+
+// Create a directory
+//
+// Returns a negative error code on failure.
+int lfs_mkdir(lfs_t *lfs, const char *path);
+
+// Open a directory
+//
+// Once open a directory can be used with read to iterate over files.
+// Returns a negative error code on failure.
+int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path);
+
+// Close a directory
+//
+// Releases any allocated resources.
+// Returns a negative error code on failure.
+int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir);
+
+// Read an entry in the directory
+//
+// Fills out the info structure, based on the specified file or directory.
+// Returns a positive value on success, 0 at the end of directory,
+// or a negative error code on failure.
+int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info);
+
+// Change the position of the directory
+//
+// The new off must be a value previous returned from tell and specifies
+// an absolute offset in the directory seek.
+//
+// Returns a negative error code on failure.
+int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off);
+
+// Return the position of the directory
+//
+// The returned offset is only meant to be consumed by seek and may not make
+// sense, but does indicate the current position in the directory iteration.
+//
+// Returns the position of the directory, or a negative error code on failure.
+lfs_soff_t lfs_dir_tell(lfs_t *lfs, lfs_dir_t *dir);
+
+// Change the position of the directory to the beginning of the directory
+//
+// Returns a negative error code on failure.
+int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir);
+
+
+/// Filesystem-level filesystem operations
+
+// Finds the current size of the filesystem
+//
+// Note: Result is best effort. If files share COW structures, the returned
+// size may be larger than the filesystem actually is.
+//
+// Returns the number of allocated blocks, or a negative error code on failure.
+lfs_ssize_t lfs_fs_size(lfs_t *lfs);
+
+// Traverse through all blocks in use by the filesystem
+//
+// The provided callback will be called with each block address that is
+// currently in use by the filesystem. This can be used to determine which
+// blocks are in use or how much of the storage is available.
+//
+// Returns a negative error code on failure.
+int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
+
+#ifdef LFS_MIGRATE
+// Attempts to migrate a previous version of littlefs
+//
+// Behaves similarly to the lfs_format function. Attempts to mount
+// the previous version of littlefs and update the filesystem so it can be
+// mounted with the current version of littlefs.
+//
+// Requires a littlefs object and config struct. This clobbers the littlefs
+// object, and does not leave the filesystem mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg);
+#endif
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

lib/LITTLEFS/src/lfs_util.c

@@ -0,0 +1,33 @@
+/*
+ * lfs util functions
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "lfs_util.h"
+
+// Only compile if user does not provide custom config
+#ifndef LFS_CONFIG
+
+
+// Software CRC implementation with small lookup table
+uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
+    static const uint32_t rtable[16] = {
+        0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
+        0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
+        0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
+        0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
+    };
+
+    const uint8_t *data = buffer;
+
+    for (size_t i = 0; i < size; i++) {
+        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 0)) & 0xf];
+        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 4)) & 0xf];
+    }
+
+    return crc;
+}
+
+
+#endif

lib/LITTLEFS/src/lfs_util.h

@@ -0,0 +1,234 @@
+/*
+ * lfs utility functions
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS_UTIL_H
+#define LFS_UTIL_H
+
+// Users can override lfs_util.h with their own configuration by defining
+// LFS_CONFIG as a header file to include (-DLFS_CONFIG=lfs_config.h).
+//
+// If LFS_CONFIG is used, none of the default utils will be emitted and must be
+// provided by the config file. To start, I would suggest copying lfs_util.h
+// and modifying as needed.
+#ifdef LFS_CONFIG
+#define LFS_STRINGIZE(x) LFS_STRINGIZE2(x)
+#define LFS_STRINGIZE2(x) #x
+#include LFS_STRINGIZE(LFS_CONFIG)
+#else
+
+// System includes
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <inttypes.h>
+
+#ifndef LFS_NO_MALLOC
+#include <stdlib.h>
+#endif
+#ifndef LFS_NO_ASSERT
+#include <assert.h>
+#endif
+#if !defined(LFS_NO_DEBUG) || \
+        !defined(LFS_NO_WARN) || \
+        !defined(LFS_NO_ERROR) || \
+        defined(LFS_YES_TRACE)
+#include <stdio.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+// Macros, may be replaced by system specific wrappers. Arguments to these
+// macros must not have side-effects as the macros can be removed for a smaller
+// code footprint
+
+// Logging functions
+#ifdef LFS_YES_TRACE
+#define LFS_TRACE_(fmt, ...) \
+    printf("%s:%d:trace: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS_TRACE(...) LFS_TRACE_(__VA_ARGS__, "")
+#else
+#define LFS_TRACE(...)
+#endif
+
+#ifndef LFS_NO_DEBUG
+#define LFS_DEBUG_(fmt, ...) \
+    printf("%s:%d:debug: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS_DEBUG(...) LFS_DEBUG_(__VA_ARGS__, "")
+#else
+#define LFS_DEBUG(...)
+#endif
+
+#ifndef LFS_NO_WARN
+#define LFS_WARN_(fmt, ...) \
+    printf("%s:%d:warn: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS_WARN(...) LFS_WARN_(__VA_ARGS__, "")
+#else
+#define LFS_WARN(...)
+#endif
+
+#ifndef LFS_NO_ERROR
+#define LFS_ERROR_(fmt, ...) \
+    printf("%s:%d:error: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS_ERROR(...) LFS_ERROR_(__VA_ARGS__, "")
+#else
+#define LFS_ERROR(...)
+#endif
+
+// Runtime assertions
+#ifndef LFS_NO_ASSERT
+#define LFS_ASSERT(test) assert(test)
+#else
+#define LFS_ASSERT(test)
+#endif
+
+
+// Builtin functions, these may be replaced by more efficient
+// toolchain-specific implementations. LFS_NO_INTRINSICS falls back to a more
+// expensive basic C implementation for debugging purposes
+
+// Min/max functions for unsigned 32-bit numbers
+static inline uint32_t lfs_max(uint32_t a, uint32_t b) {
+    return (a > b) ? a : b;
+}
+
+static inline uint32_t lfs_min(uint32_t a, uint32_t b) {
+    return (a < b) ? a : b;
+}
+
+// Align to nearest multiple of a size
+static inline uint32_t lfs_aligndown(uint32_t a, uint32_t alignment) {
+    return a - (a % alignment);
+}
+
+static inline uint32_t lfs_alignup(uint32_t a, uint32_t alignment) {
+    return lfs_aligndown(a + alignment-1, alignment);
+}
+
+// Find the smallest power of 2 greater than or equal to a
+static inline uint32_t lfs_npw2(uint32_t a) {
+#if !defined(LFS_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return 32 - __builtin_clz(a-1);
+#else
+    uint32_t r = 0;
+    uint32_t s;
+    a -= 1;
+    s = (a > 0xffff) << 4; a >>= s; r |= s;
+    s = (a > 0xff  ) << 3; a >>= s; r |= s;
+    s = (a > 0xf   ) << 2; a >>= s; r |= s;
+    s = (a > 0x3   ) << 1; a >>= s; r |= s;
+    return (r | (a >> 1)) + 1;
+#endif
+}
+
+// Count the number of trailing binary zeros in a
+// lfs_ctz(0) may be undefined
+static inline uint32_t lfs_ctz(uint32_t a) {
+#if !defined(LFS_NO_INTRINSICS) && defined(__GNUC__)
+    return __builtin_ctz(a);
+#else
+    return lfs_npw2((a & -a) + 1) - 1;
+#endif
+}
+
+// Count the number of binary ones in a
+static inline uint32_t lfs_popc(uint32_t a) {
+#if !defined(LFS_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return __builtin_popcount(a);
+#else
+    a = a - ((a >> 1) & 0x55555555);
+    a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
+    return (((a + (a >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;
+#endif
+}
+
+// Find the sequence comparison of a and b, this is the distance
+// between a and b ignoring overflow
+static inline int lfs_scmp(uint32_t a, uint32_t b) {
+    return (int)(unsigned)(a - b);
+}
+
+// Convert between 32-bit little-endian and native order
+static inline uint32_t lfs_fromle32(uint32_t a) {
+#if !defined(LFS_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_LITTLE_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_LITTLE_ENDIAN  ) && __BYTE_ORDER   == __ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+    return a;
+#elif !defined(LFS_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_BIG_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_BIG_ENDIAN  ) && __BYTE_ORDER   == __ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+    return __builtin_bswap32(a);
+#else
+    return (((uint8_t*)&a)[0] <<  0) |
+           (((uint8_t*)&a)[1] <<  8) |
+           (((uint8_t*)&a)[2] << 16) |
+           (((uint8_t*)&a)[3] << 24);
+#endif
+}
+
+static inline uint32_t lfs_tole32(uint32_t a) {
+    return lfs_fromle32(a);
+}
+
+// Convert between 32-bit big-endian and native order
+static inline uint32_t lfs_frombe32(uint32_t a) {
+#if !defined(LFS_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_LITTLE_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_LITTLE_ENDIAN  ) && __BYTE_ORDER   == __ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+    return __builtin_bswap32(a);
+#elif !defined(LFS_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_BIG_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_BIG_ENDIAN  ) && __BYTE_ORDER   == __ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+    return a;
+#else
+    return (((uint8_t*)&a)[0] << 24) |
+           (((uint8_t*)&a)[1] << 16) |
+           (((uint8_t*)&a)[2] <<  8) |
+           (((uint8_t*)&a)[3] <<  0);
+#endif
+}
+
+static inline uint32_t lfs_tobe32(uint32_t a) {
+    return lfs_frombe32(a);
+}
+
+// Calculate CRC-32 with polynomial = 0x04c11db7
+uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size);
+
+// Allocate memory, only used if buffers are not provided to littlefs
+// Note, memory must be 64-bit aligned
+static inline void *lfs_malloc(size_t size) {
+#ifndef LFS_NO_MALLOC
+    return malloc(size);
+#else
+    (void)size;
+    return NULL;
+#endif
+}
+
+// Deallocate memory, only used if buffers are not provided to littlefs
+static inline void lfs_free(void *p) {
+#ifndef LFS_NO_MALLOC
+    free(p);
+#else
+    (void)p;
+#endif
+}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
+#endif

lib/LITTLEFS/src/littlefs_api.c

@@ -0,0 +1,58 @@
+/**
+ * @file littlefs_api.c
+ * @brief Maps the HAL of esp_partition <-> littlefs
+ * @author Brian Pugh
+ */
+
+#define ESP_LOCAL_LOG_LEVEL ESP_LOG_INFO
+
+#include "esp_log.h"
+#include "esp_partition.h"
+#include "esp_vfs.h"
+#include "lfs.h"
+#include "esp_littlefs.h"
+#include "littlefs_api.h"
+
+static const char TAG[] = "esp_littlefs_api";
+
+int littlefs_api_read(const struct lfs_config *c, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size) {
+    esp_littlefs_t * efs = c->context;
+    size_t part_off = (block * c->block_size) + off;
+    esp_err_t err = esp_partition_read(efs->partition, part_off, buffer, size);
+    if (err) {
+        ESP_LOGE(TAG, "failed to read addr %08x, size %08x, err %d", part_off, size, err);
+        return LFS_ERR_IO;
+    }
+    return 0;
+}
+
+int littlefs_api_prog(const struct lfs_config *c, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size) {
+    esp_littlefs_t * efs = c->context;
+    size_t part_off = (block * c->block_size) + off;
+    esp_err_t err = esp_partition_write(efs->partition, part_off, buffer, size);
+    if (err) {
+        ESP_LOGE(TAG, "failed to write addr %08x, size %08x, err %d", part_off, size, err);
+        return LFS_ERR_IO;
+    }
+    return 0;
+}
+
+int littlefs_api_erase(const struct lfs_config *c, lfs_block_t block) {
+    esp_littlefs_t * efs = c->context;
+    size_t part_off = block * c->block_size;
+    esp_err_t err = esp_partition_erase_range(efs->partition, part_off, c->block_size);
+    if (err) {
+        ESP_LOGE(TAG, "failed to erase addr %08x, size %08x, err %d", part_off, c->block_size, err);
+        return LFS_ERR_IO;
+    }
+    return 0;
+
+}
+
+int littlefs_api_sync(const struct lfs_config *c) {
+    /* Unnecessary for esp-idf */
+    return 0;
+}
+

lib/LITTLEFS/src/littlefs_api.h

@@ -0,0 +1,106 @@
+#ifndef ESP_LITTLEFS_API_H__
+#define ESP_LITTLEFS_API_H__
+
+#include <stdint.h>
+#include <stddef.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#include "esp_vfs.h"
+#include "esp_partition.h"
+#include "lfs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief a file descriptor
+ * That's also a singly linked list used for keeping tracks of all opened file descriptor 
+ *
+ * Shortcomings/potential issues of 32-bit hash (when CONFIG_LITTLEFS_USE_ONLY_HASH) listed here:
+ *     * unlink - If a different file is open that generates a hash collision, it will report an
+ *                error that it cannot unlink an open file.
+ *     * rename - If a different file is open that generates a hash collision with
+ *                src or dst, it will report an error that it cannot rename an open file.
+ * Potential consequences:
+ *    1. A file cannot be deleted while a collision-geneating file is open.
+ *       Worst-case, if the other file is always open during the lifecycle
+ *       of your app, it's collision file cannot be deleted, which in the 
+ *       worst-case could cause storage-capacity issues.
+ *    2. Same as (1), but for renames
+ */
+typedef struct _vfs_littlefs_file_t {
+    lfs_file_t file;
+    uint32_t   hash;
+    struct _vfs_littlefs_file_t * next;       /*!< Pointer to next file in Singly Linked List */
+#ifndef CONFIG_LITTLEFS_USE_ONLY_HASH
+    char     * path;
+#endif
+} vfs_littlefs_file_t;
+
+/**
+ * @brief littlefs definition structure
+ */
+typedef struct {
+    lfs_t *fs;                                /*!< Handle to the underlying littlefs */
+    SemaphoreHandle_t lock;                   /*!< FS lock */
+    const esp_partition_t* partition;         /*!< The partition on which littlefs is located */
+    char base_path[ESP_VFS_PATH_MAX+1];       /*!< Mount point */
+
+    struct lfs_config cfg;                    /*!< littlefs Mount configuration */
+
+    vfs_littlefs_file_t *file;                /*!< Singly Linked List of files */
+
+    vfs_littlefs_file_t **cache;              /*!< A cache of pointers to the opened files */
+    uint16_t             cache_size;          /*!< The cache allocated size (in pointers) */
+    uint16_t             fd_count;            /*!< The count of opened file descriptor used to speed up computation */
+} esp_littlefs_t;
+
+/**
+ * @brief Read a region in a block.
+ *
+ * Negative error codes are propogated to the user.
+ *
+ * @return errorcode. 0 on success.
+ */
+int littlefs_api_read(const struct lfs_config *c, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size);
+
+/**
+ * @brief Program a region in a block.
+ *
+ * The block must have previously been erased. 
+ * Negative error codes are propogated to the user.
+ * May return LFS_ERR_CORRUPT if the block should be considered bad.
+ *
+ * @return errorcode. 0 on success.
+ */
+int littlefs_api_prog(const struct lfs_config *c, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size);
+
+/**
+ * @brief Erase a block.
+ *
+ * A block must be erased before being programmed.
+ * The state of an erased block is undefined.
+ * Negative error codes are propogated to the user.
+ * May return LFS_ERR_CORRUPT if the block should be considered bad.
+ * @return errorcode. 0 on success.
+ */
+int littlefs_api_erase(const struct lfs_config *c, lfs_block_t block);
+
+/**
+ * @brief Sync the state of the underlying block device.
+ *
+ * Negative error codes are propogated to the user.
+ *
+ * @return errorcode. 0 on success.
+ */
+int littlefs_api_sync(const struct lfs_config *c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/README

@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html

lib/TickerScheduler/README.md

@@ -0,0 +1,81 @@
+# TickerScheduler
+Simple scheduler for ESP8266 Arduino based on Ticker
+
+### Initialization
+
+`TickerScheduler(uint size);`
+
+| Param | Description | 
+| --- | --- |
+|  size  |  Amount of task Tickers to initialize  |
+
+**Example**: 
+
+`TickerScheduler ts(5)`
+
+
+### Add task
+
+`boolean add(uint i, uint32_t period, tscallback_t f, boolean shouldFireNow = false); `
+
+| Param | Description | 
+| --- | --- |
+|  i  |  Task ID  |
+| period  | Task execution period in ms  |
+| f | Task callback |
+| shouldFireNow|  `true` if you want to execute task right after first scheduler update or wait next scheduled start |
+
+**Returns**:
+
+`true` - task added sucessfully
+
+`false` - task was not added 
+
+**Example**:
+
+`ts.add(0, 3000, sendData)`
+
+### Execute scheduler in `loop()`
+
+`ts.update()`
+
+### Remove task
+
+`boolean remove(uint i)`
+
+**Returns**:
+
+`true` - task removed sucessfully
+
+`false` - task was not removed
+
+| Param | Description | 
+| --- | --- |
+|  i  |  Task ID  |
+
+### Enable/Disable task
+
+`boolean enable(uint i)`
+
+`boolean disable(uint i)`
+
+**Returns**:
+
+`true` - task enabled/disabled sucessfully
+
+`false` - task was not enabled/disabled
+
+| Param | Description | 
+| --- | --- |
+|  i  |  Task ID  |
+
+### Enable / disable all tasks
+
+`void enableAll()`
+
+`void disableAll()`
+
+### TODO
+
+* Task callback parameters support
+* ...

lib/TickerScheduler/TickerScheduler.cpp

@@ -0,0 +1,116 @@
+#include "TickerScheduler.h"
+
+TickerScheduler::TickerScheduler(uint8_t size)
+{
+    this->items = new TickerSchedulerItem[size];
+    this->size = size;
+}
+
+TickerScheduler::~TickerScheduler()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+    {
+        this->remove(i);
+        yield();
+    }
+
+    delete[] this->items;
+    this->items = NULL;
+    this->size = 0;
+}
+
+void TickerScheduler::handleTickerFlag(bool * flag)
+{
+	if (!*flag)
+		*flag = true;
+}
+
+void TickerScheduler::handleTicker(tscallback_t f, void * arg, bool * flag)
+{
+    if (*flag)
+    {
+        yield();
+        *flag = false;
+        yield();
+        f(arg);
+        yield();
+    }
+}
+
+bool TickerScheduler::add(uint8_t i, uint32_t period, tscallback_t f, void* arg, boolean shouldFireNow)
+{
+    if (i >= this->size || this->items[i].is_used)
+        return false;
+
+    this->items[i].cb = f;
+    this->items[i].cb_arg = arg;
+    this->items[i].flag = shouldFireNow;
+    this->items[i].period = period;
+    this->items[i].is_used = true;
+
+    enable(i);
+
+    return true;
+}
+
+bool TickerScheduler::remove(uint8_t i)
+{
+    if (i >= this->size || !this->items[i].is_used)
+        return false;
+
+    this->items[i].is_used = false;
+    this->items[i].t.detach();
+    this->items[i].flag = false;
+    this->items[i].cb = NULL;
+
+    return true;
+}
+
+bool TickerScheduler::disable(uint8_t i)
+{
+    if (i >= this->size || !this->items[i].is_used)
+        return false;
+
+    this->items[i].t.detach();
+
+    return true;
+}
+
+bool TickerScheduler::enable(uint8_t i)
+{
+    if (i >= this->size || !this->items[i].is_used)
+        return false;
+
+	bool * flag = &this->items[i].flag;
+	this->items[i].t.attach_ms(this->items[i].period, TickerScheduler::handleTickerFlag, flag);
+
+    return true;
+}
+
+void TickerScheduler::disableAll()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+        disable(i);
+}
+
+void TickerScheduler::enableAll()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+        enable(i);
+}
+
+void TickerScheduler::update()
+{
+    for (uint8_t i = 0; i < this->size; i++)
+    {
+		if (this->items[i].is_used)
+		{
+			#ifdef ARDUINO_ARCH_AVR
+			this->items[i].t.Tick();
+			#endif
+
+			handleTicker(this->items[i].cb, this->items[i].cb_arg, &this->items[i].flag);
+		}
+        yield();
+    }
+}

lib/TickerScheduler/TickerScheduler.h

@@ -0,0 +1,91 @@
+#ifndef TICKERSCHEDULER_H
+#define TICKERSCHEDULER_H
+
+#if defined(ARDUINO) && ARDUINO >= 100
+    #include "Arduino.h"
+#endif
+#include <stdint.h>
+
+
+#ifdef ARDUINO_ARCH_AVR
+class Ticker
+{
+	typedef void(*ticker_callback_t)(bool*);
+
+private:
+	bool is_attached = false;
+	uint32_t period = 0;
+	uint32_t last_tick = 0;
+	ticker_callback_t callback;
+	bool *callback_argument;
+public:
+	void Tick()
+	{
+		if (is_attached && millis() - last_tick >= period)
+		{
+			callback(callback_argument);
+			last_tick = millis();
+		}
+	}
+
+	void detach()
+	{
+		this->is_attached = true;
+	}
+
+	template<typename TArg> void attach_ms(uint32_t milliseconds, void(*callback)(TArg), TArg arg)
+	{
+		this->period = milliseconds;
+		this->callback = callback;
+		this->callback_argument = arg;
+		this->is_attached = true;
+	}
+};
+#endif
+
+//#ifdef ARDUINO_ARCH_ESP8266
+#include <Ticker.h>
+#include <functional>
+//#endif
+
+void tickerFlagHandle(volatile bool * flag);
+
+#ifdef _GLIBCXX_FUNCTIONAL
+typedef std::function<void(void*)> tscallback_t;
+#else
+typedef void(*tscallback_t)(void*);
+#endif
+
+struct TickerSchedulerItem
+{
+    Ticker t;
+    bool flag = false;
+    tscallback_t cb;
+	void * cb_arg;
+    uint32_t period;
+    volatile bool is_used = false;
+};
+
+class TickerScheduler
+{
+private:
+	uint8_t size;
+    TickerSchedulerItem *items = NULL;
+
+    void handleTicker(tscallback_t, void *, bool * flag);
+	static void handleTickerFlag(bool * flag);
+
+public:
+    TickerScheduler(uint8_t size);
+    ~TickerScheduler();
+    
+    bool add(uint8_t i, uint32_t period, tscallback_t, void *, boolean shouldFireNow = false);
+    bool remove(uint8_t i);
+    bool enable(uint8_t i);
+    bool disable(uint8_t i);
+    void enableAll();
+    void disableAll();
+    void update();
+};
+
+#endif

lib/TickerScheduler/example/blink/blink/blink.ino

@@ -0,0 +1,29 @@
+#include <TickerScheduler.h>
+
+#define LED1 4
+#define LED2 5
+
+TickerScheduler ts(2);
+
+void blink1() {
+  digitalWrite(LED1, !digitalRead(LED1));
+}
+
+void blink2() {
+  digitalWrite(LED2, !digitalRead(LED2));
+}
+
+void setup() {
+  pinMode(LED1, OUTPUT);
+  digitalWrite(LED1, LOW);
+
+  pinMode(LED2, OUTPUT);
+  digitalWrite(LED2, LOW);
+  
+  ts.add(0, 1000, [&](void *) { blink1(); }, nullptr, true);
+  ts.add(1, 3000, [&](void *) { blink2(); }, nullptr, true);
+}
+
+void loop() {
+  ts.update();
+}