Merge branch 'main' into multibutton

Have at least one button defined
Remove second pin defaults
2025-08-04 08:04:17 +02:00 · 2025-07-04 18:48:36 +02:00 · 2025-07-04 18:46:54 +02:00 · 2025-07-04 13:56:45 +02:00
60 changed files with 2345 additions and 425 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, 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, esp32dev_V4, 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,8 +108,6 @@ 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
@@ -140,11 +138,11 @@ upload_speed = 115200
 # ------------------------------------------------------------------------------
 lib_compat_mode = strict
 lib_deps =
-    fastled/FastLED @ 3.10.1
-;    IRremoteESP8266 @ 2.8.2
+    fastled/FastLED @ 3.6.0
+    IRremoteESP8266 @ 2.8.2
    makuna/NeoPixelBus @ 2.8.3
    #https://github.com/makuna/NeoPixelBus.git#CoreShaderBeta
-    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.2
+    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.0
  # for I2C interface
    ;Wire
  # ESP-NOW library
@@ -236,20 +234,25 @@ lib_deps_compat =

 [esp32_all_variants]
 lib_deps =
-  esp32async/AsyncTCP @ 3.4.7
+  willmmiles/AsyncTCP @ 1.3.1
  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 = ${esp32_idf_V5.platform}
-platform_packages =
+#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
 build_unflags = ${common.build_unflags}
-build_flags = ${esp32_idf_V5.build_flags}
-lib_deps = ${esp32_idf_V5.lib_deps}
+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}

 tiny_partitions = tools/WLED_ESP32_2MB_noOTA.csv
 default_partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
@@ -257,32 +260,41 @@ 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_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
+[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
 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_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
+  -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_V5.platform}
+platform = ${esp32_idf_V4.platform}
 build_unflags = ${common.build_unflags}
 build_flags = -g
  -DARDUINO_ARCH_ESP32
@@ -293,14 +305,15 @@ 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_idf_V5.build_flags}
+  ${esp32_all_variants.build_flags}
 lib_deps =
-  ${esp32_idf_V5.lib_deps}
+  ${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

 [esp32c3]
 ;; generic definitions for all ESP32-C3 boards
-platform = ${esp32_idf_V5.platform}
+platform = ${esp32_idf_V4.platform}
 build_unflags = ${common.build_unflags}
 build_flags = -g
  -DARDUINO_ARCH_ESP32
@@ -310,15 +323,16 @@ 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_idf_V5.build_flags}
+  ${esp32_all_variants.build_flags}
 lib_deps =
-  ${esp32_idf_V5.lib_deps}
+  ${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
 board_build.flash_mode = qio

 [esp32s3]
 ;; generic definitions for all ESP32-S3 boards
-platform = ${esp32_idf_V5.platform}
+platform = ${esp32_idf_V4.platform}
 build_unflags = ${common.build_unflags}
 build_flags = -g
  -DESP32
@@ -329,9 +343,10 @@ 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_idf_V5.build_flags}
+  ${esp32_all_variants.build_flags}
 lib_deps =
-  ${esp32_idf_V5.lib_deps}
+  ${esp32_all_variants.lib_deps}
+  ${env.lib_deps}
 board_build.partitions = ${esp32.large_partitions}   ;; default partioning for 8MB flash - can be overridden in build envs


@@ -364,7 +379,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 = ${common.default_usermods}
+custom_usermods = audioreactive

 [env:esp8266_2m]
 board = esp_wroom_02
@@ -392,7 +407,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 = ${common.default_usermods}
+custom_usermods = audioreactive

 [env:esp01_1m_full]
 board = esp01_1m
@@ -422,27 +437,37 @@ 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 = ${common.default_usermods}
+custom_usermods = audioreactive

 [env:esp32dev]
 board = esp32dev
-platform = ${esp32_idf_V5.platform}
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
+custom_usermods = audioreactive
 build_unflags = ${common.build_unflags}
-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}
+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}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.default_partitions}
 board_build.flash_mode = dio

 [env:esp32dev_8M]
 board = esp32dev
-platform = ${esp32_idf_V5.platform}
-custom_usermods = ${common.default_usermods}
+platform = ${esp32_idf_V4.platform}
+custom_usermods = audioreactive
 build_unflags = ${common.build_unflags}
-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}
+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}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.large_partitions}
 board_upload.flash_size = 8MB
@@ -452,11 +477,11 @@ board_upload.maximum_size = 8388608

 [env:esp32dev_16M]
 board = esp32dev
-platform = ${esp32_idf_V5.platform}
-custom_usermods = ${common.default_usermods}
+platform = ${esp32_idf_V4.platform}
+custom_usermods = audioreactive
 build_unflags = ${common.build_unflags}
-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}
+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}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.extreme_partitions}
 board_upload.flash_size = 16MB
@@ -464,30 +489,44 @@ 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_idf_V5.platform}
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
 upload_speed = 921600
-custom_usermods = ${common.default_usermods}
+custom_usermods = audioreactive
 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_V5
+extends = esp32_idf_V4
+platform = ${esp32_idf_V4.platform}
 board = ttgo-t7-v14-mini32
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 board_build.partitions = ${esp32.extended_partitions}
-custom_usermods = ${common.default_usermods}
+custom_usermods = audioreactive
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_WROVER\"
+build_flags = ${common.build_flags} ${esp32_idf_V4.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_V5.lib_deps}
+lib_deps = ${esp32_idf_V4.lib_deps}
  
 [env:esp32c3dev]
 extends = esp32c3
@@ -510,7 +549,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 = ${common.default_usermods}
+custom_usermods = audioreactive
 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
@@ -531,7 +570,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 = ${common.default_usermods}
+custom_usermods = audioreactive
 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
@@ -551,7 +590,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 = ${common.default_usermods}
+custom_usermods = audioreactive
 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
@@ -574,7 +613,7 @@ monitor_filters = esp32_exception_decoder
 board = lolin_s3_mini ;; -S3 mini, 4MB flash 2MB PSRAM 
 platform = ${esp32s3.platform}
 upload_speed = 921600
-custom_usermods = ${common.default_usermods}
+custom_usermods = audioreactive
 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")
@@ -593,7 +632,7 @@ board = lolin_s2_mini
 board_build.partitions = ${esp32.default_partitions}
 board_build.flash_mode = qio
 board_build.f_flash = 80000000L
-custom_usermods = ${common.default_usermods}
+custom_usermods = audioreactive
 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
@@ -614,11 +653,11 @@ lib_deps = ${esp32s2.lib_deps}

 [env:usermods]
 board = esp32dev
-platform = ${esp32_idf_V5.platform}
+platform = ${esp32_idf_V4.platform}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_USERMODS\"
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_USERMODS\"
  -DTOUCH_CS=9
-lib_deps = ${esp32_idf_V5.lib_deps}
+lib_deps = ${esp32_idf_V4.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.13
+# This file is autogenerated by pip-compile with Python 3.11
 # by the following command:
 #
-#    pip-compile
+#    pip-compile requirements.in
 #
 ajsonrpc==1.2.0
    # via platformio
-anyio==4.10.0
+anyio==4.8.0
    # via starlette
-bottle==0.13.4
+bottle==0.13.2
    # via platformio
-certifi==2025.8.3
+certifi==2025.1.31
    # via requests
-charset-normalizer==3.4.3
+charset-normalizer==3.4.1
    # via requests
-click==8.1.7
+click==8.1.8
    # via
    #   platformio
    #   uvicorn
@@ -30,9 +30,9 @@ idna==3.10
    #   requests
 marshmallow==3.26.1
    # via platformio
-packaging==25.0
+packaging==24.2
    # via marshmallow
-platformio==6.1.18
+platformio==6.1.17
    # via -r requirements.in
 pyelftools==0.32
    # via platformio
@@ -44,13 +44,15 @@ semantic-version==2.10.0
    # via platformio
 sniffio==1.3.1
    # via anyio
-starlette==0.46.2
+starlette==0.45.3
    # via platformio
 tabulate==0.9.0
    # via platformio
+typing-extensions==4.12.2
+    # via anyio
 urllib3==2.5.0
    # via requests
-uvicorn==0.34.3
+uvicorn==0.34.0
    # via platformio
 wsproto==1.2.0
    # via platformio
--- a/usermods/EXAMPLE/usermod_v2_example.cpp
+++ b/usermods/EXAMPLE/usermod_v2_example.cpp
@@ -313,11 +313,11 @@ class MyExampleUsermod : public Usermod {
      yield();
      // ignore certain button types as they may have other consequences
      if (!enabled
-       || buttonType[b] == BTN_TYPE_NONE
-       || buttonType[b] == BTN_TYPE_RESERVED
-       || buttonType[b] == BTN_TYPE_PIR_SENSOR
-       || buttonType[b] == BTN_TYPE_ANALOG
-       || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) {
+       || buttons[b].type == BTN_TYPE_NONE
+       || buttons[b].type == BTN_TYPE_RESERVED
+       || buttons[b].type == BTN_TYPE_PIR_SENSOR
+       || buttons[b].type == BTN_TYPE_ANALOG
+       || buttons[b].type == BTN_TYPE_ANALOG_INVERTED) {
        return false;
      }

--- 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) : WLEDNetwork.localIP())) ||
+            (knownIp != (apActive ? IPAddress(4, 3, 2, 1) : Network.localIP())) ||
            (knownBrightness != bri) ||
            (knownEffectSpeed != strip.getMainSegment().speed) ||
            (knownEffectIntensity != strip.getMainSegment().intensity) ||
--- a/usermods/audioreactive/audio_reactive.cpp
+++ b/usermods/audioreactive/audio_reactive.cpp
@@ -1530,7 +1530,7 @@ class AudioReactive : public Usermod {
      // better would be for AudioSource to implement getType()
      if (enabled
          && dmType == 0 && audioPin>=0
-          && (buttonType[b] == BTN_TYPE_ANALOG || buttonType[b] == BTN_TYPE_ANALOG_INVERTED)
+          && (buttons[b].type == BTN_TYPE_ANALOG || buttons[b].type == BTN_TYPE_ANALOG_INVERTED)
         ) {
        return true;
      }
--- a/usermods/multi_relay/multi_relay.cpp
+++ b/usermods/multi_relay/multi_relay.cpp
@@ -562,11 +562,11 @@ void MultiRelay::loop() {
 bool MultiRelay::handleButton(uint8_t b) {
  yield();
  if (!enabled
-    || buttonType[b] == BTN_TYPE_NONE
-    || buttonType[b] == BTN_TYPE_RESERVED
-    || buttonType[b] == BTN_TYPE_PIR_SENSOR
-    || buttonType[b] == BTN_TYPE_ANALOG
-    || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) {
+    || buttons[b].type == BTN_TYPE_NONE
+    || buttons[b].type == BTN_TYPE_RESERVED
+    || buttons[b].type == BTN_TYPE_PIR_SENSOR
+    || buttons[b].type == BTN_TYPE_ANALOG
+    || buttons[b].type == BTN_TYPE_ANALOG_INVERTED) {
    return false;
  }

@@ -581,20 +581,20 @@ bool MultiRelay::handleButton(uint8_t b) {
  unsigned long now = millis();

  //button is not momentary, but switch. This is only suitable on pins whose on-boot state does not matter (NOT gpio0)
-  if (buttonType[b] == BTN_TYPE_SWITCH) {
+  if (buttons[b].type == BTN_TYPE_SWITCH) {
    //handleSwitch(b);
-    if (buttonPressedBefore[b] != isButtonPressed(b)) {
-      buttonPressedTime[b] = now;
-      buttonPressedBefore[b] = !buttonPressedBefore[b];
+    if (buttons[b].pressedBefore != isButtonPressed(b)) {
+      buttons[b].pressedTime = now;
+      buttons[b].pressedBefore = !buttons[b].pressedBefore;
    }

-    if (buttonLongPressed[b] == buttonPressedBefore[b]) return handled;
+    if (buttons[b].longPressed == buttons[b].pressedBefore) return handled;
      
-    if (now - buttonPressedTime[b] > WLED_DEBOUNCE_THRESHOLD) { //fire edge event only after 50ms without change (debounce)
+    if (now - buttons[b].pressedTime > WLED_DEBOUNCE_THRESHOLD) { //fire edge event only after 50ms without change (debounce)
      for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
        if (_relay[i].button == b) {
-          switchRelay(i, buttonPressedBefore[b]);
-          buttonLongPressed[b] = buttonPressedBefore[b]; //save the last "long term" switch state
+          switchRelay(i, buttons[b].pressedBefore);
+          buttons[b].longPressed = buttons[b].pressedBefore; //save the last "long term" switch state
        }
      }
    }
@@ -604,40 +604,40 @@ bool MultiRelay::handleButton(uint8_t b) {
  //momentary button logic
  if (isButtonPressed(b)) { //pressed

-    if (!buttonPressedBefore[b]) buttonPressedTime[b] = now;
-    buttonPressedBefore[b] = true;
+    if (!buttons[b].pressedBefore) buttons[b].pressedTime = now;
+    buttons[b].pressedBefore = true;

-    if (now - buttonPressedTime[b] > 600) { //long press
+    if (now - buttons[b].pressedTime > 600) { //long press
      //longPressAction(b); //not exposed
      //handled = false; //use if you want to pass to default behaviour
-      buttonLongPressed[b] = true;
+      buttons[b].longPressed = true;
    }

-  } else if (!isButtonPressed(b) && buttonPressedBefore[b]) { //released
+  } else if (!isButtonPressed(b) && buttons[b].pressedBefore) { //released

-    long dur = now - buttonPressedTime[b];
+    long dur = now - buttons[b].pressedTime;
    if (dur < WLED_DEBOUNCE_THRESHOLD) {
-      buttonPressedBefore[b] = false;
+      buttons[b].pressedBefore = false;
      return handled;
    } //too short "press", debounce
-    bool doublePress = buttonWaitTime[b]; //did we have short press before?
-    buttonWaitTime[b] = 0;
+    bool doublePress = buttons[b].waitTime; //did we have short press before?
+    buttons[b].waitTime = 0;

-    if (!buttonLongPressed[b]) { //short press
+    if (!buttons[b].longPressed) { //short press
      // if this is second release within 350ms it is a double press (buttonWaitTime!=0)
      if (doublePress) {
        //doublePressAction(b); //not exposed
        //handled = false; //use if you want to pass to default behaviour
      } else  {
-        buttonWaitTime[b] = now;
+        buttons[b].waitTime = now;
      }
    }
-    buttonPressedBefore[b] = false;
-    buttonLongPressed[b] = false;
+    buttons[b].pressedBefore = false;
+    buttons[b].longPressed = false;
  }
  // if 350ms elapsed since last press/release it is a short press
-  if (buttonWaitTime[b] && now - buttonWaitTime[b] > 350 && !buttonPressedBefore[b]) {
-    buttonWaitTime[b] = 0;
+  if (buttons[b].waitTime && now - buttons[b].waitTime > 350 && !buttons[b].pressedBefore) {
+    buttons[b].waitTime = 0;
    //shortPressAction(b); //not exposed
    for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
      if (_relay[i].button == b) {
--- a/usermods/pixels_dice_tray/pixels_dice_tray.cpp
+++ b/usermods/pixels_dice_tray/pixels_dice_tray.cpp
@@ -461,11 +461,11 @@ class PixelsDiceTrayUsermod : public Usermod {
 #if USING_TFT_DISPLAY
  bool handleButton(uint8_t b) override {
    if (!enabled || b > 1  // buttons 0,1 only
-        || buttonType[b] == BTN_TYPE_SWITCH || buttonType[b] == BTN_TYPE_NONE ||
-        buttonType[b] == BTN_TYPE_RESERVED ||
-        buttonType[b] == BTN_TYPE_PIR_SENSOR ||
-        buttonType[b] == BTN_TYPE_ANALOG ||
-        buttonType[b] == BTN_TYPE_ANALOG_INVERTED) {
+        || buttons[b].type == BTN_TYPE_SWITCH || buttons[b].type == BTN_TYPE_NONE ||
+        buttons[b].type == BTN_TYPE_RESERVED ||
+        buttons[b].type == BTN_TYPE_PIR_SENSOR ||
+        buttons[b].type == BTN_TYPE_ANALOG ||
+        buttons[b].type == BTN_TYPE_ANALOG_INVERTED) {
      return false;
    }

@@ -476,43 +476,43 @@ class PixelsDiceTrayUsermod : public Usermod {
    static unsigned long buttonWaitTime[2] = {0};

    //momentary button logic
-    if (!buttonLongPressed[b] && isButtonPressed(b)) {  //pressed
-      if (!buttonPressedBefore[b]) {
-        buttonPressedTime[b] = now;
+    if (!buttons[b].longPressed && isButtonPressed(b)) {  //pressed
+      if (!buttons[b].pressedBefore) {
+        buttons[b].pressedTime = now;
      }
-      buttonPressedBefore[b] = true;
+      buttons[b].pressedBefore = true;

-      if (now - buttonPressedTime[b] > WLED_LONG_PRESS) {  //long press
+      if (now - buttons[b].pressedTime > WLED_LONG_PRESS) {  //long press
        menu_ctrl.HandleButton(ButtonType::LONG, b);
-        buttonLongPressed[b] = true;
+        buttons[b].longPressed = true;
        return true;
      }
-    } else if (!isButtonPressed(b) && buttonPressedBefore[b]) {  //released
+    } else if (!isButtonPressed(b) && buttons[b].pressedBefore) {  //released

-      long dur = now - buttonPressedTime[b];
+      long dur = now - buttons[b].pressedTime;
      if (dur < WLED_DEBOUNCE_THRESHOLD) {
-        buttonPressedBefore[b] = false;
+        buttons[b].pressedBefore = false;
        return true;
      }  //too short "press", debounce

-      bool doublePress = buttonWaitTime[b];  //did we have short press before?
-      buttonWaitTime[b] = 0;
+      bool doublePress = buttons[b].waitTime;  //did we have short press before?
+      buttons[b].waitTime = 0;

-      if (!buttonLongPressed[b]) {  //short press
+      if (!buttons[b].longPressed) {  //short press
        // if this is second release within 350ms it is a double press (buttonWaitTime!=0)
        if (doublePress) {
          menu_ctrl.HandleButton(ButtonType::DOUBLE, b);
        } else {
-          buttonWaitTime[b] = now;
+          buttons[b].waitTime = now;
        }
      }
-      buttonPressedBefore[b] = false;
-      buttonLongPressed[b] = false;
+      buttons[b].pressedBefore = false;
+      buttons[b].longPressed = false;
    }
    // if 350ms elapsed since last press/release it is a short press
-    if (buttonWaitTime[b] && now - buttonWaitTime[b] > WLED_DOUBLE_PRESS &&
-        !buttonPressedBefore[b]) {
-      buttonWaitTime[b] = 0;
+    if (buttons[b].waitTime && now - buttons[b].waitTime > WLED_DOUBLE_PRESS &&
+        !buttons[b].pressedBefore) {
+      buttons[b].waitTime = 0;
      menu_ctrl.HandleButton(ButtonType::SINGLE, b);
    }

--- 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 != WLEDNetwork.isConnected() || lastKnownIp != WLEDNetwork.localIP()
+      if (lastKnownNetworkConnected != Network.isConnected() || lastKnownIp != Network.localIP()
          || lastKnownWiFiConnected != WiFi.isConnected() || lastKnownSsid != WiFi.SSID()
          || lastKnownApActive != apActive || lastKnownApSsid != apSSID || lastKnownApPass != apPass || lastKnownApChannel != apChannel) {
-        lastKnownNetworkConnected = WLEDNetwork.isConnected();
-        lastKnownIp = WLEDNetwork.localIP();
+        lastKnownNetworkConnected = Network.isConnected();
+        lastKnownIp = Network.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   = WLEDNetwork.localIP(); //apActive ? IPAddress(4, 3, 2, 1) : WLEDNetwork.localIP();
+  knownIp   = Network.localIP(); //apActive ? IPAddress(4, 3, 2, 1) : Network.localIP();
  networkOverlay(PSTR("NETWORK INFO"),7000);
 }

@@ -749,12 +749,12 @@ bool FourLineDisplayUsermod::handleButton(uint8_t b) {
  yield();
  if (!enabled
    || b // button 0 only
-    || buttonType[b] == BTN_TYPE_SWITCH
-    || buttonType[b] == BTN_TYPE_NONE
-    || buttonType[b] == BTN_TYPE_RESERVED
-    || buttonType[b] == BTN_TYPE_PIR_SENSOR
-    || buttonType[b] == BTN_TYPE_ANALOG
-    || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) {
+    || buttons[b].type == BTN_TYPE_SWITCH
+    || buttons[b].type == BTN_TYPE_NONE
+    || buttons[b].type == BTN_TYPE_RESERVED
+    || buttons[b].type == BTN_TYPE_PIR_SENSOR
+    || buttons[b].type == BTN_TYPE_ANALOG
+    || buttons[b].type == BTN_TYPE_ANALOG_INVERTED) {
    return false;
  }

--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -66,15 +66,13 @@ Segment::Segment(const Segment &orig) {
  _dataLen = 0;
  pixels = nullptr;
  if (!stop) return;  // nothing to do if segment is inactive/invalid
+  if (orig.name) { name = static_cast<char*>(d_malloc(strlen(orig.name)+1)); if (name) strcpy(name, orig.name); }
+  if (orig.data) { if (allocateData(orig._dataLen)) memcpy(data, orig.data, orig._dataLen); }
  if (orig.pixels) {
-    // allocate pixel buffer: prefer IRAM/PSRAM
    pixels = static_cast<uint32_t*>(d_malloc(sizeof(uint32_t) * orig.length()));
-    if (pixels) {
-      memcpy(pixels, orig.pixels, sizeof(uint32_t) * orig.length());
-      if (orig.name) { name = static_cast<char*>(d_malloc(strlen(orig.name)+1)); if (name) strcpy(name, orig.name); }
-      if (orig.data) { if (allocateData(orig._dataLen)) memcpy(data, orig.data, orig._dataLen); }
-    } else {
-      DEBUGFX_PRINTLN(F("!!! Not enough RAM for pixel buffer !!!"));
+    if (pixels) memcpy(pixels, orig.pixels, sizeof(uint32_t) * orig.length());
+    else {
+      DEBUG_PRINTLN(F("!!! Not enough RAM for pixel buffer !!!"));
      errorFlag = ERR_NORAM_PX;
      stop = 0; // mark segment as inactive/invalid
    }
@@ -109,14 +107,12 @@ Segment& Segment::operator= (const Segment &orig) {
    pixels = nullptr;
    if (!stop) return *this;  // nothing to do if segment is inactive/invalid
    // copy source data
+    if (orig.name) { name = static_cast<char*>(d_malloc(strlen(orig.name)+1)); if (name) strcpy(name, orig.name); }
+    if (orig.data) { if (allocateData(orig._dataLen)) memcpy(data, orig.data, orig._dataLen); }
    if (orig.pixels) {
-      // allocate pixel buffer: prefer IRAM/PSRAM
      pixels = static_cast<uint32_t*>(d_malloc(sizeof(uint32_t) * orig.length()));
-      if (pixels) {
-        memcpy(pixels, orig.pixels, sizeof(uint32_t) * orig.length());
-        if (orig.name) { name = static_cast<char*>(d_malloc(strlen(orig.name)+1)); if (name) strcpy(name, orig.name); }
-        if (orig.data) { if (allocateData(orig._dataLen)) memcpy(data, orig.data, orig._dataLen); }
-      } else {
+      if (pixels) memcpy(pixels, orig.pixels, sizeof(uint32_t) * orig.length());
+      else {
        DEBUG_PRINTLN(F("!!! Not enough RAM for pixel buffer !!!"));
        errorFlag = ERR_NORAM_PX;
        stop = 0; // mark segment as inactive/invalid
@@ -285,9 +281,8 @@ void Segment::startTransition(uint16_t dur, bool segmentCopy) {
      if (_t->_oldSegment) {
        _t->_oldSegment->palette = _t->_palette;          // restore original palette and colors (from start of transition)
        for (unsigned i = 0; i < NUM_COLORS; i++) _t->_oldSegment->colors[i] = _t->_colors[i];
-        DEBUGFX_PRINTF_P(PSTR("-- Updated transition with segment copy: S=%p T(%p) O[%p] OP[%p]\n"), this, _t, _t->_oldSegment, _t->_oldSegment->pixels);
-        if (!_t->_oldSegment->isActive()) stopTransition();
      }
+      DEBUG_PRINTF_P(PSTR("-- Updated transition with segment copy: S=%p T(%p) O[%p] OP[%p]\n"), this, _t, _t->_oldSegment, _t->_oldSegment->pixels);
    }
    return;
  }
@@ -303,12 +298,13 @@ void Segment::startTransition(uint16_t dur, bool segmentCopy) {
    #endif
    for (int i=0; i<NUM_COLORS; i++) _t->_colors[i] = colors[i];
    if (segmentCopy) _t->_oldSegment = new(std::nothrow) Segment(*this); // store/copy current segment settings
+    #ifdef WLED_DEBUG
    if (_t->_oldSegment) {
-      DEBUGFX_PRINTF_P(PSTR("-- Started transition: S=%p T(%p) O[%p] OP[%p]\n"), this, _t, _t->_oldSegment, _t->_oldSegment->pixels);
-      if (!_t->_oldSegment->isActive()) stopTransition();
+      DEBUG_PRINTF_P(PSTR("-- Started transition: S=%p T(%p) O[%p] OP[%p]\n"), this, _t, _t->_oldSegment, _t->_oldSegment->pixels);
    } else {
-      DEBUGFX_PRINTF_P(PSTR("-- Started transition without old segment: S=%p T(%p)\n"), this, _t);
+      DEBUG_PRINTF_P(PSTR("-- Started transition without old segment: S=%p T(%p)\n"), this, _t);
    }
+    #endif
  };
 }

@@ -429,15 +425,14 @@ void Segment::setGeometry(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, ui

  unsigned oldLength = length();

-  DEBUGFX_PRINTF_P(PSTR("Segment geometry: %d,%d -> %d,%d [%d,%d]\n"), (int)i1, (int)i2, (int)i1Y, (int)i2Y, (int)grp, (int)spc);
+  DEBUG_PRINTF_P(PSTR("Segment geometry: %d,%d -> %d,%d [%d,%d]\n"), (int)i1, (int)i2, (int)i1Y, (int)i2Y, (int)grp, (int)spc);
  markForReset();
-  if (_t) stopTransition(); // we can't use transition if segment dimensions changed
-  stateChanged = true;      // send UDP/WS broadcast
+  startTransition(strip.getTransition()); // start transition prior to change (if segment is deactivated (start>stop) no transition will happen)
+  stateChanged = true; // send UDP/WS broadcast

  // apply change immediately
  if (i2 <= i1) { //disable segment
-    deallocateData();
-    p_free(pixels);
+    d_free(pixels);
    pixels = nullptr;
    stop = 0;
    return;
@@ -454,25 +449,21 @@ void Segment::setGeometry(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, ui
  #endif
  // safety check
  if (start >= stop || startY >= stopY) {
-    deallocateData();
-    p_free(pixels);
+    d_free(pixels);
    pixels = nullptr;
    stop = 0;
    return;
  }
-  // allocate FX render buffer
+  // re-allocate FX render buffer
  if (length() != oldLength) {
-    // allocate render buffer (always entire segment), prefer IRAM/PSRAM. Note: impact on FPS with PSRAM buffer is low (<2% with QSPI PSRAM) on S2/S3
-    p_free(pixels);
+    if (pixels) d_free(pixels); // using realloc on large buffers can cause additional fragmentation instead of reducing it
    pixels = static_cast<uint32_t*>(d_malloc(sizeof(uint32_t) * length()));
    if (!pixels) {
-      DEBUGFX_PRINTLN(F("!!! Not enough RAM for pixel buffer !!!"));
-      deallocateData();
+      DEBUG_PRINTLN(F("!!! Not enough RAM for pixel buffer !!!"));
      errorFlag = ERR_NORAM_PX;
      stop = 0;
      return;
    }
-
  }
  refreshLightCapabilities();
 }
@@ -581,8 +572,8 @@ Segment &Segment::setName(const char *newName) {
    if (newLen) {
      if (name) d_free(name); // free old name
      name = static_cast<char*>(d_malloc(newLen+1));
-      if (mode == FX_MODE_2DSCROLLTEXT) startTransition(strip.getTransition(), true); // if the name changes in scrolling text mode, we need to copy the segment for blending
      if (name) strlcpy(name, newName, newLen+1);
+      name[newLen] = 0;
      return *this;
    }
  }
@@ -1219,9 +1210,10 @@ void WS2812FX::finalizeInit() {
  deserializeMap();     // (re)load default ledmap (will also setUpMatrix() if ledmap does not exist)

  // allocate frame buffer after matrix has been set up (gaps!)
-  d_free(_pixels); // using realloc on large buffers can cause additional fragmentation instead of reducing it
+  if (_pixels) d_free(_pixels); // using realloc on large buffers can cause additional fragmentation instead of reducing it
  _pixels = static_cast<uint32_t*>(d_malloc(getLengthTotal() * sizeof(uint32_t)));
  DEBUG_PRINTF_P(PSTR("strip buffer size: %uB\n"), getLengthTotal() * sizeof(uint32_t));
+
  DEBUG_PRINTF_P(PSTR("Heap after strip init: %uB\n"), ESP.getFreeHeap());
 }

@@ -1266,8 +1258,7 @@ void WS2812FX::service() {
        // if segment is in transition and no old segment exists we don't need to run the old mode
        // (blendSegments() takes care of On/Off transitions and clipping)
        Segment *segO = seg.getOldSegment();
-        if (segO && segO->isActive() && (seg.mode != segO->mode || blendingStyle != BLEND_STYLE_FADE ||
-            (segO->name != seg.name && segO->name && seg.name && strncmp(segO->name, seg.name, WLED_MAX_SEGNAME_LEN) != 0))) {
+        if (segO && (seg.mode != segO->mode || blendingStyle != BLEND_STYLE_FADE)) {
          Segment::modeBlend(true);         // set semaphore for beginDraw() to blend colors and palette
          segO->beginDraw(prog);            // set up palette & colors (also sets draw dimensions), parent segment has transition progress
          _currentSegment = segO;           // set current segment
@@ -1470,10 +1461,8 @@ void WS2812FX::blendSegment(const Segment &topSegment) const {
      }
      uint32_t c_a = BLACK;
      if (x < vCols && y < vRows) c_a = seg->getPixelColorRaw(x + y*vCols); // will get clipped pixel from old segment or unclipped pixel from new segment
-      if (segO && blendingStyle == BLEND_STYLE_FADE
-        && (topSegment.mode != segO->mode || (segO->name != topSegment.name && segO->name && topSegment.name && strncmp(segO->name, topSegment.name, WLED_MAX_SEGNAME_LEN) != 0))
-        && x < oCols && y < oRows) {
-        // we need to blend old segment using fade as pixels are not clipped
+      if (segO && blendingStyle == BLEND_STYLE_FADE && topSegment.mode != segO->mode && x < oCols && y < oRows) {
+        // we need to blend old segment using fade as pixels ae not clipped
        c_a = color_blend16(c_a, segO->getPixelColorRaw(x + y*oCols), progInv);
      } else if (blendingStyle != BLEND_STYLE_FADE) {
        // workaround for On/Off transition
@@ -1627,8 +1616,6 @@ static uint8_t estimateCurrentAndLimitBri(uint8_t brightness, uint32_t *pixels)
 }

 void WS2812FX::show() {
-  if (!_pixels) return; // no pixels allocated, nothing to show
-
  unsigned long showNow = millis();
  size_t diff = showNow - _lastShow;

@@ -1901,7 +1888,7 @@ void WS2812FX::makeAutoSegments(bool forceReset) {
    for (size_t i = 1; i < s; i++) {
      _segments.emplace_back(segStarts[i], segStops[i]);
    }
-    DEBUGFX_PRINTF_P(PSTR("%d auto segments created.\n"), _segments.size());
+    DEBUG_PRINTF_P(PSTR("%d auto segments created.\n"), _segments.size());

  } else {

@@ -2025,7 +2012,7 @@ bool WS2812FX::deserializeMap(unsigned n) {
  }

  d_free(customMappingTable);
-  customMappingTable = static_cast<uint16_t*>(d_malloc(sizeof(uint16_t)*getLengthTotal())); // prefer DRAM for speed
+  customMappingTable = static_cast<uint16_t*>(d_malloc(sizeof(uint16_t)*getLengthTotal())); // do not use SPI RAM

  if (customMappingTable) {
    DEBUG_PRINTF_P(PSTR("ledmap allocated: %uB\n"), sizeof(uint16_t)*getLengthTotal());
--- 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 SemaphoreHandle_t _ledc_sys_lock;
+    extern xSemaphoreHandle _ledc_sys_lock;
  #else
    #define LEDC_MUTEX_LOCK()
    #define LEDC_MUTEX_UNLOCK()
@@ -450,7 +450,8 @@ BusPwm::BusPwm(const BusConfig &bc)
      pinMode(_pins[i], OUTPUT);
      #else
      unsigned channel = _ledcStart + i;
-      ledcAttach(_pins[i], _frequency,  _depth - (dithering*4));
+      ledcSetup(channel, _frequency, _depth - (dithering*4)); // with dithering _frequency doesn't really matter as resolution is 8 bit
+      ledcAttachPin(_pins[i], channel);
      // 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)
@@ -617,7 +618,7 @@ void BusPwm::deallocatePins() {
    #ifdef ESP8266
    digitalWrite(_pins[i], LOW); //turn off PWM interrupt
    #else
-    if (_ledcStart < WLED_MAX_ANALOG_CHANNELS) ledcDetach(_pins[i]);
+    if (_ledcStart < WLED_MAX_ANALOG_CHANNELS) ledcDetachPin(_pins[i]);
    #endif
  }
  #ifdef ARDUINO_ARCH_ESP32
@@ -742,7 +743,7 @@ size_t BusNetwork::getPins(uint8_t* pinArray) const {
 #ifdef ARDUINO_ARCH_ESP32
 void BusNetwork::resolveHostname() {
  static unsigned long nextResolve = 0;
-  if (WLEDNetwork.isConnected() && millis() > nextResolve && _hostname.length() > 0) {
+  if (Network.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/button.cpp
+++ b/wled00/button.cpp
@@ -17,13 +17,13 @@ static bool buttonBriDirection = false; // true: increase brightness, false: dec

 void shortPressAction(uint8_t b)
 {
-  if (!macroButton[b]) {
+  if (!buttons[b].macroButton) {
    switch (b) {
      case 0: toggleOnOff(); stateUpdated(CALL_MODE_BUTTON); break;
      case 1: ++effectCurrent %= strip.getModeCount(); stateChanged = true; colorUpdated(CALL_MODE_BUTTON); break;
    }
  } else {
-    applyPreset(macroButton[b], CALL_MODE_BUTTON_PRESET);
+    applyPreset(buttons[b].macroButton, CALL_MODE_BUTTON_PRESET);
  }

 #ifndef WLED_DISABLE_MQTT
@@ -38,7 +38,7 @@ void shortPressAction(uint8_t b)

 void longPressAction(uint8_t b)
 {
-  if (!macroLongPress[b]) {
+  if (!buttons[b].macroLongPress) {
    switch (b) {
      case 0: setRandomColor(colPri); colorUpdated(CALL_MODE_BUTTON); break;
      case 1: 
@@ -52,11 +52,11 @@ void longPressAction(uint8_t b)
          else bri -= WLED_LONG_BRI_STEPS;
        }
        stateUpdated(CALL_MODE_BUTTON); 
-        buttonPressedTime[b] = millis();         
+        buttons[b].pressedTime = millis();         
        break; // repeatable action
    }
  } else {
-    applyPreset(macroLongPress[b], CALL_MODE_BUTTON_PRESET);
+    applyPreset(buttons[b].macroLongPress, CALL_MODE_BUTTON_PRESET);
  }

 #ifndef WLED_DISABLE_MQTT
@@ -71,13 +71,13 @@ void longPressAction(uint8_t b)

 void doublePressAction(uint8_t b)
 {
-  if (!macroDoublePress[b]) {
+  if (!buttons[b].macroDoublePress) {
    switch (b) {
      //case 0: toggleOnOff(); colorUpdated(CALL_MODE_BUTTON); break; //instant short press on button 0 if no macro set
      case 1: ++effectPalette %= getPaletteCount(); colorUpdated(CALL_MODE_BUTTON); break;
    }
  } else {
-    applyPreset(macroDoublePress[b], CALL_MODE_BUTTON_PRESET);
+    applyPreset(buttons[b].macroDoublePress, CALL_MODE_BUTTON_PRESET);
  }

 #ifndef WLED_DISABLE_MQTT
@@ -92,10 +92,10 @@ void doublePressAction(uint8_t b)

 bool isButtonPressed(uint8_t b)
 {
-  if (btnPin[b]<0) return false;
-  unsigned pin = btnPin[b];
+  if (buttons[b].pin < 0) return false;
+  unsigned pin = buttons[b].pin;

-  switch (buttonType[b]) {
+  switch (buttons[b].type) {
    case BTN_TYPE_NONE:
    case BTN_TYPE_RESERVED:
      break;
@@ -113,7 +113,7 @@ bool isButtonPressed(uint8_t b)
        #ifdef SOC_TOUCH_VERSION_2 //ESP32 S2 and S3 provide a function to check touch state (state is updated in interrupt)
        if (touchInterruptGetLastStatus(pin)) return true;
        #else
-        if (digitalPinToTouchChannel(btnPin[b]) >= 0 && touchRead(pin) <= touchThreshold) return true;
+        if (digitalPinToTouchChannel(pin) >= 0 && touchRead(pin) <= touchThreshold) return true;
        #endif
      #endif
     break;
@@ -124,25 +124,25 @@ bool isButtonPressed(uint8_t b)
 void handleSwitch(uint8_t b)
 {
  // isButtonPressed() handles inverted/noninverted logic
-  if (buttonPressedBefore[b] != isButtonPressed(b)) {
+  if (buttons[b].pressedBefore != isButtonPressed(b)) {
    DEBUG_PRINTF_P(PSTR("Switch: State changed %u\n"), b);
-    buttonPressedTime[b] = millis();
-    buttonPressedBefore[b] = !buttonPressedBefore[b];
+    buttons[b].pressedTime = millis();
+    buttons[b].pressedBefore = !buttons[b].pressedBefore; // toggle pressed state
  }

-  if (buttonLongPressed[b] == buttonPressedBefore[b]) return;
+  if (buttons[b].longPressed == buttons[b].pressedBefore) return;

-  if (millis() - buttonPressedTime[b] > WLED_DEBOUNCE_THRESHOLD) { //fire edge event only after 50ms without change (debounce)
+  if (millis() - buttons[b].pressedTime > WLED_DEBOUNCE_THRESHOLD) { //fire edge event only after 50ms without change (debounce)
    DEBUG_PRINTF_P(PSTR("Switch: Activating  %u\n"), b);
-    if (!buttonPressedBefore[b]) { // on -> off
+    if (!buttons[b].pressedBefore) { // on -> off
      DEBUG_PRINTF_P(PSTR("Switch: On -> Off (%u)\n"), b);
-      if (macroButton[b]) applyPreset(macroButton[b], CALL_MODE_BUTTON_PRESET);
+      if (buttons[b].macroButton) applyPreset(buttons[b].macroButton, CALL_MODE_BUTTON_PRESET);
      else { //turn on
        if (!bri) {toggleOnOff(); stateUpdated(CALL_MODE_BUTTON);}
      }
    } else {  // off -> on
      DEBUG_PRINTF_P(PSTR("Switch: Off -> On (%u)\n"), b);
-      if (macroLongPress[b]) applyPreset(macroLongPress[b], CALL_MODE_BUTTON_PRESET);
+      if (buttons[b].macroLongPress) applyPreset(buttons[b].macroLongPress, CALL_MODE_BUTTON_PRESET);
      else { //turn off
        if (bri) {toggleOnOff(); stateUpdated(CALL_MODE_BUTTON);}
      }
@@ -152,13 +152,13 @@ void handleSwitch(uint8_t b)
    // publish MQTT message
    if (buttonPublishMqtt && WLED_MQTT_CONNECTED) {
      char subuf[MQTT_MAX_TOPIC_LEN + 32];
-      if (buttonType[b] == BTN_TYPE_PIR_SENSOR) sprintf_P(subuf, PSTR("%s/motion/%d"), mqttDeviceTopic, (int)b);
+      if (buttons[b].type == BTN_TYPE_PIR_SENSOR) sprintf_P(subuf, PSTR("%s/motion/%d"), mqttDeviceTopic, (int)b);
      else sprintf_P(subuf, _mqtt_topic_button, mqttDeviceTopic, (int)b);
-      mqtt->publish(subuf, 0, false, !buttonPressedBefore[b] ? "off" : "on");
+      mqtt->publish(subuf, 0, false, !buttons[b].pressedBefore ? "off" : "on");
    }
 #endif

-    buttonLongPressed[b] = buttonPressedBefore[b]; //save the last "long term" switch state
+    buttons[b].longPressed = buttons[b].pressedBefore; //save the last "long term" switch state
  }
 }

@@ -178,17 +178,17 @@ void handleAnalog(uint8_t b)
  #ifdef ESP8266
  rawReading = analogRead(A0) << 2;   // convert 10bit read to 12bit
  #else
-  if ((btnPin[b] < 0) /*|| (digitalPinToAnalogChannel(btnPin[b]) < 0)*/) return; // pin must support analog ADC - newer esp32 frameworks throw lots of warnings otherwise
-  rawReading = analogRead(btnPin[b]); // collect at full 12bit resolution
+  if ((buttons[b].pin < 0) /*|| (digitalPinToAnalogChannel(buttons[b].pin) < 0)*/) return; // pin must support analog ADC - newer esp32 frameworks throw lots of warnings otherwise
+  rawReading = analogRead(buttons[b].pin); // collect at full 12bit resolution
  #endif
  yield();                            // keep WiFi task running - analog read may take several millis on ESP8266

  filteredReading[b] += POT_SMOOTHING * ((float(rawReading) / 16.0f) - filteredReading[b]); // filter raw input, and scale to [0..255]
  unsigned aRead = max(min(int(filteredReading[b]), 255), 0);                               // squash into 8bit
-  if(aRead <= POT_SENSITIVITY) aRead = 0;                                                   // make sure that 0 and 255 are used
-  if(aRead >= 255-POT_SENSITIVITY) aRead = 255;
+  if (aRead <= POT_SENSITIVITY) aRead = 0;                                                   // make sure that 0 and 255 are used
+  if (aRead >= 255-POT_SENSITIVITY) aRead = 255;

-  if (buttonType[b] == BTN_TYPE_ANALOG_INVERTED) aRead = 255 - aRead;
+  if (buttons[b].type == BTN_TYPE_ANALOG_INVERTED) aRead = 255 - aRead;

  // remove noise & reduce frequency of UI updates
  if (abs(int(aRead) - int(oldRead[b])) <= POT_SENSITIVITY) return;  // no significant change in reading
@@ -206,10 +206,10 @@ void handleAnalog(uint8_t b)
  oldRead[b] = aRead;

  // if no macro for "short press" and "long press" is defined use brightness control
-  if (!macroButton[b] && !macroLongPress[b]) {
-    DEBUG_PRINTF_P(PSTR("Analog: Action = %u\n"), macroDoublePress[b]);
+  if (!buttons[b].macroButton && !buttons[b].macroLongPress) {
+    DEBUG_PRINTF_P(PSTR("Analog: Action = %u\n"), buttons[b].macroDoublePress);
    // if "double press" macro defines which option to change
-    if (macroDoublePress[b] >= 250) {
+    if (buttons[b].macroDoublePress >= 250) {
      // global brightness
      if (aRead == 0) {
        briLast = bri;
@@ -218,27 +218,30 @@ void handleAnalog(uint8_t b)
        if (bri == 0) strip.restartRuntime();
        bri = aRead;
      }
-    } else if (macroDoublePress[b] == 249) {
+    } else if (buttons[b].macroDoublePress == 249) {
      // effect speed
      effectSpeed = aRead;
-    } else if (macroDoublePress[b] == 248) {
+    } else if (buttons[b].macroDoublePress == 248) {
      // effect intensity
      effectIntensity = aRead;
-    } else if (macroDoublePress[b] == 247) {
+    } else if (buttons[b].macroDoublePress == 247) {
      // selected palette
      effectPalette = map(aRead, 0, 252, 0, getPaletteCount()-1);
      effectPalette = constrain(effectPalette, 0, getPaletteCount()-1);  // map is allowed to "overshoot", so we need to contrain the result
-    } else if (macroDoublePress[b] == 200) {
+    } else if (buttons[b].macroDoublePress == 200) {
      // primary color, hue, full saturation
-      colorHStoRGB(aRead*256,255,colPri);
+      colorHStoRGB(aRead*256, 255, colPri);
    } else {
      // otherwise use "double press" for segment selection
-      Segment& seg = strip.getSegment(macroDoublePress[b]);
+      Segment& seg = strip.getSegment(buttons[b].macroDoublePress);
      if (aRead == 0) {
-        seg.setOption(SEG_OPTION_ON, false); // off (use transition)
+        seg.on = false; // do not use transition
+        //seg.setOption(SEG_OPTION_ON, false); // off (use transition)
      } else {
-        seg.setOpacity(aRead);
-        seg.setOption(SEG_OPTION_ON, true); // on (use transition)
+        seg.opacity = aRead; // set brightness (opacity) of segment
+        seg.on = true;
+        //seg.setOpacity(aRead);
+        //seg.setOption(SEG_OPTION_ON, true); // on (use transition)
      }
      // this will notify clients of update (websockets,mqtt,etc)
      updateInterfaces(CALL_MODE_BUTTON);
@@ -261,16 +264,16 @@ void handleButton()
  if (strip.isUpdating() && (now - lastRun < ANALOG_BTN_READ_CYCLE+1)) return; // don't interfere with strip update (unless strip is updating continuously, e.g. very long strips)
  lastRun = now;

-  for (unsigned b=0; b<WLED_MAX_BUTTONS; b++) {
+  for (unsigned b = 0; b < buttons.size(); b++) {
    #ifdef ESP8266
-    if ((btnPin[b]<0 && !(buttonType[b] == BTN_TYPE_ANALOG || buttonType[b] == BTN_TYPE_ANALOG_INVERTED)) || buttonType[b] == BTN_TYPE_NONE) continue;
+    if ((buttons[b].pin < 0 && !(buttons[b].type == BTN_TYPE_ANALOG || buttons[b].type == BTN_TYPE_ANALOG_INVERTED)) || buttons[b].type == BTN_TYPE_NONE) continue;
    #else
-    if (btnPin[b]<0 || buttonType[b] == BTN_TYPE_NONE) continue;
+    if (buttons[b].pin < 0 || buttons[b].type == BTN_TYPE_NONE) continue;
    #endif

    if (UsermodManager::handleButton(b)) continue; // did usermod handle buttons

-    if (buttonType[b] == BTN_TYPE_ANALOG || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) { // button is not a button but a potentiometer
+    if (buttons[b].type == BTN_TYPE_ANALOG || buttons[b].type == BTN_TYPE_ANALOG_INVERTED) { // button is not a button but a potentiometer
      if (now - lastAnalogRead > ANALOG_BTN_READ_CYCLE) {
        handleAnalog(b);
      }
@@ -278,7 +281,7 @@ void handleButton()
    }

    // button is not momentary, but switch. This is only suitable on pins whose on-boot state does not matter (NOT gpio0)
-    if (buttonType[b] == BTN_TYPE_SWITCH || buttonType[b] == BTN_TYPE_TOUCH_SWITCH || buttonType[b] == BTN_TYPE_PIR_SENSOR) {
+    if (buttons[b].type == BTN_TYPE_SWITCH || buttons[b].type == BTN_TYPE_TOUCH_SWITCH || buttons[b].type == BTN_TYPE_PIR_SENSOR) {
      handleSwitch(b);
      continue;
    }
@@ -287,40 +290,39 @@ void handleButton()
    if (isButtonPressed(b)) { // pressed

      // if all macros are the same, fire action immediately on rising edge
-      if (macroButton[b] && macroButton[b] == macroLongPress[b] && macroButton[b] == macroDoublePress[b]) {
-        if (!buttonPressedBefore[b])
-          shortPressAction(b);
-        buttonPressedBefore[b] = true;
-        buttonPressedTime[b] = now; // continually update (for debouncing to work in release handler)
+      if (buttons[b].macroButton && buttons[b].macroButton == buttons[b].macroLongPress && buttons[b].macroButton == buttons[b].macroDoublePress) {
+        if (!buttons[b].pressedBefore) shortPressAction(b);
+        buttons[b].pressedBefore = true;
+        buttons[b].pressedTime = now; // continually update (for debouncing to work in release handler)
        continue;
      }

-      if (!buttonPressedBefore[b]) buttonPressedTime[b] = now;
-      buttonPressedBefore[b] = true;
+      if (!buttons[b].pressedBefore) buttons[b].pressedTime = now;
+      buttons[b].pressedBefore = true;

-      if (now - buttonPressedTime[b] > WLED_LONG_PRESS) { //long press
-        if (!buttonLongPressed[b]) {
+      if (now - buttons[b].pressedTime > WLED_LONG_PRESS) { //long press
+        if (!buttons[b].longPressed) {
          buttonBriDirection = !buttonBriDirection; //toggle brightness direction on long press
          longPressAction(b);
        } else if (b) { //repeatable action (~5 times per s) on button > 0
          longPressAction(b);
-          buttonPressedTime[b] = now - WLED_LONG_REPEATED_ACTION; //200ms
+          buttons[b].pressedTime = now - WLED_LONG_REPEATED_ACTION; //200ms
        }
-        buttonLongPressed[b] = true;
+        buttons[b].longPressed = true;
      }

-    } else if (buttonPressedBefore[b]) { //released
-      long dur = now - buttonPressedTime[b];
+    } else if (buttons[b].pressedBefore) { //released
+      long dur = now - buttons[b].pressedTime;

      // released after rising-edge short press action
-      if (macroButton[b] && macroButton[b] == macroLongPress[b] && macroButton[b] == macroDoublePress[b]) {
-        if (dur > WLED_DEBOUNCE_THRESHOLD) buttonPressedBefore[b] = false; // debounce, blocks button for 50 ms once it has been released
+      if (buttons[b].macroButton && buttons[b].macroButton == buttons[b].macroLongPress && buttons[b].macroButton == buttons[b].macroDoublePress) {
+        if (dur > WLED_DEBOUNCE_THRESHOLD) buttons[b].pressedBefore = false; // debounce, blocks button for 50 ms once it has been released
        continue;
      }

-      if (dur < WLED_DEBOUNCE_THRESHOLD) {buttonPressedBefore[b] = false; continue;} // too short "press", debounce
-      bool doublePress = buttonWaitTime[b]; //did we have a short press before?
-      buttonWaitTime[b] = 0;
+      if (dur < WLED_DEBOUNCE_THRESHOLD) {buttons[b].pressedBefore = false; continue;} // too short "press", debounce
+      bool doublePress = buttons[b].waitTime; //did we have a short press before?
+      buttons[b].waitTime = 0;

      if (b == 0 && dur > WLED_LONG_AP) { // long press on button 0 (when released)
        if (dur > WLED_LONG_FACTORY_RESET) { // factory reset if pressed > 10 seconds
@@ -332,25 +334,25 @@ void handleButton()
        } else {
          WLED::instance().initAP(true);
        }
-      } else if (!buttonLongPressed[b]) { //short press
+      } else if (!buttons[b].longPressed) { //short press
        //NOTE: this interferes with double click handling in usermods so usermod needs to implement full button handling
-        if (b != 1 && !macroDoublePress[b]) { //don't wait for double press on buttons without a default action if no double press macro set
+        if (b != 1 && !buttons[b].macroDoublePress) { //don't wait for double press on buttons without a default action if no double press macro set
          shortPressAction(b);
        } else { //double press if less than 350 ms between current press and previous short press release (buttonWaitTime!=0)
          if (doublePress) {
            doublePressAction(b);
          } else {
-            buttonWaitTime[b] = now;
+            buttons[b].waitTime = now;
          }
        }
      }
-      buttonPressedBefore[b] = false;
-      buttonLongPressed[b] = false;
+      buttons[b].pressedBefore = false;
+      buttons[b].longPressed = false;
    }

    //if 350ms elapsed since last short press release it is a short press
-    if (buttonWaitTime[b] && now - buttonWaitTime[b] > WLED_DOUBLE_PRESS && !buttonPressedBefore[b]) {
-      buttonWaitTime[b] = 0;
+    if (buttons[b].waitTime && now - buttons[b].waitTime > WLED_DOUBLE_PRESS && !buttons[b].pressedBefore) {
+      buttons[b].waitTime = 0;
      shortPressAction(b);
    }
  }
--- a/wled00/cfg.cpp
+++ b/wled00/cfg.cpp
@@ -354,97 +354,91 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
  JsonArray hw_btn_ins = btn_obj["ins"];
  if (!hw_btn_ins.isNull()) {
    // deallocate existing button pins
-    for (unsigned b = 0; b < WLED_MAX_BUTTONS; b++) PinManager::deallocatePin(btnPin[b], PinOwner::Button); // does nothing if trying to deallocate a pin with PinOwner != Button
+    for (const auto &button : buttons) PinManager::deallocatePin(button.pin, PinOwner::Button); // does nothing if trying to deallocate a pin with PinOwner != Button
+    buttons.clear(); // clear existing buttons
    unsigned s = 0;
    for (JsonObject btn : hw_btn_ins) {
-      CJSON(buttonType[s], btn["type"]);
-      int8_t pin = btn["pin"][0] | -1;
+      uint8_t type = btn["type"] | BTN_TYPE_NONE;
+      int8_t  pin  = btn["pin"][0] | -1;
      if (pin > -1 && PinManager::allocatePin(pin, false, PinOwner::Button)) {
-        btnPin[s] = pin;
-      #ifdef ARDUINO_ARCH_ESP32
+        #ifdef ARDUINO_ARCH_ESP32
        // ESP32 only: check that analog button pin is a valid ADC gpio
-        if ((buttonType[s] == BTN_TYPE_ANALOG) || (buttonType[s] == BTN_TYPE_ANALOG_INVERTED)) {
-          if (digitalPinToAnalogChannel(btnPin[s]) < 0) {
+        if ((type == BTN_TYPE_ANALOG) || (type == BTN_TYPE_ANALOG_INVERTED)) {
+          if (digitalPinToAnalogChannel(pin) < 0) {
            // not an ADC analog pin
-            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for analog button #%d is not an analog pin!\n"), btnPin[s], s);
-            btnPin[s] = -1;
-            PinManager::deallocatePin(pin,PinOwner::Button);
+            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for analog button #%d is not an analog pin!\n"), pin, s);
+            PinManager::deallocatePin(pin, PinOwner::Button);
+            pin = -1;
+            continue;
          } else {
            analogReadResolution(12); // see #4040
          }
-        }
-        else if ((buttonType[s] == BTN_TYPE_TOUCH || buttonType[s] == BTN_TYPE_TOUCH_SWITCH))
-        {
-          if (digitalPinToTouchChannel(btnPin[s]) < 0) {
+        } else if ((type == BTN_TYPE_TOUCH || type == BTN_TYPE_TOUCH_SWITCH)) {
+          if (digitalPinToTouchChannel(pin) < 0) {
            // not a touch pin
-            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for touch button #%d is not a touch pin!\n"), btnPin[s], s);
-            btnPin[s] = -1;
-            PinManager::deallocatePin(pin,PinOwner::Button);
-          }
+            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for touch button #%d is not a touch pin!\n"), pin, s);
+            PinManager::deallocatePin(pin, PinOwner::Button);
+            pin = -1;
+            continue;
+          }          
          //if touch pin, enable the touch interrupt on ESP32 S2 & S3
          #ifdef SOC_TOUCH_VERSION_2    // ESP32 S2 and S3 have a function to check touch state but need to attach an interrupt to do so
-          else
-          {
-            touchAttachInterrupt(btnPin[s], touchButtonISR, touchThreshold << 4); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000)
-          }
+          else touchAttachInterrupt(pin, touchButtonISR, touchThreshold << 4); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000)
          #endif
-        }
-        else
-      #endif
+        } else
+        #endif
        {
+          // regular buttons and switches
          if (disablePullUp) {
-            pinMode(btnPin[s], INPUT);
+            pinMode(pin, INPUT);
          } else {
            #ifdef ESP32
-            pinMode(btnPin[s], buttonType[s]==BTN_TYPE_PUSH_ACT_HIGH ? INPUT_PULLDOWN : INPUT_PULLUP);
+            pinMode(pin, type==BTN_TYPE_PUSH_ACT_HIGH ? INPUT_PULLDOWN : INPUT_PULLUP);
            #else
-            pinMode(btnPin[s], INPUT_PULLUP);
+            pinMode(pin, INPUT_PULLUP);
            #endif
          }
        }
-      } else {
-        btnPin[s] = -1;
+        JsonArray hw_btn_ins_0_macros = btn["macros"];
+        uint8_t press       = hw_btn_ins_0_macros[0] | 0;
+        uint8_t longPress   = hw_btn_ins_0_macros[1] | 0;
+        uint8_t doublePress = hw_btn_ins_0_macros[2] | 0;
+        buttons.emplace_back(pin, type, press, longPress, doublePress); // add button to vector
      }
-      JsonArray hw_btn_ins_0_macros = btn["macros"];
-      CJSON(macroButton[s], hw_btn_ins_0_macros[0]);
-      CJSON(macroLongPress[s],hw_btn_ins_0_macros[1]);
-      CJSON(macroDoublePress[s], hw_btn_ins_0_macros[2]);
      if (++s >= WLED_MAX_BUTTONS) break; // max buttons reached
    }
-    // clear remaining buttons
-    for (; s<WLED_MAX_BUTTONS; s++) {
-      btnPin[s]           = -1;
-      buttonType[s]       = BTN_TYPE_NONE;
-      macroButton[s]      = 0;
-      macroLongPress[s]   = 0;
-      macroDoublePress[s] = 0;
-    }
  } else if (fromFS) {
    // new install/missing configuration (button 0 has defaults)
    // relies upon only being called once with fromFS == true, which is currently true.
-    for (size_t s = 0; s < WLED_MAX_BUTTONS; s++) {
-      if (buttonType[s] == BTN_TYPE_NONE || btnPin[s] < 0 || !PinManager::allocatePin(btnPin[s], false, PinOwner::Button)) {
-        btnPin[s]     = -1;
-        buttonType[s] = BTN_TYPE_NONE;
+    constexpr uint8_t  defTypes[] = {BTNTYPE};
+    constexpr int8_t   defPins[]  = {BTNPIN};
+    constexpr unsigned numTypes   = (sizeof(defTypes) / sizeof(defTypes[0]));
+    constexpr unsigned numPins    = (sizeof(defPins) / sizeof(defPins[0]));
+    // check if the number of pins and types are valid; count of pins must be greater than or equal to types
+    static_assert(numTypes <= numPins, "The default button pins defined in BTNPIN do not match the button types defined in BTNTYPE");
+
+    uint8_t type = BTN_TYPE_NONE;
+    buttons.clear(); // clear existing buttons (just in case)
+    for (size_t s = 0; s < WLED_MAX_BUTTONS && s < numPins; s++) {
+      type = defTypes[s < numTypes ? s : numTypes - 1]; // use last known type to set current type if types less than pins
+      if (type == BTN_TYPE_NONE || defPins[s] < 0 || !PinManager::allocatePin(defPins[s], false, PinOwner::Button)) {
+        if (buttons.size() == 0) buttons.emplace_back(-1, BTN_TYPE_NONE); // add disabled button to vector (so we have at least one button defined)
+        continue; // pin not available or invalid, skip configuring this GPIO
      }
-      if (btnPin[s] >= 0) {
-        if (disablePullUp) {
-          pinMode(btnPin[s], INPUT);
-        } else {
-          #ifdef ESP32
-          pinMode(btnPin[s], buttonType[s]==BTN_TYPE_PUSH_ACT_HIGH ? INPUT_PULLDOWN : INPUT_PULLUP);
-          #else
-          pinMode(btnPin[s], INPUT_PULLUP);
-          #endif
-        }
+      if (disablePullUp) {
+        pinMode(defPins[s], INPUT);
+      } else {
+        #ifdef ESP32
+        pinMode(defPins[s], type==BTN_TYPE_PUSH_ACT_HIGH ? INPUT_PULLDOWN : INPUT_PULLUP);
+        #else
+        pinMode(defPins[s], INPUT_PULLUP);
+        #endif
      }
-      macroButton[s]      = 0;
-      macroLongPress[s]   = 0;
-      macroDoublePress[s] = 0;
+      buttons.emplace_back(defPins[s], type); // add button to vector
    }
  }

-  CJSON(buttonPublishMqtt,btn_obj["mqtt"]);
+  CJSON(buttonPublishMqtt, btn_obj["mqtt"]);

  #ifndef WLED_DISABLE_INFRARED
  int hw_ir_pin = hw["ir"]["pin"] | -2; // 4
@@ -998,15 +992,15 @@ void serializeConfig(JsonObject root) {
  JsonArray hw_btn_ins = hw_btn.createNestedArray("ins");

  // configuration for all buttons
-  for (int i = 0; i < WLED_MAX_BUTTONS; i++) {
+  for (const auto &button : buttons) {
    JsonObject hw_btn_ins_0 = hw_btn_ins.createNestedObject();
-    hw_btn_ins_0["type"] = buttonType[i];
+    hw_btn_ins_0["type"] = button.type;
    JsonArray hw_btn_ins_0_pin = hw_btn_ins_0.createNestedArray("pin");
-    hw_btn_ins_0_pin.add(btnPin[i]);
+    hw_btn_ins_0_pin.add(button.pin);
    JsonArray hw_btn_ins_0_macros = hw_btn_ins_0.createNestedArray("macros");
-    hw_btn_ins_0_macros.add(macroButton[i]);
-    hw_btn_ins_0_macros.add(macroLongPress[i]);
-    hw_btn_ins_0_macros.add(macroDoublePress[i]);
+    hw_btn_ins_0_macros.add(button.macroButton);
+    hw_btn_ins_0_macros.add(button.macroLongPress);
+    hw_btn_ins_0_macros.add(button.macroDoublePress);
  }

  hw_btn[F("tt")] = touchThreshold;
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -94,9 +94,9 @@ static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");

 #ifndef WLED_MAX_BUTTONS
  #ifdef ESP8266
-    #define WLED_MAX_BUTTONS 2
+    #define WLED_MAX_BUTTONS 10
  #else
-    #define WLED_MAX_BUTTONS 4
+    #define WLED_MAX_BUTTONS 32
  #endif
 #else
  #if WLED_MAX_BUTTONS < 2
--- a/wled00/data/settings_leds.htm
+++ b/wled00/data/settings_leds.htm
@@ -50,6 +50,7 @@
 			maxM  = m; // maxM - max LED memory
 			maxL  = l; // maxL - max LEDs (will serve to determine ESP >1664 == ESP32)
 			maxCO = o; // maxCO - max Color Order mappings
+			maxBT = n; // maxBT - max buttons
 		}
 		function is8266() { return maxA ==  5 && maxD ==  3; } // NOTE: see const.h
 		function is32()   { return maxA == 16 && maxD == 16; } // NOTE: see const.h
@@ -568,9 +569,10 @@ Swap: <select id="xw${s}" name="XW${s}">
 		}

 		function addBtn(i,p,t) {
-			var c = gId("btns").innerHTML;
+			var b = gId("btns");
+			var c = b.innerHTML;
 			var s = chrID(i);
-			c += `Button ${i} GPIO: <input type="number" name="BT${s}" onchange="UI()" class="xs" value="${p}">`;
+			c += `<div id="btn${i}">#${i} GPIO: <input type="number" name="BT${s}" onchange="UI()" min="-1" max="${d.max_gpio}" class="xs" value="${p}">`;
 			c += `&nbsp;<select name="BE${s}">`
 			c += `<option value="0" ${t==0?"selected":""}>Disabled</option>`;
 			c += `<option value="2" ${t==2?"selected":""}>Pushbutton</option>`;
@@ -582,8 +584,22 @@ Swap: <select id="xw${s}" name="XW${s}">
 			c += `<option value="8" ${t==8?"selected":""}>Analog inverted</option>`;
 			c += `<option value="9" ${t==9?"selected":""}>Touch (switch)</option>`;
 			c += `</select>`;
-			c += `<span style="cursor: pointer;" onclick="off('BT${s}')">&nbsp;&#x2715;</span><br>`;
-			gId("btns").innerHTML = c;
+			c += `<span style="cursor: pointer;" onclick="off('BT${s}')">&nbsp;&#x2715;</span><br></div>`;
+			b.innerHTML = c;
+			btnBtn();
+			UI();
+		}
+		function remBtn() {
+			var b = gId("btns");
+			if (b.children.length <= 1) return;
+			b.lastElementChild.remove();
+			btnBtn();
+			UI();
+		}
+		function btnBtn() {
+			var b = gId("btns");
+			gId("btn_rem").style.display = (b.children.length > 1) ? "inline" : "none";
+			gId("btn_add").style.display = (b.children.length < maxBT) ? "inline" : "none";
 		}
 		function tglSi(cs) {
 			customStarts = cs;
@@ -835,10 +851,16 @@ Swap: <select id="xw${s}" name="XW${s}">
 			<div id="com_entries"></div>
 			<hr class="sml">
 			<button type="button" id="com_add" onclick="addCOM()">+</button>
-			<button type="button" id="com_rem" onclick="remCOM()">-</button><br>
+			<button type="button" id="com_rem" onclick="remCOM()">-</button>
 		</div>
 		<hr class="sml">
-		<div id="btns"></div>
+		<div id="btn_wrap">
+			Buttons:
+			<div id="btns"></div>
+			<hr class="sml">
+			<button type="button" id="btn_add" onclick="addBtn(gId('btns').children.length,-1,0)">+</button>
+			<button type="button" id="btn_rem" onclick="remBtn()">-</button>
+		</div>
 		Disable internal pull-up/down: <input type="checkbox" name="IP"><br>
 		Touch threshold: <input type="number" class="s" min="0" max="100" name="TT" required><br>
 		<hr class="sml">
--- a/wled00/e131.cpp
+++ b/wled00/e131.cpp
@@ -407,7 +407,7 @@ void prepareArtnetPollReply(ArtPollReply *reply) {

  reply->reply_opcode = ARTNET_OPCODE_OPPOLLREPLY;

-  IPAddress localIP = WLEDNetwork.localIP();
+  IPAddress localIP = Network.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;

-  WLEDNetwork.localMAC(reply->reply_mac);
+  Network.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 (WLEDNetwork.isConnected()) improvState = 0x04; //provisioned
+              if (Network.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 (WLEDNetwork.isConnected())
+  if (Network.isConnected())
  {
    char urlStr[64];
-    IPAddress localIP = WLEDNetwork.localIP();
+    IPAddress localIP = Network.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 (WLEDNetwork.isConnected())
+  if (Network.isConnected())
  {
-    IPAddress localIP = WLEDNetwork.localIP();
+    IPAddress localIP = Network.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(WLEDNetwork.localIP());
+      DEBUG_PRINT(F("WiFi-E: IP address: ")); DEBUG_PRINTLN(Network.localIP());
      break;
    case ARDUINO_EVENT_WIFI_STA_CONNECTED:
      // followed by IDLE and SCAN_DONE
--- a/wled00/set.cpp
+++ b/wled00/set.cpp
@@ -128,12 +128,12 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
      PinManager::deallocatePin(irPin, PinOwner::IR);
    }
    #endif
-    for (unsigned s=0; s<WLED_MAX_BUTTONS; s++) {
-      if (btnPin[s]>=0 && PinManager::isPinAllocated(btnPin[s], PinOwner::Button)) {
-        PinManager::deallocatePin(btnPin[s], PinOwner::Button);
+    for (const auto &button : buttons) {
+      if (button.pin >= 0 && PinManager::isPinAllocated(button.pin, PinOwner::Button)) {
+        PinManager::deallocatePin(button.pin, PinOwner::Button);
        #ifdef SOC_TOUCH_VERSION_2 // ESP32 S2 and S3 have a function to check touch state, detach interrupt
-        if (digitalPinToTouchChannel(btnPin[s]) >= 0) // if touch capable pin
-          touchDetachInterrupt(btnPin[s]);            // if not assigned previously, this will do nothing
+        if (digitalPinToTouchChannel(button.pin) >= 0) // if touch capable pin
+          touchDetachInterrupt(button.pin);            // if not assigned previously, this will do nothing
        #endif
      }
    }
@@ -280,54 +280,56 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
      char bt[4] = "BT"; bt[2] = offset+i; bt[3] = 0; // button pin (use A,B,C,... if WLED_MAX_BUTTONS>10)
      char be[4] = "BE"; be[2] = offset+i; be[3] = 0; // button type (use A,B,C,... if WLED_MAX_BUTTONS>10)
      int hw_btn_pin = request->arg(bt).toInt();
-      if (hw_btn_pin >= 0 && PinManager::allocatePin(hw_btn_pin,false,PinOwner::Button)) {
-        btnPin[i] = hw_btn_pin;
-        buttonType[i] = request->arg(be).toInt();
-      #ifdef ARDUINO_ARCH_ESP32
+      if (i >= buttons.size()) buttons.emplace_back(hw_btn_pin, request->arg(be).toInt()); // add button to vector
+      else {
+        buttons[i].pin  = hw_btn_pin;
+        buttons[i].type = request->arg(be).toInt();
+      }
+      if (buttons[i].pin >= 0 && PinManager::allocatePin(buttons[i].pin, false, PinOwner::Button)) {
+        #ifdef ARDUINO_ARCH_ESP32
        // ESP32 only: check that button pin is a valid gpio
-        if ((buttonType[i] == BTN_TYPE_ANALOG) || (buttonType[i] == BTN_TYPE_ANALOG_INVERTED))
-        {
-          if (digitalPinToAnalogChannel(btnPin[i]) < 0) {
+        if ((buttons[i].type == BTN_TYPE_ANALOG) || (buttons[i].type == BTN_TYPE_ANALOG_INVERTED)) {
+          if (digitalPinToAnalogChannel(buttons[i].pin) < 0) {
            // not an ADC analog pin
-            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for analog button #%d is not an analog pin!\n"), btnPin[i], i);
-            btnPin[i] = -1;
-            PinManager::deallocatePin(hw_btn_pin,PinOwner::Button);
+            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for analog button #%d is not an analog pin!\n"), buttons[i].pin, i);
+            PinManager::deallocatePin(buttons[i].pin, PinOwner::Button);
+            buttons[i].type = BTN_TYPE_NONE;
          } else {
            analogReadResolution(12); // see #4040
          }
-        }
-        else if ((buttonType[i] == BTN_TYPE_TOUCH || buttonType[i] == BTN_TYPE_TOUCH_SWITCH))
-        {
-          if (digitalPinToTouchChannel(btnPin[i]) < 0)
-          {
+        } else if ((buttons[i].type == BTN_TYPE_TOUCH || buttons[i].type == BTN_TYPE_TOUCH_SWITCH)) {
+          if (digitalPinToTouchChannel(buttons[i].pin) < 0) {
            // not a touch pin
-            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for touch button #%d is not an touch pin!\n"), btnPin[i], i);
-            btnPin[i] = -1;
-            PinManager::deallocatePin(hw_btn_pin,PinOwner::Button);
+            DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for touch button #%d is not an touch pin!\n"), buttons[i].pin, i);
+            PinManager::deallocatePin(buttons[i].pin, PinOwner::Button);
+            buttons[i].type = BTN_TYPE_NONE;
          }          
          #ifdef SOC_TOUCH_VERSION_2 // ESP32 S2 and S3 have a fucntion to check touch state but need to attach an interrupt to do so
-          else                    
-          {
-            touchAttachInterrupt(btnPin[i], touchButtonISR, touchThreshold << 4); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000)
-          }
-          #endif          
-        }
-        else
-      #endif
+          else touchAttachInterrupt(buttons[i].pin, touchButtonISR, touchThreshold << 4); // threshold on Touch V2 is much higher (1500 is a value given by Espressif example, I measured changes of over 5000)
+          #endif
+        } else
+        #endif
        {
+          // regular buttons and switches
          if (disablePullUp) {
-            pinMode(btnPin[i], INPUT);
+            pinMode(buttons[i].pin, INPUT);
          } else {
            #ifdef ESP32
-            pinMode(btnPin[i], buttonType[i]==BTN_TYPE_PUSH_ACT_HIGH ? INPUT_PULLDOWN : INPUT_PULLUP);
+            pinMode(buttons[i].pin, buttons[i].type==BTN_TYPE_PUSH_ACT_HIGH ? INPUT_PULLDOWN : INPUT_PULLUP);
            #else
-            pinMode(btnPin[i], INPUT_PULLUP);
+            pinMode(buttons[i].pin, INPUT_PULLUP);
            #endif
          }
        }
      } else {
-        btnPin[i] = -1;
-        buttonType[i] = BTN_TYPE_NONE;
+        buttons[i].pin  = -1;
+        buttons[i].type = BTN_TYPE_NONE;
+      }
+    }
+    // we should remove all unused buttons from the vector
+    for (int i = buttons.size()-1; i > 0; i--) {
+      if (buttons[i].pin < 0 && buttons[i].type == BTN_TYPE_NONE) {
+        buttons.erase(buttons.begin() + i); // remove button from vector
      }
    }

@@ -532,14 +534,16 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
    macroAlexaOff = request->arg(F("A1")).toInt();
    macroCountdown = request->arg(F("MC")).toInt();
    macroNl = request->arg(F("MN")).toInt();
-    for (unsigned i=0; i<WLED_MAX_BUTTONS; i++) {
-      char mp[4] = "MP"; mp[2] = (i<10?48:55)+i; mp[3] = 0; // short
-      char ml[4] = "ML"; ml[2] = (i<10?48:55)+i; ml[3] = 0; // long
-      char md[4] = "MD"; md[2] = (i<10?48:55)+i; md[3] = 0; // double
+    int i = 0;
+    for (auto &button : buttons) {
+      char mp[4] = "MP"; mp[2] = (i<10?'0':'A'-10)+i; mp[3] = 0; // short
+      char ml[4] = "ML"; ml[2] = (i<10?'0':'A'-10)+i; ml[3] = 0; // long
+      char md[4] = "MD"; md[2] = (i<10?'0':'A'-10)+i; md[3] = 0; // double
      //if (!request->hasArg(mp)) break;
-      macroButton[i] = request->arg(mp).toInt();      // these will default to 0 if not present
-      macroLongPress[i] = request->arg(ml).toInt();
-      macroDoublePress[i] = request->arg(md).toInt();
+      button.macroButton = request->arg(mp).toInt();      // these will default to 0 if not present
+      button.macroLongPress = request->arg(ml).toInt();
+      button.macroDoublePress = request->arg(md).toInt();
+      i++;
    }

    char k[3]; k[2] = 0;
--- a/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.cpp
+++ b/wled00/src/dependencies/async-mqtt-client/AsyncMqttClient.cpp
@@ -0,0 +1,877 @@
+#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
@@ -0,0 +1,6 @@
+#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
@@ -0,0 +1,166 @@
+#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
@@ -0,0 +1,28 @@
+#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
@@ -0,0 +1,15 @@
+#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
@@ -0,0 +1,57 @@
+#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
@@ -0,0 +1,38 @@
+#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
@@ -0,0 +1,7 @@
+#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
@@ -0,0 +1,30 @@
+#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
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,11 @@
+#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
@@ -0,0 +1,21 @@
+#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
@@ -0,0 +1,21 @@
+#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
@@ -0,0 +1,30 @@
+#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
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,30 @@
+#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
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,30 @@
+#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
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,30 @@
+#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
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,91 @@
+#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
@@ -0,0 +1,38 @@
+#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
@@ -0,0 +1,46 @@
+#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
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,30 @@
+#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
@@ -0,0 +1,25 @@
+#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
@@ -0,0 +1,21 @@
+#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
@@ -0,0 +1,13 @@
+#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
@@ -0,0 +1,21 @@
+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
@@ -0,0 +1,18 @@
+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>(WLEDNetwork.localIP());
+    ifaddr.addr = static_cast<uint32_t>(Network.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 = WLEDNetwork.localIP();
+    IPAddress localIP = Network.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 = WLEDNetwork.localIP();
+    IPAddress localIP = Network.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(WLEDNetwork.localIP(), IPAddress(239, 255, 255, 250), 1900);
+    udpConnected = espalexaUdp.beginMulticast(Network.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 WLEDNetworkClass::localIP()
+IPAddress NetworkClass::localIP()
 {
  IPAddress localIP;
 #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
@@ -17,7 +17,7 @@ IPAddress WLEDNetworkClass::localIP()
  return INADDR_NONE;
 }

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

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

-void WLEDNetworkClass::localMAC(uint8_t* MAC)
+void NetworkClass::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 WLEDNetworkClass::localMAC(uint8_t* MAC)
  return;
 }

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

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

-WLEDNetworkClass WLEDNetwork;
+NetworkClass Network;
--- 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 WLEDNetworkClass
+class NetworkClass
 {
 public:
  IPAddress localIP();
@@ -19,6 +19,6 @@ public:
  bool isEthernet();
 };

-extern WLEDNetworkClass WLEDNetwork;
+extern NetworkClass Network;

 #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(WLEDNetwork.subnetMask()) | uint32_t(WLEDNetwork.gatewayIP());
+    IPAddress broadcastIp = ~uint32_t(Network.subnetMask()) | uint32_t(Network.gatewayIP());
    notifierUdp.beginPacket(broadcastIp, udpPort);
    notifierUdp.write(udpOut, WLEDPACKETSIZE); // TODO: add actual used buffer size
    notifierUdp.endPacket();
@@ -516,7 +516,7 @@ void handleNotifications()
    }
  }

-  localIP = WLEDNetwork.localIP();
+  localIP = Network.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 = WLEDNetwork.localIP();
+  IPAddress ip = Network.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 (WLEDNetwork.isConnected() && aOtaEnabled && !otaLock && correctPIN) ArduinoOTA.handle();
+    if (Network.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"), WLEDNetwork.localIP()[0], WLEDNetwork.localIP()[1], WLEDNetwork.localIP()[2], WLEDNetwork.localIP()[3]);
+    DEBUG_PRINTF_P(PSTR("Client IP: %u.%u.%u.%u\n"), Network.localIP()[0], Network.localIP()[1], Network.localIP()[2], Network.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 = WLEDNetwork.localIP();
+  IPAddress ipAddress = Network.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 (!WLEDNetwork.isConnected() && wifiConfigured) {        // trying to connect, but not connected
+      if (!Network.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 (!WLEDNetwork.isConnected()) {
+  if (!Network.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(WLEDNetwork.localIP());
+    DEBUG_PRINTLN(Network.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 WLEDNetwork.isConnected() is false (no WiFi, ?? no Ethernet ??)
+// else blink at 1Hz when Network.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 (WLEDNetwork.isConnected()) {
+  if (Network.isConnected()) {
    c = RGBW32(0,255,0,0);
    ledStatusType = 2;
  } else if (WLED_MQTT_CONNECTED) {
--- a/wled00/wled.h
+++ b/wled00/wled.h
@@ -294,10 +294,10 @@ WLED_GLOBAL char otaPass[33] _INIT(DEFAULT_OTA_PASS);

 // Hardware and pin config
 #ifndef BTNPIN
-  #define BTNPIN 0,-1
+  #define BTNPIN 0
 #endif
 #ifndef BTNTYPE
-  #define BTNTYPE BTN_TYPE_PUSH,BTN_TYPE_NONE
+  #define BTNTYPE BTN_TYPE_PUSH
 #endif
 #ifndef RLYPIN
 WLED_GLOBAL int8_t rlyPin _INIT(-1);
@@ -579,9 +579,6 @@ WLED_GLOBAL byte countdownMin  _INIT(0) , countdownSec   _INIT(0);
 WLED_GLOBAL byte macroNl   _INIT(0);        // after nightlight delay over
 WLED_GLOBAL byte macroCountdown _INIT(0);
 WLED_GLOBAL byte macroAlexaOn _INIT(0), macroAlexaOff _INIT(0);
-WLED_GLOBAL byte macroButton[WLED_MAX_BUTTONS]        _INIT({0});
-WLED_GLOBAL byte macroLongPress[WLED_MAX_BUTTONS]     _INIT({0});
-WLED_GLOBAL byte macroDoublePress[WLED_MAX_BUTTONS]   _INIT({0});

 // Security CONFIG
 #ifdef WLED_OTA_PASS
@@ -648,13 +645,32 @@ WLED_GLOBAL byte briLast             _INIT(128);           // brightness before
 WLED_GLOBAL byte whiteLast           _INIT(128);           // white channel before turned off. Used for toggle function in ir.cpp

 // button
-WLED_GLOBAL int8_t btnPin[WLED_MAX_BUTTONS]                   _INIT({BTNPIN});
-WLED_GLOBAL byte buttonType[WLED_MAX_BUTTONS]                 _INIT({BTNTYPE});
+struct Button {
+  unsigned long pressedTime;        // time button was pressed
+  unsigned long waitTime;           // time to wait for next button press
+  int8_t        pin;                // pin number
+  struct {
+    uint8_t     type          : 6;  // button type (push, long, double, etc.)
+    bool        pressedBefore : 1;  // button was pressed before
+    bool        longPressed   : 1;  // button was long pressed
+  };
+  uint8_t       macroButton;        // macro/preset to call on button press
+  uint8_t       macroLongPress;     // macro/preset to call on long press
+  uint8_t       macroDoublePress;   // macro/preset to call on double press
+
+  Button(int8_t p, uint8_t t, uint8_t mB = 0, uint8_t mLP = 0, uint8_t mDP = 0)
+  : pressedTime(0)
+  , waitTime(0)
+  , pin(p)
+  , type(t)
+  , pressedBefore(false)
+  , longPressed(false)
+  , macroButton(mB)
+  , macroLongPress(mLP)
+  , macroDoublePress(mDP) {}
+};
+WLED_GLOBAL std::vector<Button> buttons; // vector of button structs
 WLED_GLOBAL bool buttonPublishMqtt                            _INIT(false);
-WLED_GLOBAL bool buttonPressedBefore[WLED_MAX_BUTTONS]        _INIT({false});
-WLED_GLOBAL bool buttonLongPressed[WLED_MAX_BUTTONS]          _INIT({false});
-WLED_GLOBAL unsigned long buttonPressedTime[WLED_MAX_BUTTONS] _INIT({0});
-WLED_GLOBAL unsigned long buttonWaitTime[WLED_MAX_BUTTONS]    _INIT({0});
 WLED_GLOBAL bool disablePullUp                                _INIT(false);
 WLED_GLOBAL byte touchThreshold                               _INIT(TOUCH_THRESHOLD);

@@ -1026,7 +1042,7 @@ WLED_GLOBAL volatile uint8_t jsonBufferLock _INIT(0);
  WLED_GLOBAL unsigned loops _INIT(0);
 #endif

-#define WLED_CONNECTED (WLEDNetwork.isConnected())
+#define WLED_CONNECTED (Network.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, WLEDNetwork.localIP(), WLEDNetwork.subnetMask());
+  return inSubnet(client, Network.localIP(), Network.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 (WLEDNetwork.isConnected()) //is connected
+    if (Network.isConnected()) //is connected
    {
      char s[32];
-      IPAddress localIP = WLEDNetwork.localIP();
+      IPAddress localIP = Network.localIP();
      sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);

      #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
@@ -273,7 +273,7 @@ void getSettingsJS(byte subPage, Print& settingsScript)
    settingsScript.printf_P(PSTR("d.ledTypes=%s;"), BusManager::getLEDTypesJSONString().c_str());

    // set limits
-    settingsScript.printf_P(PSTR("bLimits(%d,%d,%d,%d,%d,%d,%d,%d);"),
+    settingsScript.printf_P(PSTR("bLimits(%d,%d,%d,%d,%d,%d,%d,%d,%d);"),
      WLED_MAX_BUSSES,
      WLED_MIN_VIRTUAL_BUSSES, // irrelevant, but kept to distinguish S2/S3 in UI
      MAX_LEDS_PER_BUS,
@@ -281,7 +281,8 @@ void getSettingsJS(byte subPage, Print& settingsScript)
      MAX_LEDS,
      WLED_MAX_COLOR_ORDER_MAPPINGS,
      WLED_MAX_DIGITAL_CHANNELS,
-      WLED_MAX_ANALOG_CHANNELS
+      WLED_MAX_ANALOG_CHANNELS,
+      WLED_MAX_BUTTONS
    );

    printSetFormCheckbox(settingsScript,PSTR("MS"),strip.autoSegments);
@@ -386,8 +387,9 @@ void getSettingsJS(byte subPage, Print& settingsScript)
    printSetFormValue(settingsScript,PSTR("RL"),rlyPin);
    printSetFormCheckbox(settingsScript,PSTR("RM"),rlyMde);
    printSetFormCheckbox(settingsScript,PSTR("RO"),rlyOpenDrain);
-    for (int i = 0; i < WLED_MAX_BUTTONS; i++) {
-      settingsScript.printf_P(PSTR("addBtn(%d,%d,%d);"), i, btnPin[i], buttonType[i]);
+    int i = 0;
+    for (const auto &button : buttons) {
+      settingsScript.printf_P(PSTR("addBtn(%d,%d,%d);"), i++, button.pin, button.type);
    }
    printSetFormCheckbox(settingsScript,PSTR("IP"),disablePullUp);
    printSetFormValue(settingsScript,PSTR("TT"),touchThreshold);
@@ -561,8 +563,9 @@ void getSettingsJS(byte subPage, Print& settingsScript)
    printSetFormValue(settingsScript,PSTR("A1"),macroAlexaOff);
    printSetFormValue(settingsScript,PSTR("MC"),macroCountdown);
    printSetFormValue(settingsScript,PSTR("MN"),macroNl);
-    for (unsigned i=0; i<WLED_MAX_BUTTONS; i++) {
-      settingsScript.printf_P(PSTR("addRow(%d,%d,%d,%d);"), i, macroButton[i], macroLongPress[i], macroDoublePress[i]);
+    int i = 0;
+    for (const auto &button : buttons) {
+      settingsScript.printf_P(PSTR("addRow(%d,%d,%d,%d);"), i++, button.macroButton, button.macroLongPress, button.macroDoublePress);
    }

    char k[4];
Author	SHA1	Message	Date
Blaž Kristan	cbc5dec0af	Merge branch 'main' into multibutton	2025-08-04 08:04:17 +02:00
Blaž Kristan	6c3f4a7c33	Have at least one button defined	2025-07-04 18:48:36 +02:00
Blaž Kristan	e670b26cd0	Remove second pin defaults	2025-07-04 18:46:54 +02:00
Blaž Kristan	5c0ec6750a	Variable button count (up to 32) - adds ability to configure variable number of buttons during runtime - fixes #4692	2025-07-04 13:56:45 +02:00