Merge pull request #4151 from ascillato/patch-1

KNX: Disabling ESPAsyncUDP Library

lib/ESPAsyncUDP-master/.travis.yml

@@ -1,37 +0,0 @@
-sudo: false
-language: bash
-os:
-  - linux
-
-script:
-  - /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16
-  - sleep 3
-  - export DISPLAY=:1.0
-  - wget http://downloads.arduino.cc/arduino-1.6.5-linux64.tar.xz
-  - tar xf arduino-1.6.5-linux64.tar.xz
-  - mv arduino-1.6.5 $HOME/arduino_ide
-  - export PATH="$HOME/arduino_ide:$PATH"
-  - which arduino
-  - mkdir -p $HOME/Arduino/libraries
-  - cp -r $TRAVIS_BUILD_DIR $HOME/Arduino/libraries/ESPAsyncUDP
-  - cd $HOME/arduino_ide/hardware
-  - mkdir esp8266com
-  - cd esp8266com
-  - git clone https://github.com/esp8266/Arduino.git esp8266
-  - cd esp8266/tools
-  - python get.py
-  - source $TRAVIS_BUILD_DIR/travis/common.sh
-  - arduino --board esp8266com:esp8266:generic --save-prefs
-  - arduino --get-pref sketchbook.path
-  - build_sketches arduino $HOME/Arduino/libraries/ESPAsyncUDP esp8266
-
-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

lib/ESPAsyncUDP-master/README.md

@@ -1,10 +0,0 @@
-# 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)
-
-[![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

lib/ESPAsyncUDP-master/examples/AsyncUDPClient/AsyncUDPClient.ino

@@ -1,51 +0,0 @@
-#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);
-}

lib/ESPAsyncUDP-master/examples/AsyncUDPMulticastServer/AsyncUDPMulticastServer.ino

@@ -1,52 +0,0 @@
-#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?");
-}

lib/ESPAsyncUDP-master/examples/AsyncUDPServer/AsyncUDPServer.ino

@@ -1,50 +0,0 @@
-#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?");
-}

lib/ESPAsyncUDP-master/keywords.txt

@@ -1,33 +0,0 @@
-#######################################
-# 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)
-#######################################

lib/ESPAsyncUDP-master/library.json

@@ -1,17 +0,0 @@
-{
-  "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"
-}

lib/ESPAsyncUDP-master/library.properties

@@ -1,9 +0,0 @@
-name=ESP Async UDP
-version=1.0.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=*

lib/ESPAsyncUDP-master/src/AsyncUDP.cpp

@@ -1,432 +0,0 @@
-#include <core_version.h>         // Arduino_Esp8266 version information (ARDUINO_ESP8266_RELEASE and ARDUINO_ESP8266_RELEASE_2_3_0)
-#ifndef ARDUINO_ESP8266_RELEASE_2_3_0 // This Library will only work with ARDUINO_ESP8266_RELEASE_2_4_0 and up
-
-#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)
-{
-    //return writeTo(data, len, &(_pcb->remote_ip), _pcb->remote_port);
-    if(_pcb){ // Patch applied (https://github.com/me-no-dev/ESPAsyncUDP/pull/21)
-    	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) {
-    if((!message) || (!_pcb)) { // Patch applied (https://github.com/me-no-dev/ESPAsyncUDP/pull/21)
-        return 0;
-    }
-    return writeTo(message.data(), message.length(), addr, port);
-}
-
-size_t AsyncUDP::send(AsyncUDPMessage &message)
-{
-    if(!message) {
-        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());
-}
-
-#endif

lib/ESPAsyncUDP-master/src/ESPAsyncUDP.h

@@ -1,130 +0,0 @@
-#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

lib/ESPAsyncUDP-master/travis/common.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-
-function build_sketches()
-{
-    local arduino=$1
-    local srcpath=$2
-    local platform=$3
-    local sketches=$(find $srcpath -name *.ino)
-    for sketch in $sketches; do
-        local sketchdir=$(dirname $sketch)
-        if [[ -f "$sketchdir/.$platform.skip" ]]; then
-            echo -e "\n\n ------------ Skipping $sketch ------------ \n\n";
-            continue
-        fi
-        echo -e "\n\n ------------ Building $sketch ------------ \n\n";
-        $arduino --verify $sketch;
-        local result=$?
-        if [ $result -ne 0 ]; then
-            echo "Build failed ($1)"
-            return $result
-        fi
-    done
-}

lib/esp-knx-ip-0.5.1/esp-knx-ip-send.cpp

@@ -77,13 +77,10 @@ void ESPKNXIP::send(address_t const &receiver, knx_command_type_t ct, uint8_t da
 	DEBUG_PRINTLN(F(""));
 #endif
 
-#ifdef USE_ASYNC_UDP
-  udp.writeTo(buf, len, MULTICAST_IP, MULTICAST_PORT);
-#else
 	udp.beginPacketMulticast(MULTICAST_IP, MULTICAST_PORT, WiFi.localIP());
 	udp.write(buf, len);
  	udp.endPacket();
-#endif
+
 }
 
 void ESPKNXIP::send_1bit(address_t const &receiver, knx_command_type_t ct, uint8_t bit)

lib/esp-knx-ip-0.5.1/esp-knx-ip.cpp

@@ -95,13 +95,7 @@ void ESPKNXIP::__start()
 #endif
     server->begin();
   }
-
-#ifdef USE_ASYNC_UDP
-  udp.listenMulticast(MULTICAST_IP, MULTICAST_PORT);
-  udp.onPacket([this](AsyncUDPPacket &packet) { __loop_knx(packet); });
-#else
   udp.beginMulticast(WiFi.localIP(),  MULTICAST_IP, MULTICAST_PORT);
-#endif
 }
 
 void ESPKNXIP::save_to_eeprom()
@@ -516,9 +510,7 @@ feedback_id_t ESPKNXIP::feedback_register_action(String name, feedback_action_fp
 
 void ESPKNXIP::loop()
 {
-  #ifndef USE_ASYNC_UDP
   __loop_knx();
-  #endif
   if (server != nullptr)
   {
     __loop_webserver();
@@ -530,15 +522,9 @@ void ESPKNXIP::__loop_webserver()
   server->handleClient();
 }
 
-#ifdef USE_ASYNC_UDP
-void ESPKNXIP::__loop_knx(AsyncUDPPacket &packet)
-{
-  size_t read = packet.length();
-#else
 void ESPKNXIP::__loop_knx()
 {
   int read = udp.parsePacket();
-#endif
 
   if (!read)
   {
@@ -548,23 +534,15 @@ void ESPKNXIP::__loop_knx()
   DEBUG_PRINT(F("LEN: "));
   DEBUG_PRINTLN(read);
 
-#ifdef USE_ASYNC_UDP
-  uint8_t *buf = packet.data();
-#else
   uint8_t buf[read];
   udp.read(buf, read);
   udp.flush();
-#endif
 
   DEBUG_PRINT(F("Got packet:"));
 
 #ifdef ESP_KNX_DEBUG
 
-#ifdef USE_ASYNC_UDP
-  for (size_t i = 0; i < read; ++i)
-#else
   for (int i = 0; i < read; ++i)
-#endif
 
   {
     DEBUG_PRINT(F(" 0x"));

lib/esp-knx-ip-0.5.1/esp-knx-ip.h

@@ -45,18 +45,7 @@
 #include "Arduino.h"
 #include <EEPROM.h>
 #include <ESP8266WiFi.h>
-
-#include <core_version.h>         // Arduino_Esp8266 version information (ARDUINO_ESP8266_RELEASE and ARDUINO_ESP8266_RELEASE_2_3_0)
-#ifndef ARDUINO_ESP8266_RELEASE_2_3_0
-#define USE_ASYNC_UDP             // UDP WIFI Library Selection for Multicast
-#endif
-
-#ifdef USE_ASYNC_UDP
-#include <ESPAsyncUDP.h>
-#else
 #include <WiFiUdp.h>
-#endif
-
 #include <ESP8266WebServer.h>
 
 #include "DPT.h"
@@ -529,11 +518,7 @@ class ESPKNXIP {
   private:
     void __start();
 
-#ifdef USE_ASYNC_UDP
-    void __loop_knx(AsyncUDPPacket &packet);
-#else
     void __loop_knx();
-#endif
 
     // Webserver functions
     void __loop_webserver();
@@ -569,11 +554,7 @@ class ESPKNXIP {
     ESP8266WebServer *server;
     address_t physaddr;
 
-#ifdef USE_ASYNC_UDP
-    AsyncUDP udp;
-#else
     WiFiUDP udp;
-#endif
 
     callback_assignment_id_t registered_callback_assignments;
     callback_assignment_id_t free_callback_assignment_slots;

sonoff/xdrv_11_knx.ino

@@ -49,14 +49,6 @@ byte          Settings.knx_CB_param[MAX_KNX_CB]     Type of Output (set relay, t
 \*********************************************************************************************/
 
 #include <esp-knx-ip.h>         // KNX Library
-                                //   Note: Inside the <esp-knx-ip.h> file there is a //#define USE_ASYNC_UDP    // UDP WIFI Library Selection for Multicast
-                                //         If commented out, the esp-knx-ip library will use WIFI_UDP Library that is compatible with ESP8266 Library Version 2.3.0 and up
-                                //         If not commented out, the esp-knx-ip library will use ESPAsyncUDP Library that is compatible with ESP8266 Library Version 2.4.0 and up
-                                //            The ESPAsyncUDP Library have a more reliable multicast communication
-                                //            Please Use it with Patch (https://github.com/me-no-dev/ESPAsyncUDP/pull/21) )
-
-//void KNX_CB_Action(message_t const &msg, void *arg);  // Define function (action callback) to be called by the Esp-KNX-IP Library
-                                                      // when an action is requested by another KNX Device
 
 address_t KNX_physs_addr;  // Physical KNX address of this device
 address_t KNX_addr;        // KNX Address converter variable