feat: 全量同步 254 个常用的 Arduino 扩展库文件

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.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 ""

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.github/scripts/install-arduino-ide.sh

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

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.github/scripts/install-platformio.sh

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

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.github/scripts/on-push.sh

@@ -0,0 +1,44 @@
+#!/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/ESPAsyncUDP"
+fi
+
+CHUNK_INDEX=$1
+CHUNKS_CNT=$2
+BUILD_PIO=0
+if [ "$#" -lt 2 ] || [ "$CHUNKS_CNT" -le 0 ]; then
+	CHUNK_INDEX=0
+	CHUNKS_CNT=1
+elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ]; then
+	CHUNK_INDEX=$CHUNKS_CNT
+elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then
+	BUILD_PIO=1
+fi
+
+if [ "$BUILD_PIO" -eq 0 ]; then
+	# ArduinoIDE Test
+	source ./.github/scripts/install-arduino-ide.sh
+	source ./.github/scripts/install-arduino-core-esp8266.sh
+
+	echo "Installing ESPAsyncUDP ..."
+	cp -rf "$GITHUB_WORKSPACE" "$ARDUINO_USR_PATH/libraries/ESPAsyncUDP"
+
+	FQBN="esp8266com:esp8266:generic:eesz=4M1M,ip=lm2f"
+	build_sketches "$FQBN" "$GITHUB_WORKSPACE/examples"
+else
+	# PlatformIO Test
+	source ./.github/scripts/install-platformio.sh
+
+	echo "Installing ESPAsyncUDP ..."
+	python -m platformio lib --storage-dir "$GITHUB_WORKSPACE" install
+
+	BOARD="esp12e"
+	build_pio_sketches "$BOARD" "$GITHUB_WORKSPACE/examples"
+fi

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.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.
+

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.github/workflows/push.yml

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

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.gitignore

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

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/.travis.yml

@@ -0,0 +1,34 @@
+sudo: false
+language: python
+os:
+  - linux
+
+git:
+  depth: false
+
+stages:
+  - build
+
+jobs:
+  include:
+
+    - name: "Arduino Build"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh
+
+    - name: "PlatformIO Build"
+      if: tag IS blank AND (type = pull_request OR (type = push AND branch = master))
+      stage: build
+      script: bash $TRAVIS_BUILD_DIR/.github/scripts/on-push.sh 1 1
+
+notifications:
+  email:
+    on_success: change
+    on_failure: change
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/60e65d0c78ea0a920347
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/README.md

@@ -0,0 +1,10 @@
+# ESPAsyncUDP
+Async UDP Library for ESP8266 Arduino [![Build Status](https://travis-ci.org/me-no-dev/ESPAsyncUDP.svg?branch=master)](https://travis-ci.org/me-no-dev/ESPAsyncUDP) ![](https://github.com/me-no-dev/ESPAsyncUDP/workflows/ESP%20Async%20UDP%20CI/badge.svg)
+
+[![Join the chat at https://gitter.im/me-no-dev/ESPAsyncWebServer](https://badges.gitter.im/me-no-dev/ESPAsyncWebServer.svg)](https://gitter.im/me-no-dev/ESPAsyncWebServer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+This is a fully asynchronous UDP library, aimed at enabling trouble-free, multi-connection network environment for Espressif's ESP8266 MCUs.
+
+The library is easy to use and includes support for Unicast, Broadcast and Multicast environments
+
+Latest GIT version of ESP8266 Arduino might be required for this library to work

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/examples/AsyncUDPClient/AsyncUDPClient.ino

@@ -0,0 +1,51 @@
+#include <ESP8266WiFi.h>
+#include "ESPAsyncUDP.h"
+
+const char * ssid = "***********";
+const char * password = "***********";
+
+AsyncUDP udp;
+
+void setup()
+{
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.println("WiFi Failed");
+        while(1) {
+            delay(1000);
+        }
+    }
+    if(udp.connect(IPAddress(192,168,1,100), 1234)) {
+        Serial.println("UDP connected");
+        udp.onPacket([](AsyncUDPPacket packet) {
+            Serial.print("UDP Packet Type: ");
+            Serial.print(packet.isBroadcast()?"Broadcast":packet.isMulticast()?"Multicast":"Unicast");
+            Serial.print(", From: ");
+            Serial.print(packet.remoteIP());
+            Serial.print(":");
+            Serial.print(packet.remotePort());
+            Serial.print(", To: ");
+            Serial.print(packet.localIP());
+            Serial.print(":");
+            Serial.print(packet.localPort());
+            Serial.print(", Length: ");
+            Serial.print(packet.length());
+            Serial.print(", Data: ");
+            Serial.write(packet.data(), packet.length());
+            Serial.println();
+            //reply to the client
+            packet.printf("Got %u bytes of data", packet.length());
+        });
+        //Send unicast
+        udp.print("Hello Server!");
+    }
+}
+
+void loop()
+{
+    delay(1000);
+    //Send broadcast on port 1234
+    udp.broadcastTo("Anyone here?", 1234);
+}

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/examples/AsyncUDPMulticastServer/AsyncUDPMulticastServer.ino

@@ -0,0 +1,52 @@
+#include <ESP8266WiFi.h>
+#include "ESPAsyncUDP.h"
+
+const char * ssid = "***********";
+const char * password = "***********";
+
+AsyncUDP udp;
+
+void setup()
+{
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.println("WiFi Failed");
+        while(1) {
+            delay(1000);
+        }
+    }
+    if(udp.listenMulticast(IPAddress(239,1,2,3), 1234)) {
+        Serial.print("UDP Listening on IP: ");
+        Serial.println(WiFi.localIP());
+        udp.onPacket([](AsyncUDPPacket packet) {
+            Serial.print("UDP Packet Type: ");
+            Serial.print(packet.isBroadcast()?"Broadcast":packet.isMulticast()?"Multicast":"Unicast");
+            Serial.print(", From: ");
+            Serial.print(packet.remoteIP());
+            Serial.print(":");
+            Serial.print(packet.remotePort());
+            Serial.print(", To: ");
+            Serial.print(packet.localIP());
+            Serial.print(":");
+            Serial.print(packet.localPort());
+            Serial.print(", Length: ");
+            Serial.print(packet.length());
+            Serial.print(", Data: ");
+            Serial.write(packet.data(), packet.length());
+            Serial.println();
+            //reply to the client
+            packet.printf("Got %u bytes of data", packet.length());
+        });
+        //Send multicast
+        udp.print("Hello!");
+    }
+}
+
+void loop()
+{
+    delay(1000);
+    //Send multicast
+    udp.print("Anyone here?");
+}

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/examples/AsyncUDPServer/AsyncUDPServer.ino

@@ -0,0 +1,50 @@
+#include <ESP8266WiFi.h>
+#include "ESPAsyncUDP.h"
+
+const char * ssid = "***********";
+const char * password = "***********";
+
+AsyncUDP udp;
+
+void setup()
+{
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.println("WiFi Failed");
+        while(1) {
+            delay(1000);
+        }
+    }
+    if(udp.listen(1234)) {
+        Serial.print("UDP Listening on IP: ");
+        Serial.println(WiFi.localIP());
+        udp.onPacket([](AsyncUDPPacket packet) {
+            Serial.print("UDP Packet Type: ");
+            Serial.print(packet.isBroadcast()?"Broadcast":packet.isMulticast()?"Multicast":"Unicast");
+            Serial.print(", From: ");
+            Serial.print(packet.remoteIP());
+            Serial.print(":");
+            Serial.print(packet.remotePort());
+            Serial.print(", To: ");
+            Serial.print(packet.localIP());
+            Serial.print(":");
+            Serial.print(packet.localPort());
+            Serial.print(", Length: ");
+            Serial.print(packet.length());
+            Serial.print(", Data: ");
+            Serial.write(packet.data(), packet.length());
+            Serial.println();
+            //reply to the client
+            packet.printf("Got %u bytes of data", packet.length());
+        });
+    }
+}
+
+void loop()
+{
+    delay(1000);
+    //Send broadcast
+    udp.broadcast("Anyone here?");
+}

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/keywords.txt

@@ -0,0 +1,33 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+AsyncUDP	KEYWORD1
+AsyncUDPPacket	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+connect	KEYWORD2
+connected	KEYWORD2
+listen	KEYWORD2
+listenMulticast	KEYWORD2
+close	KEYWORD2
+write	KEYWORD2
+broadcast	KEYWORD2
+onPacket	KEYWORD2
+data	KEYWORD2
+length	KEYWORD2
+localIP	KEYWORD2
+localPort	KEYWORD2
+remoteIP	KEYWORD2
+remotePort	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/library.json

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

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/library.properties

@@ -0,0 +1,9 @@
+name=ESP Async UDP
+version=1.1.0
+author=Me-No-Dev
+maintainer=Me-No-Dev
+sentence=Async UDP Library for ESP8266
+paragraph=Async UDP Library for ESP8266
+category=Other
+url=https://github.com/me-no-dev/ESPAsyncUDP
+architectures=*

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/src/AsyncUDP.cpp

@@ -0,0 +1,425 @@
+#include "Arduino.h"
+#include "ESPAsyncUDP.h"
+
+extern "C" {
+#include "user_interface.h"
+#include "lwip/opt.h"
+#include "lwip/inet.h"
+#include "lwip/udp.h"
+#include "lwip/igmp.h"
+}
+
+AsyncUDPMessage::AsyncUDPMessage(size_t size)
+{
+    _index = 0;
+    if(size > 1460) {
+        size = 1460;
+    }
+    _size = size;
+    _buffer = (uint8_t *)malloc(size);
+}
+
+AsyncUDPMessage::~AsyncUDPMessage()
+{
+    if(_buffer) {
+        free(_buffer);
+    }
+}
+
+size_t AsyncUDPMessage::write(const uint8_t *data, size_t len)
+{
+    if(_buffer == NULL) {
+        return 0;
+    }
+    size_t s = space();
+    if(len > s) {
+        len = s;
+    }
+    memcpy(_buffer + _index, data, len);
+    _index += len;
+    return len;
+}
+
+size_t AsyncUDPMessage::write(uint8_t data)
+{
+    return write(&data, 1);
+}
+
+size_t AsyncUDPMessage::space()
+{
+    if(_buffer == NULL) {
+        return 0;
+    }
+    return _size - _index;
+}
+
+uint8_t * AsyncUDPMessage::data()
+{
+    return _buffer;
+}
+
+size_t AsyncUDPMessage::length()
+{
+    return _index;
+}
+
+void AsyncUDPMessage::flush()
+{
+    _index = 0;
+}
+
+
+AsyncUDPPacket::AsyncUDPPacket(AsyncUDP *udp, ip_addr_t *localIp, uint16_t localPort, ip_addr_t *remoteIp, uint16_t remotePort, uint8_t *data, size_t len)
+{
+    _udp = udp;
+    _localIp = localIp;
+    _localPort = localPort;
+    _remoteIp = remoteIp;
+    _remotePort = remotePort;
+    _data = data;
+    _len = len;
+}
+
+AsyncUDPPacket::~AsyncUDPPacket()
+{
+
+}
+
+uint8_t * AsyncUDPPacket::data()
+{
+    return _data;
+}
+
+size_t AsyncUDPPacket::length()
+{
+    return _len;
+}
+
+IPAddress AsyncUDPPacket::localIP()
+{
+    return IPAddress(_localIp->addr);
+}
+
+uint16_t AsyncUDPPacket::localPort()
+{
+    return _localPort;
+}
+
+IPAddress AsyncUDPPacket::remoteIP()
+{
+    return IPAddress(_remoteIp->addr);
+}
+
+uint16_t AsyncUDPPacket::remotePort()
+{
+    return _remotePort;
+}
+
+bool AsyncUDPPacket::isBroadcast()
+{
+    return _localIp->addr == 0xFFFFFFFF || _localIp->addr == (uint32_t)(0);
+}
+
+bool AsyncUDPPacket::isMulticast()
+{
+    return ip_addr_ismulticast(_localIp);
+}
+
+size_t AsyncUDPPacket::write(const uint8_t *data, size_t len)
+{
+    return _udp->writeTo(data, len, _remoteIp, _remotePort);
+}
+
+size_t AsyncUDPPacket::write(uint8_t data)
+{
+    return write(&data, 1);
+}
+
+size_t AsyncUDPPacket::send(AsyncUDPMessage &message)
+{
+    return write(message.data(), message.length());
+}
+
+
+
+AsyncUDP::AsyncUDP()
+{
+    _pcb = NULL;
+    _connected = false;
+    _handler = NULL;
+}
+
+AsyncUDP::~AsyncUDP()
+{
+    close();
+}
+
+AsyncUDP::operator bool()
+{
+    return _connected;
+}
+
+bool AsyncUDP::connected()
+{
+    return _connected;
+}
+
+void AsyncUDP::onPacket(AuPacketHandlerFunctionWithArg cb, void * arg)
+{
+    onPacket(std::bind(cb, arg, std::placeholders::_1));
+}
+
+void AsyncUDP::onPacket(AuPacketHandlerFunction cb)
+{
+    _handler = cb;
+}
+
+void AsyncUDP::_recv(udp_pcb *upcb, pbuf *pb, ip_addr_t *addr, uint16_t port)
+{
+    (void)upcb; // its unused, avoid warning
+    while(pb != NULL) {
+        if(_handler) {
+            uint8_t * data = (uint8_t*)((pb)->payload);
+            size_t len = pb->len;
+
+            ip_hdr* iphdr = reinterpret_cast<ip_hdr*>(data - UDP_HLEN - IP_HLEN);
+            ip_addr_t daddr;
+            daddr.addr = iphdr->dest.addr;
+
+            udp_hdr* udphdr = reinterpret_cast<udp_hdr*>(((uint8_t*)((pb)->payload)) - UDP_HLEN);
+            uint16_t dport = ntohs(udphdr->dest);
+
+            AsyncUDPPacket packet(this, &daddr, dport, addr, port, data, len);
+            _handler(packet);
+        }
+
+        pbuf * this_pb = pb;
+        pb = pb->next;
+        this_pb->next = NULL;
+        pbuf_free(this_pb);
+    }
+}
+
+#if LWIP_VERSION_MAJOR == 1
+void AsyncUDP::_s_recv(void *arg, udp_pcb *upcb, pbuf *p, ip_addr_t *addr, uint16_t port)
+#else
+void AsyncUDP::_s_recv(void *arg, udp_pcb *upcb, pbuf *p, const ip_addr_t *addr, uint16_t port)
+#endif
+{
+    reinterpret_cast<AsyncUDP*>(arg)->_recv(upcb, p, (ip_addr_t *)addr, port);
+}
+
+bool AsyncUDP::listen(ip_addr_t *addr, uint16_t port)
+{
+    close();
+    _pcb = udp_new();
+    if(_pcb == NULL) {
+        return false;
+    }
+    err_t err = udp_bind(_pcb, addr, port);
+    if(err != ERR_OK) {
+        close();
+        return false;
+    }
+    udp_recv(_pcb, &_s_recv, (void *) this);
+    _connected = true;
+    return true;
+}
+
+bool AsyncUDP::listenMulticast(ip_addr_t *addr, uint16_t port, uint8_t ttl)
+{
+    close();
+    if(!ip_addr_ismulticast(addr)) {
+        return false;
+    }
+    ip_addr_t multicast_if_addr;
+    struct ip_info ifIpInfo;
+    int mode = wifi_get_opmode();
+    if(mode & STATION_MODE) {
+        wifi_get_ip_info(STATION_IF, &ifIpInfo);
+        multicast_if_addr.addr = ifIpInfo.ip.addr;
+    } else if (mode & SOFTAP_MODE) {
+        wifi_get_ip_info(SOFTAP_IF, &ifIpInfo);
+        multicast_if_addr.addr = ifIpInfo.ip.addr;
+    } else {
+        return false;
+    }
+    if (igmp_joingroup(&multicast_if_addr, addr)!= ERR_OK) {
+        return false;
+    }
+    if(!listen(IPADDR_ANY, port)) {
+        return false;
+    }
+#if LWIP_VERSION_MAJOR == 1
+    udp_set_multicast_netif_addr(_pcb, multicast_if_addr);
+#else
+    udp_set_multicast_netif_addr(_pcb, &multicast_if_addr);
+#endif
+    udp_set_multicast_ttl(_pcb, ttl);
+    ip_addr_copy(_pcb->remote_ip, *addr);
+    _pcb->remote_port = port;
+    return true;
+}
+
+bool AsyncUDP::connect(ip_addr_t *addr, uint16_t port)
+{
+    close();
+    _pcb = udp_new();
+    if(_pcb == NULL) {
+        return false;
+    }
+    err_t err = udp_connect(_pcb, addr, port);
+    if(err != ERR_OK) {
+        close();
+        return false;
+    }
+    udp_recv(_pcb, &_s_recv, (void *) this);
+    _connected = true;
+    return true;
+}
+
+void AsyncUDP::close()
+{
+    if(_pcb != NULL) {
+        if(_connected) {
+            udp_disconnect(_pcb);
+        }
+        udp_remove(_pcb);
+        _connected = false;
+        _pcb = NULL;
+    }
+}
+
+size_t AsyncUDP::writeTo(const uint8_t *data, size_t len, ip_addr_t *addr, uint16_t port)
+{
+    if(!_pcb && !connect(addr, port)) {
+        return 0;
+    }
+    if(len > 1460) {
+        len = 1460;
+    }
+    pbuf* pbt = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
+    if(pbt != NULL) {
+        uint8_t* dst = reinterpret_cast<uint8_t*>(pbt->payload);
+        memcpy(dst, data, len);
+        err_t err = udp_sendto(_pcb, pbt, addr, port);
+        pbuf_free(pbt);
+        if(err < ERR_OK) {
+            return 0;
+        }
+        return len;
+    }
+    return 0;
+}
+
+bool AsyncUDP::listen(const IPAddress addr, uint16_t port)
+{
+    ip_addr_t laddr;
+    laddr.addr = addr;
+    return listen(&laddr, port);
+}
+
+bool AsyncUDP::listen(uint16_t port)
+{
+    return listen(IPAddress((uint32_t)INADDR_ANY), port);
+}
+
+bool AsyncUDP::listenMulticast(const IPAddress addr, uint16_t port, uint8_t ttl)
+{
+    ip_addr_t laddr;
+    laddr.addr = addr;
+    return listenMulticast(&laddr, port, ttl);
+}
+
+bool AsyncUDP::connect(const IPAddress addr, uint16_t port)
+{
+    ip_addr_t daddr;
+    daddr.addr = addr;
+    return connect(&daddr, port);
+}
+
+size_t AsyncUDP::writeTo(const uint8_t *data, size_t len, const IPAddress addr, uint16_t port)
+{
+    ip_addr_t daddr;
+    daddr.addr = addr;
+    return writeTo(data, len, &daddr, port);
+}
+
+size_t AsyncUDP::write(const uint8_t *data, size_t len)
+{
+	if(_pcb){
+		return writeTo(data, len, &(_pcb->remote_ip), _pcb->remote_port);
+	}
+    return 0;
+}
+
+size_t AsyncUDP::write(uint8_t data)
+{
+    return write(&data, 1);
+}
+
+size_t AsyncUDP::broadcastTo(uint8_t *data, size_t len, uint16_t port)
+{
+    ip_addr_t daddr;
+    daddr.addr = 0xFFFFFFFF;
+    return writeTo(data, len, &daddr, port);
+}
+
+size_t AsyncUDP::broadcastTo(const char * data, uint16_t port)
+{
+    return broadcastTo((uint8_t *)data, strlen(data), port);
+}
+
+size_t AsyncUDP::broadcast(uint8_t *data, size_t len)
+{
+    if(_pcb->local_port != 0) {
+        return broadcastTo(data, len, _pcb->local_port);
+    }
+    return 0;
+}
+
+size_t AsyncUDP::broadcast(const char * data)
+{
+    return broadcast((uint8_t *)data, strlen(data));
+}
+
+
+size_t AsyncUDP::sendTo(AsyncUDPMessage &message, ip_addr_t *addr, uint16_t port)
+{
+    if(!message) {
+        return 0;
+    }
+    return writeTo(message.data(), message.length(), addr, port);
+}
+
+size_t AsyncUDP::sendTo(AsyncUDPMessage &message, const IPAddress addr, uint16_t port)
+{
+    if(!message) {
+        return 0;
+    }
+    return writeTo(message.data(), message.length(), addr, port);
+}
+
+size_t AsyncUDP::send(AsyncUDPMessage &message)
+{
+    if((!message) || (!_pcb)) {
+        return 0;
+    }
+    return writeTo(message.data(), message.length(), &(_pcb->remote_ip), _pcb->remote_port);
+}
+
+size_t AsyncUDP::broadcastTo(AsyncUDPMessage &message, uint16_t port)
+{
+    if(!message) {
+        return 0;
+    }
+    return broadcastTo(message.data(), message.length(), port);
+}
+
+size_t AsyncUDP::broadcast(AsyncUDPMessage &message)
+{
+    if(!message) {
+        return 0;
+    }
+    return broadcast(message.data(), message.length());
+}

arduino-libs/arduino-cli/libraries/ESPAsyncUDP/src/ESPAsyncUDP.h

@@ -0,0 +1,130 @@
+#ifndef ESPASYNCUDP_H
+#define ESPASYNCUDP_H
+
+#include "IPAddress.h"
+#include "Print.h"
+#include <functional>
+#include "lwip/init.h"
+
+class AsyncUDP;
+class AsyncUDPPacket;
+class AsyncUDPMessage;
+struct udp_pcb;
+struct pbuf;
+#if LWIP_VERSION_MAJOR == 1
+struct ip_addr;
+typedef struct ip_addr ip_addr_t;
+#else
+struct ip4_addr;
+typedef struct ip4_addr ip_addr_t;
+#endif
+
+class AsyncUDPMessage : public Print
+{
+protected:
+    uint8_t *_buffer;
+    size_t _index;
+    size_t _size;
+public:
+    AsyncUDPMessage(size_t size=1460);
+    virtual ~AsyncUDPMessage();
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+    size_t space();
+    uint8_t * data();
+    size_t length();
+    void flush();
+    operator bool()
+    {
+        return _buffer != NULL;
+    }
+};
+
+class AsyncUDPPacket : public Print
+{
+protected:
+    AsyncUDP *_udp;
+    ip_addr_t *_localIp;
+    uint16_t _localPort;
+    ip_addr_t *_remoteIp;
+    uint16_t _remotePort;
+    uint8_t *_data;
+    size_t _len;
+public:
+    AsyncUDPPacket(AsyncUDP *udp, ip_addr_t *localIp, uint16_t localPort, ip_addr_t *remoteIp, uint16_t remotePort, uint8_t *data, size_t len);
+    virtual ~AsyncUDPPacket();
+
+    uint8_t * data();
+    size_t length();
+    bool isBroadcast();
+    bool isMulticast();
+
+    IPAddress localIP();
+    uint16_t localPort();
+    IPAddress remoteIP();
+    uint16_t remotePort();
+
+    size_t send(AsyncUDPMessage &message);
+
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+};
+
+typedef std::function<void(AsyncUDPPacket& packet)> AuPacketHandlerFunction;
+typedef std::function<void(void * arg, AsyncUDPPacket& packet)> AuPacketHandlerFunctionWithArg;
+
+class AsyncUDP : public Print
+{
+protected:
+    udp_pcb *_pcb;
+    bool _connected;
+    AuPacketHandlerFunction _handler;
+
+    void _recv(udp_pcb *upcb, pbuf *pb, ip_addr_t *addr, uint16_t port);
+#if LWIP_VERSION_MAJOR == 1
+    static void _s_recv(void *arg, udp_pcb *upcb, pbuf *p, ip_addr_t *addr, uint16_t port);
+#else
+    static void _s_recv(void *arg, udp_pcb *upcb, pbuf *p, const ip_addr_t *addr, uint16_t port);
+#endif
+
+public:
+    AsyncUDP();
+    virtual ~AsyncUDP();
+
+    void onPacket(AuPacketHandlerFunctionWithArg cb, void * arg=NULL);
+    void onPacket(AuPacketHandlerFunction cb);
+
+    bool listen(ip_addr_t *addr, uint16_t port);
+    bool listen(const IPAddress addr, uint16_t port);
+    bool listen(uint16_t port);
+
+    bool listenMulticast(ip_addr_t *addr, uint16_t port, uint8_t ttl=1);
+    bool listenMulticast(const IPAddress addr, uint16_t port, uint8_t ttl=1);
+
+    bool connect(ip_addr_t *addr, uint16_t port);
+    bool connect(const IPAddress addr, uint16_t port);
+
+    void close();
+
+    size_t writeTo(const uint8_t *data, size_t len, ip_addr_t *addr, uint16_t port);
+    size_t writeTo(const uint8_t *data, size_t len, const IPAddress addr, uint16_t port);
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+
+    size_t broadcastTo(uint8_t *data, size_t len, uint16_t port);
+    size_t broadcastTo(const char * data, uint16_t port);
+    size_t broadcast(uint8_t *data, size_t len);
+    size_t broadcast(const char * data);
+
+    size_t sendTo(AsyncUDPMessage &message, ip_addr_t *addr, uint16_t port);
+    size_t sendTo(AsyncUDPMessage &message, const IPAddress addr, uint16_t port);
+    size_t send(AsyncUDPMessage &message);
+
+    size_t broadcastTo(AsyncUDPMessage &message, uint16_t port);
+    size_t broadcast(AsyncUDPMessage &message);
+
+    bool connected();
+    operator bool();
+};
+
+#endif