Update PlatformIO

2025-08-16 12:45:36 +01:00 · 2025-08-16 12:36:41 +01:00 · 2025-08-16 12:33:25 +01:00 · 2025-08-16 12:05:41 +01:00 · 2025-08-16 11:57:50 +01:00 · 2025-08-16 11:57:20 +01:00
50 changed files with 116 additions and 2008 deletions
--- a/platformio.ini
+++ b/platformio.ini
@@ -10,7 +10,7 @@
 # ------------------------------------------------------------------------------

 # CI/release binaries
-default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, nodemcuv2_160, esp8266_2m_160, esp01_1m_full_160, nodemcuv2_compat, esp8266_2m_compat, esp01_1m_full_compat, esp32dev, esp32dev_V4, esp32_eth, lolin_s2_mini, esp32c3dev, esp32s3dev_16MB_opi, esp32s3dev_8MB_opi, esp32s3_4M_qspi, esp32_wrover, usermods
+default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, nodemcuv2_160, esp8266_2m_160, esp01_1m_full_160, nodemcuv2_compat, esp8266_2m_compat, esp01_1m_full_compat, esp32dev, esp32_eth, lolin_s2_mini, esp32c3dev, esp32s3dev_16MB_opi, esp32s3dev_8MB_opi, esp32s3_4M_qspi, esp32_wrover, usermods

 src_dir  = ./wled00
 data_dir = ./wled00/data
@@ -108,6 +108,8 @@ ldscript_2m512k = eagle.flash.2m512.ld
 ldscript_2m1m = eagle.flash.2m1m.ld
 ldscript_4m1m = eagle.flash.4m1m.ld

+default_usermods = ;; TODO: add back audioreactive once V5 compatible
+
 [scripts_defaults]
 extra_scripts =
  pre:pio-scripts/set_version.py
@@ -138,11 +140,11 @@ upload_speed = 115200
 # ------------------------------------------------------------------------------
 lib_compat_mode = strict
 lib_deps =
-    fastled/FastLED @ 3.6.0
-    IRremoteESP8266 @ 2.8.2
+    fastled/FastLED @ 3.10.1
+;    IRremoteESP8266 @ 2.8.2
    makuna/NeoPixelBus @ 2.8.3
    #https://github.com/makuna/NeoPixelBus.git#CoreShaderBeta
-    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.0
+    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.2
  # for I2C interface
    ;Wire
  # ESP-NOW library
@@ -234,25 +236,20 @@ lib_deps_compat =

 [esp32_all_variants]
 lib_deps =
-  willmmiles/AsyncTCP @ 1.3.1
+  esp32async/AsyncTCP @ 3.4.7
  bitbank2/AnimatedGIF@^1.4.7
  https://github.com/Aircoookie/GifDecoder#bc3af18
 build_flags =
  -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
  -D WLED_ENABLE_GIF

 [esp32]
-#platform = https://github.com/tasmota/platform-espressif32/releases/download/v2.0.2.3/platform-espressif32-2.0.2.3.zip
-platform = espressif32@3.5.0
-platform_packages = framework-arduinoespressif32 @ https://github.com/Aircoookie/arduino-esp32.git#1.0.6.4
+platform = ${esp32_idf_V5.platform}
+platform_packages =
 build_unflags = ${common.build_unflags}
-build_flags = -g
-  -DARDUINO_ARCH_ESP32
-  #-DCONFIG_LITTLEFS_FOR_IDF_3_2
-  #use LITTLEFS library by lorol in ESP32 core 1.x.x instead of built-in in 2.x.x
-  -D LOROL_LITTLEFS
-  ; -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
-  ${esp32_all_variants.build_flags}
+build_flags = ${esp32_idf_V5.build_flags}
+lib_deps = ${esp32_idf_V5.lib_deps}

 tiny_partitions = tools/WLED_ESP32_2MB_noOTA.csv
 default_partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
@@ -260,41 +257,32 @@ extended_partitions = tools/WLED_ESP32_4MB_700k_FS.csv
 big_partitions = tools/WLED_ESP32_4MB_256KB_FS.csv     ;; 1.8MB firmware, 256KB filesystem, coredump support
 large_partitions = tools/WLED_ESP32_8MB.csv
 extreme_partitions = tools/WLED_ESP32_16MB_9MB_FS.csv
-lib_deps =
-  https://github.com/lorol/LITTLEFS.git
-  ${esp32_all_variants.lib_deps}
-  ${env.lib_deps}
+
 board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
 # additional build flags for audioreactive - must be applied globally
 AR_build_flags = ;; -fsingle-precision-constant ;; forces ArduinoFFT to use float math (2x faster)
 AR_lib_deps =  ;; for pre-usermod-library platformio_override compatibility


-[esp32_idf_V4]
-;; experimental build environment for ESP32 using ESP-IDF 4.4.x / arduino-esp32 v2.0.5
-;; very similar to the normal ESP32 flags, but omitting Lorol LittleFS, as littlefs is included in the new framework already.
-;;
-;; please note that you can NOT update existing ESP32 installs with a "V4" build. Also updating by OTA will not work properly.
-;; You need to completely erase your device (esptool erase_flash) first, then install the "V4" build from VSCode+platformio.
-
-;; select arduino-esp32 v2.0.9 (arduino-esp32 2.0.10 thru 2.0.14 are buggy so avoid them)
-platform = https://github.com/tasmota/platform-espressif32/releases/download/2023.06.02/platform-espressif32.zip ;; Tasmota Arduino Core 2.0.9 with IPv6 support, based on IDF 4.4.4
+[esp32_idf_V5]
+;; build environment for ESP32 using ESP-IDF 5.3.3 / arduino-esp32 v3.1.3
+platform = https://github.com/tasmota/platform-espressif32/releases/download/2025.08.30/platform-espressif32-2025.08.30.zip ;; Platform 2025.08.30 Tasmota Arduino Core 3.1.3.250808 based on IDF 5.3.3.250801
 build_unflags = ${common.build_unflags}
 build_flags = -g
  -Wshadow=compatible-local ;; emit warning in case a local variable "shadows" another local one
  -DARDUINO_ARCH_ESP32 -DESP32
-  -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
  ${esp32_all_variants.build_flags}
-  -D WLED_ENABLE_DMX_INPUT
+ -D WLED_DISABLE_INFRARED ;; TODO: remove once we have updated library for V5
+ -D WLED_DISABLE_MQTT  ;; TODO: remove once we have updated library for V5
+;  -D WLED_ENABLE_DMX_INPUT
 lib_deps =
  ${esp32_all_variants.lib_deps}
-  https://github.com/someweisguy/esp_dmx.git#47db25d
+;  https://github.com/someweisguy/esp_dmx.git#47db25d
  ${env.lib_deps}
-board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs

 [esp32s2]
 ;; generic definitions for all ESP32-S2 boards
-platform = ${esp32_idf_V4.platform}
+platform = ${esp32_idf_V5.platform}
 build_unflags = ${common.build_unflags}
 build_flags = -g
  -DARDUINO_ARCH_ESP32
@@ -305,15 +293,14 @@ build_flags = -g
  -DARDUINO_USB_MODE=0 ;; this flag is mandatory for ESP32-S2 !
  ;; please make sure that the following flags are properly set (to 0 or 1) by your board.json, or included in your custom platformio_override.ini entry:
  ;; ARDUINO_USB_CDC_ON_BOOT
-  ${esp32_all_variants.build_flags}
+  ${esp32_idf_V5.build_flags}
 lib_deps =
-  ${esp32_all_variants.lib_deps}
-  ${env.lib_deps}
+  ${esp32_idf_V5.lib_deps}
 board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs

 [esp32c3]
 ;; generic definitions for all ESP32-C3 boards
-platform = ${esp32_idf_V4.platform}
+platform = ${esp32_idf_V5.platform}
 build_unflags = ${common.build_unflags}
 build_flags = -g
  -DARDUINO_ARCH_ESP32
@@ -323,16 +310,15 @@ build_flags = -g
  -DARDUINO_USB_MODE=1 ;; this flag is mandatory for ESP32-C3
  ;; please make sure that the following flags are properly set (to 0 or 1) by your board.json, or included in your custom platformio_override.ini entry:
  ;; ARDUINO_USB_CDC_ON_BOOT
-  ${esp32_all_variants.build_flags}
+  ${esp32_idf_V5.build_flags}
 lib_deps =
-  ${esp32_all_variants.lib_deps}
-  ${env.lib_deps}
+  ${esp32_idf_V5.lib_deps}
 board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
 board_build.flash_mode = qio

 [esp32s3]
 ;; generic definitions for all ESP32-S3 boards
-platform = ${esp32_idf_V4.platform}
+platform = ${esp32_idf_V5.platform}
 build_unflags = ${common.build_unflags}
 build_flags = -g
  -DESP32
@@ -343,10 +329,9 @@ build_flags = -g
  -DCO
  ;; please make sure that the following flags are properly set (to 0 or 1) by your board.json, or included in your custom platformio_override.ini entry:
  ;; ARDUINO_USB_MODE, ARDUINO_USB_CDC_ON_BOOT
-  ${esp32_all_variants.build_flags}
+  ${esp32_idf_V5.build_flags}
 lib_deps =
-  ${esp32_all_variants.lib_deps}
-  ${env.lib_deps}
+  ${esp32_idf_V5.lib_deps}
 board_build.partitions = ${esp32.large_partitions}   ;; default partioning for 8MB flash - can be overridden in build envs


@@ -379,7 +364,7 @@ extends = env:nodemcuv2
 board_build.f_cpu = 160000000L
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP8266_160\" #-DWLED_DISABLE_2D
  -D WLED_DISABLE_PARTICLESYSTEM2D
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}

 [env:esp8266_2m]
 board = esp_wroom_02
@@ -407,7 +392,7 @@ board_build.f_cpu = 160000000L
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP02_160\"
  -D WLED_DISABLE_PARTICLESYSTEM1D
  -D WLED_DISABLE_PARTICLESYSTEM2D
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}

 [env:esp01_1m_full]
 board = esp01_1m
@@ -437,37 +422,27 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=
  ; -D WLED_USE_REAL_MATH ;; may fix wrong sunset/sunrise times, at the cost of 7064 bytes FLASH and 975 bytes RAM
  -D WLED_DISABLE_PARTICLESYSTEM1D
  -D WLED_DISABLE_PARTICLESYSTEM2D
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}

 [env:esp32dev]
 board = esp32dev
-platform = ${esp32.platform}
-platform_packages = ${esp32.platform_packages}
-custom_usermods = audioreactive
+platform = ${esp32_idf_V5.platform}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=\"ESP32\" #-D WLED_DISABLE_BROWNOUT_DET
-lib_deps = ${esp32.lib_deps}
-monitor_filters = esp32_exception_decoder
-board_build.partitions = ${esp32.default_partitions}
-
-[env:esp32dev_V4]
-board = esp32dev
-platform = ${esp32_idf_V4.platform}
-build_unflags = ${common.build_unflags}
-custom_usermods = audioreactive
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_V4\" #-D WLED_DISABLE_BROWNOUT_DET
-lib_deps = ${esp32_idf_V4.lib_deps}
+custom_usermods = ${common.default_usermods}
+build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_V4\" #-D WLED_DISABLE_BROWNOUT_DET
+              -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
+lib_deps = ${esp32_idf_V5.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.default_partitions}
 board_build.flash_mode = dio

 [env:esp32dev_8M]
 board = esp32dev
-platform = ${esp32_idf_V4.platform}
-custom_usermods = audioreactive
+platform = ${esp32_idf_V5.platform}
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_8M\" #-D WLED_DISABLE_BROWNOUT_DET
-lib_deps = ${esp32_idf_V4.lib_deps}
+build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_8M\" #-D WLED_DISABLE_BROWNOUT_DET
+lib_deps = ${esp32_idf_V5.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.large_partitions}
 board_upload.flash_size = 8MB
@@ -477,11 +452,11 @@ board_upload.maximum_size = 8388608

 [env:esp32dev_16M]
 board = esp32dev
-platform = ${esp32_idf_V4.platform}
-custom_usermods = audioreactive
+platform = ${esp32_idf_V5.platform}
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_16M\" #-D WLED_DISABLE_BROWNOUT_DET
-lib_deps = ${esp32_idf_V4.lib_deps}
+build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_16M\" #-D WLED_DISABLE_BROWNOUT_DET
+lib_deps = ${esp32_idf_V5.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.extreme_partitions}
 board_upload.flash_size = 16MB
@@ -489,44 +464,30 @@ board_upload.maximum_size = 16777216
 board_build.f_flash = 80000000L
 board_build.flash_mode = dio

-;[env:esp32dev_audioreactive]
-;board = esp32dev
-;platform = ${esp32.platform}
-;platform_packages = ${esp32.platform_packages}
-;custom_usermods = audioreactive
-;build_unflags = ${common.build_unflags}
-;build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=\"ESP32_audioreactive\" #-D WLED_DISABLE_BROWNOUT_DET
-;lib_deps = ${esp32.lib_deps}
-;monitor_filters = esp32_exception_decoder
-;board_build.partitions = ${esp32.default_partitions}
-;; board_build.f_flash = 80000000L
-;; board_build.flash_mode = dio
-
 [env:esp32_eth]
 board = esp32-poe
-platform = ${esp32.platform}
-platform_packages = ${esp32.platform_packages}
+platform = ${esp32_idf_V5.platform}
 upload_speed = 921600
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=\"ESP32_Ethernet\" -D RLYPIN=-1 -D WLED_USE_ETHERNET -D BTNPIN=-1
 ;  -D WLED_DISABLE_ESPNOW ;; ESP-NOW requires wifi, may crash with ethernet only
 lib_deps = ${esp32.lib_deps}
 board_build.partitions = ${esp32.default_partitions}
+board_build.flash_mode = dio

 [env:esp32_wrover]
-extends = esp32_idf_V4
-platform = ${esp32_idf_V4.platform}
+extends = esp32_idf_V5
 board = ttgo-t7-v14-mini32
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 board_build.partitions = ${esp32.extended_partitions}
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_WROVER\"
+build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_WROVER\"
  -DBOARD_HAS_PSRAM -mfix-esp32-psram-cache-issue ;; Older ESP32 (rev.<3) need a PSRAM fix (increases static RAM used) https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/external-ram.html
  -D DATA_PINS=25
-lib_deps = ${esp32_idf_V4.lib_deps}
+lib_deps = ${esp32_idf_V5.lib_deps}
  
 [env:esp32c3dev]
 extends = esp32c3
@@ -549,7 +510,7 @@ board = esp32-s3-devkitc-1 ;; generic dev board; the next line adds PSRAM suppor
 board_build.arduino.memory_type = qio_opi     ;; use with PSRAM: 8MB or 16MB
 platform = ${esp32s3.platform}
 upload_speed = 921600
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_16MB_opi\"
  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
@@ -570,7 +531,7 @@ board = esp32-s3-devkitc-1 ;; generic dev board; the next line adds PSRAM suppor
 board_build.arduino.memory_type = qio_opi     ;; use with PSRAM: 8MB or 16MB
 platform = ${esp32s3.platform}
 upload_speed = 921600
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_8MB_opi\"
  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
@@ -590,7 +551,7 @@ platform = ${esp32s3.platform}
 board = esp32s3camlcd ;; this is the only standard board with "opi_opi"
 board_build.arduino.memory_type = opi_opi
 upload_speed = 921600
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_WROOM-2\"
  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
@@ -613,7 +574,7 @@ monitor_filters = esp32_exception_decoder
 board = lolin_s3_mini ;; -S3 mini, 4MB flash 2MB PSRAM 
 platform = ${esp32s3.platform}
 upload_speed = 921600
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_4M_qspi\"
  -DARDUINO_USB_CDC_ON_BOOT=1 -DARDUINO_USB_MODE=1      ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
@@ -632,7 +593,7 @@ board = lolin_s2_mini
 board_build.partitions = ${esp32.default_partitions}
 board_build.flash_mode = qio
 board_build.f_flash = 80000000L
-custom_usermods = audioreactive
+custom_usermods = ${common.default_usermods}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s2.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S2\"
  -DARDUINO_USB_CDC_ON_BOOT=1
@@ -653,11 +614,11 @@ lib_deps = ${esp32s2.lib_deps}

 [env:usermods]
 board = esp32dev
-platform = ${esp32_idf_V4.platform}
+platform = ${esp32_idf_V5.platform}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_USERMODS\"
+build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_USERMODS\"
  -DTOUCH_CS=9
-lib_deps = ${esp32_idf_V4.lib_deps}
+lib_deps = ${esp32_idf_V5.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.flash_mode = dio
 custom_usermods = *   ; Expands to all usermods in usermods folder
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,20 +1,20 @@
 #
-# This file is autogenerated by pip-compile with Python 3.11
+# This file is autogenerated by pip-compile with Python 3.13
 # by the following command:
 #
-#    pip-compile requirements.in
+#    pip-compile
 #
 ajsonrpc==1.2.0
    # via platformio
-anyio==4.8.0
+anyio==4.10.0
    # via starlette
-bottle==0.13.2
+bottle==0.13.4
    # via platformio
-certifi==2025.1.31
+certifi==2025.8.3
    # via requests
-charset-normalizer==3.4.1
+charset-normalizer==3.4.3
    # via requests
-click==8.1.8
+click==8.1.7
    # via
    #   platformio
    #   uvicorn
@@ -30,9 +30,9 @@ idna==3.10
    #   requests
 marshmallow==3.26.1
    # via platformio
-packaging==24.2
+packaging==25.0
    # via marshmallow
-platformio==6.1.17
+platformio==6.1.18
    # via -r requirements.in
 pyelftools==0.32
    # via platformio
@@ -44,15 +44,13 @@ semantic-version==2.10.0
    # via platformio
 sniffio==1.3.1
    # via anyio
-starlette==0.45.3
+starlette==0.46.2
    # via platformio
 tabulate==0.9.0
    # via platformio
-typing-extensions==4.12.2
-    # via anyio
 urllib3==2.5.0
    # via requests
-uvicorn==0.34.0
+uvicorn==0.34.3
    # via platformio
 wsproto==1.2.0
    # via platformio
--- a/usermods/ST7789_display/ST7789_display.cpp
+++ b/usermods/ST7789_display/ST7789_display.cpp
@@ -196,7 +196,7 @@ class St7789DisplayUsermod : public Usermod {

        // Check if values which are shown on display changed from the last time.
        if ((((apActive) ? String(apSSID) : WiFi.SSID()) != knownSsid) ||
-            (knownIp != (apActive ? IPAddress(4, 3, 2, 1) : Network.localIP())) ||
+            (knownIp != (apActive ? IPAddress(4, 3, 2, 1) : WLEDNetwork.localIP())) ||
            (knownBrightness != bri) ||
            (knownEffectSpeed != strip.getMainSegment().speed) ||
            (knownEffectIntensity != strip.getMainSegment().intensity) ||
--- a/usermods/quinled-an-penta/quinled-an-penta.cpp
+++ b/usermods/quinled-an-penta/quinled-an-penta.cpp
@@ -234,11 +234,11 @@ class QuinLEDAnPentaUsermod : public Usermod

    bool oledCheckForNetworkChanges()
    {
-      if (lastKnownNetworkConnected != Network.isConnected() || lastKnownIp != Network.localIP()
+      if (lastKnownNetworkConnected != WLEDNetwork.isConnected() || lastKnownIp != WLEDNetwork.localIP()
          || lastKnownWiFiConnected != WiFi.isConnected() || lastKnownSsid != WiFi.SSID()
          || lastKnownApActive != apActive || lastKnownApSsid != apSSID || lastKnownApPass != apPass || lastKnownApChannel != apChannel) {
-        lastKnownNetworkConnected = Network.isConnected();
-        lastKnownIp = Network.localIP();
+        lastKnownNetworkConnected = WLEDNetwork.isConnected();
+        lastKnownIp = WLEDNetwork.localIP();
        lastKnownWiFiConnected = WiFi.isConnected();
        lastKnownSsid = WiFi.SSID();
        lastKnownApActive = apActive;
--- a/usermods/usermod_v2_four_line_display_ALT/usermod_v2_four_line_display_ALT.cpp
+++ b/usermods/usermod_v2_four_line_display_ALT/usermod_v2_four_line_display_ALT.cpp
@@ -264,7 +264,7 @@ void FourLineDisplayUsermod::setup() {
 // interfaces here
 void FourLineDisplayUsermod::connected() {
  knownSsid = WiFi.SSID();       //apActive ? apSSID : WiFi.SSID(); //apActive ? WiFi.softAPSSID() :
-  knownIp   = Network.localIP(); //apActive ? IPAddress(4, 3, 2, 1) : Network.localIP();
+  knownIp   = WLEDNetwork.localIP(); //apActive ? IPAddress(4, 3, 2, 1) : WLEDNetwork.localIP();
  networkOverlay(PSTR("NETWORK INFO"),7000);
 }

--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -12,7 +12,7 @@
  #if !(defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3))
    #define LEDC_MUTEX_LOCK()    do {} while (xSemaphoreTake(_ledc_sys_lock, portMAX_DELAY) != pdPASS)
    #define LEDC_MUTEX_UNLOCK()  xSemaphoreGive(_ledc_sys_lock)
-    extern xSemaphoreHandle _ledc_sys_lock;
+    extern SemaphoreHandle_t _ledc_sys_lock;
  #else
    #define LEDC_MUTEX_LOCK()
    #define LEDC_MUTEX_UNLOCK()
@@ -450,8 +450,7 @@ BusPwm::BusPwm(const BusConfig &bc)
      pinMode(_pins[i], OUTPUT);
      #else
      unsigned channel = _ledcStart + i;
-      ledcSetup(channel, _frequency, _depth - (dithering*4)); // with dithering _frequency doesn't really matter as resolution is 8 bit
-      ledcAttachPin(_pins[i], channel);
+      ledcAttach(_pins[i], _frequency,  _depth - (dithering*4));
      // LEDC timer reset credit @dedehai
      uint8_t group = (channel / 8), timer = ((channel / 2) % 4); // same fromula as in ledcSetup()
      ledc_timer_rst((ledc_mode_t)group, (ledc_timer_t)timer); // reset timer so all timers are almost in sync (for phase shift)
@@ -618,7 +617,7 @@ void BusPwm::deallocatePins() {
    #ifdef ESP8266
    digitalWrite(_pins[i], LOW); //turn off PWM interrupt
    #else
-    if (_ledcStart < WLED_MAX_ANALOG_CHANNELS) ledcDetachPin(_pins[i]);
+    if (_ledcStart < WLED_MAX_ANALOG_CHANNELS) ledcDetach(_pins[i]);
    #endif
  }
  #ifdef ARDUINO_ARCH_ESP32
@@ -743,7 +742,7 @@ size_t BusNetwork::getPins(uint8_t* pinArray) const {
 #ifdef ARDUINO_ARCH_ESP32
 void BusNetwork::resolveHostname() {
  static unsigned long nextResolve = 0;
-  if (Network.isConnected() && millis() > nextResolve && _hostname.length() > 0) {
+  if (WLEDNetwork.isConnected() && millis() > nextResolve && _hostname.length() > 0) {
    nextResolve = millis() + 600000; // resolve only every 10 minutes
    IPAddress clnt;
    if (strlen(cmDNS) > 0) clnt = MDNS.queryHost(_hostname);
--- a/wled00/e131.cpp
+++ b/wled00/e131.cpp
@@ -407,7 +407,7 @@ void prepareArtnetPollReply(ArtPollReply *reply) {

  reply->reply_opcode = ARTNET_OPCODE_OPPOLLREPLY;

-  IPAddress localIP = Network.localIP();
+  IPAddress localIP = WLEDNetwork.localIP();
  for (unsigned i = 0; i < 4; i++) {
    reply->reply_ip[i] = localIP[i];
  }
@@ -482,7 +482,7 @@ void prepareArtnetPollReply(ArtPollReply *reply) {
  // A DMX to / from Art-Net device
  reply->reply_style = 0x00;

-  Network.localMAC(reply->reply_mac);
+  WLEDNetwork.localMAC(reply->reply_mac);

  for (unsigned i = 0; i < 4; i++) {
    reply->reply_bind_ip[i] = localIP[i];
--- a/wled00/improv.cpp
+++ b/wled00/improv.cpp
@@ -94,7 +94,7 @@ void handleImprovPacket() {
            case ImprovRPCType::Request_State: {
              unsigned improvState = 0x02; //authorized
              if (WLED_WIFI_CONFIGURED) improvState = 0x03; //provisioning
-              if (Network.isConnected()) improvState = 0x04; //provisioned
+              if (WLEDNetwork.isConnected()) improvState = 0x04; //provisioned
              sendImprovStateResponse(improvState, false);
              if (improvState == 0x04) sendImprovIPRPCResult(ImprovRPCType::Request_State);
              break;
@@ -178,10 +178,10 @@ void sendImprovRPCResult(ImprovRPCType type, uint8_t n_strings, const char **str
 }

 void sendImprovIPRPCResult(ImprovRPCType type) {
-  if (Network.isConnected())
+  if (WLEDNetwork.isConnected())
  {
    char urlStr[64];
-    IPAddress localIP = Network.localIP();
+    IPAddress localIP = WLEDNetwork.localIP();
    unsigned len = sprintf(urlStr, "http://%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);
    if (len > 24) return; //sprintf fail?
    const char *str[1] = {urlStr};
--- a/wled00/json.cpp
+++ b/wled00/json.cpp
@@ -876,9 +876,9 @@ void serializeInfo(JsonObject root)
  root[F("product")] = F(WLED_PRODUCT_NAME);
  root["mac"] = escapedMac;
  char s[16] = "";
-  if (Network.isConnected())
+  if (WLEDNetwork.isConnected())
  {
-    IPAddress localIP = Network.localIP();
+    IPAddress localIP = WLEDNetwork.localIP();
    sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);
  }
  root["ip"] = s;
--- a/wled00/network.cpp
+++ b/wled00/network.cpp
@@ -358,7 +358,7 @@ void WiFiEvent(WiFiEvent_t event)
      DEBUG_PRINTF_P(PSTR("WiFi-E: AP Client Connected (%d) @ %lus.\n"), (int)apClients, millis()/1000);
      break;
    case ARDUINO_EVENT_WIFI_STA_GOT_IP:
-      DEBUG_PRINT(F("WiFi-E: IP address: ")); DEBUG_PRINTLN(Network.localIP());
+      DEBUG_PRINT(F("WiFi-E: IP address: ")); DEBUG_PRINTLN(WLEDNetwork.localIP());
      break;
    case ARDUINO_EVENT_WIFI_STA_CONNECTED:
      // followed by IDLE and SCAN_DONE
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.cpp
@@ -1,877 +0,0 @@
-#include "AsyncMqttClient.hpp"
-
-AsyncMqttClient::AsyncMqttClient()
-: _connected(false)
-, _connectPacketNotEnoughSpace(false)
-, _disconnectFlagged(false)
-, _tlsBadFingerprint(false)
-, _lastClientActivity(0)
-, _lastServerActivity(0)
-, _lastPingRequestTime(0)
-, _host(nullptr)
-, _useIp(false)
-#if ASYNC_TCP_SSL_ENABLED
-, _secure(false)
-#endif
-, _port(0)
-, _keepAlive(15)
-, _cleanSession(true)
-, _clientId(nullptr)
-, _username(nullptr)
-, _password(nullptr)
-, _willTopic(nullptr)
-, _willPayload(nullptr)
-, _willPayloadLength(0)
-, _willQos(0)
-, _willRetain(false)
-, _parsingInformation { .bufferState = AsyncMqttClientInternals::BufferState::NONE }
-, _currentParsedPacket(nullptr)
-, _remainingLengthBufferPosition(0)
-, _nextPacketId(1) {
-  _client.onConnect([](void* obj, AsyncClient* c) { (static_cast<AsyncMqttClient*>(obj))->_onConnect(c); }, this);
-  _client.onDisconnect([](void* obj, AsyncClient* c) { (static_cast<AsyncMqttClient*>(obj))->_onDisconnect(c); }, this);
-  _client.onError([](void* obj, AsyncClient* c, int8_t error) { (static_cast<AsyncMqttClient*>(obj))->_onError(c, error); }, this);
-  _client.onTimeout([](void* obj, AsyncClient* c, uint32_t time) { (static_cast<AsyncMqttClient*>(obj))->_onTimeout(c, time); }, this);
-  _client.onAck([](void* obj, AsyncClient* c, size_t len, uint32_t time) { (static_cast<AsyncMqttClient*>(obj))->_onAck(c, len, time); }, this);
-  _client.onData([](void* obj, AsyncClient* c, void* data, size_t len) { (static_cast<AsyncMqttClient*>(obj))->_onData(c, static_cast<char*>(data), len); }, this);
-  _client.onPoll([](void* obj, AsyncClient* c) { (static_cast<AsyncMqttClient*>(obj))->_onPoll(c); }, this);
-
-#ifdef ESP32
-  sprintf(_generatedClientId, "esp32%06x", (uint32_t)ESP.getEfuseMac());
-  _xSemaphore = xSemaphoreCreateMutex();
-#elif defined(ESP8266)
-  sprintf(_generatedClientId, "esp8266%06x", (uint32_t)ESP.getChipId());
-#endif
-  _clientId = _generatedClientId;
-
-  setMaxTopicLength(128);
-}
-
-AsyncMqttClient::~AsyncMqttClient() {
-  delete _currentParsedPacket;
-  delete[] _parsingInformation.topicBuffer;
-#ifdef ESP32
-  vSemaphoreDelete(_xSemaphore);
-#endif
-}
-
-AsyncMqttClient& AsyncMqttClient::setKeepAlive(uint16_t keepAlive) {
-  _keepAlive = keepAlive;
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::setClientId(const char* clientId) {
-  _clientId = clientId;
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::setCleanSession(bool cleanSession) {
-  _cleanSession = cleanSession;
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::setMaxTopicLength(uint16_t maxTopicLength) {
-  _parsingInformation.maxTopicLength = maxTopicLength;
-  delete[] _parsingInformation.topicBuffer;
-  _parsingInformation.topicBuffer = new char[maxTopicLength + 1];
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::setCredentials(const char* username, const char* password) {
-  _username = username;
-  _password = password;
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::setWill(const char* topic, uint8_t qos, bool retain, const char* payload, size_t length) {
-  _willTopic = topic;
-  _willQos = qos;
-  _willRetain = retain;
-  _willPayload = payload;
-  _willPayloadLength = length;
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::setServer(IPAddress ip, uint16_t port) {
-  _useIp = true;
-  _ip = ip;
-  _port = port;
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::setServer(const char* host, uint16_t port) {
-  _useIp = false;
-  _host = host;
-  _port = port;
-  return *this;
-}
-
-#if ASYNC_TCP_SSL_ENABLED
-AsyncMqttClient& AsyncMqttClient::setSecure(bool secure) {
-  _secure = secure;
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::addServerFingerprint(const uint8_t* fingerprint) {
-  std::array<uint8_t, SHA1_SIZE> newFingerprint;
-  memcpy(newFingerprint.data(), fingerprint, SHA1_SIZE);
-  _secureServerFingerprints.push_back(newFingerprint);
-  return *this;
-}
-#endif
-
-AsyncMqttClient& AsyncMqttClient::onConnect(AsyncMqttClientInternals::OnConnectUserCallback callback) {
-  _onConnectUserCallbacks.push_back(callback);
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::onDisconnect(AsyncMqttClientInternals::OnDisconnectUserCallback callback) {
-  _onDisconnectUserCallbacks.push_back(callback);
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::onSubscribe(AsyncMqttClientInternals::OnSubscribeUserCallback callback) {
-  _onSubscribeUserCallbacks.push_back(callback);
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::onUnsubscribe(AsyncMqttClientInternals::OnUnsubscribeUserCallback callback) {
-  _onUnsubscribeUserCallbacks.push_back(callback);
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::onMessage(AsyncMqttClientInternals::OnMessageUserCallback callback) {
-  _onMessageUserCallbacks.push_back(callback);
-  return *this;
-}
-
-AsyncMqttClient& AsyncMqttClient::onPublish(AsyncMqttClientInternals::OnPublishUserCallback callback) {
-  _onPublishUserCallbacks.push_back(callback);
-  return *this;
-}
-
-void AsyncMqttClient::_freeCurrentParsedPacket() {
-  delete _currentParsedPacket;
-  _currentParsedPacket = nullptr;
-}
-
-void AsyncMqttClient::_clear() {
-  _lastPingRequestTime = 0;
-  _connected = false;
-  _disconnectFlagged = false;
-  _connectPacketNotEnoughSpace = false;
-  _tlsBadFingerprint = false;
-  _freeCurrentParsedPacket();
-
-  _pendingPubRels.clear();
-  _pendingPubRels.shrink_to_fit();
-
-  _toSendAcks.clear();
-  _toSendAcks.shrink_to_fit();
-
-  _nextPacketId = 1;
-  _parsingInformation.bufferState = AsyncMqttClientInternals::BufferState::NONE;
-}
-
-/* TCP */
-void AsyncMqttClient::_onConnect(AsyncClient* client) {
-  (void)client;
-
-#if ASYNC_TCP_SSL_ENABLED
-  if (_secure && _secureServerFingerprints.size() > 0) {
-    SSL* clientSsl = _client.getSSL();
-
-    bool sslFoundFingerprint = false;
-    for (std::array<uint8_t, SHA1_SIZE> fingerprint : _secureServerFingerprints) {
-      if (ssl_match_fingerprint(clientSsl, fingerprint.data()) == SSL_OK) {
-        sslFoundFingerprint = true;
-        break;
-      }
-    }
-
-    if (!sslFoundFingerprint) {
-      _tlsBadFingerprint = true;
-      _client.close(true);
-      return;
-    }
-  }
-#endif
-
-  char fixedHeader[5];
-  fixedHeader[0] = AsyncMqttClientInternals::PacketType.CONNECT;
-  fixedHeader[0] = fixedHeader[0] << 4;
-  fixedHeader[0] = fixedHeader[0] | AsyncMqttClientInternals::HeaderFlag.CONNECT_RESERVED;
-
-  uint16_t protocolNameLength = 4;
-  char protocolNameLengthBytes[2];
-  protocolNameLengthBytes[0] = protocolNameLength >> 8;
-  protocolNameLengthBytes[1] = protocolNameLength & 0xFF;
-
-  char protocolLevel[1];
-  protocolLevel[0] = 0x04;
-
-  char connectFlags[1];
-  connectFlags[0] = 0;
-  if (_cleanSession) connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.CLEAN_SESSION;
-  if (_username != nullptr) connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.USERNAME;
-  if (_password != nullptr) connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.PASSWORD;
-  if (_willTopic != nullptr) {
-    connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.WILL;
-    if (_willRetain) connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.WILL_RETAIN;
-    switch (_willQos) {
-      case 0:
-        connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.WILL_QOS0;
-        break;
-      case 1:
-        connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.WILL_QOS1;
-        break;
-      case 2:
-        connectFlags[0] |= AsyncMqttClientInternals::ConnectFlag.WILL_QOS2;
-        break;
-    }
-  }
-
-  char keepAliveBytes[2];
-  keepAliveBytes[0] = _keepAlive >> 8;
-  keepAliveBytes[1] = _keepAlive & 0xFF;
-
-  uint16_t clientIdLength = strlen(_clientId);
-  char clientIdLengthBytes[2];
-  clientIdLengthBytes[0] = clientIdLength >> 8;
-  clientIdLengthBytes[1] = clientIdLength & 0xFF;
-
-  // Optional fields
-  uint16_t willTopicLength = 0;
-  char willTopicLengthBytes[2];
-  uint16_t willPayloadLength = _willPayloadLength;
-  char willPayloadLengthBytes[2];
-  if (_willTopic != nullptr) {
-    willTopicLength = strlen(_willTopic);
-    willTopicLengthBytes[0] = willTopicLength >> 8;
-    willTopicLengthBytes[1] = willTopicLength & 0xFF;
-
-    if (_willPayload != nullptr && willPayloadLength == 0) willPayloadLength = strlen(_willPayload);
-
-    willPayloadLengthBytes[0] = willPayloadLength >> 8;
-    willPayloadLengthBytes[1] = willPayloadLength & 0xFF;
-  }
-
-  uint16_t usernameLength = 0;
-  char usernameLengthBytes[2];
-  if (_username != nullptr) {
-    usernameLength = strlen(_username);
-    usernameLengthBytes[0] = usernameLength >> 8;
-    usernameLengthBytes[1] = usernameLength & 0xFF;
-  }
-
-  uint16_t passwordLength = 0;
-  char passwordLengthBytes[2];
-  if (_password != nullptr) {
-    passwordLength = strlen(_password);
-    passwordLengthBytes[0] = passwordLength >> 8;
-    passwordLengthBytes[1] = passwordLength & 0xFF;
-  }
-
-  uint32_t remainingLength = 2 + protocolNameLength + 1 + 1 + 2 + 2 + clientIdLength;  // always present
-  if (_willTopic != nullptr) remainingLength += 2 + willTopicLength + 2 + willPayloadLength;
-  if (_username != nullptr) remainingLength += 2 + usernameLength;
-  if (_password != nullptr) remainingLength += 2 + passwordLength;
-  uint8_t remainingLengthLength = AsyncMqttClientInternals::Helpers::encodeRemainingLength(remainingLength, fixedHeader + 1);
-
-  uint32_t neededSpace = 1 + remainingLengthLength;
-  neededSpace += 2;
-  neededSpace += protocolNameLength;
-  neededSpace += 1;
-  neededSpace += 1;
-  neededSpace += 2;
-  neededSpace += 2;
-  neededSpace += clientIdLength;
-  if (_willTopic != nullptr) {
-    neededSpace += 2;
-    neededSpace += willTopicLength;
-
-    neededSpace += 2;
-    if (_willPayload != nullptr) neededSpace += willPayloadLength;
-  }
-  if (_username != nullptr) {
-    neededSpace += 2;
-    neededSpace += usernameLength;
-  }
-  if (_password != nullptr) {
-    neededSpace += 2;
-    neededSpace += passwordLength;
-  }
-
-  SEMAPHORE_TAKE();
-  if (_client.space() < neededSpace) {
-    _connectPacketNotEnoughSpace = true;
-    _client.close(true);
-    SEMAPHORE_GIVE();
-    return;
-  }
-
-  _client.add(fixedHeader, 1 + remainingLengthLength);
-  _client.add(protocolNameLengthBytes, 2);
-  _client.add("MQTT", protocolNameLength);
-  _client.add(protocolLevel, 1);
-  _client.add(connectFlags, 1);
-  _client.add(keepAliveBytes, 2);
-  _client.add(clientIdLengthBytes, 2);
-  _client.add(_clientId, clientIdLength);
-  if (_willTopic != nullptr) {
-    _client.add(willTopicLengthBytes, 2);
-    _client.add(_willTopic, willTopicLength);
-
-    _client.add(willPayloadLengthBytes, 2);
-    if (_willPayload != nullptr) _client.add(_willPayload, willPayloadLength);
-  }
-  if (_username != nullptr) {
-    _client.add(usernameLengthBytes, 2);
-    _client.add(_username, usernameLength);
-  }
-  if (_password != nullptr) {
-    _client.add(passwordLengthBytes, 2);
-    _client.add(_password, passwordLength);
-  }
-  _client.send();
-  _lastClientActivity = millis();
-  SEMAPHORE_GIVE();
-}
-
-void AsyncMqttClient::_onDisconnect(AsyncClient* client) {
-  (void)client;
-  if (!_disconnectFlagged) {
-    AsyncMqttClientDisconnectReason reason;
-
-    if (_connectPacketNotEnoughSpace) {
-      reason = AsyncMqttClientDisconnectReason::ESP8266_NOT_ENOUGH_SPACE;
-    } else if (_tlsBadFingerprint) {
-      reason = AsyncMqttClientDisconnectReason::TLS_BAD_FINGERPRINT;
-    } else {
-      reason = AsyncMqttClientDisconnectReason::TCP_DISCONNECTED;
-    }
-    for (auto callback : _onDisconnectUserCallbacks) callback(reason);
-  }
-  _clear();
-}
-
-void AsyncMqttClient::_onError(AsyncClient* client, int8_t error) {
-  (void)client;
-  (void)error;
-  // _onDisconnect called anyway
-}
-
-void AsyncMqttClient::_onTimeout(AsyncClient* client, uint32_t time) {
-  (void)client;
-  (void)time;
-  // disconnection will be handled by ping/pong management
-}
-
-void AsyncMqttClient::_onAck(AsyncClient* client, size_t len, uint32_t time) {
-  (void)client;
-  (void)len;
-  (void)time;
-}
-
-void AsyncMqttClient::_onData(AsyncClient* client, char* data, size_t len) {
-  (void)client;
-  size_t currentBytePosition = 0;
-  char currentByte;
-  do {
-    switch (_parsingInformation.bufferState) {
-      case AsyncMqttClientInternals::BufferState::NONE:
-        currentByte = data[currentBytePosition++];
-        _parsingInformation.packetType = currentByte >> 4;
-        _parsingInformation.packetFlags = (currentByte << 4) >> 4;
-        _parsingInformation.bufferState = AsyncMqttClientInternals::BufferState::REMAINING_LENGTH;
-        _lastServerActivity = millis();
-        switch (_parsingInformation.packetType) {
-          case AsyncMqttClientInternals::PacketType.CONNACK:
-            _currentParsedPacket = new AsyncMqttClientInternals::ConnAckPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onConnAck, this, std::placeholders::_1, std::placeholders::_2));
-            break;
-          case AsyncMqttClientInternals::PacketType.PINGRESP:
-            _currentParsedPacket = new AsyncMqttClientInternals::PingRespPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onPingResp, this));
-            break;
-          case AsyncMqttClientInternals::PacketType.SUBACK:
-            _currentParsedPacket = new AsyncMqttClientInternals::SubAckPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onSubAck, this, std::placeholders::_1, std::placeholders::_2));
-            break;
-          case AsyncMqttClientInternals::PacketType.UNSUBACK:
-            _currentParsedPacket = new AsyncMqttClientInternals::UnsubAckPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onUnsubAck, this, std::placeholders::_1));
-            break;
-          case AsyncMqttClientInternals::PacketType.PUBLISH:
-            _currentParsedPacket = new AsyncMqttClientInternals::PublishPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onMessage, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8, std::placeholders::_9), std::bind(&AsyncMqttClient::_onPublish, this, std::placeholders::_1, std::placeholders::_2));
-            break;
-          case AsyncMqttClientInternals::PacketType.PUBREL:
-            _currentParsedPacket = new AsyncMqttClientInternals::PubRelPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onPubRel, this, std::placeholders::_1));
-            break;
-          case AsyncMqttClientInternals::PacketType.PUBACK:
-            _currentParsedPacket = new AsyncMqttClientInternals::PubAckPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onPubAck, this, std::placeholders::_1));
-            break;
-          case AsyncMqttClientInternals::PacketType.PUBREC:
-            _currentParsedPacket = new AsyncMqttClientInternals::PubRecPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onPubRec, this, std::placeholders::_1));
-            break;
-          case AsyncMqttClientInternals::PacketType.PUBCOMP:
-            _currentParsedPacket = new AsyncMqttClientInternals::PubCompPacket(&_parsingInformation, std::bind(&AsyncMqttClient::_onPubComp, this, std::placeholders::_1));
-            break;
-          default:
-            break;
-        }
-        break;
-      case AsyncMqttClientInternals::BufferState::REMAINING_LENGTH:
-        currentByte = data[currentBytePosition++];
-        _remainingLengthBuffer[_remainingLengthBufferPosition++] = currentByte;
-        if (currentByte >> 7 == 0) {
-          _parsingInformation.remainingLength = AsyncMqttClientInternals::Helpers::decodeRemainingLength(_remainingLengthBuffer);
-          _remainingLengthBufferPosition = 0;
-          if (_parsingInformation.remainingLength > 0) {
-            _parsingInformation.bufferState = AsyncMqttClientInternals::BufferState::VARIABLE_HEADER;
-          } else {
-            // PINGRESP is a special case where it has no variable header, so the packet ends right here
-            _parsingInformation.bufferState = AsyncMqttClientInternals::BufferState::NONE;
-            _onPingResp();
-          }
-        }
-        break;
-      case AsyncMqttClientInternals::BufferState::VARIABLE_HEADER:
-        _currentParsedPacket->parseVariableHeader(data, len, &currentBytePosition);
-        break;
-      case AsyncMqttClientInternals::BufferState::PAYLOAD:
-        _currentParsedPacket->parsePayload(data, len, &currentBytePosition);
-        break;
-      default:
-        currentBytePosition = len;
-    }
-  } while (currentBytePosition != len);
-}
-
-void AsyncMqttClient::_onPoll(AsyncClient* client) {
-  if (!_connected) return;
-
-  // if there is too much time the client has sent a ping request without a response, disconnect client to avoid half open connections
-  if (_lastPingRequestTime != 0 && (millis() - _lastPingRequestTime) >= (_keepAlive * 1000 * 2)) {
-    disconnect();
-    return;
-  // send ping to ensure the server will receive at least one message inside keepalive window
-  } else if (_lastPingRequestTime == 0 && (millis() - _lastClientActivity) >= (_keepAlive * 1000 * 0.7)) {
-    _sendPing();
-
-  // send ping to verify if the server is still there (ensure this is not a half connection)
-  } else if (_connected && _lastPingRequestTime == 0 && (millis() - _lastServerActivity) >= (_keepAlive * 1000 * 0.7)) {
-    _sendPing();
-  }
-
-  // handle to send ack packets
-
-  _sendAcks();
-
-  // handle disconnect
-
-  if (_disconnectFlagged) {
-    _sendDisconnect();
-  }
-}
-
-/* MQTT */
-void AsyncMqttClient::_onPingResp() {
-  _freeCurrentParsedPacket();
-  _lastPingRequestTime = 0;
-}
-
-void AsyncMqttClient::_onConnAck(bool sessionPresent, uint8_t connectReturnCode) {
-  (void)sessionPresent;
-  _freeCurrentParsedPacket();
-
-  if (connectReturnCode == 0) {
-    _connected = true;
-    for (auto callback : _onConnectUserCallbacks) callback(sessionPresent);
-  } else {
-    for (auto callback : _onDisconnectUserCallbacks) callback(static_cast<AsyncMqttClientDisconnectReason>(connectReturnCode));
-    _disconnectFlagged = true;
-  }
-}
-
-void AsyncMqttClient::_onSubAck(uint16_t packetId, char status) {
-  _freeCurrentParsedPacket();
-
-  for (auto callback : _onSubscribeUserCallbacks) callback(packetId, status);
-}
-
-void AsyncMqttClient::_onUnsubAck(uint16_t packetId) {
-  _freeCurrentParsedPacket();
-
-  for (auto callback : _onUnsubscribeUserCallbacks) callback(packetId);
-}
-
-void AsyncMqttClient::_onMessage(char* topic, char* payload, uint8_t qos, bool dup, bool retain, size_t len, size_t index, size_t total, uint16_t packetId) {
-  bool notifyPublish = true;
-
-  if (qos == 2) {
-    for (AsyncMqttClientInternals::PendingPubRel pendingPubRel : _pendingPubRels) {
-      if (pendingPubRel.packetId == packetId) {
-        notifyPublish = false;
-        break;
-      }
-    }
-  }
-
-  if (notifyPublish) {
-    AsyncMqttClientMessageProperties properties;
-    properties.qos = qos;
-    properties.dup = dup;
-    properties.retain = retain;
-
-    for (auto callback : _onMessageUserCallbacks) callback(topic, payload, properties, len, index, total);
-  }
-}
-
-void AsyncMqttClient::_onPublish(uint16_t packetId, uint8_t qos) {
-  AsyncMqttClientInternals::PendingAck pendingAck;
-
-  if (qos == 1) {
-    pendingAck.packetType = AsyncMqttClientInternals::PacketType.PUBACK;
-    pendingAck.headerFlag = AsyncMqttClientInternals::HeaderFlag.PUBACK_RESERVED;
-    pendingAck.packetId = packetId;
-    _toSendAcks.push_back(pendingAck);
-  } else if (qos == 2) {
-    pendingAck.packetType = AsyncMqttClientInternals::PacketType.PUBREC;
-    pendingAck.headerFlag = AsyncMqttClientInternals::HeaderFlag.PUBREC_RESERVED;
-    pendingAck.packetId = packetId;
-    _toSendAcks.push_back(pendingAck);
-
-    bool pubRelAwaiting = false;
-    for (AsyncMqttClientInternals::PendingPubRel pendingPubRel : _pendingPubRels) {
-      if (pendingPubRel.packetId == packetId) {
-        pubRelAwaiting = true;
-        break;
-      }
-    }
-
-    if (!pubRelAwaiting) {
-      AsyncMqttClientInternals::PendingPubRel pendingPubRel;
-      pendingPubRel.packetId = packetId;
-      _pendingPubRels.push_back(pendingPubRel);
-    }
-
-    _sendAcks();
-  }
-
-  _freeCurrentParsedPacket();
-}
-
-void AsyncMqttClient::_onPubRel(uint16_t packetId) {
-  _freeCurrentParsedPacket();
-
-  AsyncMqttClientInternals::PendingAck pendingAck;
-  pendingAck.packetType = AsyncMqttClientInternals::PacketType.PUBCOMP;
-  pendingAck.headerFlag = AsyncMqttClientInternals::HeaderFlag.PUBCOMP_RESERVED;
-  pendingAck.packetId = packetId;
-  _toSendAcks.push_back(pendingAck);
-
-  for (size_t i = 0; i < _pendingPubRels.size(); i++) {
-    if (_pendingPubRels[i].packetId == packetId) {
-      _pendingPubRels.erase(_pendingPubRels.begin() + i);
-      _pendingPubRels.shrink_to_fit();
-    }
-  }
-
-  _sendAcks();
-}
-
-void AsyncMqttClient::_onPubAck(uint16_t packetId) {
-  _freeCurrentParsedPacket();
-
-  for (auto callback : _onPublishUserCallbacks) callback(packetId);
-}
-
-void AsyncMqttClient::_onPubRec(uint16_t packetId) {
-  _freeCurrentParsedPacket();
-
-  AsyncMqttClientInternals::PendingAck pendingAck;
-  pendingAck.packetType = AsyncMqttClientInternals::PacketType.PUBREL;
-  pendingAck.headerFlag = AsyncMqttClientInternals::HeaderFlag.PUBREL_RESERVED;
-  pendingAck.packetId = packetId;
-  _toSendAcks.push_back(pendingAck);
-
-  _sendAcks();
-}
-
-void AsyncMqttClient::_onPubComp(uint16_t packetId) {
-  _freeCurrentParsedPacket();
-
-  for (auto callback : _onPublishUserCallbacks) callback(packetId);
-}
-
-bool AsyncMqttClient::_sendPing() {
-  char fixedHeader[2];
-  fixedHeader[0] = AsyncMqttClientInternals::PacketType.PINGREQ;
-  fixedHeader[0] = fixedHeader[0] << 4;
-  fixedHeader[0] = fixedHeader[0] | AsyncMqttClientInternals::HeaderFlag.PINGREQ_RESERVED;
-  fixedHeader[1] = 0;
-
-  size_t neededSpace = 2;
-
-  SEMAPHORE_TAKE(false);
-  if (_client.space() < neededSpace) { SEMAPHORE_GIVE(); return false; }
-
-  _client.add(fixedHeader, 2);
-  _client.send();
-  _lastClientActivity = millis();
-  _lastPingRequestTime = millis();
-
-  SEMAPHORE_GIVE();
-  return true;
-}
-
-void AsyncMqttClient::_sendAcks() {
-  uint8_t neededAckSpace = 2 + 2;
-
-  SEMAPHORE_TAKE();
-  for (size_t i = 0; i < _toSendAcks.size(); i++) {
-    if (_client.space() < neededAckSpace) break;
-
-    AsyncMqttClientInternals::PendingAck pendingAck = _toSendAcks[i];
-
-    char fixedHeader[2];
-    fixedHeader[0] = pendingAck.packetType;
-    fixedHeader[0] = fixedHeader[0] << 4;
-    fixedHeader[0] = fixedHeader[0] | pendingAck.headerFlag;
-    fixedHeader[1] = 2;
-
-    char packetIdBytes[2];
-    packetIdBytes[0] = pendingAck.packetId >> 8;
-    packetIdBytes[1] = pendingAck.packetId & 0xFF;
-
-    _client.add(fixedHeader, 2);
-    _client.add(packetIdBytes, 2);
-    _client.send();
-
-    _toSendAcks.erase(_toSendAcks.begin() + i);
-    _toSendAcks.shrink_to_fit();
-
-    _lastClientActivity = millis();
-  }
-  SEMAPHORE_GIVE();
-}
-
-bool AsyncMqttClient::_sendDisconnect() {
-  if (!_connected) return true;
-
-  const uint8_t neededSpace = 2;
-
-  SEMAPHORE_TAKE(false);
-
-  if (_client.space() < neededSpace) { SEMAPHORE_GIVE(); return false; }
-
-  char fixedHeader[2];
-  fixedHeader[0] = AsyncMqttClientInternals::PacketType.DISCONNECT;
-  fixedHeader[0] = fixedHeader[0] << 4;
-  fixedHeader[0] = fixedHeader[0] | AsyncMqttClientInternals::HeaderFlag.DISCONNECT_RESERVED;
-  fixedHeader[1] = 0;
-
-  _client.add(fixedHeader, 2);
-  _client.send();
-  _client.close(true);
-
-  _disconnectFlagged = false;
-
-  SEMAPHORE_GIVE();
-  return true;
-}
-
-uint16_t AsyncMqttClient::_getNextPacketId() {
-  uint16_t nextPacketId = _nextPacketId;
-
-  if (_nextPacketId == 65535) _nextPacketId = 0;  // 0 is forbidden
-  _nextPacketId++;
-
-  return nextPacketId;
-}
-
-bool AsyncMqttClient::connected() const {
-  return _connected;
-}
-
-void AsyncMqttClient::connect() {
-  if (_connected) return;
-
-#if ASYNC_TCP_SSL_ENABLED
-  if (_useIp) {
-    _client.connect(_ip, _port, _secure);
-  } else {
-    _client.connect(_host, _port, _secure);
-  }
-#else
-  if (_useIp) {
-    _client.connect(_ip, _port);
-  } else {
-    _client.connect(_host, _port);
-  }
-#endif
-}
-
-void AsyncMqttClient::disconnect(bool force) {
-  if (!_connected) return;
-
-  if (force) {
-    _client.close(true);
-  } else {
-    _disconnectFlagged = true;
-    _sendDisconnect();
-  }
-}
-
-uint16_t AsyncMqttClient::subscribe(const char* topic, uint8_t qos) {
-  if (!_connected) return 0;
-
-  char fixedHeader[5];
-  fixedHeader[0] = AsyncMqttClientInternals::PacketType.SUBSCRIBE;
-  fixedHeader[0] = fixedHeader[0] << 4;
-  fixedHeader[0] = fixedHeader[0] | AsyncMqttClientInternals::HeaderFlag.SUBSCRIBE_RESERVED;
-
-  uint16_t topicLength = strlen(topic);
-  char topicLengthBytes[2];
-  topicLengthBytes[0] = topicLength >> 8;
-  topicLengthBytes[1] = topicLength & 0xFF;
-
-  char qosByte[1];
-  qosByte[0] = qos;
-
-  uint8_t remainingLengthLength = AsyncMqttClientInternals::Helpers::encodeRemainingLength(2 + 2 + topicLength + 1, fixedHeader + 1);
-
-  size_t neededSpace = 0;
-  neededSpace += 1 + remainingLengthLength;
-  neededSpace += 2;
-  neededSpace += 2;
-  neededSpace += topicLength;
-  neededSpace += 1;
-
-  SEMAPHORE_TAKE(0);
-  if (_client.space() < neededSpace) { SEMAPHORE_GIVE(); return 0; }
-
-  uint16_t packetId = _getNextPacketId();
-  char packetIdBytes[2];
-  packetIdBytes[0] = packetId >> 8;
-  packetIdBytes[1] = packetId & 0xFF;
-
-  _client.add(fixedHeader, 1 + remainingLengthLength);
-  _client.add(packetIdBytes, 2);
-  _client.add(topicLengthBytes, 2);
-  _client.add(topic, topicLength);
-  _client.add(qosByte, 1);
-  _client.send();
-  _lastClientActivity = millis();
-
-  SEMAPHORE_GIVE();
-  return packetId;
-}
-
-uint16_t AsyncMqttClient::unsubscribe(const char* topic) {
-  if (!_connected) return 0;
-
-  char fixedHeader[5];
-  fixedHeader[0] = AsyncMqttClientInternals::PacketType.UNSUBSCRIBE;
-  fixedHeader[0] = fixedHeader[0] << 4;
-  fixedHeader[0] = fixedHeader[0] | AsyncMqttClientInternals::HeaderFlag.UNSUBSCRIBE_RESERVED;
-
-  uint16_t topicLength = strlen(topic);
-  char topicLengthBytes[2];
-  topicLengthBytes[0] = topicLength >> 8;
-  topicLengthBytes[1] = topicLength & 0xFF;
-
-  uint8_t remainingLengthLength = AsyncMqttClientInternals::Helpers::encodeRemainingLength(2 + 2 + topicLength, fixedHeader + 1);
-
-  size_t neededSpace = 0;
-  neededSpace += 1 + remainingLengthLength;
-  neededSpace += 2;
-  neededSpace += 2;
-  neededSpace += topicLength;
-
-  SEMAPHORE_TAKE(0);
-  if (_client.space() < neededSpace) { SEMAPHORE_GIVE(); return 0; }
-
-  uint16_t packetId = _getNextPacketId();
-  char packetIdBytes[2];
-  packetIdBytes[0] = packetId >> 8;
-  packetIdBytes[1] = packetId & 0xFF;
-
-  _client.add(fixedHeader, 1 + remainingLengthLength);
-  _client.add(packetIdBytes, 2);
-  _client.add(topicLengthBytes, 2);
-  _client.add(topic, topicLength);
-  _client.send();
-  _lastClientActivity = millis();
-
-  SEMAPHORE_GIVE();
-  return packetId;
-}
-
-uint16_t AsyncMqttClient::publish(const char* topic, uint8_t qos, bool retain, const char* payload, size_t length, bool dup, uint16_t message_id) {
-  if (!_connected) return 0;
-
-  char fixedHeader[5];
-  fixedHeader[0] = AsyncMqttClientInternals::PacketType.PUBLISH;
-  fixedHeader[0] = fixedHeader[0] << 4;
-  if (dup) fixedHeader[0] |= AsyncMqttClientInternals::HeaderFlag.PUBLISH_DUP;
-  if (retain) fixedHeader[0] |= AsyncMqttClientInternals::HeaderFlag.PUBLISH_RETAIN;
-  switch (qos) {
-    case 0:
-      fixedHeader[0] |= AsyncMqttClientInternals::HeaderFlag.PUBLISH_QOS0;
-      break;
-    case 1:
-      fixedHeader[0] |= AsyncMqttClientInternals::HeaderFlag.PUBLISH_QOS1;
-      break;
-    case 2:
-      fixedHeader[0] |= AsyncMqttClientInternals::HeaderFlag.PUBLISH_QOS2;
-      break;
-  }
-
-  uint16_t topicLength = strlen(topic);
-  char topicLengthBytes[2];
-  topicLengthBytes[0] = topicLength >> 8;
-  topicLengthBytes[1] = topicLength & 0xFF;
-
-  uint32_t payloadLength = length;
-  if (payload != nullptr && payloadLength == 0) payloadLength = strlen(payload);
-
-  uint32_t remainingLength = 2 + topicLength + payloadLength;
-  if (qos != 0) remainingLength += 2;
-  uint8_t remainingLengthLength = AsyncMqttClientInternals::Helpers::encodeRemainingLength(remainingLength, fixedHeader + 1);
-
-  size_t neededSpace = 0;
-  neededSpace += 1 + remainingLengthLength;
-  neededSpace += 2;
-  neededSpace += topicLength;
-  if (qos != 0) neededSpace += 2;
-  if (payload != nullptr) neededSpace += payloadLength;
-
-  SEMAPHORE_TAKE(0);
-  if (_client.space() < neededSpace) { SEMAPHORE_GIVE(); return 0; }
-
-  uint16_t packetId = 0;
-  char packetIdBytes[2];
-  if (qos != 0) {
-    if (dup && message_id > 0) {
-      packetId = message_id;
-    } else {
-      packetId = _getNextPacketId();
-    }
-
-    packetIdBytes[0] = packetId >> 8;
-    packetIdBytes[1] = packetId & 0xFF;
-  }
-
-  _client.add(fixedHeader, 1 + remainingLengthLength);
-  _client.add(topicLengthBytes, 2);
-  _client.add(topic, topicLength);
-  if (qos != 0) _client.add(packetIdBytes, 2);
-  if (payload != nullptr) _client.add(payload, payloadLength);
-  _client.send();
-  _lastClientActivity = millis();
-
-  SEMAPHORE_GIVE();
-  if (qos != 0) {
-    return packetId;
-  } else {
-    return 1;
-  }
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.h
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.h
@@ -1,6 +0,0 @@
-#ifndef SRC_ASYNCMQTTCLIENT_H_
-#define SRC_ASYNCMQTTCLIENT_H_
-
-#include "AsyncMqttClient.hpp"
-
-#endif  // SRC_ASYNCMQTTCLIENT_H_
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.hpp
@@ -1,166 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <vector>
-
-#include "Arduino.h"
-
-#ifdef ESP32
-#include <AsyncTCP.h>
-#include <freertos/semphr.h>
-#elif defined(ESP8266)
-#include <ESPAsyncTCP.h>
-#else
-#error Platform not supported
-#endif
-
-#if ASYNC_TCP_SSL_ENABLED
-#include <tcp_axtls.h>
-#define SHA1_SIZE 20
-#endif
-
-#include "AsyncMqttClient/Flags.hpp"
-#include "AsyncMqttClient/ParsingInformation.hpp"
-#include "AsyncMqttClient/MessageProperties.hpp"
-#include "AsyncMqttClient/Helpers.hpp"
-#include "AsyncMqttClient/Callbacks.hpp"
-#include "AsyncMqttClient/DisconnectReasons.hpp"
-#include "AsyncMqttClient/Storage.hpp"
-
-#include "AsyncMqttClient/Packets/Packet.hpp"
-#include "AsyncMqttClient/Packets/ConnAckPacket.hpp"
-#include "AsyncMqttClient/Packets/PingRespPacket.hpp"
-#include "AsyncMqttClient/Packets/SubAckPacket.hpp"
-#include "AsyncMqttClient/Packets/UnsubAckPacket.hpp"
-#include "AsyncMqttClient/Packets/PublishPacket.hpp"
-#include "AsyncMqttClient/Packets/PubRelPacket.hpp"
-#include "AsyncMqttClient/Packets/PubAckPacket.hpp"
-#include "AsyncMqttClient/Packets/PubRecPacket.hpp"
-#include "AsyncMqttClient/Packets/PubCompPacket.hpp"
-
-#if ESP32
-#define SEMAPHORE_TAKE(X) if (xSemaphoreTake(_xSemaphore, 1000 / portTICK_PERIOD_MS) != pdTRUE) { return X; }  // Waits max 1000ms
-#define SEMAPHORE_GIVE() xSemaphoreGive(_xSemaphore);
-#elif defined(ESP8266)
-#define SEMAPHORE_TAKE(X) void()
-#define SEMAPHORE_GIVE() void()
-#endif
-
-class AsyncMqttClient {
- public:
-  AsyncMqttClient();
-  ~AsyncMqttClient();
-
-  AsyncMqttClient& setKeepAlive(uint16_t keepAlive);
-  AsyncMqttClient& setClientId(const char* clientId);
-  AsyncMqttClient& setCleanSession(bool cleanSession);
-  AsyncMqttClient& setMaxTopicLength(uint16_t maxTopicLength);
-  AsyncMqttClient& setCredentials(const char* username, const char* password = nullptr);
-  AsyncMqttClient& setWill(const char* topic, uint8_t qos, bool retain, const char* payload = nullptr, size_t length = 0);
-  AsyncMqttClient& setServer(IPAddress ip, uint16_t port);
-  AsyncMqttClient& setServer(const char* host, uint16_t port);
-#if ASYNC_TCP_SSL_ENABLED
-  AsyncMqttClient& setSecure(bool secure);
-  AsyncMqttClient& addServerFingerprint(const uint8_t* fingerprint);
-#endif
-
-  AsyncMqttClient& onConnect(AsyncMqttClientInternals::OnConnectUserCallback callback);
-  AsyncMqttClient& onDisconnect(AsyncMqttClientInternals::OnDisconnectUserCallback callback);
-  AsyncMqttClient& onSubscribe(AsyncMqttClientInternals::OnSubscribeUserCallback callback);
-  AsyncMqttClient& onUnsubscribe(AsyncMqttClientInternals::OnUnsubscribeUserCallback callback);
-  AsyncMqttClient& onMessage(AsyncMqttClientInternals::OnMessageUserCallback callback);
-  AsyncMqttClient& onPublish(AsyncMqttClientInternals::OnPublishUserCallback callback);
-
-  bool connected() const;
-  void connect();
-  void disconnect(bool force = false);
-  uint16_t subscribe(const char* topic, uint8_t qos);
-  uint16_t unsubscribe(const char* topic);
-  uint16_t publish(const char* topic, uint8_t qos, bool retain, const char* payload = nullptr, size_t length = 0, bool dup = false, uint16_t message_id = 0);
-
- private:
-  AsyncClient _client;
-
-  bool _connected;
-  bool _connectPacketNotEnoughSpace;
-  bool _disconnectFlagged;
-  bool _tlsBadFingerprint;
-  uint32_t _lastClientActivity;
-  uint32_t _lastServerActivity;
-  uint32_t _lastPingRequestTime;
-
-  char _generatedClientId[13 + 1];  // esp8266abc123
-  IPAddress _ip;
-  const char* _host;
-  bool _useIp;
-#if ASYNC_TCP_SSL_ENABLED
-  bool _secure;
-#endif
-  uint16_t _port;
-  uint16_t _keepAlive;
-  bool _cleanSession;
-  const char* _clientId;
-  const char* _username;
-  const char* _password;
-  const char* _willTopic;
-  const char* _willPayload;
-  uint16_t _willPayloadLength;
-  uint8_t _willQos;
-  bool _willRetain;
-
-#if ASYNC_TCP_SSL_ENABLED
-  std::vector<std::array<uint8_t, SHA1_SIZE>> _secureServerFingerprints;
-#endif
-
-  std::vector<AsyncMqttClientInternals::OnConnectUserCallback> _onConnectUserCallbacks;
-  std::vector<AsyncMqttClientInternals::OnDisconnectUserCallback> _onDisconnectUserCallbacks;
-  std::vector<AsyncMqttClientInternals::OnSubscribeUserCallback> _onSubscribeUserCallbacks;
-  std::vector<AsyncMqttClientInternals::OnUnsubscribeUserCallback> _onUnsubscribeUserCallbacks;
-  std::vector<AsyncMqttClientInternals::OnMessageUserCallback> _onMessageUserCallbacks;
-  std::vector<AsyncMqttClientInternals::OnPublishUserCallback> _onPublishUserCallbacks;
-
-  AsyncMqttClientInternals::ParsingInformation _parsingInformation;
-  AsyncMqttClientInternals::Packet* _currentParsedPacket;
-  uint8_t _remainingLengthBufferPosition;
-  char _remainingLengthBuffer[4];
-
-  uint16_t _nextPacketId;
-
-  std::vector<AsyncMqttClientInternals::PendingPubRel> _pendingPubRels;
-
-  std::vector<AsyncMqttClientInternals::PendingAck> _toSendAcks;
-
-#ifdef ESP32
-  SemaphoreHandle_t _xSemaphore = nullptr;
-#endif
-
-  void _clear();
-  void _freeCurrentParsedPacket();
-
-  // TCP
-  void _onConnect(AsyncClient* client);
-  void _onDisconnect(AsyncClient* client);
-  static void _onError(AsyncClient* client, int8_t error);
-  void _onTimeout(AsyncClient* client, uint32_t time);
-  static void _onAck(AsyncClient* client, size_t len, uint32_t time);
-  void _onData(AsyncClient* client, char* data, size_t len);
-  void _onPoll(AsyncClient* client);
-
-  // MQTT
-  void _onPingResp();
-  void _onConnAck(bool sessionPresent, uint8_t connectReturnCode);
-  void _onSubAck(uint16_t packetId, char status);
-  void _onUnsubAck(uint16_t packetId);
-  void _onMessage(char* topic, char* payload, uint8_t qos, bool dup, bool retain, size_t len, size_t index, size_t total, uint16_t packetId);
-  void _onPublish(uint16_t packetId, uint8_t qos);
-  void _onPubRel(uint16_t packetId);
-  void _onPubAck(uint16_t packetId);
-  void _onPubRec(uint16_t packetId);
-  void _onPubComp(uint16_t packetId);
-
-  bool _sendPing();
-  void _sendAcks();
-  bool _sendDisconnect();
-
-  uint16_t _getNextPacketId();
-};
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Callbacks.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Callbacks.hpp
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <functional>
-
-#include "DisconnectReasons.hpp"
-#include "MessageProperties.hpp"
-
-namespace AsyncMqttClientInternals {
-// user callbacks
-typedef std::function<void(bool sessionPresent)> OnConnectUserCallback;
-typedef std::function<void(AsyncMqttClientDisconnectReason reason)> OnDisconnectUserCallback;
-typedef std::function<void(uint16_t packetId, uint8_t qos)> OnSubscribeUserCallback;
-typedef std::function<void(uint16_t packetId)> OnUnsubscribeUserCallback;
-typedef std::function<void(char* topic, char* payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total)> OnMessageUserCallback;
-typedef std::function<void(uint16_t packetId)> OnPublishUserCallback;
-
-// internal callbacks
-typedef std::function<void(bool sessionPresent, uint8_t connectReturnCode)> OnConnAckInternalCallback;
-typedef std::function<void()> OnPingRespInternalCallback;
-typedef std::function<void(uint16_t packetId, char status)> OnSubAckInternalCallback;
-typedef std::function<void(uint16_t packetId)> OnUnsubAckInternalCallback;
-typedef std::function<void(char* topic, char* payload, uint8_t qos, bool dup, bool retain, size_t len, size_t index, size_t total, uint16_t packetId)> OnMessageInternalCallback;
-typedef std::function<void(uint16_t packetId, uint8_t qos)> OnPublishInternalCallback;
-typedef std::function<void(uint16_t packetId)> OnPubRelInternalCallback;
-typedef std::function<void(uint16_t packetId)> OnPubAckInternalCallback;
-typedef std::function<void(uint16_t packetId)> OnPubRecInternalCallback;
-typedef std::function<void(uint16_t packetId)> OnPubCompInternalCallback;
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/DisconnectReasons.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/DisconnectReasons.hpp
@@ -1,15 +0,0 @@
-#pragma once
-
-enum class AsyncMqttClientDisconnectReason : int8_t {
-  TCP_DISCONNECTED = 0,
-
-  MQTT_UNACCEPTABLE_PROTOCOL_VERSION = 1,
-  MQTT_IDENTIFIER_REJECTED = 2,
-  MQTT_SERVER_UNAVAILABLE = 3,
-  MQTT_MALFORMED_CREDENTIALS = 4,
-  MQTT_NOT_AUTHORIZED = 5,
-
-  ESP8266_NOT_ENOUGH_SPACE = 6,
-
-  TLS_BAD_FINGERPRINT = 7
-};
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Flags.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Flags.hpp
@@ -1,57 +0,0 @@
-#pragma once
-
-namespace AsyncMqttClientInternals {
-constexpr struct {
-  const uint8_t RESERVED    = 0;
-  const uint8_t CONNECT     = 1;
-  const uint8_t CONNACK     = 2;
-  const uint8_t PUBLISH     = 3;
-  const uint8_t PUBACK      = 4;
-  const uint8_t PUBREC      = 5;
-  const uint8_t PUBREL      = 6;
-  const uint8_t PUBCOMP     = 7;
-  const uint8_t SUBSCRIBE   = 8;
-  const uint8_t SUBACK      = 9;
-  const uint8_t UNSUBSCRIBE = 10;
-  const uint8_t UNSUBACK    = 11;
-  const uint8_t PINGREQ     = 12;
-  const uint8_t PINGRESP    = 13;
-  const uint8_t DISCONNECT  = 14;
-  const uint8_t RESERVED2   = 1;
-} PacketType;
-
-constexpr struct {
-  const uint8_t CONNECT_RESERVED     = 0x00;
-  const uint8_t CONNACK_RESERVED     = 0x00;
-  const uint8_t PUBLISH_DUP          = 0x08;
-  const uint8_t PUBLISH_QOS0         = 0x00;
-  const uint8_t PUBLISH_QOS1         = 0x02;
-  const uint8_t PUBLISH_QOS2         = 0x04;
-  const uint8_t PUBLISH_QOSRESERVED  = 0x06;
-  const uint8_t PUBLISH_RETAIN       = 0x01;
-  const uint8_t PUBACK_RESERVED      = 0x00;
-  const uint8_t PUBREC_RESERVED      = 0x00;
-  const uint8_t PUBREL_RESERVED      = 0x02;
-  const uint8_t PUBCOMP_RESERVED     = 0x00;
-  const uint8_t SUBSCRIBE_RESERVED   = 0x02;
-  const uint8_t SUBACK_RESERVED      = 0x00;
-  const uint8_t UNSUBSCRIBE_RESERVED = 0x02;
-  const uint8_t UNSUBACK_RESERVED    = 0x00;
-  const uint8_t PINGREQ_RESERVED     = 0x00;
-  const uint8_t PINGRESP_RESERVED    = 0x00;
-  const uint8_t DISCONNECT_RESERVED  = 0x00;
-  const uint8_t RESERVED2_RESERVED   = 0x00;
-} HeaderFlag;
-
-constexpr struct {
-  const uint8_t USERNAME      = 0x80;
-  const uint8_t PASSWORD      = 0x40;
-  const uint8_t WILL_RETAIN   = 0x20;
-  const uint8_t WILL_QOS0     = 0x00;
-  const uint8_t WILL_QOS1     = 0x08;
-  const uint8_t WILL_QOS2     = 0x10;
-  const uint8_t WILL          = 0x04;
-  const uint8_t CLEAN_SESSION = 0x02;
-  const uint8_t RESERVED      = 0x00;
-} ConnectFlag;
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Helpers.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Helpers.hpp
@@ -1,38 +0,0 @@
-#pragma once
-
-namespace AsyncMqttClientInternals {
-class Helpers {
- public:
-  static uint32_t decodeRemainingLength(char* bytes) {
-    uint32_t multiplier = 1;
-    uint32_t value = 0;
-    uint8_t currentByte = 0;
-    uint8_t encodedByte;
-    do {
-      encodedByte = bytes[currentByte++];
-      value += (encodedByte & 127) * multiplier;
-      multiplier *= 128;
-    } while ((encodedByte & 128) != 0);
-
-    return value;
-  }
-
-  static uint8_t encodeRemainingLength(uint32_t remainingLength, char* destination) {
-    uint8_t currentByte = 0;
-    uint8_t bytesNeeded = 0;
-
-    do {
-      uint8_t encodedByte = remainingLength % 128;
-      remainingLength /= 128;
-      if (remainingLength > 0) {
-        encodedByte = encodedByte | 128;
-      }
-
-      destination[currentByte++] = encodedByte;
-      bytesNeeded++;
-    } while (remainingLength > 0);
-
-    return bytesNeeded;
-  }
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/MessageProperties.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/MessageProperties.hpp
@@ -1,7 +0,0 @@
-#pragma once
-
-struct AsyncMqttClientMessageProperties {
-  uint8_t qos;
-  bool dup;
-  bool retain;
-};
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/ConnAckPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/ConnAckPacket.cpp
@@ -1,30 +0,0 @@
-#include "ConnAckPacket.hpp"
-
-using AsyncMqttClientInternals::ConnAckPacket;
-
-ConnAckPacket::ConnAckPacket(ParsingInformation* parsingInformation, OnConnAckInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback)
-, _bytePosition(0)
-, _sessionPresent(false)
-, _connectReturnCode(0) {
-}
-
-ConnAckPacket::~ConnAckPacket() {
-}
-
-void ConnAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition++ == 0) {
-    _sessionPresent = (currentByte << 7) >> 7;
-  } else {
-    _connectReturnCode = currentByte;
-    _parsingInformation->bufferState = BufferState::NONE;
-    _callback(_sessionPresent, _connectReturnCode);
-  }
-}
-
-void ConnAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/ConnAckPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/ConnAckPacket.hpp
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class ConnAckPacket : public Packet {
- public:
-  explicit ConnAckPacket(ParsingInformation* parsingInformation, OnConnAckInternalCallback callback);
-  ~ConnAckPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnConnAckInternalCallback _callback;
-
-  uint8_t _bytePosition;
-  bool _sessionPresent;
-  uint8_t _connectReturnCode;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/Packet.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/Packet.hpp
@@ -1,11 +0,0 @@
-#pragma once
-
-namespace AsyncMqttClientInternals {
-class Packet {
- public:
-  virtual ~Packet() {}
-
-  virtual void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) = 0;
-  virtual void parsePayload(char* data, size_t len, size_t* currentBytePosition) = 0;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PingRespPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PingRespPacket.cpp
@@ -1,21 +0,0 @@
-#include "PingRespPacket.hpp"
-
-using AsyncMqttClientInternals::PingRespPacket;
-
-PingRespPacket::PingRespPacket(ParsingInformation* parsingInformation, OnPingRespInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback) {
-}
-
-PingRespPacket::~PingRespPacket() {
-}
-
-void PingRespPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
-
-void PingRespPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PingRespPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PingRespPacket.hpp
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class PingRespPacket : public Packet {
- public:
-  explicit PingRespPacket(ParsingInformation* parsingInformation, OnPingRespInternalCallback callback);
-  ~PingRespPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnPingRespInternalCallback _callback;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubAckPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubAckPacket.cpp
@@ -1,30 +0,0 @@
-#include "PubAckPacket.hpp"
-
-using AsyncMqttClientInternals::PubAckPacket;
-
-PubAckPacket::PubAckPacket(ParsingInformation* parsingInformation, OnPubAckInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback)
-, _bytePosition(0)
-, _packetIdMsb(0)
-, _packetId(0) {
-}
-
-PubAckPacket::~PubAckPacket() {
-}
-
-void PubAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition++ == 0) {
-    _packetIdMsb = currentByte;
-  } else {
-    _packetId = currentByte | _packetIdMsb << 8;
-    _parsingInformation->bufferState = BufferState::NONE;
-    _callback(_packetId);
-  }
-}
-
-void PubAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubAckPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubAckPacket.hpp
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class PubAckPacket : public Packet {
- public:
-  explicit PubAckPacket(ParsingInformation* parsingInformation, OnPubAckInternalCallback callback);
-  ~PubAckPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnPubAckInternalCallback _callback;
-
-  uint8_t _bytePosition;
-  char _packetIdMsb;
-  uint16_t _packetId;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubCompPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubCompPacket.cpp
@@ -1,30 +0,0 @@
-#include "PubCompPacket.hpp"
-
-using AsyncMqttClientInternals::PubCompPacket;
-
-PubCompPacket::PubCompPacket(ParsingInformation* parsingInformation, OnPubCompInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback)
-, _bytePosition(0)
-, _packetIdMsb(0)
-, _packetId(0) {
-}
-
-PubCompPacket::~PubCompPacket() {
-}
-
-void PubCompPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition++ == 0) {
-    _packetIdMsb = currentByte;
-  } else {
-    _packetId = currentByte | _packetIdMsb << 8;
-    _parsingInformation->bufferState = BufferState::NONE;
-    _callback(_packetId);
-  }
-}
-
-void PubCompPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubCompPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubCompPacket.hpp
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class PubCompPacket : public Packet {
- public:
-  explicit PubCompPacket(ParsingInformation* parsingInformation, OnPubCompInternalCallback callback);
-  ~PubCompPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnPubCompInternalCallback _callback;
-
-  uint8_t _bytePosition;
-  char _packetIdMsb;
-  uint16_t _packetId;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRecPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRecPacket.cpp
@@ -1,30 +0,0 @@
-#include "PubRecPacket.hpp"
-
-using AsyncMqttClientInternals::PubRecPacket;
-
-PubRecPacket::PubRecPacket(ParsingInformation* parsingInformation, OnPubRecInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback)
-, _bytePosition(0)
-, _packetIdMsb(0)
-, _packetId(0) {
-}
-
-PubRecPacket::~PubRecPacket() {
-}
-
-void PubRecPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition++ == 0) {
-    _packetIdMsb = currentByte;
-  } else {
-    _packetId = currentByte | _packetIdMsb << 8;
-    _parsingInformation->bufferState = BufferState::NONE;
-    _callback(_packetId);
-  }
-}
-
-void PubRecPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRecPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRecPacket.hpp
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class PubRecPacket : public Packet {
- public:
-  explicit PubRecPacket(ParsingInformation* parsingInformation, OnPubRecInternalCallback callback);
-  ~PubRecPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnPubRecInternalCallback _callback;
-
-  uint8_t _bytePosition;
-  char _packetIdMsb;
-  uint16_t _packetId;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRelPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRelPacket.cpp
@@ -1,30 +0,0 @@
-#include "PubRelPacket.hpp"
-
-using AsyncMqttClientInternals::PubRelPacket;
-
-PubRelPacket::PubRelPacket(ParsingInformation* parsingInformation, OnPubRelInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback)
-, _bytePosition(0)
-, _packetIdMsb(0)
-, _packetId(0) {
-}
-
-PubRelPacket::~PubRelPacket() {
-}
-
-void PubRelPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition++ == 0) {
-    _packetIdMsb = currentByte;
-  } else {
-    _packetId = currentByte | _packetIdMsb << 8;
-    _parsingInformation->bufferState = BufferState::NONE;
-    _callback(_packetId);
-  }
-}
-
-void PubRelPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRelPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PubRelPacket.hpp
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class PubRelPacket : public Packet {
- public:
-  explicit PubRelPacket(ParsingInformation* parsingInformation, OnPubRelInternalCallback callback);
-  ~PubRelPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnPubRelInternalCallback _callback;
-
-  uint8_t _bytePosition;
-  char _packetIdMsb;
-  uint16_t _packetId;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PublishPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PublishPacket.cpp
@@ -1,91 +0,0 @@
-#include "PublishPacket.hpp"
-
-using AsyncMqttClientInternals::PublishPacket;
-
-PublishPacket::PublishPacket(ParsingInformation* parsingInformation, OnMessageInternalCallback dataCallback, OnPublishInternalCallback completeCallback)
-: _parsingInformation(parsingInformation)
-, _dataCallback(dataCallback)
-, _completeCallback(completeCallback)
-, _dup(false)
-, _qos(0)
-, _retain(0)
-, _bytePosition(0)
-, _topicLengthMsb(0)
-, _topicLength(0)
-, _ignore(false)
-, _packetIdMsb(0)
-, _packetId(0)
-, _payloadLength(0)
-, _payloadBytesRead(0) {
-    _dup = _parsingInformation->packetFlags & HeaderFlag.PUBLISH_DUP;
-    _retain = _parsingInformation->packetFlags & HeaderFlag.PUBLISH_RETAIN;
-    char qosMasked = _parsingInformation->packetFlags & 0x06;
-    switch (qosMasked) {
-      case HeaderFlag.PUBLISH_QOS0:
-        _qos = 0;
-        break;
-      case HeaderFlag.PUBLISH_QOS1:
-        _qos = 1;
-        break;
-      case HeaderFlag.PUBLISH_QOS2:
-        _qos = 2;
-        break;
-    }
-}
-
-PublishPacket::~PublishPacket() {
-}
-
-void PublishPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition == 0) {
-    _topicLengthMsb = currentByte;
-  } else if (_bytePosition == 1) {
-    _topicLength = currentByte | _topicLengthMsb << 8;
-    if (_topicLength > _parsingInformation->maxTopicLength) {
-      _ignore = true;
-    } else {
-      _parsingInformation->topicBuffer[_topicLength] = '\0';
-    }
-  } else if (_bytePosition >= 2 && _bytePosition < 2 + _topicLength) {
-    // Starting from here, _ignore might be true
-    if (!_ignore) _parsingInformation->topicBuffer[_bytePosition - 2] = currentByte;
-    if (_bytePosition == 2 + _topicLength - 1 && _qos == 0) {
-      _preparePayloadHandling(_parsingInformation->remainingLength - (_bytePosition + 1));
-      return;
-    }
-  } else if (_bytePosition == 2 + _topicLength) {
-    _packetIdMsb = currentByte;
-  } else {
-    _packetId = currentByte | _packetIdMsb << 8;
-    _preparePayloadHandling(_parsingInformation->remainingLength - (_bytePosition + 1));
-  }
-  _bytePosition++;
-}
-
-void PublishPacket::_preparePayloadHandling(uint32_t payloadLength) {
-  _payloadLength = payloadLength;
-  if (payloadLength == 0) {
-    _parsingInformation->bufferState = BufferState::NONE;
-    if (!_ignore) {
-      _dataCallback(_parsingInformation->topicBuffer, nullptr, _qos, _dup, _retain, 0, 0, 0, _packetId);
-      _completeCallback(_packetId, _qos);
-    }
-  } else {
-    _parsingInformation->bufferState = BufferState::PAYLOAD;
-  }
-}
-
-void PublishPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  size_t remainToRead = len - (*currentBytePosition);
-  if (_payloadBytesRead + remainToRead > _payloadLength) remainToRead = _payloadLength - _payloadBytesRead;
-
-  if (!_ignore) _dataCallback(_parsingInformation->topicBuffer, data + (*currentBytePosition), _qos, _dup, _retain, remainToRead, _payloadBytesRead, _payloadLength, _packetId);
-  _payloadBytesRead += remainToRead;
-  (*currentBytePosition) += remainToRead;
-
-  if (_payloadBytesRead == _payloadLength) {
-    _parsingInformation->bufferState = BufferState::NONE;
-    if (!_ignore) _completeCallback(_packetId, _qos);
-  }
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PublishPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/PublishPacket.hpp
@@ -1,38 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../Flags.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class PublishPacket : public Packet {
- public:
-  explicit PublishPacket(ParsingInformation* parsingInformation, OnMessageInternalCallback dataCallback, OnPublishInternalCallback completeCallback);
-  ~PublishPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnMessageInternalCallback _dataCallback;
-  OnPublishInternalCallback _completeCallback;
-
-  void _preparePayloadHandling(uint32_t payloadLength);
-
-  bool _dup;
-  uint8_t _qos;
-  bool _retain;
-
-  uint8_t _bytePosition;
-  char _topicLengthMsb;
-  uint16_t _topicLength;
-  bool _ignore;
-  char _packetIdMsb;
-  uint16_t _packetId;
-  uint32_t _payloadLength;
-  uint32_t _payloadBytesRead;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/SubAckPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/SubAckPacket.cpp
@@ -1,46 +0,0 @@
-#include "SubAckPacket.hpp"
-
-using AsyncMqttClientInternals::SubAckPacket;
-
-SubAckPacket::SubAckPacket(ParsingInformation* parsingInformation, OnSubAckInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback)
-, _bytePosition(0)
-, _packetIdMsb(0)
-, _packetId(0) {
-}
-
-SubAckPacket::~SubAckPacket() {
-}
-
-void SubAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition++ == 0) {
-    _packetIdMsb = currentByte;
-  } else {
-    _packetId = currentByte | _packetIdMsb << 8;
-    _parsingInformation->bufferState = BufferState::PAYLOAD;
-  }
-}
-
-void SubAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  char status = data[(*currentBytePosition)++];
-
-  /* switch (status) {
-    case 0:
-      Serial.println("Success QoS 0");
-      break;
-    case 1:
-      Serial.println("Success QoS 1");
-      break;
-    case 2:
-      Serial.println("Success QoS 2");
-      break;
-    case 0x80:
-      Serial.println("Failure");
-      break;
-  } */
-
-  _parsingInformation->bufferState = BufferState::NONE;
-  _callback(_packetId, status);
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/SubAckPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/SubAckPacket.hpp
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class SubAckPacket : public Packet {
- public:
-  explicit SubAckPacket(ParsingInformation* parsingInformation, OnSubAckInternalCallback callback);
-  ~SubAckPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnSubAckInternalCallback _callback;
-
-  uint8_t _bytePosition;
-  char _packetIdMsb;
-  uint16_t _packetId;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/UnsubAckPacket.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/UnsubAckPacket.cpp
@@ -1,30 +0,0 @@
-#include "UnsubAckPacket.hpp"
-
-using AsyncMqttClientInternals::UnsubAckPacket;
-
-UnsubAckPacket::UnsubAckPacket(ParsingInformation* parsingInformation, OnUnsubAckInternalCallback callback)
-: _parsingInformation(parsingInformation)
-, _callback(callback)
-, _bytePosition(0)
-, _packetIdMsb(0)
-, _packetId(0) {
-}
-
-UnsubAckPacket::~UnsubAckPacket() {
-}
-
-void UnsubAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
-  char currentByte = data[(*currentBytePosition)++];
-  if (_bytePosition++ == 0) {
-    _packetIdMsb = currentByte;
-  } else {
-    _packetId = currentByte | _packetIdMsb << 8;
-    _parsingInformation->bufferState = BufferState::NONE;
-    _callback(_packetId);
-  }
-}
-
-void UnsubAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
-  (void)data;
-  (void)currentBytePosition;
-}
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/UnsubAckPacket.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Packets/UnsubAckPacket.hpp
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Arduino.h"
-#include "Packet.hpp"
-#include "../ParsingInformation.hpp"
-#include "../Callbacks.hpp"
-
-namespace AsyncMqttClientInternals {
-class UnsubAckPacket : public Packet {
- public:
-  explicit UnsubAckPacket(ParsingInformation* parsingInformation, OnUnsubAckInternalCallback callback);
-  ~UnsubAckPacket();
-
-  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
-  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
-
- private:
-  ParsingInformation* _parsingInformation;
-  OnUnsubAckInternalCallback _callback;
-
-  uint8_t _bytePosition;
-  char _packetIdMsb;
-  uint16_t _packetId;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/ParsingInformation.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/ParsingInformation.hpp
@@ -1,21 +0,0 @@
-#pragma once
-
-namespace AsyncMqttClientInternals {
-enum class BufferState : uint8_t {
-  NONE = 0,
-  REMAINING_LENGTH = 2,
-  VARIABLE_HEADER = 3,
-  PAYLOAD = 4
-};
-
-struct ParsingInformation {
-  BufferState bufferState;
-
-  uint16_t maxTopicLength;
-  char* topicBuffer;
-
-  uint8_t packetType;
-  uint16_t packetFlags;
-  uint32_t remainingLength;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Storage.hpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient/Storage.hpp
@@ -1,13 +0,0 @@
-#pragma once
-
-namespace AsyncMqttClientInternals {
-struct PendingPubRel {
-  uint16_t packetId;
-};
-
-struct PendingAck {
-  uint8_t packetType;
-  uint8_t headerFlag;
-  uint16_t packetId;
-};
-}  // namespace AsyncMqttClientInternals
--- a/wled00/src/dependencies/async-mqtt-client/LICENSE
+++ b/wled00/src/dependencies/async-mqtt-client/LICENSE
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Marvin Roger
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
--- a/wled00/src/dependencies/async-mqtt-client/README.md
+++ b/wled00/src/dependencies/async-mqtt-client/README.md
@@ -1,18 +0,0 @@
-Async MQTT client for ESP8266 and ESP32 (Github: https://github.com/marvinroger/async-mqtt-client)
-=============================
-
-[![Build Status](https://img.shields.io/travis/marvinroger/async-mqtt-client/master.svg?style=flat-square)](https://travis-ci.org/marvinroger/async-mqtt-client)
-
-An Arduino for ESP8266 and ESP32 asynchronous [MQTT](http://mqtt.org/) client implementation, built on [me-no-dev/ESPAsyncTCP (ESP8266)](https://github.com/me-no-dev/ESPAsyncTCP) | [me-no-dev/AsyncTCP (ESP32)](https://github.com/me-no-dev/AsyncTCP) .
-## Features
-
-* Compliant with the 3.1.1 version of the protocol
-* Fully asynchronous
-* Subscribe at QoS 0, 1 and 2
-* Publish at QoS 0, 1 and 2
-* SSL/TLS support
-* Available in the [PlatformIO registry](http://platformio.org/lib/show/346/AsyncMqttClient)
-
-## Requirements, installation and usage
-
-The project is documented in the [/docs folder](docs).
--- a/wled00/src/dependencies/e131/ESPAsyncE131.cpp
+++ b/wled00/src/dependencies/e131/ESPAsyncE131.cpp
@@ -76,7 +76,7 @@ bool ESPAsyncE131::initMulticast(uint16_t port, uint16_t universe, uint8_t n) {
    ip4_addr_t ifaddr;
    ip4_addr_t multicast_addr;

-    ifaddr.addr = static_cast<uint32_t>(Network.localIP());
+    ifaddr.addr = static_cast<uint32_t>(WLEDNetwork.localIP());
    for (uint8_t i = 1; i < n; i++) {
        multicast_addr.addr = static_cast<uint32_t>(IPAddress(239, 255,
          (((universe + i) >> 8) & 0xff), (((universe + i) >> 0)
--- a/wled00/src/dependencies/espalexa/Espalexa.h
+++ b/wled00/src/dependencies/espalexa/Espalexa.h
@@ -215,7 +215,7 @@ private:
  void serveDescription()
  {
    EA_DEBUGLN("# Responding to description.xml ... #\n");
-    IPAddress localIP = Network.localIP();
+    IPAddress localIP = WLEDNetwork.localIP();
    char s[16];
    snprintf(s, sizeof(s), "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);
    char buf[1024];
@@ -289,7 +289,7 @@ private:
  //respond to UDP SSDP M-SEARCH
  void respondToSearch()
  {
-    IPAddress localIP = Network.localIP();
+    IPAddress localIP = WLEDNetwork.localIP();
    char s[16];
    sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);

@@ -344,7 +344,7 @@ public:
    #ifdef ARDUINO_ARCH_ESP32
    udpConnected = espalexaUdp.beginMulticast(IPAddress(239, 255, 255, 250), 1900);
    #else
-    udpConnected = espalexaUdp.beginMulticast(Network.localIP(), IPAddress(239, 255, 255, 250), 1900);
+    udpConnected = espalexaUdp.beginMulticast(WLEDNetwork.localIP(), IPAddress(239, 255, 255, 250), 1900);
    #endif

    if (udpConnected){
--- a/wled00/src/dependencies/network/Network.cpp
+++ b/wled00/src/dependencies/network/Network.cpp
@@ -1,6 +1,6 @@
 #include "Network.h"

-IPAddress NetworkClass::localIP()
+IPAddress WLEDNetworkClass::localIP()
 {
  IPAddress localIP;
 #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
@@ -17,7 +17,7 @@ IPAddress NetworkClass::localIP()
  return INADDR_NONE;
 }

-IPAddress NetworkClass::subnetMask()
+IPAddress WLEDNetworkClass::subnetMask()
 {
 #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
  if (ETH.localIP()[0] != 0) {
@@ -30,7 +30,7 @@ IPAddress NetworkClass::subnetMask()
  return IPAddress(255, 255, 255, 0);
 }

-IPAddress NetworkClass::gatewayIP()
+IPAddress WLEDNetworkClass::gatewayIP()
 {
 #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
  if (ETH.localIP()[0] != 0) {
@@ -43,7 +43,7 @@ IPAddress NetworkClass::gatewayIP()
  return INADDR_NONE;
 }

-void NetworkClass::localMAC(uint8_t* MAC)
+void WLEDNetworkClass::localMAC(uint8_t* MAC)
 {
 #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
  // ETH.macAddress(MAC); // Does not work because of missing ETHClass:: in ETH.ccp
@@ -71,12 +71,12 @@ void NetworkClass::localMAC(uint8_t* MAC)
  return;
 }

-bool NetworkClass::isConnected()
+bool WLEDNetworkClass::isConnected()
 {
  return (WiFi.localIP()[0] != 0 && WiFi.status() == WL_CONNECTED) || isEthernet();
 }

-bool NetworkClass::isEthernet()
+bool WLEDNetworkClass::isEthernet()
 {
 #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
  return (ETH.localIP()[0] != 0) && ETH.linkUp();
@@ -84,4 +84,4 @@ bool NetworkClass::isEthernet()
  return false;
 }

-NetworkClass Network;
+WLEDNetworkClass WLEDNetwork;
--- a/wled00/src/dependencies/network/Network.h
+++ b/wled00/src/dependencies/network/Network.h
@@ -8,7 +8,7 @@
 #ifndef Network_h
 #define Network_h

-class NetworkClass
+class WLEDNetworkClass
 {
 public:
  IPAddress localIP();
@@ -19,6 +19,6 @@ public:
  bool isEthernet();
 };

-extern NetworkClass Network;
+extern WLEDNetworkClass WLEDNetwork;

 #endif
--- a/wled00/udp.cpp
+++ b/wled00/udp.cpp
@@ -196,7 +196,7 @@ void notify(byte callMode, bool followUp)
 #endif
  {
    DEBUG_PRINTLN(F("UDP sending packet."));
-    IPAddress broadcastIp = ~uint32_t(Network.subnetMask()) | uint32_t(Network.gatewayIP());
+    IPAddress broadcastIp = ~uint32_t(WLEDNetwork.subnetMask()) | uint32_t(WLEDNetwork.gatewayIP());
    notifierUdp.beginPacket(broadcastIp, udpPort);
    notifierUdp.write(udpOut, WLEDPACKETSIZE); // TODO: add actual used buffer size
    notifierUdp.endPacket();
@@ -516,7 +516,7 @@ void handleNotifications()
    }
  }

-  localIP = Network.localIP();
+  localIP = WLEDNetwork.localIP();
  //notifier and UDP realtime
  if (!packetSize || packetSize > UDP_IN_MAXSIZE) return;
  if (!isSupp && notifierUdp.remoteIP() == localIP) return; //don't process broadcasts we send ourselves
@@ -707,7 +707,7 @@ void sendSysInfoUDP()
 {
  if (!udp2Connected) return;

-  IPAddress ip = Network.localIP();
+  IPAddress ip = WLEDNetwork.localIP();
  if (!ip || ip == IPAddress(255,255,255,255)) ip = IPAddress(4,3,2,1);

  // TODO: make a nice struct of it and clean up
--- a/wled00/wled.cpp
+++ b/wled00/wled.cpp
@@ -109,7 +109,7 @@ void WLED::loop()
  {
    if (apActive) dnsServer.processNextRequest();
    #ifdef WLED_ENABLE_AOTA
-    if (Network.isConnected() && aOtaEnabled && !otaLock && correctPIN) ArduinoOTA.handle();
+    if (WLEDNetwork.isConnected() && aOtaEnabled && !otaLock && correctPIN) ArduinoOTA.handle();
    #endif
    handleNightlight();
    yield();
@@ -262,7 +262,7 @@ void WLED::loop()
    lastWifiState = WiFi.status();
    DEBUG_PRINTF_P(PSTR("State time: %lu\n"),        wifiStateChangedTime);
    DEBUG_PRINTF_P(PSTR("NTP last sync: %lu\n"),     ntpLastSyncTime);
-    DEBUG_PRINTF_P(PSTR("Client IP: %u.%u.%u.%u\n"), Network.localIP()[0], Network.localIP()[1], Network.localIP()[2], Network.localIP()[3]);
+    DEBUG_PRINTF_P(PSTR("Client IP: %u.%u.%u.%u\n"), WLEDNetwork.localIP()[0], WLEDNetwork.localIP()[1], WLEDNetwork.localIP()[2], WLEDNetwork.localIP()[3]);
    if (loops > 0) { // avoid division by zero
      DEBUG_PRINTF_P(PSTR("Loops/sec: %u\n"),         loops / 30);
      DEBUG_PRINTF_P(PSTR("Loop time[ms]: %u/%lu\n"), avgLoopMillis/loops,    maxLoopMillis);
@@ -700,7 +700,7 @@ void WLED::initInterfaces()
  DEBUG_PRINTLN(F("Init STA interfaces"));

 #ifndef WLED_DISABLE_HUESYNC
-  IPAddress ipAddress = Network.localIP();
+  IPAddress ipAddress = WLEDNetwork.localIP();
  if (hueIP[0] == 0) {
    hueIP[0] = ipAddress[0];
    hueIP[1] = ipAddress[1];
@@ -786,7 +786,7 @@ void WLED::handleConnection()
    if (stac != stacO) {
      stacO = stac;
      DEBUG_PRINTF_P(PSTR("Connected AP clients: %d\n"), (int)stac);
-      if (!Network.isConnected() && wifiConfigured) {        // trying to connect, but not connected
+      if (!WLEDNetwork.isConnected() && wifiConfigured) {        // trying to connect, but not connected
        if (stac)
          WiFi.disconnect();        // disable search so that AP can work
        else
@@ -795,7 +795,7 @@ void WLED::handleConnection()
    }
  }

-  if (!Network.isConnected()) {
+  if (!WLEDNetwork.isConnected()) {
    if (interfacesInited) {
      if (scanDone && multiWiFi.size() > 1) {
        DEBUG_PRINTLN(F("WiFi scan initiated on disconnect."));
@@ -839,7 +839,7 @@ void WLED::handleConnection()
  } else if (!interfacesInited) { //newly connected
    DEBUG_PRINTLN();
    DEBUG_PRINT(F("Connected! IP address: "));
-    DEBUG_PRINTLN(Network.localIP());
+    DEBUG_PRINTLN(WLEDNetwork.localIP());
    if (improvActive) {
      if (improvError == 3) sendImprovStateResponse(0x00, true);
      sendImprovStateResponse(0x04);
@@ -861,7 +861,7 @@ void WLED::handleConnection()
 }

 // If status LED pin is allocated for other uses, does nothing
-// else blink at 1Hz when Network.isConnected() is false (no WiFi, ?? no Ethernet ??)
+// else blink at 1Hz when WLEDNetwork.isConnected() is false (no WiFi, ?? no Ethernet ??)
 // else blink at 2Hz when MQTT is enabled but not connected
 // else turn the status LED off
 #if defined(STATUSLED)
@@ -875,7 +875,7 @@ void WLED::handleStatusLED()
  }
  #endif

-  if (Network.isConnected()) {
+  if (WLEDNetwork.isConnected()) {
    c = RGBW32(0,255,0,0);
    ledStatusType = 2;
  } else if (WLED_MQTT_CONNECTED) {
--- a/wled00/wled.h
+++ b/wled00/wled.h
@@ -1026,7 +1026,7 @@ WLED_GLOBAL volatile uint8_t jsonBufferLock _INIT(0);
  WLED_GLOBAL unsigned loops _INIT(0);
 #endif

-#define WLED_CONNECTED (Network.isConnected())
+#define WLED_CONNECTED (WLEDNetwork.isConnected())

 #ifndef WLED_AP_SSID_UNIQUE
  #define WLED_SET_AP_SSID() do { \
--- a/wled00/wled_server.cpp
+++ b/wled00/wled_server.cpp
@@ -44,7 +44,7 @@ static bool inSubnet(const IPAddress &ip, const IPAddress &subnet, const IPAddre
 }

 static bool inSameSubnet(const IPAddress &client) {
-  return inSubnet(client, Network.localIP(), Network.subnetMask());
+  return inSubnet(client, WLEDNetwork.localIP(), WLEDNetwork.subnetMask());
 }

 static bool inLocalSubnet(const IPAddress &client) {
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -233,10 +233,10 @@ void getSettingsJS(byte subPage, Print& settingsScript)
    settingsScript.print(F("gId('ethd').style.display='none';"));
    #endif

-    if (Network.isConnected()) //is connected
+    if (WLEDNetwork.isConnected()) //is connected
    {
      char s[32];
-      IPAddress localIP = Network.localIP();
+      IPAddress localIP = WLEDNetwork.localIP();
      sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);

      #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
Author	SHA1	Message	Date
Will Tatam	81c92257da	Update PlatformIO	2025-08-16 12:45:36 +01:00
Will Tatam	e4815d1ff5	Update PlatformIO	2025-08-16 12:36:41 +01:00
Will Tatam	bc19133e73	Update PlatformIO	2025-08-16 12:33:25 +01:00
Will Tatam	03a9d9e56f	ledc changes for versions 2.X (based on ESP-IDF 4.4) to version 3.0 (based on ESP-IDF 5.1) - https://docs.espressif.com/projects/arduino-esp32/en/latest/migration_guides/2.x_to_3.0.html	2025-08-16 12:05:41 +01:00
Will Tatam	2c0259f214	Rename Network to WLEDNetwork to prevent clash	2025-08-16 11:57:50 +01:00
Will Tatam	1de8c2e79b	Remove local copy of MQTT and disable for now in build	2025-08-16 11:57:20 +01:00
Will Tatam	07ab6aa3ea	Rename Network to WLEDNetwork to prevent clash	2025-08-14 18:59:06 +01:00
Will Tatam	ba2b182bb3	Update platformio.ini for V5	2025-08-14 18:26:12 +01:00
Will Tatam	965e794094	Rename Network to WLEDNetwork to prevent clash	2025-08-14 18:25:39 +01:00
Will Tatam	c33e303323	Fix eth build, update lib_deps for v4	2025-08-14 17:56:17 +01:00
Will Tatam	caf3c7a2f9	Remove old V3 IDF	2025-08-14 17:50:21 +01:00
Will Tatam	c8d8ab020e	ARDUINO_USB_CDC_ON_BOOT should not be in common esp32_idf_V4	2025-08-14 14:52:49 +01:00
Will Tatam	297d5ced75	Use esp32_idf_V4.build_flags and esp32_idf_V4.lib_deps for all V4 builds	2025-08-14 14:52:49 +01:00
Will Miles	3f90366aa8	Merge pull request #4796 from willmmiles/asynctcp-update Update AsyncTCP (and AsyncWebServer)	2025-08-09 12:05:13 -04:00
Will Miles	f74d1459b9	Downtune AsyncTCP stack size We downtuned the stack usage of AsyncTCP, and at some point in the history of our fork, this got folded in to the default. Re-apply the stack size we've been using and recover that RAM.	2025-08-04 14:21:11 -04:00
Will Miles	e374c7ae55	Update to AsyncTCP 3.4.7 Bugfix on 3.4.6	2025-08-02 15:49:47 -04:00
Will Miles	9e4675ef46	Update AsyncWebServer and AsyncTCP This should fix (or at least improve) some of the crash cases under excessive web server load.	2025-07-30 22:17:44 -04:00