16.0.1

* fix bug in bus removal
* optimized some JS alerts
* removed unneeded code

.coderabbit.yaml

@@ -17,7 +17,7 @@ language: en-US
 
 reviews:
   # generic review setting, see https://docs.coderabbit.ai/reference/configuration#reference
-  auto_apply_labels: false
+  auto_apply_labels: true
   # abort_on_close: false
   high_level_summary: true
   review_status: true

.devcontainer/devcontainer-lock.json

@@ -1,14 +0,0 @@
-{
-  "features": {
-    "ghcr.io/ar90n/devcontainer-features/platformio:1": {
-      "version": "1.0.2",
-      "resolved": "ghcr.io/ar90n/devcontainer-features/platformio@sha256:4a28f8c147d81ff996afebe6f43e453355b6373dd4022960351090b532ac9dd3",
-      "integrity": "sha256:4a28f8c147d81ff996afebe6f43e453355b6373dd4022960351090b532ac9dd3"
-    },
-    "ghcr.io/devcontainers/features/node:2": {
-      "version": "2.0.0",
-      "resolved": "ghcr.io/devcontainers/features/node@sha256:fedd4c11f7adfb64283b578dddc7da906728daa25fa293351c9d913231acf12f",
-      "integrity": "sha256:fedd4c11f7adfb64283b578dddc7da906728daa25fa293351c9d913231acf12f"
-    }
-  }
-}

.devcontainer/devcontainer.json

@@ -1,10 +1,11 @@
 {
-	"name": "WLED-dev",
-	"image": "mcr.microsoft.com/devcontainers/python:3",
-	"features": {
-    	"ghcr.io/ar90n/devcontainer-features/platformio:1": {},
-		"ghcr.io/devcontainers/features/node:2": {
-			"version": "v20.18.3"
+	"name": "Python 3",
+	"build": {
+		"dockerfile": "Dockerfile",
+		"context": "..",
+		"args": { 
+			// Update 'VARIANT' to pick a Python version: 3, 3.6, 3.7, 3.8, 3.9
+			"VARIANT": "3"
 		}
 	},
 
@@ -42,8 +43,7 @@
 			},
 			"extensions": [
 				"ms-python.python",
-				"platformio.platformio-ide",
-				"ms-vscode.cpptools-extension-pack"
+				"platformio.platformio-ide"
 			]
 		}
 	},
@@ -52,7 +52,7 @@
 	// "forwardPorts": [],
 
 	// Use 'postCreateCommand' to run commands after the container is created.
-	"postCreateCommand": "",
+	"postCreateCommand": "bash -i -c 'nvm install && npm ci'",
 
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
 	"remoteUser": "vscode"

.github/ISSUE_TEMPLATE/bug.yml

@@ -5,9 +5,7 @@ body:
   - type: markdown
     attributes:
       value: |
-        Please quickly search existing issues first before submitting a bug.  
-        Please don't submit long error analyses created by an AI agent, these are often totally wrong.  
-        Just describe the problem in your own words.
+        Please quickly search existing issues first before submitting a bug.
   - type: textarea
     id: what-happened
     attributes:
@@ -61,13 +59,12 @@ body:
       options:
         - ESP8266
         - ESP32
-        - ESP32 with ethernet
-        - ESP32-S2
         - ESP32-S3
+        - ESP32-S2
         - ESP32-C3
-        - ESP32-C5 (experimental)
+        - Other
         - ESP32-C6 (experimental)
-        - ESP32-P4 (experimental)
+        - ESP32-C5 (experimental)
     validations:
       required: true
   - type: textarea

.github/platformio_release.ini.template

@@ -43,3 +43,4 @@ default_envs = nodemcuv2
                adafruit_matrixportal_esp32s3
                esp32s3dev_16MB_opi_hub75 ;; MoonHub
                esp32s3dev_4MB_qspi_hub75 ;; HD-WF2
+               waveshare_esp32s3_32MB_hub75

.github/workflows/nightly.yml

@@ -29,7 +29,7 @@ jobs:
         uses: janheinrichmerker/action-github-changelog-generator@v2.4
         with:
           token: ${{ secrets.GITHUB_TOKEN }} 
-          sinceTag: v16.0.0
+          sinceTag: v0.15.0
           output: CHANGELOG_NIGHTLY.md
           # Exclude issues that were closed without resolution from changelog
           excludeLabels: 'stale,wontfix,duplicate,invalid,external,question,use-as-is,not_planned'

.github/workflows/usermods.yml

@@ -4,9 +4,6 @@ on:
   pull_request:
     paths:
       - usermods/**
-  push:
-    paths:
-      - usermods/**
 
 env:
   FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
@@ -15,40 +12,28 @@ jobs:
 
   get_usermod_envs:
     # Only run for pull requests from forks (not from branches within wled/WLED)
-    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository
+    if: github.event.pull_request.head.repo.full_name != github.repository
     name: Gather Usermods
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
       with:
-        fetch-depth: 0
-    - name: Get changed usermod environments
+        python-version: '3.12'
+        cache: 'pip'
+    - name: Install PlatformIO
+      run: pip install -r requirements.txt
+    - name: Get default environments
       id: envs
       run: |
-        # Usermods whose directories changed in this PR
-        changed=$(git diff --name-only ${{ github.event.pull_request.base.sha }} HEAD \
-          | grep '^usermods/' | cut -d/ -f2 | sort -u || true)
-
-        # All usermods with a library.json (excluding known-incompatible ones)
-        all=$(find usermods/ -name library.json \
-          | xargs dirname | xargs -n 1 basename \
-          | grep -v PWM_fan | grep -v BME68X_v2 | grep -v pixels_dice_tray \
-          | sort || true)
-
-        if [ -z "$changed" ] || [ -z "$all" ]; then
-          echo "usermods=[]" >> $GITHUB_OUTPUT
-        else
-          usermods=$(comm -12 <(echo "$all") <(echo "$changed") | jq -R | jq --slurp -c)
-          echo "usermods=$usermods" >> $GITHUB_OUTPUT
-        fi
+        echo "usermods=$(find usermods/ -name library.json | xargs dirname | xargs -n 1 basename | jq -R | grep -v PWM_fan | grep -v BME68X_v2| grep -v pixels_dice_tray | jq --slurp -c)" >> $GITHUB_OUTPUT
     outputs:
       usermods: ${{ steps.envs.outputs.usermods }}
 
 
   build:
     # Only run for pull requests from forks (not from branches within wled/WLED)
-    # Skip when no changed usermods were found (e.g. only non-library changes)
-    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository && needs.get_usermod_envs.outputs.usermods != '[]'
+    if: github.event.pull_request.head.repo.full_name != github.repository
     name: Build Enviornments
     runs-on: ubuntu-latest
     needs: get_usermod_envs
@@ -89,85 +74,4 @@ jobs:
         cat platformio_override.ini
 
     - name: Build firmware
-      run: pio run -e ${{ matrix.environment }}
-
-
-  get_custom_build_envs:
-    name: Gather Custom Build Environments
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-    - name: Find usermods with custom build environments
-      id: custom_envs
-      run: |
-        # On PRs: only scan usermods whose directories changed.
-        # On push: scan all usermods (validates the full set on merge).
-        if [ "${{ github.event_name }}" = "pull_request" ]; then
-          changed=$(git diff --name-only ${{ github.event.pull_request.base.sha }} HEAD \
-            | grep '^usermods/' | cut -d/ -f2 | sort -u || true)
-          if [ -z "$changed" ]; then
-            echo "matrix=[]" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-          samples=$(for mod in $changed; do
-            f="usermods/$mod/platformio_override.ini.sample"
-            [ -f "$f" ] && echo "$f"
-          done | sort)
-        else
-          samples=$(find usermods/ -name "platformio_override.ini.sample" | sort)
-        fi
-
-        result='[]'
-        for sample in $samples; do
-          usermod=$(dirname "$sample" | xargs basename)
-          # Skip usermods known to be incompatible (same list as get_usermod_envs)
-          case "$usermod" in PWM_fan|BME68X_v2|pixels_dice_tray) continue ;; esac
-          envs=$(grep -E '^\[env:[^]]+\]' "$sample" | sed 's/^\[env:\(.*\)\]$/\1/')
-          for env in $envs; do
-            result=$(echo "$result" | jq --arg u "$usermod" --arg e "$env" '. + [{usermod: $u, env: $e}]')
-          done
-        done
-        echo "matrix=$(echo "$result" | jq -c '.')" >> $GITHUB_OUTPUT
-    outputs:
-      matrix: ${{ steps.custom_envs.outputs.matrix }}
-
-
-  build_custom:
-    name: Build Custom Env (${{ matrix.usermod }} / ${{ matrix.env }})
-    runs-on: ubuntu-latest
-    needs: get_custom_build_envs
-    if: needs.get_custom_build_envs.outputs.matrix != '[]'
-    strategy:
-      fail-fast: false
-      matrix:
-        include: ${{ fromJSON(needs.get_custom_build_envs.outputs.matrix) }}
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version-file: '.nvmrc'
-        cache: 'npm'
-    - run: npm ci
-    - name: Cache PlatformIO
-      uses: actions/cache@v4
-      with:
-        path: |
-          ~/.platformio/.cache
-          ~/.buildcache
-          build_output
-        key: pio-${{ runner.os }}-${{ matrix.env }}-${{ hashFiles('platformio.ini', 'pio-scripts/output_bins.py') }}-${{ hashFiles('wled00/**', 'usermods/**') }}
-        restore-keys: pio-${{ runner.os }}-${{ matrix.env }}-${{ hashFiles('platformio.ini', 'pio-scripts/output_bins.py') }}-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.12'
-        cache: 'pip'
-    - name: Install PlatformIO
-      run: pip install -r requirements.txt
-    - name: Apply custom build environment
-      run: cp -v "usermods/${{ matrix.usermod }}/platformio_override.ini.sample" platformio_override.ini
-    - name: Build firmware
-      run: pio run -e ${{ matrix.env }}
+      run: pio run -e ${{ matrix.environment }}    

.vscode/extensions.json

@@ -2,7 +2,6 @@
     // See http://go.microsoft.com/fwlink/?LinkId=827846
     // for the documentation about the extensions.json format
     "recommendations": [
-        "pioarduino.pioarduino-ide",
         "platformio.platformio-ide"
     ],
     "unwantedRecommendations": [

AGENTS.md

@@ -17,8 +17,8 @@ Always reference these instructions - including coding guidelines in `docs/` - f
 | `npm run build` | Build web UI into `wled00/html_*.h` / `wled00/js_*.h` | 30s |
 | `npm test` | Run test suite (Node.js built-in `node --test`) | 2 min |
 | `npm run dev` | Watch mode — auto-rebuilds web UI on changes | continuous |
-| `pio run -e esp32dev` | Build firmware (ESP32, most common target) | 5 min |
-| `pio run -e nodemcuv2` | Build firmware (ESP8266) | 5 min |
+| `pio run -e esp32dev` | Build firmware (ESP32, most common target) | 30 min |
+| `pio run -e nodemcuv2` | Build firmware (ESP8266) | 30 min |
 
 **Always run `npm ci && npm run build` before `pio run`.** The web UI build generates
 required C headers for firmware compilation.
@@ -133,8 +133,8 @@ main                # Main development trunk (daily/nightly) 17.0.0-dev. Target
 
 Background Info:
 
-- PSRAM access is up to 15× slower than DRAM on ESP32 (dual-SPI bus), 3–10× slower than DRAM on ESP32-S3/-S2 with quad-SPI bus. On ESP32-S3 with octal PSRAM (`CONFIG_SPIRAM_MODE_OCT`), the penalty is smaller (~2×) because the 8-line DTR bus can transfer 8 bits in parallel. On ESP32-P4 with hex PSRAM (`CONFIG_SPIRAM_MODE_HEX`), the 16-line bus runs at 200 MHz which brings it on-par with DRAM.
-- Consider that ESP32 often crashes when the largest available DRAM chunk gets below 10 KB.
+- PSRAM access is up to 18× slower than DRAM on ESP32 (dual-SPI bus), 3–10× slower than DRAM on ESP32-S3/-S2 with quad-SPI bus. On ESP32-S3 with octal PSRAM (`CONFIG_SPIRAM_MODE_OCT`), the penalty is smaller (~2×) because the 8-line DTR bus can transfer 8 bits in parallel. On ESP32-P4 with hex PSRAM (`CONFIG_SPIRAM_MODE_HEX`), the 16-line bus runs at 200 MHz which brings it on-par with DRAM.
+- Consider that ESP32 often crashes when the largest DRAM chunk gets below 10 KB.
 
 ### Preprocessor / Feature Flags
 - Feature toggling: `WLED_DISABLE_*` and `WLED_ENABLE_*` flags (exact names matter!)

lib/NeoESP32RmtHI/include/NeoEsp32RmtHIMethod.h

@@ -29,7 +29,6 @@ License along with NeoPixel.  If not, see
 #pragma once
 
 #if defined(ARDUINO_ARCH_ESP32)
-#if !defined(WLED_USE_SHARED_RMT) // V5 fix: don't compile this file on unsupported platforms
 
 // Use the NeoEspRmtSpeed types from the driver-based implementation
 #include <NeoPixelBus.h>
@@ -468,4 +467,3 @@ typedef NeoEsp32RmtHI7Ws2805InvertedMethod NeoEsp32RmtHI7Ws2814InvertedMethod;
 #endif // !defined(CONFIG_IDF_TARGET_ESP32C3)
 
 #endif
-#endif

lib/NeoESP32RmtHI/src/NeoEsp32RmtHI.S

@@ -5,17 +5,15 @@
  *
  */
 
-#if defined(__XTENSA__) && defined(ESP32)
-
-#include "esp_idf_version.h"
-#include "sdkconfig.h"
-
-/* If the Bluetooth driver has hooked the high-priority interrupt, we piggyback on it and don't need this. */
-#if !defined(CONFIG_BTDM_CTRL_HLI) && ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
+#if defined(__XTENSA__) && defined(ESP32) && !defined(CONFIG_BTDM_CTRL_HLI)
 
 #include <freertos/xtensa_context.h>
+#include "sdkconfig.h"
 #include "soc/soc.h"
 
+/* If the Bluetooth driver has hooked the high-priority interrupt, we piggyback on it and don't need this. */
+#ifndef CONFIG_BTDM_CTRL_HLI
+
 /*
    Select interrupt based on system check level
    - Base ESP32: could be 4 or 5, depends on platform config
@@ -260,5 +258,6 @@ _highint_stack_switch:
     .global ld_include_hli_vectors_rmt
 ld_include_hli_vectors_rmt:
 
+
 #endif // CONFIG_BTDM_CTRL_HLI
 #endif // XTensa

lib/NeoESP32RmtHI/src/NeoEsp32RmtHIMethod.cpp

@@ -29,7 +29,7 @@ License along with NeoPixel.  If not, see
 
 #include <Arduino.h>
 
-#if defined(ARDUINO_ARCH_ESP32) && ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
+#if defined(ARDUINO_ARCH_ESP32)
 
 #include <algorithm>  
 #include "esp_idf_version.h"
@@ -504,4 +504,4 @@ esp_err_t NeoEsp32RmtHiMethodDriver::WaitForTxDone(rmt_channel_t channel, TickTy
     return rv;
 }
 
-#endif
+#endif

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "wled",
-  "version": "17.0.0-devV5",
+  "version": "16.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "wled",
-      "version": "17.0.0-devV5",
+      "version": "16.0.1",
       "license": "ISC",
       "dependencies": {
         "clean-css": "^5.3.3",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "wled",
-  "version": "17.0.0-devV5",
+  "version": "16.0.1",
   "description": "Tools for WLED project",
   "main": "tools/cdata.js",
   "directories": {

pio-scripts/dynarray.py

@@ -2,7 +2,6 @@
 # This is implemented as a pio post-script to ensure that we can
 # place our linker script at the correct point in the command arguments.
 Import("env")
-import shutil
 from pathlib import Path
 
 # Linker script fragment injected into the rodata output section of whichever
@@ -19,13 +18,7 @@ DYNARRAY_INJECTION = (
 def inject_before_marker(path, marker):
     """Patch a linker script file in-place, inserting DYNARRAY_INJECTION before marker."""
     original = path.read_text()
-    marker_pos = original.find(marker)
-    if marker_pos < 0:
-        raise RuntimeError(
-            f"DYNARRAY injection marker not found in linker script: path={path}, marker={marker!r}"
-        )
-    patched = original[:marker_pos] + DYNARRAY_INJECTION + original[marker_pos:]
-    path.write_text(patched)
+    path.write_text(original.replace(marker, DYNARRAY_INJECTION + marker, 1))
 
 
 if env.get("PIOPLATFORM") == "espressif32":
@@ -45,6 +38,7 @@ if env.get("PIOPLATFORM") == "espressif32":
         # leaves the ASSERTs satisfied.
         build_dir = Path(env.subst("$BUILD_DIR"))
         patched_path = build_dir / "dynarray_sections.ld"
+        import shutil
         shutil.copy(sections_ld_path, patched_path)
         inject_before_marker(patched_path, "_rodata_end = ABSOLUTE(.);")
 

pio-scripts/fastled_cxx_workaround.py

@@ -1,12 +0,0 @@
-# FastLED exports some weak cxx symbols as a way of managing integration with C-only
-# projects that cause it to be preferentially linked instead of unused code being 
-# discarded like other libraries.  This causes not only bloat of the final binaries
-# but can incorrectly invoke some of their driver framework on some platforms.
-#
-# Solve this problem by moving the cxx library up in the linker command line, so
-# that it will be chosen over FastLED's.
-Import("env")
-
-if "-lcxx" in env["LIBS"]:
-  env["LIBS"].remove("-lcxx")
-  env["LIBS"].insert(0, "-lcxx")

pio-scripts/validate_modules.py

@@ -37,14 +37,14 @@ def check_elf_modules(elf_path: Path, env, module_lib_builders) -> set[str]:
         Returns the set of build_dir basenames for confirmed modules.
     """
     readelf_path = _get_readelf_path(env)
+    secho(f"INFO: Checking for usermod compilation units...")
+
     try:
         result = subprocess.run(
             [readelf_path, "--debug-dump=info", "--dwarf-depth=1", str(elf_path)],
             capture_output=True, text=True, errors="ignore", timeout=120,
         )
         output = result.stdout
-        if result.returncode != 0 or result.stderr.strip():
-            secho(f"WARNING: readelf exited {result.returncode}: {result.stderr.strip()}", fg="yellow", err=True)
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as e:
         secho(f"WARNING: readelf failed ({e}); skipping per-module validation", fg="yellow", err=True)
         return {Path(b.build_dir).name for b in module_lib_builders}  # conservative pass
@@ -143,27 +143,20 @@ def validate_map_file(source, target, env):
         Exit(1)
 
     # Identify the WLED module builders, set by load_usermods.py
-    module_lib_builders = env.get('WLED_MODULES')
-    if module_lib_builders is None:
-        secho("ERROR: WLED_MODULES not set — ensure load_usermods.py is run as a pre: script", fg="red", err=True)
-        Exit(1)
+    module_lib_builders = env['WLED_MODULES']
 
     # Extract the values we care about
     modules = {Path(builder.build_dir).name: builder.name for builder in module_lib_builders}
-    secho(f"INFO: {len(modules)} libraries included as WLED optional/user modules")
+    secho(f"INFO: {len(modules)} libraries linked as WLED optional/user modules")
 
     # Now parse the map file
     map_file_contents = read_lines(map_file_path)
     usermod_object_count = count_usermod_objects(map_file_contents)
-    secho(f"INFO: {usermod_object_count} usermod object entries found")
+    secho(f"INFO: {usermod_object_count} usermod object entries")
 
     elf_path = build_dir / env.subst("${PROGNAME}.elf")
 
     confirmed_modules = check_elf_modules(elf_path, env, module_lib_builders)
-    if confirmed_modules:
-        secho(f"INFO: Code from usermod libraries found in binary: {', '.join(confirmed_modules)}")
-    # else - if there's no usermods found, don't generate a message.  If we're legitimately missing all entries, the error report on the
-    # next line will trip; and if the usermod set is expected to be empty, then there's no need for yet another null message.
 
     missing_modules = [modname for mdir, modname in modules.items() if mdir not in confirmed_modules]
     if missing_modules:

platformio.ini

@@ -10,41 +10,29 @@
 # ------------------------------------------------------------------------------
 
 # CI/release binaries
-default_envs =
-               ; nodemcuv2
-               ; esp8266_2m
-               ; esp01_1m_full
-               nodemcuv2_160   ;; 8266 regression test build
-               ; esp8266_2m_160
-               ; esp01_1m_full_160
-               ; nodemcuv2_compat
-               ; esp8266_2m_compat
-               ; esp01_1m_full_compat
-               esp32dev_V4  ;; V4 regression test build
+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_debug
                esp32_eth
                esp32_wrover
-               lolin_s2_mini ;; TODO: disabled NeoEsp32RmtMethodIsr
+               lolin_s2_mini
                esp32c3dev
-               esp32c6dev_4MB
-               ; esp32c6dev_8MB
-               esp32c5dev
-               esp32c5dev_8MB_qspi
-               esp32p4_16MB      ;; P4 360 Mhz 16MB flash - experimental
-               ; esp32p4_32MB
-               ; esp32P4_400  ;; P4 rev3 400 Mhz - not usable yet
-               ; esp32s3dev_16MB_opi ;; TODO: disabled NeoEsp32RmtMethodIsr
-               ; esp32s3dev_8MB_opi ;; TODO: disabled NeoEsp32RmtMethodIsr
-               esp32s3_4M_qspi ;; TODO: disabled NeoEsp32RmtMethodIsr
                esp32c3dev_qio
-;               esp32S3_wroom2 ;; TODO: disabled NeoEsp32RmtMethodIsr
-;               esp32s3dev_16MB_opi ;; TODO: disabled NeoEsp32RmtMethodIsr
-               esp32s3dev_8MB_opi ;; TODO: disabled NeoEsp32RmtMethodIsr
-;               esp32s3dev_8MB_qspi ;; TODO: disabled NeoEsp32RmtMethodIsr
-;               esp32s3dev_8MB_none ;; TODO: disabled NeoEsp32RmtMethodIsr
-;               esp32s3_4M_qspi ;; TODO: disabled NeoEsp32RmtMethodIsr
-              ; usermods ;; TODO: disabled until the core is building
+               esp32S3_wroom2
+               esp32s3dev_16MB_opi
+               esp32s3dev_8MB_opi
+               esp32s3dev_8MB_qspi
+               esp32s3dev_8MB_none
+               esp32s3_4M_qspi
+               usermods
 
 src_dir  = ./wled00
 data_dir = ./wled00/data
@@ -54,6 +42,40 @@ extra_configs =
   platformio_release.ini
 
 [common]
+# ------------------------------------------------------------------------------
+# PLATFORM:
+#   !! DO NOT confuse platformio's ESP8266 development platform with Arduino core for ESP8266
+#
+#   arduino core 2.6.3 = platformIO 2.3.2
+#   arduino core 2.7.0 = platformIO 2.5.0
+# ------------------------------------------------------------------------------
+arduino_core_2_6_3 = espressif8266@2.3.3
+arduino_core_2_7_4 = espressif8266@2.6.2
+arduino_core_3_0_0 = espressif8266@3.0.0
+arduino_core_3_0_2 = espressif8266@3.2.0
+arduino_core_3_1_0 = espressif8266@4.1.0
+arduino_core_3_1_2 = espressif8266@4.2.1
+
+# Development platforms
+arduino_core_develop = https://github.com/platformio/platform-espressif8266#develop
+arduino_core_git = https://github.com/platformio/platform-espressif8266#feature/stage
+
+# Platform to use for ESP8266
+platform_wled_default = ${common.arduino_core_3_1_2}
+# We use 2.7.4.7 for all, includes PWM flicker fix and Wstring optimization
+#platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
+platform_packages = platformio/toolchain-xtensa @ ~2.100300.220621 #2.40802.200502
+                    platformio/tool-esptool #@ ~1.413.0
+                    platformio/tool-esptoolpy #@ ~1.30000.0
+
+## previous platform for 8266, in case of problems with the new one
+## you'll need  makuna/NeoPixelBus@ 2.6.9 for arduino_core_3_0_2, which does not support Ucs890x
+;; platform_wled_default = ${common.arduino_core_3_0_2}
+;; platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
+;;                    platformio/toolchain-xtensa @ ~2.40802.200502
+;;                    platformio/tool-esptool @ ~1.413.0
+;;                    platformio/tool-esptoolpy @ ~1.30000.0
+
 # ------------------------------------------------------------------------------
 # FLAGS: DEBUG
 # esp8266 : see https://docs.platformio.org/en/latest/platforms/espressif8266.html#debug-level
@@ -110,9 +132,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
-;; default_usermods = wizlights animartrix ;; for testing
-
 [scripts_defaults]
 extra_scripts =
   pre:pio-scripts/set_metadata.py
@@ -122,7 +141,6 @@ extra_scripts =
   pre:pio-scripts/user_config_copy.py
   pre:pio-scripts/load_usermods.py
   pre:pio-scripts/build_ui.py
-  ;;post:pio-scripts/fastled_cxx_workaround.py
   post:pio-scripts/validate_modules.py  ;; double-check the build output usermods
   ; post:pio-scripts/obj-dump.py  ;; convenience script to create a disassembly dump of the firmware (hardcore debugging)
 
@@ -145,57 +163,37 @@ upload_speed = 115200
 # ------------------------------------------------------------------------------
 lib_compat_mode = strict
 lib_deps =
-    ;; IRremoteESP8266 @ 2.8.2
-    ;; https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.2
-    ;; https://github.com/Makuna/NeoPixelBus.git#1d7ff38f14d04a976f9c6e365c83a232bcba04fc
-    crankyoldgit/IRremoteESP8266 @ 2.9.0
-    ;; neopixelbus dependancy moved into [8266] and [esp32_all_variants] sections
-    ESPAsyncWebServerWLED = git+https://github.com/Aircoookie/ESPAsyncWebServer#ac44e32abf2a69ae650412fb6bc193c59ccac38a
+    IRremoteESP8266 @ 2.8.2
+    https://github.com/Makuna/NeoPixelBus.git#1d7ff38f14d04a976f9c6e365c83a232bcba04fc
+    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.2
     marvinroger/AsyncMqttClient @ 0.9.0
   # for I2C interface
     ;Wire
   # ESP-NOW library
     ;gmag11/QuickESPNow @ ~0.7.0
     https://github.com/blazoncek/QuickESPNow.git#optional-debug
+  #For use of the TTGO T-Display ESP32 Module with integrated TFT display uncomment the following line
+    #TFT_eSPI
+  #For compatible OLED display uncomment following
+    #olikraus/U8g2 #@ ~2.33.15
+  #For Dallas sensor uncomment following
+    #paulstoffregen/OneWire @ ~2.3.8
+  #For BME280 sensor uncomment following
+    #BME280 @ ~3.0.0
+    ;adafruit/Adafruit BMP280 Library @ 2.1.0
+    ;adafruit/Adafruit CCS811 Library @ 1.0.4
+    ;adafruit/Adafruit Si7021 Library @ 1.4.0
+  #For MAX1704x Lipo Monitor / Fuel Gauge uncomment following
+    ; https://github.com/adafruit/Adafruit_BusIO @ 1.14.5
+    ; https://github.com/adafruit/Adafruit_MAX1704X @ 1.0.2
+  #For MPU6050 IMU uncomment follwoing
+    ;electroniccats/MPU6050 @1.0.1
+  # SHT85
+    ;robtillaart/SHT85@~0.3.3
 
 extra_scripts = ${scripts_defaults.extra_scripts}
 
 [esp8266]
-# ------------------------------------------------------------------------------
-# PLATFORM:
-#   !! DO NOT confuse platformio's ESP8266 development platform with Arduino core for ESP8266
-#
-#   arduino core 2.6.3 = platformIO 2.3.2
-#   arduino core 2.7.0 = platformIO 2.5.0
-# ------------------------------------------------------------------------------
-arduino_core_2_6_3 = espressif8266@2.3.3
-arduino_core_2_7_4 = espressif8266@2.6.2
-arduino_core_3_0_0 = espressif8266@3.0.0
-arduino_core_3_0_2 = espressif8266@3.2.0
-arduino_core_3_1_0 = espressif8266@4.1.0
-arduino_core_3_1_2 = espressif8266@4.2.1
-
-# Development platforms
-arduino_core_develop = https://github.com/platformio/platform-espressif8266#develop
-arduino_core_git = https://github.com/platformio/platform-espressif8266#feature/stage
-
-# Platform to use for ESP8266
-platform_wled_default = ${esp8266.arduino_core_3_1_2}
-# We use 2.7.4.7 for all, includes PWM flicker fix and Wstring optimization
-#platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
-platform_packages = platformio/toolchain-xtensa @ ~2.100300.220621 #2.40802.200502
-                    platformio/tool-esptool #@ ~1.413.0
-                    platformio/tool-esptoolpy #@ ~1.30000.0
-
-## previous platform for 8266, in case of problems with the new one
-## you'll need  makuna/NeoPixelBus@ 2.6.9 for arduino_core_3_0_2, which does not support Ucs890x
-;; platform_wled_default = ${esp8266.arduino_core_3_0_2}
-;; platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
-;;                    platformio/toolchain-xtensa @ ~2.40802.200502
-;;                    platformio/tool-esptool @ ~1.413.0
-;;                    platformio/tool-esptoolpy @ ~1.30000.0
-
-platform = ${esp8266.platform_wled_default}
 build_unflags = ${common.build_unflags}
 custom_usermods = 
 build_flags =
@@ -220,6 +218,7 @@ build_flags =
   -D PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48 ;; in case of linker errors like "section `.text1' will not fit in region `iram1_0_seg'"
   ; -D PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48_SECHEAP_SHARED ;; (experimental) adds some extra heap, but may cause slowdown
   -D NON32XFER_HANDLER ;; ask forgiveness for PROGMEM misuse
+
 lib_deps =
   #https://github.com/lorol/LITTLEFS.git
   ESPAsyncTCP @ 1.2.2
@@ -227,9 +226,6 @@ lib_deps =
   ESP8266PWM
   https://github.com/tignioj/ArduinoUZlib.git#20aff95cd80c141f80bdbf66895409a0046d2c2f
   ${env.lib_deps}
-  https://github.com/Makuna/NeoPixelBus.git#1d7ff38f14d04a976f9c6e365c83a232bcba04fc ;; standard NPB version used in main branch
-
-monitor_filters = esp8266_exception_decoder
 
 ;; compatibilty flags - same as 0.14.0 which seems to work better on some 8266 boards. Not using PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48
 build_flags_compat =
@@ -264,23 +260,20 @@ lib_deps_compat =
 
 [esp32_all_variants]
 lib_deps =
-  esp32async/AsyncTCP @ 3.4.10
+  esp32async/AsyncTCP @ 3.4.7
   bitbank2/AnimatedGIF@^1.4.7
   https://github.com/Aircoookie/GifDecoder.git#bc3af189b6b1e06946569f6b4287f0b79a860f8e
-  NeoPixelBus = git+https://github.com/Makuna/NeoPixelBus#76afe832f74b0738a3fa1bba0caf389ade9e7693 ;; CORE3 branch
 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 = ${esp32_idf_V4.platform}
 platform_packages =
-build_unflags = ${esp32_idf_V5.build_unflags}
-build_flags = ${esp32_idf_V5.build_flags}
-lib_deps = ${esp32_idf_V5.lib_deps}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
-monitor_filters = esp32_exception_decoder
+build_unflags = ${common.build_unflags}
+build_flags = ${esp32_idf_V4.build_flags}
+lib_deps = ${esp32_idf_V4.lib_deps}
 
 tiny_partitions = tools/WLED_ESP32_2MB_noOTA.csv
 default_partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
@@ -294,6 +287,7 @@ board_build.partitions = ${esp32.default_partitions}   ;; default partioning for
 AR_build_flags = ;; -fsingle-precision-constant ;; forces ArduinoFFT to use float math (2x faster)
 AR_lib_deps =  ;; for pre-usermod-library platformio_override compatibility
 
+
 [esp32_idf_V4]
 ;; build environment for ESP32 using ESP-IDF 4.4.x / arduino-esp32 v2.0.5
 ;; *** important: build flags from esp32_idf_V4 are inherited by _all_ esp32-based MCUs: esp32, esp32s2, esp32s3, esp32c3
@@ -323,45 +317,12 @@ lib_deps =
   ${esp32_all_variants.lib_deps}
   https://github.com/someweisguy/esp_dmx.git#47db25d8c515e76fabcf5fc5ab0b786f98eeade0
   ${env.lib_deps}
-lib_ignore = 
-
-[esp32_idf_V5]
-;; build environment for ESP32 using ESP-IDF 5.3.4 / arduino-esp32 v3.1.10
-platform = https://github.com/tasmota/platform-espressif32/releases/download/2026.02.30/platform-espressif32.zip
-platform_packages =
-build_unflags = ${common.build_unflags}
-  -Wno-volatile ;; avoid warning on .c files: "-Wno-volatile only applies to c++ files"
-build_flags = -g
-  ;;-Wno-deprecated        ;; disables a ton of  warnings: implicit capture of 'this' via '[=]' is deprecated in C++20 [-Wdeprecated]
-  -Wshadow=compatible-local ;; emit warning in case a local variable "shadows" another local one
-  -DARDUINO_ARCH_ESP32
-  ; -DESP32=ESP32 ;; disabled to avoid compiler warning: "ESP32" redefined
-  ${esp32_all_variants.build_flags}
-  -D WLED_USE_SHARED_RMT     ;; ToDO: check if NeoESP32RmtHI is still needed with V5 (see discussion in PR#4838)
-  -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 ESP32_ARDUINO_NO_RGB_BUILTIN ;; avoids RMT driver abort on startup "E (98) rmt(legacy): CONFLICT! driver_ng is not allowed to be used with the legacy driver"
-lib_deps =
-  ${esp32_all_variants.lib_deps}
-  https://github.com/netmindz/esp_dmx/#esp-idf-v5-fixes  ;; TODO: need an upstream update for V5
-  ${env.lib_deps}
-lib_ignore =
-  NeoESP32RmtHI
-
-[v5_pioarduino_workaround]
-# This is a disgusting workaround for a pioarduino "feature": if you don't ever mention lib_archive in your platformio.ini
-# it forces it off globally, causing unused code from all libraries to be included even if you don't use it.
-# This causes FastLED to activate its driver framework, stealing hardware resources we want to use.
-# To work around this, all that we have to do is mention lib_archive in any section, even if it's never used; then
-# pioarduino believes we know what we're doing, and lets us do what we want.
-lib_archive = yes
 
 [esp32s2]
 ;; generic definitions for all ESP32-S2 boards
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
-build_unflags = ${esp32_idf_V5.build_unflags}
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
+build_unflags = ${common.build_unflags}
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32S2
@@ -371,18 +332,16 @@ 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_idf_V4.build_flags}
 lib_deps =
-  ${esp32_idf_V5.lib_deps}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
+  ${esp32_idf_V4.lib_deps}
 board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
-monitor_filters = esp32_exception_decoder
 
 [esp32c3]
 ;; generic definitions for all ESP32-C3 boards
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
-build_unflags = ${esp32_idf_V5.build_unflags}
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
+build_unflags = ${common.build_unflags}
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32C3
@@ -391,21 +350,19 @@ 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_idf_V4.build_flags}
 lib_deps =
-  ${esp32_idf_V5.lib_deps}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
+  ${esp32_idf_V4.lib_deps}
 board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
 board_build.flash_mode = qio
-monitor_filters = esp32_exception_decoder
 
 [esp32s3]
 ;; generic definitions for all ESP32-S3 boards
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
-build_unflags = ${esp32_idf_V5.build_unflags}
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
+build_unflags = ${common.build_unflags}
 build_flags = -g
-  ;; -DESP32  ;; disabled to avoid compiler warning: "ESP32" redefined
+  -DESP32
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32S3
   -DCONFIG_IDF_TARGET_ESP32S3=1
@@ -413,242 +370,26 @@ 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_idf_V4.build_flags}
 lib_deps =
-  ${esp32_idf_V5.lib_deps}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
+  ${esp32_idf_V4.lib_deps}
 board_build.partitions = ${esp32.large_partitions}   ;; default partioning for 8MB flash - can be overridden in build envs
-upload_speed = 921600
-monitor_filters = esp32_exception_decoder
 
-[esp32c5]
-;; generic definitions for all ESP32-C5 boards
-;; NOTE: ESP32-C5 requires pioarduino platform (Tasmota framework doesn't include C5 Arduino libs yet)
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.37/platform-espressif32.zip
-platform_packages =
-build_unflags = ${esp32_idf_V5.build_unflags}
-  -D WLED_ENABLE_DMX_INPUT  ;; esp_dmx library doesn't support C5 UART registers yet
-build_flags = -g
-  -Wshadow=compatible-local
-  -DARDUINO_ARCH_ESP32
-  -DARDUINO_ARCH_ESP32C5
-  -DCONFIG_IDF_TARGET_ESP32C5=1
-  -D CONFIG_ASYNC_TCP_USE_WDT=0
-  -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}
-lib_deps =
-  ${esp32_all_variants.lib_deps}
-  ${env.lib_deps}
-  ;; NeoPixelBus = https://github.com/jonny190/NeoPixelBus.git#wled-c5-stable ;; jonny190 wled-c5-stable fork C5 support: I2S exclusion, bit-bang CSR/GPIO, channel ctor overload
-lib_ignore = ${esp32_idf_V5.lib_ignore}
-  esp_dmx  ;; esp_dmx library doesn't support C5 UART registers yet
-
-[esp32c6]
-;; generic definitions for all ESP32-C6 boards
-platform = ${esp32_idf_V5.platform}
-platform_packages =  ${esp32_idf_V5.platform_packages}
-;;platform_packages =
-;;  framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#3.0.1
-;;  framework-arduinoespressif32-libs @ https://github.com/espressif/arduino-esp32/releases/download/3.0.1/esp32-arduino-libs-3.0.1.zip
-
-;; board = esp32-c6-devkitm-1 ;; board must be defined in the lower-level [env:*] buildenvs for C6-based boards
-build_unflags = ${esp32_idf_V5.build_unflags}
-build_flags = -g
-  -DARDUINO_ARCH_ESP32
-  -DARDUINO_ARCH_ESP32C6
-  -DCONFIG_IDF_TARGET_ESP32C6=1
-  -D CONFIG_ASYNC_TCP_USE_WDT=0
-  -DCO
-  -DARDUINO_USB_MODE=1 ;; this flag is - most likely - mandatory for ESP32-C6
-  ;; 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}
-lib_deps = ${esp32_idf_V5.lib_deps}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
-
-[esp32p4]
-;; !! Important: if your board shows errors when trying to start WiFi, the C6 coprocessor might need a firmware update.
-;; !! go here ==> https://esp32-c6-firmware-update.github.io/
-;; 
-;; generic definitions for all ESP32-P4 boards. TODO: make wifi work by using esp-hosted networking
-;; Using latest tasmota framework - older frameworks only have minimal support for P4
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.37/platform-espressif32.zip
-platform_packages =
-build_unflags = ${esp32_idf_V5.build_unflags}
-  -D WLED_ENABLE_DMX_INPUT ;; library not compatible with -P4
-  -D WLED_ENABLE_DMX       ;; DMX serial out needs adaptations for P4 compatibility
-build_flags = -g
-  -DARDUINO_ARCH_ESP32
-  -DARDUINO_ARCH_ESP32P4
-  -DCONFIG_IDF_TARGET_ESP32P4=1
-  -D CONFIG_ASYNC_TCP_USE_WDT=0
-  -DCO
-  -DARDUINO_USB_MODE=1 ;; this flag is - most likely - mandatory for ESP32-P4
-  -D WLED_DISABLE_INFRARED       ;; library not compatible with -P4
-  -D WLED_DISABLE_ESPNOW         ;; not yet tested
-  ;; 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}
-
-lib_deps = ${esp32_idf_V5.lib_deps}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
-  IRremoteESP8266 ; TODo: remove once we have a version thats compatible
-  QuickEspNow     ; ToDO: disabled until we find a compatible version
-  esp_dmx         ; ToDO: disabled until we find a compatible version
-
-
-# ------------------------------------------------------------------------------
-# EXPERIMENTAL: WLED NEW MCU BUILDS (-C5, -C6, -P4)
-# ------------------------------------------------------------------------------
-
-[env:esp32c6dev_8MB]
-;; ESP32-C6 "devkit C" with 8MB flash
-extends = esp32c6
-platform = ${esp32c6.platform}
-platform_packages = ${esp32c6.platform_packages}
-board = esp32-c6-devkitc-1
-
-build_unflags = ${esp32c6.build_unflags}
-  ;;-D CORE_DEBUG_LEVEL=0
-  ;;-D NDEBUG
-build_flags = ${common.build_flags} ${esp32c6.build_flags} -D WLED_RELEASE_NAME=\"ESP32-C6_8MB\"
-  -Wno-volatile -Wno-deprecated-declarations ;; silence compiler warnings
-  ;; -Wno-cpp                                   ;; silence '#pragma warning' messages
-  ;;-D DEBUG -g3 -ggdb
-  ;;-D CORE_DEBUG_LEVEL=4
-  -D WLED_WATCHDOG_TIMEOUT=0
-  ;; -DLOLIN_WIFI_FIX ; might be needed on "-C6 mini"
-  ;;-DARDUINO_USB_CDC_ON_BOOT=1 ;; for virtual CDC USB
-  -DARDUINO_USB_CDC_ON_BOOT=0   ;; for serial-to-USB chip
-  -D WLED_DISABLE_INFRARED     ;; library not not compatible with -C6
-  -D WLED_DISABLE_ESPNOW       ;; ToDO: temporarily disabled, until we find a solution for esp-now build errors with -C6
-upload_speed = 460800
-lib_deps = ${esp32c6.lib_deps}
-lib_ignore = ${esp32c6.lib_ignore}
-  IRremoteESP8266 ; use with WLED_DISABLE_INFRARED for faster compilation
-  QuickEspNow     ; ToDO: disabled until we find a compatible version
-
-board_build.partitions = ${esp32.large_partitions}
-board_build.f_flash = 80000000L
-board_build.flash_mode = qio
-board_build.arduino.memory_type = qio_qspi
-monitor_filters = esp32_exception_decoder
-
-[env:esp32c6dev_4MB]
-;; ESP32-C6 "devkit M" with 4MB flash
-extends = env:esp32c6dev_8MB
-board = esp32-c6-devkitm-1
-board_build.partitions = ${esp32.default_partitions}
-build_unflags = ${env:esp32c6dev_8MB.build_unflags} -D WLED_RELEASE_NAME=\"ESP32-C6_8MB\"
-build_flags = ${env:esp32c6dev_8MB.build_flags}     -D WLED_RELEASE_NAME=\"ESP32-C6_4MB\"
-monitor_filters = esp32_exception_decoder
-
-
-[env:esp32c5dev]
-;; ESP32-C5 "devkit C" with 4MB flash, no PSRAM - EXPERIMENTAL
-extends = esp32c5
-board = esp32-c5-devkitc-1
-board_build.f_flash = 80000000L
-board_build.flash_mode = qio
-board_build.arduino.memory_type = qio_qspi  ;; flash config only, this board has no PSRAM
-
-build_flags = ${common.build_flags} ${esp32c5.build_flags} -D WLED_RELEASE_NAME=\"ESP32-C5\"
-  -Wno-volatile -Wno-deprecated-declarations
-  -D WLED_WATCHDOG_TIMEOUT=0
-  -DARDUINO_USB_MODE=1            ;; this flag is mandatory for ESP32-C5
-  -DARDUINO_USB_CDC_ON_BOOT=0     ;; for serial-to-USB chip
-  -D WLED_DISABLE_INFRARED       ;; library not compatible with -C5
-  -D WLED_DISABLE_ESPNOW         ;; ToDO: ESP-NOW support not yet tested
-  ;; -D WLED_DEBUG
-lib_ignore = ${esp32c5.lib_ignore}
-  IRremoteESP8266
-  QuickEspNow       ;; ToDO: ESP-NOW support not yet tested
-
-board_build.partitions = ${esp32.big_partitions}
-upload_speed = 460800
-monitor_filters = esp32_exception_decoder
-
-[env:esp32c5dev_8MB_qspi]
-;; ESP32-C5 with 8MB flash and PSRAM - EXPERIMENTAL
-extends = esp32c5
-board = esp32-c5-devkitc1-n8r4
-board_build.f_flash = 80000000L
-board_build.flash_mode = qio
-board_build.arduino.memory_type = qio_qspi  ;; this board has PSRAM
-
-build_flags = ${common.build_flags} ${esp32c5.build_flags} -D WLED_RELEASE_NAME=\"ESP32-C5_8MB_qspi\"
-  -Wno-volatile -Wno-deprecated-declarations
-  -D BOARD_HAS_PSRAM
-  -D WLED_WATCHDOG_TIMEOUT=0
-  -DARDUINO_USB_MODE=1            ;; this flag is mandatory for ESP32-C5
-  -DARDUINO_USB_CDC_ON_BOOT=0     ;; for serial-to-USB chip
-  -D WLED_DISABLE_INFRARED       ;; library not compatible with -C5
-  -D WLED_DISABLE_ESPNOW         ;; ToDO: ESP-NOW support not yet tested
-  ;; -D WLED_DEBUG
-lib_ignore = ${esp32c5.lib_ignore}
-  IRremoteESP8266
-  QuickEspNow                    ;; ToDO: ESP-NOW support not yet tested
-
-board_build.partitions = ${esp32.large_partitions}
-board_upload.flash_size = 8MB
-board_upload.maximum_size = 8388608
-upload_speed = 460800
-monitor_filters = esp32_exception_decoder
-
-
-[env:esp32p4_16MB]
-;; (experimental) ESP32-P4 with 16 MB Flash, 32MB PSRAM
-;; https://www.waveshare.com/esp32-p4-nano.htm
-extends = esp32p4
-platform = ${esp32p4.platform}
-platform_packages = ${esp32p4.platform_packages}
-board = esp32-p4-evboard       ;; P4 eval board, 360Mhz
-;; board = esp32-p4_r3-evboard ;; P4 eval board with "revision 3" CPU, 400Mhz
-;; board = esp32-p4    ;; 360Mhz
-;; board = esp32-p4_r3 ;; 400Mhz
-
-board_build.flash_mode = qio
-board_build.partitions = ${esp32.extreme_partitions}   ;; for 16MB Flash
-build_unflags = ${esp32p4.build_unflags}
-  ;; -DCORE_DEBUG_LEVEL=0
-  ;; -flto
-build_flags = ${common.build_flags} ${esp32p4.build_flags}  -D WLED_RELEASE_NAME=\"ESP32-P4_16MB\" -DBOARD_HAS_PSRAM
-  ;; -D WLED_DEBUG
-  ;; -DCORE_DEBUG_LEVEL=3 -g3 -ggdb -fno-lto
-lib_ignore = ${esp32p4.lib_ignore}
-upload_speed = 460800
-monitor_filters = esp32_exception_decoder
-
-[env:esp32p4_32MB]
-;; (experimental) ESP32-P4 with 32 MB Flash, 32MB PSRAM
-extends = esp32p4
-board = esp32-p4-evboard       ;; P4 eval board, 360Mhz
-;;board = esp32-p4_r3-evboard  ;; P4 eval board with "revision 3" CPU, 400Mhz
-board_build.flash_mode = qio
-board_build.partitions = tools/WLED_ESP32_32MB.csv
-;;build_type = debug
-build_unflags = ${esp32p4.build_unflags}
-  ;; -DCORE_DEBUG_LEVEL=0
-  ;; -flto
-build_flags = ${common.build_flags} ${esp32p4.build_flags}  -D WLED_RELEASE_NAME=\"ESP32-P4_32MB\" -DBOARD_HAS_PSRAM
-  ;; -D WLED_DEBUG
-  ;; -DCORE_DEBUG_LEVEL=3 -g3 -ggdb -fno-lto
-upload_speed = 460800
-monitor_filters = esp32_exception_decoder
 
 # ------------------------------------------------------------------------------
 # WLED BUILDS
 # ------------------------------------------------------------------------------
 
 [env:nodemcuv2]
-extends = esp8266
 board = nodemcuv2
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
+build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP8266\" #-DWLED_DISABLE_2D
   -D WLED_DISABLE_PARTICLESYSTEM2D
+lib_deps = ${esp8266.lib_deps}
+monitor_filters = esp8266_exception_decoder
 custom_usermods = audioreactive
 
 [env:nodemcuv2_compat]
@@ -666,15 +407,18 @@ 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]
-extends = esp8266
 board = esp_wroom_02
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
+build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP02\"
   -D WLED_DISABLE_PARTICLESYSTEM2D
   -D WLED_DISABLE_PARTICLESYSTEM1D
+lib_deps = ${esp8266.lib_deps}
 custom_usermods = audioreactive
 
 [env:esp8266_2m_compat]
@@ -693,13 +437,13 @@ 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:esp8266_2m_min]
 ;; Minimal-feature build for ESP02 (2MB flash).
 ;; Use this to recover from a failed OTA: flash via serial, then OTA-upload the regular esp8266_2m binary.
 ;; OTA is intentionally kept enabled. All other optional features are stripped to minimise binary size.
-extends = esp8266
+extends = env:esp8266_2m
 board = esp_wroom_02
 board_build.ldscript = ${common.ldscript_2m512k}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP02_min\"
@@ -718,14 +462,17 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=
   -D WLED_DISABLE_IMPROV_WIFISCAN
 
 [env:esp01_1m_full]
-extends = esp8266
 board = esp01_1m
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_1m128k}
+build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP01\" -D WLED_DISABLE_OTA
   ; -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
   -D WLED_DISABLE_PIXELFORGE
+lib_deps = ${esp8266.lib_deps}
 
 [env:esp01_1m_full_compat]
 extends = env:esp01_1m_full
@@ -747,117 +494,95 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=
   -D WLED_DISABLE_PIXELFORGE
 ;; custom_usermods = audioreactive ;; pushed program flash size over the limits
 
-[env:esp32dev_V4]
-;; uses V4 framework - for checking that the code still builds in V4
+[env:esp32dev]
 board = esp32dev
 platform = ${esp32_idf_V4.platform}
 platform_packages = ${esp32_idf_V4.platform_packages}
-build_unflags = ${esp32_idf_V4.build_unflags}
-  -D WLED_ENABLE_DMX_INPUT ;; TODO: fix lots of compile errors in dmx_input.cpp
-custom_usermods = ${common.default_usermods}
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_V4\" #-D WLED_DISABLE_BROWNOUT_DET
+build_unflags = ${common.build_unflags}
+custom_usermods = audioreactive
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32\" #-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
-              -D WLED_USE_ETHERNET -D RLYPIN=-1 -D BTNPIN=-1 ;; TODO: this is just for testing - remove before merging to main 
 lib_deps = ${esp32_idf_V4.lib_deps}
-lib_ignore = ${esp32_idf_V4.lib_ignore}
-  esp_dmx                     ;; TODO: fix lots of compile errors in dmx_input.cpp
-monitor_filters = esp32_exception_decoder
-board_build.partitions = ${esp32.default_partitions}
-board_build.flash_mode = dio
-
-[env:esp32dev]
-board = esp32dev
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
-build_unflags = ${esp32_idf_V5.build_unflags}
-custom_usermods = ${common.default_usermods}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32\" #-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}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.default_partitions}
 board_build.flash_mode = dio
 
 [env:esp32dev_debug]
 extends = env:esp32dev
-build_type = debug
-monitor_filters = esp32_exception_decoder
 upload_speed = 921600
-build_unflags = ${esp32_idf_V5.build_unflags}
-              -D WLED_RELEASE_NAME=\"ESP32\"
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags}
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags}
               -D WLED_DEBUG
               -D WLED_RELEASE_NAME=\"ESP32_DEBUG\"
-              -DARDUINO_USB_CDC_ON_BOOT=0
+
 [env:esp32dev_8M]
 board = esp32dev
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
-custom_usermods = ${common.default_usermods}
-build_unflags = ${esp32_idf_V5.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_8M\" #-D WLED_DISABLE_BROWNOUT_DET
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
+custom_usermods = audioreactive
+build_unflags = ${common.build_unflags}
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_8M\" #-D WLED_DISABLE_BROWNOUT_DET
   -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}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
+lib_deps = ${esp32_idf_V4.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.large_partitions}
 board_upload.flash_size = 8MB
 board_upload.maximum_size = 8388608
 ; board_build.f_flash = 80000000L
+board_build.flash_mode = dio
 
 [env:esp32dev_16M]
 board = esp32dev
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
-custom_usermods = ${common.default_usermods}
-build_unflags = ${esp32_idf_V5.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_16M\" #-D WLED_DISABLE_BROWNOUT_DET
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
+custom_usermods = audioreactive
+build_unflags = ${common.build_unflags}
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_16M\" #-D WLED_DISABLE_BROWNOUT_DET
               -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}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
+lib_deps = ${esp32_idf_V4.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.extreme_partitions}
 board_upload.flash_size = 16MB
 board_upload.maximum_size = 16777216
 board_build.f_flash = 80000000L
+board_build.flash_mode = dio
 
 [env:esp32_eth]
-extends = esp32
 board = esp32-poe
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
 upload_speed = 921600
-custom_usermods = ${common.default_usermods}
-build_unflags = ${esp32_idf_V5.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_Ethernet\" -D RLYPIN=-1 -D WLED_USE_ETHERNET -D BTNPIN=-1
-              -D SR_DMTYPE=-1 -D AUDIOPIN=-1 -D I2S_SDPIN=-1 -D I2S_WSPIN=-1 -D I2S_CKPIN=-1 -D MCLK_PIN=-1 ;; force AR to not allocate any PINs at startup
-              -D DATA_PINS=4 ;; default led pin = 16 conflicts with pins used for ethernet
-              ; -D WLED_DISABLE_ESPNOW ;; ESP-NOW requires wifi, may crash with ethernet only => uncomment if your board uses ETH_CLOCK_GPIO0_OUT, ETH_CLOCK_GPIO16_OUT, ETH_CLOCK_GPIO17_OUT
-              -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
-;  -D WLED_DISABLE_ESPNOW ;; ESP-NOW requires wifi, may crash with ethernet only
-lib_deps = ${esp32_idf_V5.lib_deps}
-lib_ignore = ${esp32_idf_V5.lib_ignore}
+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 SR_DMTYPE=-1 -D AUDIOPIN=-1 -D I2S_SDPIN=-1 -D I2S_WSPIN=-1 -D I2S_CKPIN=-1 -D MCLK_PIN=-1 ;; force AR to not allocate any PINs at startup
+  -D DATA_PINS=4 ;; default led pin = 16 conflicts with pins used for ethernet
+  ; -D WLED_DISABLE_ESPNOW ;; ESP-NOW requires wifi, may crash with ethernet only => uncomment if your board uses ETH_CLOCK_GPIO0_OUT, ETH_CLOCK_GPIO16_OUT, ETH_CLOCK_GPIO17_OUT
+  -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
+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
 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}
-build_unflags = ${esp32_idf_V5.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_WROVER\"
+custom_usermods = audioreactive
+build_unflags = ${common.build_unflags}
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=\"ESP32_WROVER\"
   -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
   -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
+platform = ${esp32c3.platform}
+platform_packages = ${esp32c3.platform_packages}
+framework = arduino
 board = esp32-c3-devkitm-1
+board_build.partitions = ${esp32.default_partitions}
 custom_usermods = audioreactive
 build_flags = ${common.build_flags} ${esp32c3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-C3\"
   -D WLED_WATCHDOG_TIMEOUT=0
@@ -865,7 +590,7 @@ build_flags = ${common.build_flags} ${esp32c3.build_flags} -D WLED_RELEASE_NAME=
   -DARDUINO_USB_CDC_ON_BOOT=1 ;; for virtual CDC USB
   ;-DARDUINO_USB_CDC_ON_BOOT=0   ;; for serial-to-USB chip
 upload_speed = 460800
-build_unflags = ${esp32c3.build_unflags}
+build_unflags = ${common.build_unflags}
 lib_deps = ${esp32c3.lib_deps}
 board_build.flash_mode = dio ; safe default, required for OTA updates to 0.16 from older version which used dio (must match the bootloader!)
 
@@ -876,47 +601,45 @@ board_build.flash_mode = qio ; qio is faster and works on almost all boards (som
 
 [env:esp32s3dev_16MB_opi]
 ;; ESP32-S3 development board, with 16MB FLASH and >= 8MB PSRAM (memory_type: qio_opi)
-extends = esp32s3
 board = esp32-s3-devkitc-1 ;; generic dev board; the next line adds PSRAM support
 board_build.arduino.memory_type = qio_opi     ;; use with PSRAM: 8MB or 16MB
 platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
-custom_usermods = ${common.default_usermods}
-build_unflags = ${esp32s3.build_unflags}
+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 WLED_WATCHDOG_TIMEOUT=0
   ;-D ARDUINO_USB_CDC_ON_BOOT=0  ;; -D ARDUINO_USB_MODE=1 ;; for boards with serial-to-USB chip
   -D ARDUINO_USB_CDC_ON_BOOT=1 ;; -D ARDUINO_USB_MODE=1      ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
   -DBOARD_HAS_PSRAM
 lib_deps = ${esp32s3.lib_deps}
-lib_ignore = ${esp32s3.lib_ignore}
 board_build.partitions = ${esp32.extreme_partitions}
 board_upload.flash_size = 16MB
 board_upload.maximum_size = 16777216
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
+monitor_filters = esp32_exception_decoder
 
 [env:esp32s3dev_8MB_opi]
 ;; ESP32-S3 development board, with 8MB FLASH and >= 8MB PSRAM (memory_type: qio_opi)
-extends = esp32s3
 board = esp32-s3-devkitc-1 ;; generic dev board; the next line adds PSRAM support
 board_build.arduino.memory_type = qio_opi     ;; use with PSRAM: 8MB or 16MB
 platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
-custom_usermods = ${common.default_usermods}
-build_unflags = ${esp32s3.build_unflags}
+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 WLED_WATCHDOG_TIMEOUT=0
   ;-D ARDUINO_USB_CDC_ON_BOOT=0  ;; -D ARDUINO_USB_MODE=1 ;; for boards with serial-to-USB chip
   -D ARDUINO_USB_CDC_ON_BOOT=1 ;; -D ARDUINO_USB_MODE=1      ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
   -DBOARD_HAS_PSRAM
 lib_deps = ${esp32s3.lib_deps}
-lib_ignore = ${esp32s3.lib_ignore}
 board_build.partitions = ${esp32.large_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
+monitor_filters = esp32_exception_decoder
 
 [env:esp32s3dev_8MB_qspi]
 ;; generic ESP32-S3 board with 8MB FLASH and PSRAM (memory_type: qio_qspi). Try this one if esp32s3dev_8MB_opi does not work on your board
@@ -929,6 +652,7 @@ build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=
   -D ARDUINO_USB_CDC_ON_BOOT=1 ;; -D ARDUINO_USB_MODE=1      ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
   -DBOARD_HAS_PSRAM
   ;; -DLOLIN_WIFI_FIX ;; uncomment if you have WiFi connectivity problems
+monitor_filters = esp32_exception_decoder
 
 [env:esp32s3dev_8MB_none]
 ;; ESP32-S3 development board, 8MB FLASH, no PSRAM
@@ -946,12 +670,13 @@ board_build.flash_mode = qio
 [env:esp32S3_wroom2]
 ;; For ESP32-S3 WROOM-2, a.k.a. ESP32-S3 DevKitC-1 v1.1
 ;; with >= 16MB FLASH and >= 8MB PSRAM (memory_type: opi_opi)
-extends = esp32s3
+platform = ${esp32s3.platform}
+platform_packages = ${esp32s3.platform_packages}
 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}
-build_unflags = ${esp32s3.build_unflags}
+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 WLED_WATCHDOG_TIMEOUT=0
   -D ARDUINO_USB_CDC_ON_BOOT=0  ;; -D ARDUINO_USB_MODE=1 ;; for boards with serial-to-USB chip
@@ -962,11 +687,11 @@ build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=
   ;;-D WLED_DEBUG
   -D SR_DMTYPE=1 -D I2S_SDPIN=13 -D I2S_CKPIN=14 -D I2S_WSPIN=15 -D MCLK_PIN=4  ;; I2S mic
 lib_deps = ${esp32s3.lib_deps}
-lib_ignore = ${esp32s3.lib_ignore}
 
 board_build.partitions = ${esp32.extreme_partitions}
 board_upload.flash_size = 16MB
 board_upload.maximum_size = 16777216
+monitor_filters = esp32_exception_decoder
 
 [env:esp32S3_wroom2_32MB]
 ;; For ESP32-S3 WROOM-2 with 32MB Flash, and >= 8MB PSRAM (memory_type: opi_opi)
@@ -983,24 +708,26 @@ build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=
 board_build.partitions = tools/WLED_ESP32_32MB.csv
 board_upload.flash_size = 32MB
 board_upload.maximum_size = 33554432
+monitor_filters = esp32_exception_decoder
 
 [env:esp32s3_4M_qspi]
 ;; ESP32-S3, with 4MB FLASH and <= 4MB PSRAM (memory_type: qio_qspi)
-extends = esp32s3
 board = lolin_s3_mini ;; -S3 mini, 4MB flash 2MB PSRAM 
+platform = ${esp32s3.platform}
+platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
-custom_usermods = ${common.default_usermods}
-build_unflags = ${esp32s3.build_unflags}
+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")
   -DBOARD_HAS_PSRAM
   -DLOLIN_WIFI_FIX ; seems to work much better with this
   -D WLED_WATCHDOG_TIMEOUT=0
 lib_deps = ${esp32s3.lib_deps}
-lib_ignore = ${esp32s3.lib_ignore}
 board_build.partitions = ${esp32.default_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
+monitor_filters = esp32_exception_decoder
 
 [env:esp32s3_4M_none]
 ;; ESP32-S3 with 4MB FLASH, no PSRAM
@@ -1018,12 +745,14 @@ board_build.flash_mode = qio
 
 
 [env:lolin_s2_mini]
-extends = esp32s2
+platform = ${esp32s2.platform}
+platform_packages = ${esp32s2.platform_packages}
 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}
-build_unflags = ${esp32s2.build_unflags}
+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
   -DARDUINO_USB_MSC_ON_BOOT=0
@@ -1039,21 +768,19 @@ build_flags = ${common.build_flags} ${esp32s2.build_flags} -D WLED_RELEASE_NAME=
   -D HW_PIN_MISOSPI=9
 ;  -D STATUSLED=15
 lib_deps = ${esp32s2.lib_deps}
-lib_ignore = ${esp32s2.lib_ignore}
+
 
 [env:usermods]
 board = esp32dev
-platform = ${esp32_idf_V5.platform}
-platform_packages = ${esp32_idf_V5.platform_packages}
-build_unflags = ${esp32_idf_V5.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V5.build_flags} -D WLED_RELEASE_NAME=\"ESP32_USERMODS\"
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
+build_unflags = ${common.build_unflags}
+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_ignore = ${esp32_idf_V5.lib_ignore}
+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
-custom_usermods =      ; ToDO: fix usermods build once the main V5 build works without errors and warnings
+custom_usermods = *   ; Expands to all usermods in usermods folder
 board_build.partitions = ${esp32.extreme_partitions}  ; We're gonna need a bigger boat
 
 
@@ -1135,11 +862,18 @@ extends = env:esp32S3_wroom2_32MB
 monitor_filters = esp32_exception_decoder
 build_unflags = ${env:esp32S3_wroom2_32MB.build_unflags}
   -D WLED_RELEASE_NAME=\"ESP32-S3_WROOM-2_32MB\" ;; need to un-set the relese name before setting a new one
-build_flags = ${common.build_flags} ${esp32s3.build_flags} ${hub75.build_flags} ${hub75.s3_build_flags} ${hub75.i2s_disable_flags}
+custom_usermods =
+	Internal_Temperature
+	audioreactive = https://github.com/MoonModules/WLED-AudioReactive-Usermod#171c0bbc2bc47e2c11ae203dd00beed82865df2b ;; broadcast
+build_flags = ${common.build_flags} ${esp32s3.build_flags} ${hub75.build_flags} ${hub75.s3_build_flags}
   -D WLED_RELEASE_NAME=\"ESP32-S3_Waveshare_HUB75\"
   -D WAVESHARE_S3_PINOUT
-;  -D WLED_USE_SD_SPI
-;  -D SD_PRINT_HOME_DIR
+  -D BTNPIN=0
+  -D I2CSDAPIN=47 -D I2CSCLPIN=48
+  -D SR_DMTYPE=9 -D I2S_SDPIN=39 -D I2S_CKPIN=43 -D I2S_WSPIN=38 -D MCLK_PIN=12 ; Waveshare ES8311 Codec pins
+  -D UM_SD_SELECT=14 -D UM_SD_CLOCK=1 -D UM_SD_POCI=17 -D UM_SD_PICO=44 ; Waveshare SD Card pins ** Requires updated sd_card from this PR https://github.com/wled/WLED/pull/5679 **
+  -D WLED_USE_SD_SPI
+  -D SD_PRINT_HOME_DIR
 ;  -D WLED_DEBUG
 lib_deps = ${esp32s3.lib_deps}
   ${hub75.lib_deps}

platformio_override.sample.ini

@@ -13,8 +13,8 @@ default_envs = WLED_generic8266_1M, esp32dev_dio80  # put the name(s) of your ow
 [env:WLED_generic8266_1M]
 extends = env:esp01_1m_full  # when you want to extend the existing environment (define only updated options)
 ; board = esp01_1m  # uncomment when ou need different board
-; platform = ${esp8266.platform_wled_default}  # uncomment and change when you want particular platform
-; platform_packages = ${esp8266.platform_packages}
+; platform = ${common.platform_wled_default}  # uncomment and change when you want particular platform
+; platform_packages = ${common.platform_packages}
 ; board_build.ldscript = ${common.ldscript_1m128k}
 ; upload_speed = 921600 # fast upload speed (remove ';' if your board supports fast upload speed)
 # Sample libraries used for various usermods. Uncomment when using particular usermod.
@@ -36,12 +36,7 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=
   -D WLED_DISABLE_OTA -D WLED_DISABLE_2D
 ;
 ; *** To use the below defines/overrides, copy and paste each onto its own line just below build_flags in the section above.
-; *** Note: on adding custom usermods
-;     custom_usermods entries are a separate key in the env section (not inside build_flags). Place them on their own line in the env.
-;     Multiple usermods are separated by a space, the names can be found in the library.json file of the usermod.
-;     Example: use the default usermods from the esp32dev env and add the Temperature and four_line_display_ALT usermods
-;     custom_usermods = ${env:esp32dev.custom_usermods} Temperature four_line_display_ALT
-;
+; 
 ; Set a release name that may be used to distinguish required binary for flashing
 ;   -D WLED_RELEASE_NAME=\"ESP32_MULTI_USREMODS\"
 ;
@@ -106,17 +101,17 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=
 ;   -D WLED_DEBUG_PORT=7868
 ;
 ; Use Autosave usermod and set it to do save after 90s
-;   custom_usermods = ${env:esp32dev.custom_usermods} auto_save
+;   -D USERMOD_AUTO_SAVE
 ;   -D AUTOSAVE_AFTER_SEC=90
 ;
 ; Use AHT10/AHT15/AHT20 usermod
-;   custom_usermods = ${env:esp32dev.custom_usermods} AHT10_v2
+;   -D USERMOD_AHT10
 ;
 ; Use INA226 usermod
-;   custom_usermods = ${env:esp32dev.custom_usermods} INA226_v2
+;   -D USERMOD_INA226
 ;
 ; Use 4 Line Display usermod with SPI display
-;   custom_usermods = ${env:esp32dev.custom_usermods} four_line_display_ALT
+;   -D USERMOD_FOUR_LINE_DISPLAY
 ;   -DFLD_SPI_DEFAULT
 ;   -D FLD_TYPE=SSD1306_SPI64
 ;   -D FLD_PIN_CLOCKSPI=14
@@ -126,22 +121,22 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=
 ;   -D FLD_PIN_RESET=27
 ;
 ; Use Rotary encoder usermod (in conjunction with 4LD)
-;   custom_usermods = ${env:esp32dev.custom_usermods} rotary_encoder_ui_ALT
+;   -D USERMOD_ROTARY_ENCODER_UI
 ;   -D ENCODER_DT_PIN=5
 ;   -D ENCODER_CLK_PIN=18
 ;   -D ENCODER_SW_PIN=19
 ;
 ; Use Dallas DS18B20 temperature sensor usermod and configure it to use GPIO13
-;   custom_usermods = ${env:esp32dev.custom_usermods} Temperature
+;   -D USERMOD_DALLASTEMPERATURE
 ;   -D TEMPERATURE_PIN=13
 ;
 ; Use Multi Relay usermod and configure it to use 6 relays and appropriate GPIO
-;   custom_usermods = ${env:esp32dev.custom_usermods} multi_relay
+;   -D USERMOD_MULTI_RELAY
 ;   -D MULTI_RELAY_MAX_RELAYS=6
 ;   -D MULTI_RELAY_PINS=12,23,22,21,24,25
 ;
 ; Use PIR sensor usermod and configure it to use GPIO4 and timer of 60s
-;   custom_usermods = ${env:esp32dev.custom_usermods} PIR_sensor_switch
+;   -D USERMOD_PIRSWITCH
 ;   -D PIR_SENSOR_PIN=4   # use -1 to disable usermod
 ;   -D PIR_SENSOR_OFF_SEC=60
 ;   -D PIR_SENSOR_MAX_SENSORS=2 # max allowable sensors (uses OR logic for triggering)
@@ -154,12 +149,12 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=
 ;   -D I2S_CKPIN=19
 ;
 ; Use PWM fan usermod
-;   custom_usermods = ${env:esp32dev.custom_usermods} PWM_fan
+;   -D USERMOD_PWM_FAN
 ;   -D TACHO_PIN=33
 ;   -D PWM_PIN=32
 ;
 ;  Use POV Display usermod
-;   custom_usermods = ${env:esp32dev.custom_usermods} pov_display
+;   -D USERMOD_POV_DISPLAY
 ; Use built-in or custom LED as a status indicator (assumes LED is connected to GPIO16)
 ;   -D STATUSLED=16
 ;
@@ -224,8 +219,8 @@ build_flags =
 
 [env:esp07]
 board = esp07
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags}  -D WLED_RELEASE_NAME=\"ESP8266_ESP07\" #-DWLED_DISABLE_2D
@@ -234,8 +229,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:d1_mini]
 board = d1_mini
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 upload_speed = 921600
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
@@ -246,8 +241,8 @@ monitor_filters = esp8266_exception_decoder
 
 [env:heltec_wifi_kit_8]
 board = d1_mini
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP8266_HT_D1MINI\" #-DWLED_DISABLE_2D
@@ -256,8 +251,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:h803wf]
 board = d1_mini
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=1 -D WLED_DISABLE_INFRARED  -D WLED_RELEASE_NAME=\"ESP8266_HT803WF\" #-DWLED_DISABLE_2D
@@ -294,8 +289,8 @@ lib_deps = ${esp32s2.lib_deps}
 
 [env:esp8285_4CH_MagicHome]
 board = esp8285
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_1m128k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_DISABLE_OTA  -D WLED_RELEASE_NAME=\"ESP8285_4CH_MagicHome\" #-DWLED_DISABLE_2D
@@ -304,8 +299,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:esp8285_H801]
 board = esp8285
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_1m128k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_DISABLE_OTA  -D WLED_RELEASE_NAME=\"ESP8285_H801\" #-DWLED_DISABLE_2D
@@ -314,8 +309,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:d1_mini_5CH_Shojo_PCB]
 board = d1_mini
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_USE_SHOJO_PCB ;; NB: WLED_USE_SHOJO_PCB is not used anywhere in the source code. Not sure why its needed.
@@ -326,8 +321,8 @@ lib_deps = ${esp8266.lib_deps}
 [env:d1_mini_debug]
 board = d1_mini
 build_type = debug
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} ${common.debug_flags} -D WLED_RELEASE_NAME=\"ESP8266_D1MINI_DEBUG\" #-DWLED_DISABLE_2D
@@ -339,8 +334,8 @@ board = d1_mini
 upload_protocol = espota
 # exchange for your WLED IP
 upload_port = "10.10.1.27"
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP8266_D1MINI_OTA\" #-DWLED_DISABLE_2D
@@ -349,8 +344,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:anavi_miracle_controller]
 board = d1_mini
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=12 -D IRPIN=-1 -D RLYPIN=2
@@ -383,7 +378,6 @@ board_upload.maximum_size = 2097152
 extends = esp32              ;; use default esp32 platform
 board = esp32dev
 upload_speed = 460800
-custom_usermods = ${env:esp32dev.custom_usermods} Temperature four_line_display_ALT
 build_flags = ${common.build_flags} ${esp32.build_flags}
   -D WLED_RELEASE_NAME=\"ESP32_wemos_shield\"
   -D DATA_PINS=16
@@ -391,8 +385,12 @@ build_flags = ${common.build_flags} ${esp32.build_flags}
   -D BTNPIN=17
   -D IRPIN=18
   -UWLED_USE_MY_CONFIG
+  -D USERMOD_DALLASTEMPERATURE
+  -D USERMOD_FOUR_LINE_DISPLAY
   -D TEMPERATURE_PIN=23
 lib_deps = ${esp32.lib_deps}
+  OneWire@~2.3.5          ;; needed for USERMOD_DALLASTEMPERATURE
+  olikraus/U8g2 @ ^2.28.8 ;; needed for USERMOD_FOUR_LINE_DISPLAY
 board_build.partitions = ${esp32.default_partitions}
 
 [env:esp32_pico-D4]
@@ -419,7 +417,7 @@ build_flags = ${common.build_flags} ${esp32.build_flags} -D DATA_PINS=27 -D BTNP
 
 [env:sp501e]
 board = esp_wroom_02
-platform = ${esp8266.platform_wled_default}
+platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=3 -D BTNPIN=1
   -D WLED_RELEASE_NAME=\"ESP8266_sp501e\" -D WLED_DISABLE_PARTICLESYSTEM2D
@@ -427,7 +425,7 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:sp511e]
 board = esp_wroom_02
-platform = ${esp8266.platform_wled_default}
+platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=3 -D BTNPIN=2 -D IRPIN=5 -D WLED_MAX_BUTTONS=3
   -D WLED_RELEASE_NAME=\"ESP8266_sp511e\" -D WLED_DISABLE_PARTICLESYSTEM2D
@@ -435,8 +433,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_RGBCW]        ;7w and 5w(GU10) bulbs
 board = esp8285
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=-1 -D RLYPIN=-1 -D DATA_PINS=4,12,14,13,5
@@ -446,8 +444,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_15w_RGBCW]        ;15w bulb
 board = esp8285
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=-1 -D RLYPIN=-1 -D DATA_PINS=4,12,14,5,13
@@ -457,8 +455,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_3Pin_Controller]        ;small controller with only data
 board = esp8285
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=-1 -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
@@ -467,8 +465,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_4Pin_Controller]       ; With clock and data interface
 board = esp8285
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=12 -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
@@ -477,8 +475,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_5Pin_Controller]      ;Analog light strip controller
 board = esp8285
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=-1 DATA_PINS=4,12,14,13 -D WLED_DISABLE_INFRARED
@@ -487,8 +485,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:MY9291]
 board = esp01_1m
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_1m128k}
 build_unflags = ${common.build_unflags}
 custom_usermods = ${env:esp01_1m_full.custom_usermods} MY9291
@@ -502,8 +500,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:codm-controller-0_6]
 board = esp_wroom_02
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP8266_CODM06_2MB\" -D WLED_DISABLE_PARTICLESYSTEM2D
@@ -511,8 +509,8 @@ lib_deps = ${esp8266.lib_deps}
 
 [env:codm-controller-0_6-rev2]
 board = esp_wroom_02
-platform = ${esp8266.platform_wled_default}
-platform_packages = ${esp8266.platform_packages}
+platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags}  -D WLED_RELEASE_NAME=\"ESP8266_CODM06R2_4MB\" -D WLED_DISABLE_PARTICLESYSTEM2D
@@ -520,15 +518,42 @@ lib_deps = ${esp8266.lib_deps}
 
 # ------------------------------------------------------------------------------
 # EleksTube-IPS
-# See usermods/EleksTube_IPS/platformio_override.ini.sample
 # ------------------------------------------------------------------------------
+[env:elekstube_ips]
+extends = esp32              ;; use default esp32 platform
+board = esp32dev
+upload_speed = 921600
+custom_usermods = ${env:esp32dev.custom_usermods} RTC EleksTube_IPS
+build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_DISABLE_BROWNOUT_DET -D WLED_DISABLE_INFRARED
+  -D DATA_PINS=12
+  -D RLYPIN=27
+  -D BTNPIN=34
+  -D PIXEL_COUNTS=6
+  # Display config
+  -D ST7789_DRIVER
+  -D TFT_WIDTH=135
+  -D TFT_HEIGHT=240
+  -D CGRAM_OFFSET
+  -D TFT_SDA_READ
+  -D TFT_MOSI=23
+  -D TFT_SCLK=18
+  -D TFT_DC=25
+  -D TFT_RST=26
+  -D SPI_FREQUENCY=40000000
+  -D USER_SETUP_LOADED
+monitor_filters = esp32_exception_decoder
 
 
 # ------------------------------------------------------------------------------
 # Usermod examples
 # ------------------------------------------------------------------------------
 
-# 433MHz RF remote example: see usermods/usermod_v2_RF433/platformio_override.ini.sample
+# 433MHz RF remote example for esp32dev
+[env:esp32dev_usermod_RF433]
+extends = env:esp32dev
+custom_usermods =
+  ${env:esp32dev.custom_usermods}
+  RF433
 
 # External usermod from a git repository.
 # The library's `library.json` must include `"build": {"libArchive": false}`.

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

tools/cdata-test.js

@@ -119,7 +119,7 @@ describe('Script', () => {
 
   async function checkIfFileWasNewlyCreated(file) {
     const modifiedTime = fs.statSync(file).mtimeMs;
-    assert(Date.now() - modifiedTime < 850, file + ' was not modified');
+    assert(Date.now() - modifiedTime < 500, file + ' was not modified');
   }
 
   async function testFileModification(sourceFilePath, resultFile) {
@@ -129,7 +129,7 @@ describe('Script', () => {
     // modify file
     fs.appendFileSync(sourceFilePath, ' ');
     // delay for 1 second to ensure the modified time is different
-    await new Promise(resolve => setTimeout(resolve, 1400));
+    await new Promise(resolve => setTimeout(resolve, 1000));
 
     // run script cdata.js again and wait for it to finish
     await execPromise('node tools/cdata.js');
@@ -175,19 +175,13 @@ describe('Script', () => {
     });
 
     it('a settings file changes', async () => {
-      await testFileModification(path.join(dataPath, 'settings_leds.htm'), 'html_settings.h');
+      await testFileModification(path.join(dataPath, 'settings_leds.htm'), 'html_ui.h');
     });
 
-    it('common.js changes', async () => {
-      await testFileModification(path.join(dataPath, 'common.js'), 'html_settings.h');
+    it('the favicon changes', async () => {
+      await testFileModification(path.join(dataPath, 'favicon.ico'), 'html_ui.h');
     });
 
-    // this testcase currently fails - might be due to npm updates (maybe "faking" a favicon.ico change is harder now), or a real regression
-    // see https://github.com/wled/WLED/issues/5581
-    // it('the favicon changes', async () => {
-    //   await testFileModification(path.join(dataPath, 'favicon.ico'), 'html_other.h');
-    // });
-
     it('cdata.js changes', async () => {
       await testFileModification('tools/cdata.js', 'html_ui.h');
     });
@@ -215,4 +209,4 @@ describe('Script', () => {
       assert(secondRunTime < firstRunTime / 2, 'html_*.h files were rebuilt');
     });
   });
-});
+});

tools/wled-tools

@@ -141,16 +141,8 @@ discover_devices() {
         exit 1  
     fi  
 
-    # Map avahi responses to strings separated by 0x1F (unit separator), deduplicated
-    mapfile -t raw_devices < <(
-        avahi-browse _wled._tcp --terminate -r -p |
-        awk -F';' '
-            /^=/ {
-                key = $7 "\x1F" $8 "\x1F" $9
-                if (!seen[key]++) print key
-            }
-        '
-    )
+    # Map avahi responses to strings seperated by 0x1F (unit separator)
+    mapfile -t raw_devices < <(avahi-browse _wled._tcp --terminate -r -p | awk -F';' '/^=/ {print $7"\x1F"$8"\x1F"$9}')  
 
     local devices_array=()  
     for device in "${raw_devices[@]}"; do  

usermods/ADS1115_v2/ADS1115_v2.cpp

@@ -28,19 +28,18 @@ class ADS1115Usermod : public Usermod {
     }
 
     void loop() {
-      if (!isEnabled || strip.isUpdating() || millis() - lastTime <= loopInterval)
-        return;
+      if (isEnabled && millis() - lastTime > loopInterval) {
+        lastTime = millis();
 
-      lastTime = millis();
+        // If we don't have new data, skip this iteration.
+        if (!ads.conversionComplete()) {
+          return;
+        }
 
-      // If we don't have new data, skip this iteration.
-      if (!ads.conversionComplete()) {
-        return;
+        updateResult();
+        moveToNextChannel();
+        startReading();
       }
-
-      updateResult();
-      moveToNextChannel();
-      startReading();
     }
 
     void addToJsonInfo(JsonObject& root)
@@ -70,8 +69,6 @@ class ADS1115Usermod : public Usermod {
     {
       JsonObject top = root.createNestedObject(F("ADC ADS1115"));
       
-      top[F("Loop Interval")] = loopInterval;
-
       for (uint8_t i = 0; i < channelsCount; i++) {
         ChannelSettings* settingsPtr = &(channelSettings[i]);
         JsonObject channel = top.createNestedObject(settingsPtr->settingName);
@@ -82,6 +79,8 @@ class ADS1115Usermod : public Usermod {
         channel[F("Offset")] = settingsPtr->offset;
         channel[F("Decimals")] = settingsPtr->decimals;
       }
+
+      top[F("Loop Interval")] = loopInterval;
     }
 
     bool readFromConfig(JsonObject& root)

usermods/ADS1115_v2/library.json

@@ -2,7 +2,7 @@
   "name": "ADS1115_v2",
   "build": { "libArchive": false },
   "dependencies": {
-    "Adafruit BusIO": "https://github.com/adafruit/Adafruit_BusIO#1.17.4",
-    "Adafruit ADS1X15": "https://github.com/adafruit/Adafruit_ADS1X15#2.6.2"
+    "Adafruit BusIO": "https://github.com/adafruit/Adafruit_BusIO#1.13.2",
+    "Adafruit ADS1X15": "https://github.com/adafruit/Adafruit_ADS1X15#2.4.0"
   }
 }

usermods/ADS1115_v2/readme.md

@@ -1,29 +1,10 @@
-# ADS1115 Usermod
+# ADS1115 16-Bit ADC with four inputs
 
-Reads values from an ADS1115 16-bit ADC and exposes them in the `Info` tab.
+This usermod will read from an ADS1115 ADC. The voltages are displayed in the Info section of the web UI.
 
-## Features
-- Reads values from an ADS1115 over I2C.
-- Supports 8 ADS1115 input modes:
-	- 4 single-ended inputs (`AIN0` to `AIN3`)
-	- 4 differential pairs (`AIN0-AIN1`, `AIN0-AIN3`, `AIN1-AIN3`, `AIN2-AIN3`)
-- Per-channel configuration in the Usermod settings:
-	- Enable/disable
-	- Display name
-	- Units
-	- Multiplier and offset
-	- Decimal precision
-- Configurable measurement loop interval.
-- Publishes configured channel values to the `Info` tab.
+Configuration is performed via the Usermod menu. There are no parameters to set in code!
 
-## Compatibility
-- Requires an ADS1115 module connected via I2C.
-- Works on targets with I2C support.
-- Default ADC gain is `1x` (input range `+/-4.096V`).
+## Installation 
 
-## Installation
-- Add `ADS1115` to `custom_usermods` in your `platformio.ini` (or `platformio_override.ini`).
-
-## Author
-- Dima Zhemkov [@dima-zhemkov](https://github.com/dima-zhemkov)
+Add 'ADS1115' to `custom_usermods` in your platformio environment.
 

usermods/AHT10_v2/platformio_override.ini

@@ -0,0 +1,5 @@
+[env:aht10_example]
+extends = env:esp32dev
+build_flags =
+  ${common.build_flags} ${esp32.build_flags}
+  ; -D USERMOD_AHT10_DEBUG ; -- add a debug status to the info modal

usermods/Animated_Staircase/Animated_Staircase.cpp

@@ -25,8 +25,6 @@ class Animated_Staircase : public Usermod {
     unsigned int topMaxDist        = 50;    // default maximum measured distance in cm, top
     unsigned int bottomMaxDist     = 50;    // default maximum measured distance in cm, bottom
     bool togglePower               = false; // toggle power on/off with staircase on/off
-    bool topAPinInvert             = false; // invert output of top sensor
-    bool bottomAPinInvert          = false; // invert output of bottom sensor
 
     /* runtime variables */
     bool initDone = false;
@@ -93,8 +91,6 @@ class Animated_Staircase : public Usermod {
     static const char _topEchoCm[];
     static const char _bottomEchoCm[];
     static const char _togglePower[];
-    static const char _topPIRorTrigger_pin_invert[];
-    static const char _bottomPIRorTrigger_pin_invert[];
 
     void publishMqtt(bool bottom, const char* state) {
 #ifndef WLED_DISABLE_MQTT
@@ -160,12 +156,6 @@ class Animated_Staircase : public Usermod {
       return pulseIn(echoPin, HIGH, maxTimeUs) > 0;
     }
 
-    bool readPIRPin(int8_t pin, bool invert) {
-      if (pin < 0) return false;
-        bool v = digitalRead(pin);
-      return invert ? !v : v;
-    }
-
     bool checkSensors() {
       bool sensorChanged = false;
 
@@ -174,15 +164,15 @@ class Animated_Staircase : public Usermod {
 
         bottomSensorRead = bottomSensorWrite ||
           (!useUSSensorBottom ?
-            (bottomPIRorTriggerPin<0 ? false : readPIRPin(bottomPIRorTriggerPin, bottomAPinInvert)) :
+            (bottomPIRorTriggerPin<0 ? false : digitalRead(bottomPIRorTriggerPin)) :
             ultrasoundRead(bottomPIRorTriggerPin, bottomEchoPin, bottomMaxDist*59)  // cm to us
           );
         topSensorRead = topSensorWrite ||
           (!useUSSensorTop ?
-            (topPIRorTriggerPin<0 ? false : readPIRPin(topPIRorTriggerPin, topAPinInvert)) :
+            (topPIRorTriggerPin<0 ? false : digitalRead(topPIRorTriggerPin)) :
             ultrasoundRead(topPIRorTriggerPin, topEchoPin, topMaxDist*59)   // cm to us
           );
-     
+
         if (bottomSensorRead != bottomSensorState) {
           bottomSensorState = bottomSensorRead; // change previous state
           sensorChanged = true;
@@ -449,20 +439,18 @@ class Animated_Staircase : public Usermod {
       if (staircase.isNull()) {
         staircase = root.createNestedObject(FPSTR(_name));
       }
-      staircase[FPSTR(_enabled)]                       = enabled;
-      staircase[FPSTR(_segmentDelay)]                  = segment_delay_ms;
-      staircase[FPSTR(_onTime)]                        = on_time_ms / 1000;
-      staircase[FPSTR(_useTopUltrasoundSensor)]        = useUSSensorTop;
-      staircase[FPSTR(_topPIRorTrigger_pin)]           = topPIRorTriggerPin;
-      staircase[FPSTR(_topEcho_pin)]                   = useUSSensorTop ? topEchoPin : -1;
-      staircase[FPSTR(_useBottomUltrasoundSensor)]     = useUSSensorBottom;
-      staircase[FPSTR(_bottomPIRorTrigger_pin)]        = bottomPIRorTriggerPin;
-      staircase[FPSTR(_bottomEcho_pin)]                = useUSSensorBottom ? bottomEchoPin : -1;
-      staircase[FPSTR(_topEchoCm)]                     = topMaxDist;
-      staircase[FPSTR(_bottomEchoCm)]                  = bottomMaxDist;
-      staircase[FPSTR(_togglePower)]                   = togglePower;
-      staircase[FPSTR(_topPIRorTrigger_pin_invert)]    = topAPinInvert;
-      staircase[FPSTR(_bottomPIRorTrigger_pin_invert)] = bottomAPinInvert;
+      staircase[FPSTR(_enabled)]                   = enabled;
+      staircase[FPSTR(_segmentDelay)]              = segment_delay_ms;
+      staircase[FPSTR(_onTime)]                    = on_time_ms / 1000;
+      staircase[FPSTR(_useTopUltrasoundSensor)]    = useUSSensorTop;
+      staircase[FPSTR(_topPIRorTrigger_pin)]       = topPIRorTriggerPin;
+      staircase[FPSTR(_topEcho_pin)]               = useUSSensorTop ? topEchoPin : -1;
+      staircase[FPSTR(_useBottomUltrasoundSensor)] = useUSSensorBottom;
+      staircase[FPSTR(_bottomPIRorTrigger_pin)]    = bottomPIRorTriggerPin;
+      staircase[FPSTR(_bottomEcho_pin)]            = useUSSensorBottom ? bottomEchoPin : -1;
+      staircase[FPSTR(_topEchoCm)]                 = topMaxDist;
+      staircase[FPSTR(_bottomEchoCm)]              = bottomMaxDist;
+      staircase[FPSTR(_togglePower)]               = togglePower;
       DEBUG_PRINTLN(F("Staircase config saved."));
     }
 
@@ -474,13 +462,11 @@ class Animated_Staircase : public Usermod {
     bool readFromConfig(JsonObject& root) {
       bool oldUseUSSensorTop = useUSSensorTop;
       bool oldUseUSSensorBottom = useUSSensorBottom;
-      bool oldTopAPinInvert = topAPinInvert;
-      bool oldBottomAPinInvert = bottomAPinInvert;
       int8_t oldTopAPin = topPIRorTriggerPin;
       int8_t oldTopBPin = topEchoPin;
       int8_t oldBottomAPin = bottomPIRorTriggerPin;
       int8_t oldBottomBPin = bottomEchoPin;
-     
+
       JsonObject top = root[FPSTR(_name)];
       if (top.isNull()) {
         DEBUG_PRINT(FPSTR(_name));
@@ -499,12 +485,10 @@ class Animated_Staircase : public Usermod {
       useUSSensorTop     = top[FPSTR(_useTopUltrasoundSensor)] | useUSSensorTop;
       topPIRorTriggerPin = top[FPSTR(_topPIRorTrigger_pin)] | topPIRorTriggerPin;
       topEchoPin         = top[FPSTR(_topEcho_pin)] | topEchoPin;
-      topAPinInvert      = top[FPSTR(_topPIRorTrigger_pin_invert)] | topAPinInvert;
-     
+
       useUSSensorBottom     = top[FPSTR(_useBottomUltrasoundSensor)] | useUSSensorBottom;
       bottomPIRorTriggerPin = top[FPSTR(_bottomPIRorTrigger_pin)] | bottomPIRorTriggerPin;
       bottomEchoPin         = top[FPSTR(_bottomEcho_pin)] | bottomEchoPin;
-      bottomAPinInvert      = top[FPSTR(_bottomPIRorTrigger_pin_invert)] | bottomAPinInvert;
 
       topMaxDist    = top[FPSTR(_topEchoCm)] | topMaxDist;
       topMaxDist    = min(150,max(30,(int)topMaxDist));     // max distance ~1.5m (a lag of 9ms may be expected)
@@ -570,15 +554,14 @@ const char Animated_Staircase::_segmentDelay[]              PROGMEM = "segment-d
 const char Animated_Staircase::_onTime[]                    PROGMEM = "on-time-s";
 const char Animated_Staircase::_useTopUltrasoundSensor[]    PROGMEM = "useTopUltrasoundSensor";
 const char Animated_Staircase::_topPIRorTrigger_pin[]       PROGMEM = "topPIRorTrigger_pin";
-const char Animated_Staircase::_topPIRorTrigger_pin_invert[]    PROGMEM = "topPIRorTrigger_pin_invert";
 const char Animated_Staircase::_topEcho_pin[]               PROGMEM = "topEcho_pin";
 const char Animated_Staircase::_useBottomUltrasoundSensor[] PROGMEM = "useBottomUltrasoundSensor";
 const char Animated_Staircase::_bottomPIRorTrigger_pin[]    PROGMEM = "bottomPIRorTrigger_pin";
-const char Animated_Staircase::_bottomPIRorTrigger_pin_invert[] PROGMEM = "bottomPIRorTrigger_pin_invert";
 const char Animated_Staircase::_bottomEcho_pin[]            PROGMEM = "bottomEcho_pin";
 const char Animated_Staircase::_topEchoCm[]                 PROGMEM = "top-dist-cm";
 const char Animated_Staircase::_bottomEchoCm[]              PROGMEM = "bottom-dist-cm";
 const char Animated_Staircase::_togglePower[]               PROGMEM = "toggle-on-off";
 
+
 static Animated_Staircase animated_staircase;
 REGISTER_USERMOD(animated_staircase);

usermods/DHT/platformio_override.ini

@@ -8,13 +8,13 @@
 ; USERMOD_DHT_MQTT                 - publish measurements to the MQTT broker
 ; USERMOD_DHT_STATS                - For debug, report delay stats
 
-[env:esp8266_2m_usermod_dht_C]
-extends = env:esp8266_2m
-custom_usermods = ${env:esp8266_2m.custom_usermods} DHT
-build_flags = ${env:esp8266_2m.build_flags} -D USERMOD_DHT_CELSIUS
+[env:d1_mini_usermod_dht_C]
+extends = env:d1_mini
+custom_usermods = ${env:d1_mini.custom_usermods} DHT
+build_flags = ${env:d1_mini.build_flags} -D USERMOD_DHT_CELSIUS
 
-[env:esp32dev_LEDPIN_16_usermod_dht_C]
-extends = env:esp32dev
-custom_usermods = ${env:esp32dev.custom_usermods} DHT
-build_flags = ${env:esp32dev.build_flags} -D LEDPIN=16 -D USERMOD_DHT_CELSIUS -D USERMOD_DHT_STATS
+[env:custom32_LEDPIN_16_usermod_dht_C]
+extends = env:custom32_LEDPIN_16
+custom_usermods = ${env:custom32_LEDPIN_16.custom_usermods} DHT
+build_flags = ${env:custom32_LEDPIN_16.build_flags} -D USERMOD_DHT_CELSIUS -D USERMOD_DHT_STATS
 

usermods/EleksTube_IPS/library.json.disabled

@@ -1,5 +1,5 @@
 {
-  "name": "EleksTube_IPS",
+  "name:": "EleksTube_IPS",
   "build": { "libArchive": false },
   "dependencies": {
     "TFT_eSPI" : "2.5.33"

usermods/INA226_v2/INA226_v2.cpp

@@ -1,38 +1,14 @@
 #include "wled.h"
 #include <INA226_WE.h>
 
-#ifndef INA226_ADDRESS
 #define INA226_ADDRESS 0x40 // Default I2C address for INA226
-#endif
 
-#ifndef INA226_CHECK_INTERVAL_MS
-#define INA226_CHECK_INTERVAL_MS 60000 // Default check interval in milliseconds
-#endif
-
-#define DEFAULT_CHECKINTERVAL INA226_CHECK_INTERVAL_MS
+#define DEFAULT_CHECKINTERVAL 60000
 #define DEFAULT_INASAMPLES 128
 #define DEFAULT_INASAMPLESENUM AVERAGE_128
 #define DEFAULT_INACONVERSIONTIME 1100
 #define DEFAULT_INACONVERSIONTIMEENUM CONV_TIME_1100
 
-// Compile-time defaults for shunt resistor (micro-ohms), current range (mA), and current offset (mA)
-// These can be overridden via -D flags in platformio.ini / platformio_override.ini
-#ifndef INA226_SHUNT_MICRO_OHMS
-#define INA226_SHUNT_MICRO_OHMS 1000000  // 1 Ohm = 1,000,000 μΩ
-#endif
-
-#ifndef INA226_DEFAULT_CURRENT_RANGE
-#define INA226_DEFAULT_CURRENT_RANGE 1000  // 1000 mA = 1 A
-#endif
-
-#ifndef INA226_CURRENT_OFFSET_MA
-#define INA226_CURRENT_OFFSET_MA 0  // No offset by default
-#endif
-
-#ifndef INA226_ENABLED_DEFAULT
-#define INA226_ENABLED_DEFAULT false
-#endif
-
 // A packed version of all INA settings enums and their human friendly counterparts packed into a 32 bit structure
 // Some values are shifted and need to be preprocessed before usage
 struct InaSettingLookup
@@ -105,11 +81,10 @@ private:
     uint16_t _settingInaSamples : 11;          // Number of samples for averaging, max 1024
 
     uint8_t _i2cAddress;
-    uint32_t _checkIntervalMs;  // milliseconds, user settings is in seconds
-    float _decimalFactor;       // a power of 10 factor. 1 would be no change, 10 is one decimal, 100 is two etc. User sees a power of 10 (0, 1, 2, ..)
-    uint32_t _shuntResistorUOhm; // Shunt resistor value in micro-ohms (μΩ)
-    uint16_t _currentRangeMa;    // Expected maximum current in milliamps
-    int16_t _currentOffsetMa;    // Current offset in milliamps, subtracted from readings
+    uint16_t _checkInterval; // milliseconds, user settings is in seconds
+    float _decimalFactor;    // a power of 10 factor. 1 would be no change, 10 is one decimal, 100 is two etc. User sees a power of 10 (0, 1, 2, ..)
+    uint16_t _shuntResistor; // Shunt resistor value in milliohms
+    uint16_t _currentRange;  // Expected maximum current in milliamps
 
     uint8_t _lastStatus = 0;
     float _lastCurrent = 0;
@@ -118,7 +93,7 @@ private:
     float _lastShuntVoltage = 0;
     bool _lastOverflow = false;
 
-#ifndef WLED_DISABLE_MQTT
+#ifndef WLED_MQTT_DISABLE
     float _lastCurrentSent = 0;
     float _lastVoltageSent = 0;
     float _lastPowerSent = 0;
@@ -143,11 +118,9 @@ private:
         _ina226 = new INA226_WE(_i2cAddress);
         if (!_ina226->init())
         {
-            DEBUG_PRINTLN(F("INA226: init failed!"));
+            DEBUG_PRINTLN(F("INA226 initialization failed!"));
             return;
         }
-        DEBUG_PRINTF_P(PSTR("INA226: addr=0x%02X shunt=%luμΩ range=%umA offset=%dmA\n"),
-                       _i2cAddress, _shuntResistorUOhm, _currentRangeMa, _currentOffsetMa);
         _ina226->setCorrectionFactor(1.0);
 
         uint16_t tmpShort = _settingInaSamples;
@@ -156,7 +129,7 @@ private:
         tmpShort = _settingInaConversionTimeUs << 2;
         _ina226->setConversionTime(getConversionTimeEnum(tmpShort));
 
-        if (_checkIntervalMs >= 20000)
+        if (_checkInterval >= 20000)
         {
             _isTriggeredOperationMode = true;
             _ina226->setMeasureMode(TRIGGERED);
@@ -167,11 +140,7 @@ private:
             _ina226->setMeasureMode(CONTINUOUS);
         }
 
-        _ina226->setResistorRange(static_cast<float>(_shuntResistorUOhm) / 1000000.0f, static_cast<float>(_currentRangeMa) / 1000.0f);
-
-        DEBUG_PRINTF_P(PSTR("INA226: mode=%s interval=%lums samples=%u convTime=%uμs\n"),
-                       _isTriggeredOperationMode ? "triggered" : "continuous",
-                       _checkIntervalMs, _settingInaSamples, _settingInaConversionTimeUs << 2);
+        _ina226->setResistorRange(static_cast<float>(_shuntResistor) / 1000.0, static_cast<float>(_currentRange) / 1000.0);
     }
 
     void fetchAndPushValues()
@@ -181,19 +150,17 @@ private:
         if (_lastStatus != 0)
             return;
 
-        float current = truncateDecimals((_ina226->getCurrent_mA() - _currentOffsetMa) / 1000.0f);
+        float current = truncateDecimals(_ina226->getCurrent_mA() / 1000.0);
         float voltage = truncateDecimals(_ina226->getBusVoltage_V());
-        float power = truncateDecimals(_ina226->getBusPower() / 1000.0f);
-        float shuntVoltage = truncateDecimals(_ina226->getShuntVoltage_mV());
+        float power = truncateDecimals(_ina226->getBusPower() / 1000.0);
+        float shuntVoltage = truncateDecimals(_ina226->getShuntVoltage_V());
         bool overflow = _ina226->overflow;
 
 #ifndef WLED_DISABLE_MQTT
         mqttPublishIfChanged(F("current"), _lastCurrentSent, current, 0.01f);
         mqttPublishIfChanged(F("voltage"), _lastVoltageSent, voltage, 0.01f);
         mqttPublishIfChanged(F("power"), _lastPowerSent, power, 0.1f);
-        // Publish in V for backward compatibility
-        float shuntVoltageV = shuntVoltage / 1000.0f;
-        mqttPublishIfChanged(F("shunt_voltage"), _lastShuntVoltageSent, shuntVoltageV, 0.01f);
+        mqttPublishIfChanged(F("shunt_voltage"), _lastShuntVoltageSent, shuntVoltage, 0.01f);
         mqttPublishIfChanged(F("overflow"), _lastOverflowSent, overflow);
 #endif
 
@@ -202,9 +169,6 @@ private:
         _lastPower = power;
         _lastShuntVoltage = shuntVoltage;
         _lastOverflow = overflow;
-
-        DEBUG_PRINTF_P(PSTR("INA226: %.3fA %.2fV %.2fW shunt=%.2fmV%s\n"),
-                       current, voltage, power, shuntVoltage, overflow ? " OVF" : "");
     }
 
     void handleTriggeredMode(unsigned long currentTime)
@@ -224,7 +188,7 @@ private:
         }
         else
         {
-            if (currentTime - _lastLoopCheck >= _checkIntervalMs)
+            if (currentTime - _lastLoopCheck >= _checkInterval)
             {
                 // Start a measurement and use isBusy() later to determine when it is done
                 _ina226->startSingleMeasurementNoWait();
@@ -237,7 +201,7 @@ private:
 
     void handleContinuousMode(unsigned long currentTime)
     {
-        if (currentTime - _lastLoopCheck >= _checkIntervalMs)
+        if (currentTime - _lastLoopCheck >= _checkInterval)
         {
             _lastLoopCheck = currentTime;
             fetchAndPushValues();
@@ -251,23 +215,19 @@ private:
             return;
 
         char topic[128];
-        auto buildTopic = [&](const char *suffix) {
-            snprintf_P(topic, sizeof(topic), PSTR("%s/%s"), mqttDeviceTopic, suffix);
-        };
-
-        buildTopic("current");
+        snprintf_P(topic, 127, "%s/current", mqttDeviceTopic);
         mqttCreateHassSensor(F("Current"), topic, F("current"), F("A"));
 
-        buildTopic("voltage");
+        snprintf_P(topic, 127, "%s/voltage", mqttDeviceTopic);
         mqttCreateHassSensor(F("Voltage"), topic, F("voltage"), F("V"));
 
-        buildTopic("power");
+        snprintf_P(topic, 127, "%s/power", mqttDeviceTopic);
         mqttCreateHassSensor(F("Power"), topic, F("power"), F("W"));
 
-        buildTopic("shunt_voltage");
+        snprintf_P(topic, 127, "%s/shunt_voltage", mqttDeviceTopic);
         mqttCreateHassSensor(F("Shunt Voltage"), topic, F("voltage"), F("V"));
 
-        buildTopic("overflow");
+        snprintf_P(topic, 127, "%s/overflow", mqttDeviceTopic);
         mqttCreateHassBinarySensor(F("Overflow"), topic);
     }
 
@@ -355,23 +315,14 @@ public:
     UsermodINA226()
     {
         // Default values
-        _settingEnabled = INA226_ENABLED_DEFAULT;
         _settingInaSamples = DEFAULT_INASAMPLES;
-        _settingInaConversionTimeUs = DEFAULT_INACONVERSIONTIME >> 2; // stored shifted to fit 12-bit field
+        _settingInaConversionTimeUs = DEFAULT_INACONVERSIONTIME;
 
         _i2cAddress = INA226_ADDRESS;
-        _checkIntervalMs = DEFAULT_CHECKINTERVAL;
+        _checkInterval = DEFAULT_CHECKINTERVAL;
         _decimalFactor = 100;
-        _shuntResistorUOhm = INA226_SHUNT_MICRO_OHMS;
-        _currentRangeMa = INA226_DEFAULT_CURRENT_RANGE;
-        _currentOffsetMa = INA226_CURRENT_OFFSET_MA;
-
-        _mqttPublish = false;
-        _mqttPublishAlways = false;
-        _mqttHomeAssistant = false;
-        _initDone = false;
-        _isTriggeredOperationMode = false;
-        _measurementTriggered = false;
+        _shuntResistor = 1000;
+        _currentRange = 1000;
     }
 
     void setup()
@@ -448,7 +399,7 @@ public:
         JsonArray jsonCurrent = user.createNestedArray(F("Current"));
         JsonArray jsonVoltage = user.createNestedArray(F("Voltage"));
         JsonArray jsonPower = user.createNestedArray(F("Power"));
-        JsonArray jsonShuntVoltage = user.createNestedArray(F("Shunt Voltage Drop"));
+        JsonArray jsonShuntVoltage = user.createNestedArray(F("Shunt Voltage"));
         JsonArray jsonOverflow = user.createNestedArray(F("Overflow"));
 
         if (_lastLoopCheck == 0)
@@ -481,7 +432,7 @@ public:
         jsonPower.add(F("W"));
 
         jsonShuntVoltage.add(_lastShuntVoltage);
-        jsonShuntVoltage.add(F("mV"));
+        jsonShuntVoltage.add(F("V"));
 
         jsonOverflow.add(_lastOverflow ? F("true") : F("false"));
     }
@@ -491,13 +442,12 @@ public:
         JsonObject top = root.createNestedObject(FPSTR(_name));
         top[F("Enabled")] = _settingEnabled;
         top[F("I2CAddress")] = static_cast<uint8_t>(_i2cAddress);
-        top[F("CheckInterval")] = _checkIntervalMs / 1000;
+        top[F("CheckInterval")] = _checkInterval / 1000;
         top[F("INASamples")] = _settingInaSamples;
         top[F("INAConversionTime")] = _settingInaConversionTimeUs << 2;
         top[F("Decimals")] = log10f(_decimalFactor);
-        top[F("ShuntResistor")] = static_cast<float>(_shuntResistorUOhm) / 1000.0f;
-        top[F("CurrentRange")] = _currentRangeMa;
-        top[F("CurrentOffset")] = _currentOffsetMa;
+        top[F("ShuntResistor")] = _shuntResistor;
+        top[F("CurrentRange")] = _currentRange;
 #ifndef WLED_DISABLE_MQTT
         top[F("MqttPublish")] = _mqttPublish;
         top[F("MqttPublishAlways")] = _mqttPublishAlways;
@@ -507,17 +457,6 @@ public:
         DEBUG_PRINTLN(F("INA226 config saved."));
     }
 
-    void appendConfigData() override
-    {
-        oappend(F("addInfo('INA226:CheckInterval',1,'seconds');"));
-        oappend(F("addInfo('INA226:INASamples',1,'samples (1-1024)');"));
-        oappend(F("addInfo('INA226:INAConversionTime',1,'&micro;s');"));
-        oappend(F("addInfo('INA226:Decimals',1,'(0-5)');"));
-        oappend(F("addInfo('INA226:ShuntResistor',1,'m&Omega;');"));
-        oappend(F("addInfo('INA226:CurrentRange',1,'mA');"));
-        oappend(F("addInfo('INA226:CurrentOffset',1,'mA');"));
-    }
-
     bool readFromConfig(JsonObject &root) override
     {
         JsonObject top = root[FPSTR(_name)];
@@ -533,12 +472,12 @@ public:
             configComplete = false;
 
         configComplete &= getJsonValue(top[F("I2CAddress")], _i2cAddress);
-        if (getJsonValue(top[F("CheckInterval")], _checkIntervalMs))
+        if (getJsonValue(top[F("CheckInterval")], _checkInterval))
         {
-            if (1 <= _checkIntervalMs && _checkIntervalMs <= 600)
-                _checkIntervalMs *= 1000;
+            if (1 <= _checkInterval && _checkInterval <= 600)
+                _checkInterval *= 1000;
             else
-                _checkIntervalMs = DEFAULT_CHECKINTERVAL;
+                _checkInterval = DEFAULT_CHECKINTERVAL;
         }
         else
             configComplete = false;
@@ -572,26 +511,8 @@ public:
         else
             configComplete = false;
 
-        float shuntMilliOhms;
-        if (getJsonValue(top[F("ShuntResistor")], shuntMilliOhms))
-        {
-            if (shuntMilliOhms > 0)
-                _shuntResistorUOhm = static_cast<uint32_t>(shuntMilliOhms * 1000.0f + 0.5f);
-            else
-                _shuntResistorUOhm = INA226_SHUNT_MICRO_OHMS;
-        }
-        else
-            configComplete = false;
-
-        if (getJsonValue(top[F("CurrentRange")], _currentRangeMa))
-        {
-            if (_currentRangeMa == 0 || _currentRangeMa > 20000)
-                _currentRangeMa = INA226_DEFAULT_CURRENT_RANGE;
-        }
-        else
-            configComplete = false;
-        if (!getJsonValue(top[F("CurrentOffset")], _currentOffsetMa))
-            _currentOffsetMa = INA226_CURRENT_OFFSET_MA;  // Use compile-time default if missing from config
+        configComplete &= getJsonValue(top[F("ShuntResistor")], _shuntResistor);
+        configComplete &= getJsonValue(top[F("CurrentRange")], _currentRange);
 
 #ifndef WLED_DISABLE_MQTT
         if (getJsonValue(top[F("MqttPublish")], tmpBool))

usermods/INA226_v2/README.md

@@ -18,7 +18,6 @@ The following settings can be configured in the Usermod Menu:
 - **Decimals**: Number of decimals in the output.
 - **ShuntResistor**: Shunt resistor value in milliohms. An R100 shunt resistor should be written as "100", while R010 should be "10".
 - **CurrentRange**: Expected maximum current in milliamps (e.g., 5 A = 5000 mA).
-- **CurrentOffset**: Current offset in milliamps, subtracted from raw readings. Useful for compensating a consistent bias in the sensor. Default is 0.
 - **MqttPublish**: Enable or disable MQTT publishing.
 - **MqttPublishAlways**: Publish always, regardless if there is a change.
 - **MqttHomeAssistantDiscovery**: Enable Home Assistant discovery.
@@ -64,33 +63,4 @@ extends = env:esp32dev
 custom_usermods = ${env:esp32dev.custom_usermods} INA226
 build_flags = ${env:esp32dev.build_flags}
   ; -D USERMOD_INA226_DEBUG ; -- add a debug status to the info modal
-```
-
-### Compile-time Defaults
-
-Several parameters can be overridden at compile time via `-D` build flags. This is useful for setting board-specific defaults so the device works correctly on first boot without manual configuration.
-
-| Build Flag | Default | Unit | Description |
-|---|---|---|---|
-| `INA226_ADDRESS` | `0x40` | — | I2C address of the INA226 |
-| `INA226_SHUNT_MICRO_OHMS` | `1000000` | μΩ | Shunt resistor value (1 000 000 μΩ = 1 Ω) |
-| `INA226_DEFAULT_CURRENT_RANGE` | `1000` | mA | Expected maximum current (1000 mA = 1 A) |
-| `INA226_CURRENT_OFFSET_MA` | `0` | mA | Current offset subtracted from readings |
-| `INA226_CHECK_INTERVAL_MS` | `60000` | ms | Default interval between readings on first boot |
-| `INA226_ENABLED_DEFAULT` | `false` | — | Enable the usermod on first boot |
-
-Example for a board with a 2.888 mΩ effective shunt, 10 A range, -118 mA offset, 1 second polling, and enabled by default:
-
-```ini
-[env:my_board]
-extends = env:esp32dev
-custom_usermods = ${env:esp32dev.custom_usermods} INA226
-build_flags = ${env:esp32dev.build_flags}
-  -D INA226_ENABLED_DEFAULT=true
-  -D INA226_SHUNT_MICRO_OHMS=2888
-  -D INA226_DEFAULT_CURRENT_RANGE=10000
-  -D INA226_CURRENT_OFFSET_MA=-118
-  -D INA226_CHECK_INTERVAL_MS=1000
-```
-
-All compile-time defaults can still be changed at runtime through the Usermod settings page.
+```

usermods/INA226_v2/platformio_override.ini

@@ -0,0 +1,6 @@
+[env:ina226_example]
+extends = env:esp32dev
+custom_usermods = ${env:esp32dev.custom_usermods} INA226_v2
+build_flags =
+  ${env:esp32dev.build_flags}
+  ; -D USERMOD_INA226_DEBUG ; -- add a debug status to the info modal

usermods/PWM_fan/PWM_fan.cpp

@@ -129,14 +129,11 @@ class PWMFanUsermod : public Usermod {
       if (pwmChannel == 255) { //no more free LEDC channels
         deinitPWMfan(); return;
       }
-      // configure LED PWM functionalitites - ESP-IDF 5.x API
-      #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-      ledcAttachChannel(pwmPin, 25000, 8, pwmChannel);  // New API: ledcAttach(pin, freq, resolution, channel); keep PinManager channel ownership consistent
-      #else
+      // configure LED PWM functionalitites
       ledcSetup(pwmChannel, 25000, 8);
+      // attach the channel to the GPIO to be controlled
       ledcAttachPin(pwmPin, pwmChannel);
       #endif
-      #endif
       DEBUG_PRINTLN(F("Fan PWM sucessfully initialized."));
     }
 

usermods/SN_Photoresistor/platformio_override.ini

@@ -1,5 +1,6 @@
 ; Options
 ; -------
+; USERMOD_SN_PHOTORESISTOR                      - define this to have this user mod included wled00\usermods_list.cpp
 ; USERMOD_SN_PHOTORESISTOR_MEASUREMENT_INTERVAL - the number of milliseconds between measurements, defaults to 60 seconds
 ; USERMOD_SN_PHOTORESISTOR_FIRST_MEASUREMENT_AT - the number of milliseconds after boot to take first measurement, defaults to 20 seconds
 ; USERMOD_SN_PHOTORESISTOR_REFERENCE_VOLTAGE    - the voltage supplied to the sensor, defaults to 5v
@@ -7,10 +8,9 @@
 ; USERMOD_SN_PHOTORESISTOR_RESISTOR_VALUE       - the resistor size, defaults to 10000.0 (10K hms)
 ; USERMOD_SN_PHOTORESISTOR_OFFSET_VALUE         - the offset value to report on, defaults to 25
 ;
-[env:usermod_sn_photoresistor_esp8266_2m]
-extends = env:esp8266_2m
-custom_usermods = ${env:esp8266_2m.custom_usermods} SN_Photoresistor
+[env:usermod_sn_photoresistor_d1_mini]
+extends = env:d1_mini
 build_flags =
-    ${env:esp8266_2m.build_flags}
-    -D USERMOD_SN_PHOTORESISTOR_MEASUREMENT_INTERVAL=60
-lib_deps = ${env:esp8266_2m.lib_deps}
+    ${common.build_flags_esp8266}
+    -D USERMOD_SN_PHOTORESISTOR
+lib_deps = ${env.lib_deps}

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) ||
@@ -225,7 +225,7 @@ class St7789DisplayUsermod : public Usermod {
         #else
             knownSsid = WiFi.SSID();
         #endif
-        knownIp = apActive ? IPAddress(4, 3, 2, 1) : WLEDNetwork.localIP();
+        knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
         knownBrightness = bri;
         knownMode = strip.getMainSegment().mode;
         knownPalette = strip.getMainSegment().palette;

usermods/ST7789_display/library.json.disabled

@@ -1,4 +1,4 @@
 {
-  "name": "ST7789_display",
+  "name:": "ST7789_display",
   "build": { "libArchive": false }
 }

usermods/TTGO-T-Display/platformio_override.ini

@@ -0,0 +1,8 @@
+[env:esp32dev]
+build_flags = ${common.build_flags_esp32} 
+; PIN defines - uncomment and change, if needed:
+;  -D LEDPIN=2
+   -D BTNPIN=35
+;  -D IRPIN=4
+;  -D RLYPIN=12
+;  -D RLYMDE=1

usermods/Temperature/platformio_override.ini

@@ -0,0 +1,5 @@
+; Options
+; -------
+; USERMOD_DALLASTEMPERATURE_MEASUREMENT_INTERVAL - the number of milliseconds between measurements, defaults to 60 seconds
+;
+

usermods/audioreactive/audio_reactive.cpp

@@ -296,17 +296,17 @@ void FFTcode(void * parameter)
   ArduinoFFT<float> FFT = ArduinoFFT<float>(valFFT, vImag, samplesFFT, SAMPLE_RATE, true);
 #elif !defined(UM_AUDIOREACTIVE_USE_INTEGER_FFT)
   // allocate and initialize FFT buffers on first call
-  // note: free() is never used on these pointers. If it ever is implemented, this implementation can cause memory leaks (need to free raw pointers)
   if (valFFT == nullptr) {
-    float* raw_buffer = (float*)heap_caps_malloc((2 * samplesFFT * sizeof(float)) + 16, MALLOC_CAP_8BIT);
-    if ((raw_buffer == nullptr)) return; // something went wrong
-    valFFT = (float*)(((uintptr_t)raw_buffer + 15) & ~15);  // SIMD requires aligned memory to 16-byte boundary. note in IDF5 there is MALLOC_CAP_SIMD available
+    valFFT = (float*)heap_caps_aligned_calloc(16, 2 * samplesFFT, sizeof(float), MALLOC_CAP_8BIT); // SIMD requires aligned memory to 16-byte boundary. note in IDF5 there is MALLOC_CAP_SIMD available
+    if ((valFFT == nullptr)) return; // something went wrong
   }
   // create window
   if (windowFFT == nullptr) {
-    float* raw_buffer = (float*)heap_caps_malloc((samplesFFT * sizeof(float)) + 16, MALLOC_CAP_8BIT);
-    if ((raw_buffer == nullptr)) return; // something went wrong
-    windowFFT = (float*)(((uintptr_t)raw_buffer + 15) & ~15);  // SIMD requires aligned memory to 16-byte boundary
+    windowFFT = (float*)heap_caps_aligned_calloc(16, samplesFFT, sizeof(float), MALLOC_CAP_8BIT); // SIMD requires aligned memory to 16-byte boundary. note in IDF5 there is MALLOC_CAP_SIMD available
+    if ((windowFFT == nullptr)) {
+      heap_caps_free(valFFT); valFFT = nullptr;
+      return; // something went wrong
+    }
   }
   if (dsps_fft2r_init_fc32(NULL, samplesFFT) != ESP_OK) return; // initialize FFT tables
   // create window function for FFT
@@ -316,16 +316,20 @@ void FFTcode(void * parameter)
   dsps_wind_flat_top_f32(windowFFT, samplesFFT);
 #endif
 #else
-  // allocate and initialize integer FFT buffers on first call
-  if (valFFT == nullptr) valFFT = (int16_t*) calloc(sizeof(int16_t), samplesFFT * 2);
-  if ((valFFT == nullptr)) return; // something went wrong
+  // use integer FFT - allocate and initialize integer FFT buffers on first call, 4 bytes aligned (just in case, even if not strictly needed for int16_t)
+  if (valFFT == nullptr) valFFT = (int16_t*) heap_caps_aligned_calloc(4, samplesFFT * 2, sizeof(int16_t), MALLOC_CAP_8BIT); 
   // create window
-  if (windowFFT == nullptr) windowFFT = (int16_t*) calloc(sizeof(int16_t), samplesFFT);
-  if ((windowFFT == nullptr)) return; // something went wrong
-  if (dsps_fft2r_init_sc16(NULL, samplesFFT) != ESP_OK) return; // initialize FFT tables
+  if (windowFFT == nullptr) windowFFT = (int16_t*) heap_caps_aligned_calloc(4, samplesFFT, sizeof(int16_t), MALLOC_CAP_8BIT);
   // create window function for FFT
-  float *windowFloat = (float*) calloc(sizeof(float), samplesFFT); // temporary buffer for window function
-  if ((windowFloat == nullptr)) return; // something went wrong
+  float *windowFloat = (float*) heap_caps_aligned_calloc(4, samplesFFT, sizeof(float), MALLOC_CAP_8BIT); // temporary buffer for window function
+  if (windowFloat == nullptr || windowFFT == nullptr || valFFT == nullptr) { // something went wrong
+    if (windowFloat) heap_caps_free(windowFloat);
+    if (windowFFT) heap_caps_free(windowFFT); windowFFT = nullptr;
+    if (valFFT) heap_caps_free(valFFT); valFFT = nullptr;
+    return;
+  }
+  if (dsps_fft2r_init_sc16(NULL, samplesFFT) != ESP_OK) return; // initialize FFT tables
+
 #ifdef FFT_PREFER_EXACT_PEAKS
   dsps_wind_blackman_harris_f32(windowFloat, samplesFFT);
 #else
@@ -335,7 +339,7 @@ void FFTcode(void * parameter)
   for (int i = 0; i < samplesFFT; i++) {
     windowFFT[i] = (int16_t)(windowFloat[i] * 32767.0f);
   }
-  free(windowFloat); // free temporary buffer
+  heap_caps_free(windowFloat); // free temporary buffer
 #endif
 
   // see https://www.freertos.org/vtaskdelayuntil.html
@@ -468,7 +472,6 @@ void FFTcode(void * parameter)
       }
       FFT_Magnitude = FFT_Magnitude_int * 512; // scale to match raw float value
       FFT_MajorPeak = FFT_MajorPeak_int;
-      FFT_Magnitude = FFT_Magnitude_int;
 #endif
 #endif
       FFT_MajorPeak = constrain(FFT_MajorPeak, 1.0f, 11025.0f);   // restrict value to range expected by effects
@@ -876,7 +879,7 @@ class AudioReactive : public Usermod {
     static const char _dynamics[];
     static const char _frequency[];
     static const char _inputLvl[];
-#if defined(CONFIG_IDF_TARGET_ESP32) // analog mic is only supported on classic esp32
+#if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
     static const char _analogmic[];
 #endif
     static const char _digitalmic[];
@@ -1376,7 +1379,7 @@ class AudioReactive : public Usermod {
 
       // Reset I2S peripheral for good measure
       i2s_driver_uninstall(I2S_NUM_0);   // E (696) I2S: i2s_driver_uninstall(2006): I2S port 0 has not installed
-      #if !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5)
+      #if !defined(CONFIG_IDF_TARGET_ESP32C3)
         delay(100);
         periph_module_reset(PERIPH_I2S0_MODULE);   // not possible on -C3
       #endif
@@ -1384,15 +1387,15 @@ class AudioReactive : public Usermod {
       useBandPassFilter = false; // filter cuts lowest and highest frequency bands from FFT result (use on very noisy mic inputs)
       useMicFilter = true;       // filter fixes aliasing to base & highest frequency bands and reduces noise floor (recommended for all mic inputs)
 
-      #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5)
+      #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3)
         if ((i2sckPin == I2S_PIN_NO_CHANGE) && (i2ssdPin >= 0) && (i2swsPin >= 0) && ((dmType == 1) || (dmType == 4)) ) dmType = 5;   // dummy user support: SCK == -1 --means--> PDM microphone
       #endif
 
       switch (dmType) {
-      #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32S3)
+      #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
         // stub cases for not-yet-supported I2S modes on other ESP32 chips
         case 0:  //ADC analog
-        #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5)
+        #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3)
         case 5:  //PDM Microphone
         #endif
       #endif
@@ -1421,7 +1424,7 @@ class AudioReactive : public Usermod {
           delay(100);
           if (audioSource) audioSource->initialize(i2swsPin, i2ssdPin, i2sckPin, mclkPin);
           break;
-        #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5)
+        #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3)
         case 5:
           DEBUGSR_PRINT(F("AR: Generic PDM Microphone - ")); DEBUGSR_PRINTLN(F(I2S_PDM_MIC_CHANNEL_TEXT));
           audioSource = new I2SSource(SAMPLE_RATE, BLOCK_SIZE, 1.0f/4.0f);
@@ -1438,7 +1441,7 @@ class AudioReactive : public Usermod {
           if (audioSource) audioSource->initialize(i2swsPin, i2ssdPin, i2sckPin, mclkPin);
           break;
 
-        #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32S3)
+        #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
         // ADC over I2S is only possible on "classic" ESP32
         case 0:
           DEBUGSR_PRINTLN(F("AR: Analog Microphone (left channel only)."));
@@ -2017,7 +2020,7 @@ class AudioReactive : public Usermod {
       top[FPSTR(_addPalettes)] = addPalettes;
 
 #ifdef ARDUINO_ARCH_ESP32
-    #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32S3)
+    #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
       JsonObject amic = top.createNestedObject(FPSTR(_analogmic));
       amic["pin"] = audioPin;
     #endif
@@ -2083,16 +2086,16 @@ class AudioReactive : public Usermod {
       configComplete &= getJsonValue(top[FPSTR(_addPalettes)], addPalettes);
 
 #ifdef ARDUINO_ARCH_ESP32
-    #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32S3)
+    #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
       configComplete &= getJsonValue(top[FPSTR(_analogmic)]["pin"], audioPin);
     #else
       audioPin = -1; // MCU does not support analog mic
     #endif
 
       configComplete &= getJsonValue(top[FPSTR(_digitalmic)]["type"],   dmType);
-    #if  defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32S3)
+    #if  defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
       if (dmType == 0) dmType = SR_DMTYPE;   // MCU does not support analog
-      #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5)
+      #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3)
       if (dmType == 5) dmType = SR_DMTYPE;   // MCU does not support PDM
       #endif
     #endif
@@ -2139,14 +2142,14 @@ class AudioReactive : public Usermod {
 #ifdef ARDUINO_ARCH_ESP32
       uiScript.print(F("uxp=ux+':digitalmic:pin[]';")); // uxp = shortcut for AudioReactive:digitalmic:pin[]
       uiScript.print(F("dd=addDropdown(ux,'digitalmic:type');"));
-    #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32S3)
+    #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
       uiScript.print(F("addOption(dd,'Generic Analog',0);"));
     #endif
       uiScript.print(F("addOption(dd,'Generic I2S',1);"));
       uiScript.print(F("addOption(dd,'ES7243',2);"));
       uiScript.print(F("addOption(dd,'SPH0654',3);"));
       uiScript.print(F("addOption(dd,'Generic I2S with Mclk',4);"));
-    #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32C6) && !defined(CONFIG_IDF_TARGET_ESP32C61)
+    #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3)
       uiScript.print(F("addOption(dd,'Generic PDM',5);"));
     #endif
     uiScript.print(F("addOption(dd,'ES8388',6);"));
@@ -2185,7 +2188,7 @@ class AudioReactive : public Usermod {
       uiScript.print(F("addInfo(uxp,0,'<i>sd/data/dout</i>','I2S SD');"));
       uiScript.print(F("addInfo(uxp,1,'<i>ws/clk/lrck</i>','I2S WS');"));
       uiScript.print(F("addInfo(uxp,2,'<i>sck/bclk</i>','I2S SCK');"));
-      #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32S3)
+      #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
         uiScript.print(F("addInfo(uxp,3,'<i>only use -1, 0, 1 or 3</i>','I2S MCLK');"));
       #else
         uiScript.print(F("addInfo(uxp,3,'<i>master clock</i>','I2S MCLK');"));
@@ -2306,7 +2309,7 @@ const char AudioReactive::_config[]     PROGMEM = "config";
 const char AudioReactive::_dynamics[]   PROGMEM = "dynamics";
 const char AudioReactive::_frequency[]  PROGMEM = "frequency";
 const char AudioReactive::_inputLvl[]   PROGMEM = "inputLevel";
-#if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32S3)
+#if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
 const char AudioReactive::_analogmic[]  PROGMEM = "analogmic";
 #endif
 const char AudioReactive::_digitalmic[] PROGMEM = "digitalmic";

usermods/audioreactive/audio_source.h

@@ -22,14 +22,14 @@
 
 // see https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/hw-reference/chip-series-comparison.html#related-documents
 // and https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-reference/peripherals/i2s.html#overview-of-all-modes
-#if defined(CONFIG_IDF_TARGET_ESP32C2) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61) || defined(CONFIG_IDF_TARGET_ESP32H2) || defined(ESP8266) || defined(ESP8265)
+#if defined(CONFIG_IDF_TARGET_ESP32C2) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32H2) || defined(ESP8266) || defined(ESP8265)
   // there are two things in these MCUs that could lead to problems with audio processing:
   // * no floating point hardware (FPU) support - FFT uses float calculations. If done in software, a strong slow-down can be expected (between 8x and 20x)
   // * single core, so FFT task might slow down other things like LED updates
   #if !defined(SOC_I2S_NUM) || (SOC_I2S_NUM < 1)
-  #error This audio reactive usermod does not support your MCU yet.
+  #error This audio reactive usermod does not support ESP32-C2 or ESP32-C3.
   #else
-  #warning This audio reactive usermod does not support your MCU yet.
+  #warning This audio reactive usermod does not support ESP32-C2 and ESP32-C3.
   #endif
 #endif
 

usermods/pixels_dice_tray/platformio_override.ini.sample

@@ -13,7 +13,7 @@ board_build.partitions = ${esp32.large_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 monitor_filters = esp32_exception_decoder
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"T-QT-PRO-8MB_dice\"
+build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=T-QT-PRO-8MB
   -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
   -D ARDUINO_USB_CDC_ON_BOOT=1 -D ARDUINO_USB_MODE=1      ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
   
@@ -75,7 +75,7 @@ board_build.partitions = ${esp32.large_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 monitor_filters = esp32_exception_decoder
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_8MB_qspi_dice\"
+build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_8MB_qspi
   -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
   -D ARDUINO_USB_CDC_ON_BOOT=1 -D ARDUINO_USB_MODE=1      ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
   
@@ -105,7 +105,7 @@ lib_deps = ${esp32s3.lib_deps}
 # https://github.com/wled-dev/WLED/issues/1382
 ; [env:esp32dev_dice]
 ; extends = env:esp32dev
-; build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=\"ESP32_dice\"
+; build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=ESP32
 ;   ; Enable Pixels dice mod
 ;   -D USERMOD_PIXELS_DICE_TRAY
 ; lib_deps = ${esp32.lib_deps}

usermods/pov_display/library.json

@@ -1,5 +1,5 @@
 {
-  "name": "pov_display",
+  "name:": "pov_display",
   "build": { "libArchive": false},
   "platforms": ["espressif32"]
 }

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;

usermods/sht/sht.cpp

@@ -143,13 +143,7 @@ void ShtUsermod::appendDeviceToMqttDiscoveryMessage(JsonDocument& root) {
   device[F("ids")] = escapedMac.c_str();
   device[F("name")] = serverDescription;
   device[F("sw")] = versionString;
-  // AI: below section was generated by an AI
-  #ifdef ARDUINO_ARCH_ESP32
   device[F("mdl")] = ESP.getChipModel();
-  #else
-  device[F("mdl")] = F("ESP8266");
-  #endif
-  // AI: end
   device[F("mf")] = F("espressif");
 }
 

usermods/usermod_v2_HttpPullLightControl/usermod_v2_HttpPullLightControl.cpp

@@ -71,7 +71,6 @@ String HttpPullLightControl::generateUniqueId() {
     unsigned char shaResult[20]; // SHA1 produces a hash of 20 bytes  (which is 40 HEX characters)
     mbedtls_sha1_context ctx;
     mbedtls_sha1_init(&ctx);
-#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
     status = mbedtls_sha1_starts_ret(&ctx);
     if (status != 0) {
       DEBUG_PRINTLN(F("Error starting SHA1 checksum calculation"));
@@ -84,21 +83,6 @@ String HttpPullLightControl::generateUniqueId() {
     if (status != 0) {
       DEBUG_PRINTLN(F("Error finishing SHA1 checksum calculation"));
     }
-#else
-    // function names have changed in esp-idf V5
-    status = mbedtls_sha1_starts(&ctx);
-    if (status != 0) {
-      DEBUG_PRINTLN(F("Error starting SHA1 checksum calculation"));
-    }
-    status = mbedtls_sha1_update(&ctx, reinterpret_cast<const unsigned char*>(input.c_str()), input.length());
-    if (status != 0) {
-      DEBUG_PRINTLN(F("Error feeding update buffer into ongoing SHA1 checksum calculation"));
-    }
-    status = mbedtls_sha1_finish(&ctx, shaResult);
-    if (status != 0) {
-      DEBUG_PRINTLN(F("Error finishing SHA1 checksum calculation"));
-    }
-#endif
     mbedtls_sha1_free(&ctx);
 
     // Convert the Hash to a hexadecimal string

usermods/usermod_v2_four_line_display_ALT/platformio_override.sample.ini

@@ -2,10 +2,10 @@
 default_envs = esp32dev_fld
 
 [env:esp32dev_fld]
-extends = env:esp32dev
-custom_usermods = ${env:esp32dev.custom_usermods} four_line_display_ALT
+extends = env:esp32dev_V4
+custom_usermods = ${env:esp32dev_V4.custom_usermods} four_line_display_ALT
 build_flags =
-    ${env:esp32dev.build_flags}
+    ${env:esp32dev_V4.build_flags}
     -D FLD_TYPE=SH1106
     -D I2CSCLPIN=27
     -D I2CSDAPIN=26

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);
 }
 

usermods/usermod_v2_rotary_encoder_ui_ALT/platformio_override.sample.ini

@@ -2,10 +2,10 @@
 default_envs = esp32dev_re
 
 [env:esp32dev_re]
-extends = env:esp32dev
-custom_usermods = ${env:esp32dev.custom_usermods} rotary_encoder_ui_ALT
+extends = env:esp32dev_V4
+custom_usermods = ${env:esp32dev_V4.custom_usermods} rotary_encoder_ui_ALT
 build_flags =
-    ${env:esp32dev.build_flags}
+    ${env:esp32dev_V4.build_flags}
     -D USERMOD_ROTARY_ENCODER_GPIO=INPUT
     -D ENCODER_DT_PIN=21
     -D ENCODER_CLK_PIN=23

wled00/FX.h

@@ -61,12 +61,10 @@ extern byte realtimeMode;           // used in getMappedPixelIndex()
 #define WLED_FPS         42
 #define FRAMETIME_FIXED  (1000/WLED_FPS)
 #define FRAMETIME        strip.getFrameTime()
-#if defined(ARDUINO_ARCH_ESP32)
-  #if (SOC_CPU_CORES_NUM < 2)
-    #define MIN_FRAME_DELAY  3                                            // S2/C3/C6/C5 are slower than normal esp32, and only have one core
-  #else
-    #define MIN_FRAME_DELAY  2                                            // classic esp32/S3/P4: minimum wait between repaints, to keep other functions like WiFi alive
-  #endif
+#if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S2)
+  #define MIN_FRAME_DELAY  2                                              // minimum wait between repaints, to keep other functions like WiFi alive 
+#elif defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3)
+  #define MIN_FRAME_DELAY  3                                              // S2/C3 are slower than normal esp32, and only have one core
 #else
   #define MIN_FRAME_DELAY  8                                              // 8266 legacy MIN_SHOW_DELAY
 #endif

wled00/FX_fcn.cpp

@@ -29,7 +29,9 @@
   19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 29, 28, 27, 26, 25]}
 */
 
-static_assert(MAX_NUM_SEGMENTS >= WLED_MAX_BUSSES, "Max segments must be at least max number of busses!");
+#if MAX_NUM_SEGMENTS < WLED_MAX_BUSSES
+  #error "Max segments must be at least max number of busses!"
+#endif
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1204,7 +1206,7 @@ void WS2812FX::finalizeInit() {
   BusManager::removeAll();
   // TODO: ideally we would free everything segment related here to reduce fragmentation (pixel buffers, ledamp, segments, etc) but that somehow leads to heap corruption if touchig any of the buffers.
   unsigned digitalCount = 0;
-  #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_HAS_PARALLEL_I2S)
+  #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3)
   // validate the bus config: count I2S buses and check if they meet requirements
   unsigned i2sBusCount = 0;
 
@@ -1246,7 +1248,7 @@ void WS2812FX::finalizeInit() {
     unsigned busMemUsage = bus.memUsage(); // does not include DMA/RMT buffer but includes pixel buffers (segment buffer + global buffer)
     mem += busMemUsage;
     // estimate maximum I2S memory usage (only relevant for digital non-2pin busses when I2S is enabled)
-    #if defined(WLED_HAS_PARALLEL_I2S)
+    #if !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(ESP8266)
     bool usesI2S = (bus.iType & 0x01) == 0; // I2S bus types are even numbered, can't use bus.driverType == 1 as getI() may have defaulted to RMT
     if (Bus::isDigital(bus.type) && !Bus::is2Pin(bus.type) && usesI2S) {
       #ifdef NPB_CONF_4STEP_CADENCE
@@ -1390,8 +1392,8 @@ static uint8_t _add       (uint8_t a, uint8_t b) { unsigned t = a + b; return t
 static uint8_t _subtract  (uint8_t a, uint8_t b) { return b > a ? (b - a) : 0; }
 static uint8_t _difference(uint8_t a, uint8_t b) { return b > a ? (b - a) : (a - b); }
 static uint8_t _average   (uint8_t a, uint8_t b) { return (a + b) >> 1; }
-#if !defined(WLED_HAVE_FAST_int_DIVIDE)
-static uint8_t _multiply  (uint8_t a, uint8_t b) { return ((a * b) + 255) >> 8; } // faster than division on C3/C5 but slightly less accurate
+#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)
+static uint8_t _multiply  (uint8_t a, uint8_t b) { return ((a * b) + 255) >> 8; } // faster than division on C3 but slightly less accurate
 #else
 static uint8_t _multiply  (uint8_t a, uint8_t b) { return (a * b) / 255; } // origianl uses a & b in range [0,1]
 #endif
@@ -1401,7 +1403,7 @@ static uint8_t _darken    (uint8_t a, uint8_t b) { return a < b ? a : b; }
 static uint8_t _screen    (uint8_t a, uint8_t b) { return 255 - _multiply(~a,~b); } // 255 - (255-a)*(255-b)/255
 static uint8_t _overlay   (uint8_t a, uint8_t b) { return b < 128 ? 2 * _multiply(a,b) : (255 - 2 * _multiply(~a,~b)); }
 static uint8_t _hardlight (uint8_t a, uint8_t b) { return a < 128 ? 2 * _multiply(a,b) : (255 - 2 * _multiply(~a,~b)); }
-#if !defined(WLED_HAVE_FAST_int_DIVIDE)
+#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)
 static uint8_t _softlight (uint8_t a, uint8_t b) { return (((b * b * (255 - 2 * a))) + ((2 * a * b + 256) << 8)) >> 16; } // Pegtop's formula (1 - 2a)b^2
 #else
 static uint8_t _softlight (uint8_t a, uint8_t b) { return (b * b * (255 - 2 * a) + 255 * 2 * a * b) / (255 * 255); } // Pegtop's formula (1 - 2a)b^2 + 2ab
@@ -1416,7 +1418,6 @@ static uint8_t _dummy     (uint8_t a, uint8_t b) { return a; } // dummy (same as
 void WS2812FX::blendSegment(const Segment &topSegment) const {
   typedef uint8_t(*FuncType)(uint8_t, uint8_t);
   // function pointer array: fill with _dummy if using special case: avoid OOB access and always provide a valid path
-  // note: making the function array static const uses more ram and comes at no significant speed gain
   FuncType funcs[] = {
     _dummy,      _dummy,     _dummy,    _subtract,
     _difference, _average,   _dummy,    _divide,
@@ -1448,71 +1449,14 @@ void WS2812FX::blendSegment(const Segment &topSegment) const {
   const size_t  matrixSize = Segment::maxWidth * Segment::maxHeight;
   const size_t  startIndx  = XY(topSegment.start, topSegment.startY);
   const size_t  stopIndx   = startIndx + length;
+  const unsigned progress  = topSegment.progress();
+  const unsigned progInv   = 0xFFFFU - progress;
   uint8_t       opacity    = topSegment.currentBri(); // returns transitioned opacity for style FADE
   uint8_t       cct        = topSegment.currentCCT();
   if (gammaCorrectCol) opacity = gamma8inv(opacity); // use inverse gamma on brightness for correct color scaling after gamma correction (see #5343 for details)
 
-  const Segment *segO = topSegment.getOldSegment();
-  const bool hasGrouping = topSegment.groupLength() != 1;
+  Segment::setClippingRect(0, 0);             // disable clipping by default
 
-  // fast path: handle the default case - no transitions, no grouping/spacing, no mirroring, no CCT
-  if (!segO && blendingStyle == TRANSITION_FADE && !hasGrouping && !topSegment.mirror && !topSegment.mirror_y) {
-    if (isMatrix && stopIndx <= matrixSize && !_pixelCCT) {
-#ifndef WLED_DISABLE_2D
-      // Calculate pointer steps to avoid 'if' and 'XY()' inside loops
-      int x_inc = 1;
-      int y_inc = Segment::maxWidth;
-      int start_offset = XY(topSegment.start, topSegment.startY);
-
-      // adjust starting position and steps based on Reverse/Transpose
-      // note: transpose is handled in separate loop so it is still fast and no branching is needed in default path
-      if (!topSegment.transpose) {
-        if (topSegment.reverse)   { start_offset += (width - 1); x_inc = -1; }
-        if (topSegment.reverse_y) { start_offset += (height - 1) * Segment::maxWidth; y_inc = -Segment::maxWidth; }
-
-        for (int y = 0; y < height; y++) {
-          uint32_t* pRow = &_pixels[start_offset + y * y_inc];
-          const int y_width = y * width;
-          for (int x = 0; x < width; x++) {
-            uint32_t* p = pRow + x * x_inc;
-            uint32_t c_a = topSegment.getPixelColorRaw(x + y_width);
-            *p = color_blend(*p, segblend(c_a, *p), opacity);
-          }
-        }
-      } else { // transposed
-        for (int y = 0; y < height; y++) {
-          const int px = topSegment.reverse ? (height - y - 1) : y;  // source pixel: swap y into x, reverse if needed
-          for (int x = 0; x < width; x++) {
-            const int py = topSegment.reverse_y ? (width  - x - 1) : x;  // source pixel: swap x into y, reverse if needed
-            const uint32_t c_a = topSegment.getPixelColorRaw(px + py * height); // height = virtual width
-            const size_t idx = XY(topSegment.start + x, topSegment.startY + y); // write logical (non swapped) pixel coordinate
-            _pixels[idx] = color_blend(_pixels[idx], segblend(c_a, _pixels[idx]), opacity);
-          }
-        }
-      }
-      return;
-#endif
-    } else if (!isMatrix) {
-      // 1D fast path, include CCT as it is more common on 1D setups
-      uint32_t* strip = _pixels;
-      int start = topSegment.start;
-      int off   = topSegment.offset;
-      for (int i = 0; i < length; i++) {
-        uint32_t c_a = topSegment.getPixelColorRaw(i);
-        int p = topSegment.reverse ? (length - i - 1) : i;
-        int idx = start + p + off;
-        if (idx >= topSegment.stop) idx -= length;
-        strip[idx] = color_blend(strip[idx], segblend(c_a, strip[idx]), opacity);
-        if (_pixelCCT) _pixelCCT[idx] = cct;
-      }
-      return;
-    }
-  }
-
-  // slow path: handle transitions, grouping/spacing, segments with clipping and CCT pixels
-  Segment::setClippingRect(0, 0);  // disable clipping by default
-  const unsigned progress = topSegment.progress();
-  const unsigned progInv  = 0xFFFFU - progress;
   const unsigned dw = (blendingStyle==TRANSITION_OUTSIDE_IN ? progInv : progress) * width / 0xFFFFU + 1;
   const unsigned dh = (blendingStyle==TRANSITION_OUTSIDE_IN ? progInv : progress) * height / 0xFFFFU + 1;
   const unsigned orgBS = blendingStyle;
@@ -1573,6 +1517,7 @@ void WS2812FX::blendSegment(const Segment &topSegment) const {
 #ifndef WLED_DISABLE_2D
     const int nCols = topSegment.virtualWidth();
     const int nRows = topSegment.virtualHeight();
+    const Segment *segO = topSegment.getOldSegment();
     const int oCols = segO ? segO->virtualWidth() : nCols;
     const int oRows = segO ? segO->virtualHeight() : nRows;
 
@@ -1668,8 +1613,8 @@ void WS2812FX::blendSegment(const Segment &topSegment) const {
     }
 #endif
   } else {
-    // 1D Slow Path
     const int nLen = topSegment.virtualLength();
+    const Segment *segO = topSegment.getOldSegment();
     const int oLen = segO ? segO->virtualLength() : nLen;
 
     const auto setMirroredPixel = [&](int i, uint32_t c, uint8_t o) {
@@ -1749,7 +1694,7 @@ void WS2812FX::show() {
 
   if (realtimeMode == REALTIME_MODE_INACTIVE || useMainSegmentOnly || realtimeOverride > REALTIME_OVERRIDE_NONE) {
     // clear frame buffer
-    memset(_pixels, 0, sizeof(uint32_t) * totalLen);
+    for (size_t i = 0; i < totalLen; i++) _pixels[i] = BLACK; // memset(_pixels, 0, sizeof(uint32_t) * getLengthTotal());
     // blend all segments into (cleared) buffer
     for (Segment &seg : _segments) if (seg.isActive() && (seg.on || seg.isInTransition())) {
       blendSegment(seg);              // blend segment's buffer into frame buffer

wled00/FXparticleSystem.cpp

@@ -500,7 +500,7 @@ void ParticleSystem2D::applyGravity(PSparticle &part) {
 // note: a coefficient smaller than 0 will speed them up (this is a feature, not a bug), coefficient larger than 255 inverts the speed, so don't do that
 void ParticleSystem2D::applyFriction(PSparticle &part, const int32_t coefficient) {
   // note: not checking if particle is dead can be done by caller (or can be omitted)
-  #if !defined(WLED_HAVE_FAST_int_DIVIDE) // use bitshifts with rounding instead of division (2x faster)
+  #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(ESP8266) // use bitshifts with rounding instead of division (2x faster)
   int32_t friction = 256 - coefficient;
   part.vx = ((int32_t)part.vx * friction + (((int32_t)part.vx >> 31) & 0xFF)) >> 8; // note: (v>>31) & 0xFF)) extracts the sign and adds 255 if negative for correct rounding using shifts
   part.vy = ((int32_t)part.vy * friction + (((int32_t)part.vy >> 31) & 0xFF)) >> 8;
@@ -514,7 +514,7 @@ void ParticleSystem2D::applyFriction(PSparticle &part, const int32_t coefficient
 // apply friction to all particles
 // note: not checking if particle is dead is faster as most are usually alive and if few are alive, rendering is fast anyways
 void ParticleSystem2D::applyFriction(const int32_t coefficient) {
-  #if !defined(WLED_HAVE_FAST_int_DIVIDE) // use bitshifts with rounding instead of division (2x faster)
+  #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(ESP8266) // use bitshifts with rounding instead of division (2x faster)
   int32_t friction = 256 - coefficient;
   for (uint32_t i = 0; i < usedParticles; i++) {
     particles[i].vx = ((int32_t)particles[i].vx * friction + (((int32_t)particles[i].vx >> 31) & 0xFF)) >> 8; // note: (v>>31) & 0xFF)) extracts the sign and adds 255 if negative for correct rounding using shifts
@@ -927,7 +927,7 @@ void WLED_O2_ATTR ParticleSystem2D::collideParticles(PSparticle &particle1, PSpa
     int32_t surfacehardness = max(collisionHardness, (int32_t)PS_P_MINSURFACEHARDNESS >> 1); // if particles are soft, the impulse must stay above a limit or collisions slip through at higher speeds, 170 seems to be a good value
     int32_t impulse = (((((-dotProduct) << 15) / distanceSquared) * surfacehardness) >> 8); // note: inverting before bitshift corrects for asymmetry in right-shifts (is slightly faster)
 
-    #if !defined(WLED_HAVE_FAST_int_DIVIDE) // use bitshifts with rounding instead of division (2x faster)
+    #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(ESP8266) // use bitshifts with rounding instead of division (2x faster)
     int32_t ximpulse = (impulse * dx + ((dx >> 31) & 0x7FFF)) >> 15; // note: extracting sign bit and adding rounding value to correct for asymmetry in right shifts
     int32_t yimpulse = (impulse * dy + ((dy >> 31) & 0x7FFF)) >> 15;
     #else
@@ -955,7 +955,7 @@ void WLED_O2_ATTR ParticleSystem2D::collideParticles(PSparticle &particle1, PSpa
     if (collisionHardness < PS_P_MINSURFACEHARDNESS && (SEGMENT.call & 0x07) == 0) { // if particles are soft, they become 'sticky' i.e. apply some friction (they do pile more nicely and stop sloshing around)
       const uint32_t coeff = collisionHardness + (255 - PS_P_MINSURFACEHARDNESS);
       // Note: could call applyFriction, but this is faster and speed is key here
-      #if !defined(WLED_HAVE_FAST_int_DIVIDE) // use bitshifts with rounding instead of division (2x faster)
+      #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(ESP8266) // use bitshifts with rounding instead of division (2x faster)
       particle1.vx = ((int32_t)particle1.vx * coeff + (((int32_t)particle1.vx >> 31) & 0xFF)) >> 8; // note: (v>>31) & 0xFF)) extracts the sign and adds 255 if negative for correct rounding using shifts
       particle1.vy = ((int32_t)particle1.vy * coeff + (((int32_t)particle1.vy >> 31) & 0xFF)) >> 8;
       particle2.vx = ((int32_t)particle2.vx * coeff + (((int32_t)particle2.vx >> 31) & 0xFF)) >> 8;
@@ -1408,7 +1408,7 @@ void ParticleSystem1D::applyGravity(PSparticle1D &part, PSparticleFlags1D &partF
 // slow down particle by friction, the higher the speed, the higher the friction. a high friction coefficient slows them more (255 means instant stop)
 // note: a coefficient smaller than 0 will speed them up (this is a feature, not a bug), coefficient larger than 255 inverts the speed, so don't do that
 void ParticleSystem1D::applyFriction(int32_t coefficient) {
-  #if !defined(WLED_HAVE_FAST_int_DIVIDE) // use bitshifts with rounding instead of division (2x faster)
+  #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(ESP8266) // use bitshifts with rounding instead of division (2x faster)
   int32_t friction = 256 - coefficient;
   for (uint32_t i = 0; i < usedParticles; i++) {
     if (particles[i].ttl)
@@ -1699,7 +1699,7 @@ void WLED_O2_ATTR ParticleSystem1D::collideParticles(uint32_t partIdx1, uint32_t
       }
       int32_t surfacehardness = max(collisionHardness, (int32_t)PS_P_MINSURFACEHARDNESS_1D); // if particles are soft, the impulse must stay above a limit or collisions slip through
       // Calculate new velocities after collision  note: not using dot product like in 2D as impulse is purely speed depnedent
-      #if !defined(WLED_HAVE_FAST_int_DIVIDE) // use bitshifts with rounding instead of division (2x faster)
+      #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(ESP8266) // use bitshifts with rounding instead of division (2x faster)
       int32_t impulse = (dv * surfacehardness + ((dv >> 31) & 0xFF)) >> 8; // note: (v>>31) & 0xFF)) extracts the sign and adds 255 if negative for correct rounding using shifts
       #else // division is faster on ESP32, S2 and S3
       int32_t impulse = (dv * surfacehardness) / 255;
@@ -1720,7 +1720,7 @@ void WLED_O2_ATTR ParticleSystem1D::collideParticles(uint32_t partIdx1, uint32_t
 
       if (collisionHardness < PS_P_MINSURFACEHARDNESS_1D && (SEGMENT.call & 0x07) == 0) { // if particles are soft, they become 'sticky' i.e. apply some friction
         const uint32_t coeff = collisionHardness + (250 - PS_P_MINSURFACEHARDNESS_1D);
-        #if !defined(WLED_HAVE_FAST_int_DIVIDE) // use bitshifts with rounding instead of division (2x faster)
+        #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(ESP8266) // use bitshifts with rounding instead of division (2x faster)
         particles[partIdx1].vx = ((int32_t)particles[partIdx1].vx * coeff + (((int32_t)particles[partIdx1].vx >> 31) & 0xFF)) >> 8; // note: (v>>31) & 0xFF)) extracts the sign and adds 255 if negative for correct rounding using shifts
         particles[partIdx2].vx = ((int32_t)particles[partIdx2].vx * coeff + (((int32_t)particles[partIdx2].vx >> 31) & 0xFF)) >> 8;
         #else // division is faster on ESP32, S2 and S3

wled00/NodeStruct.h

@@ -55,4 +55,4 @@ struct NodeStruct
 };
 typedef std::map<uint8_t, NodeStruct> NodesMap;
 
-#endif // WLED_NODESTRUCT_H
+#endif // WLED_NODESTRUCT_H

wled00/bus_manager.cpp

@@ -452,13 +452,8 @@ BusPwm::BusPwm(const BusConfig &bc)
       pinMode(_pins[i], OUTPUT);
       #else
       unsigned channel = _ledcStart + i;
-      #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
       ledcSetup(channel, _frequency, _depth - (dithering*4)); // with dithering _frequency doesn't really matter as resolution is 8 bit
       ledcAttachPin(_pins[i], channel);
-      #else
-      ledcAttachChannel(_pins[i], _frequency,  _depth - (dithering*4), channel);
-      // LEDC timer reset credit @dedehai
-      #endif
       // 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)
@@ -590,23 +585,10 @@ void BusPwm::show() {
     unsigned ch = channel%8;  // group channel
     // directly write to LEDC struct as there is no HAL exposed function for dithering
     // duty has 20 bit resolution with 4 fractional bits (24 bits in total)
-    #if defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61) || defined(CONFIG_IDF_TARGET_ESP32P4)
-    // TODO: we need a full rewrite of the "analog LEDs" driver!
-    //   see https://github.com/wled/WLED/pull/5048#discussion_r2794185845
-
-    // the .duty_init.duty member seems to only affect fade operations, and its necessary to also trigger an update with
-    // LEDC.channel_group[gr].channel[ch].conf0.para_up = 1;
-    // --> research latest (V5.5.x) esp-idf documentation on how to set the duty cycle registers (by API calls?).
-    //    https://docs.espressif.com/projects/esp-idf/en/v5.5.2/esp32c5/api-reference/peripherals/ledc.html#_CPPv424ledc_set_duty_and_update11ledc_mode_t14ledc_channel_t8uint32_t8uint32_t
-    //   LEDC.channel_group[gr].channel[ch].duty_init.duty = duty << ((!dithering)*4);  // C5 LEDC struct uses duty_init, but requires additional steps to activate
-    // TODO: find out if / how dithering support can be implemented on P4
-    ledc_set_duty_and_update((ledc_mode_t)gr, (ledc_channel_t)ch, duty >> bitShift, hPoint >> bitShift);
-    #else
     LEDC.channel_group[gr].channel[ch].duty.duty = duty << ((!dithering)*4);  // lowest 4 bits are used for dithering, shift by 4 bits if not using dithering
     LEDC.channel_group[gr].channel[ch].hpoint.hpoint = hPoint >> bitShift;    // hPoint is at _depth resolution (needs shifting if dithering)
     ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
-    #endif // ESP32C5
-    #endif // 8266
+    #endif
 
     if (!_reversed) hPoint += duty;
     hPoint += deadTime;        // offset to cascade the signals
@@ -641,11 +623,7 @@ void BusPwm::deallocatePins() {
     #ifdef ESP8266
     digitalWrite(_pins[i], LOW); //turn off PWM interrupt
     #else
-    #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
     if (_ledcStart < WLED_MAX_ANALOG_CHANNELS) ledcDetachPin(_pins[i]);
-    #else
-    if (_ledcStart < WLED_MAX_ANALOG_CHANNELS) ledcDetach(_pins[i]);
-    #endif
     #endif
   }
   #ifdef ARDUINO_ARCH_ESP32
@@ -766,7 +744,7 @@ size_t BusNetwork::getPins(uint8_t* pinArray) const {
 #ifdef ARDUINO_ARCH_ESP32
 void BusNetwork::resolveHostname() {
   static std::shared_ptr<AsyncDNS> DNSlookup; // TODO: make this dynamic? requires to handle the callback properly
-  if (WLEDNetwork.isConnected()) {
+  if (Network.isConnected()) {
     IPAddress clnt;
     if (strlen(cmDNS) > 0) {
       clnt = MDNS.queryHost(_hostname);
@@ -1361,10 +1339,6 @@ void BusManager::removeAll() {
 // since I2S outputs are known only during config of buses, lets just assume RMT is used for digital buses
 // unused RMT channels should have no effect
 void BusManager::esp32RMTInvertIdle() {
-#if defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61) || defined(CONFIG_IDF_TARGET_ESP32P4)
-  // ESP32-C5/C6/P4 use shared RMT method - idle level inversion not supported
-  return;
-#else
   bool idle_out;
   unsigned rmt = 0;
   unsigned u = 0;
@@ -1382,7 +1356,6 @@ void BusManager::esp32RMTInvertIdle() {
     rmt_set_idle_level(ch, idle_out, lvl);
     u++;
   }
-#endif
 }
 #endif
 

wled00/bus_wrapper.h

@@ -1,17 +1,10 @@
-#pragma once
+#pragma once
 #ifndef BusWrapper_h
 #define BusWrapper_h
 
 //#define NPB_CONF_4STEP_CADENCE
 #include "NeoPixelBus.h"
 
-#include "wled_boards.h"  // pull in board-specific capability defines
-
-#ifdef CONFIG_IDF_TARGET_ESP32C5
-// see https://github.com/wled/WLED/pull/5048#issuecomment-3937888182
-#warning "second output on -C5 may fail, until NPB channel handling is fixed"
-#endif
-
 //Hardware SPI Pins
 #define P_8266_HS_MOSI 13
 #define P_8266_HS_CLK  14
@@ -238,7 +231,7 @@
   typedef NeoEsp32I2s0Apa106Method X1Apa106Method;
   typedef NeoEsp32I2s0Ws2805Method X1Ws2805Method;
   typedef NeoEsp32I2s0Tm1914Method X1Tm1914Method;
-#elif !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32C6) && !defined(CONFIG_IDF_TARGET_ESP32C61) && !defined(CONFIG_IDF_TARGET_ESP32P4)
+#elif !defined(CONFIG_IDF_TARGET_ESP32C3)
   // regular ESP32 will use I2S1
   typedef NeoEsp32I2s1Ws2812xMethod X1Ws2812xMethod;
   typedef NeoEsp32I2s1Sk6812Method X1Sk6812Method;
@@ -252,9 +245,7 @@
 #endif
 
 // RMT driver selection
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-#define NeoEsp32RmtMethod(x) NeoEsp32RmtX ## x ## Method
-#elif !defined(WLED_USE_SHARED_RMT)  && !defined(__riscv)
+#if !defined(WLED_USE_SHARED_RMT)  && !defined(__riscv)
 #include <NeoEsp32RmtHIMethod.h>
 #define NeoEsp32RmtMethod(x) NeoEsp32RmtHIN ## x ## Method
 #else
@@ -463,7 +454,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: beginTM1914<B_32_RN_TM1914_3*>(busPtr); break;
       case I_32_RN_SM16825_5: (static_cast<B_32_RN_SM16825_5*>(busPtr))->Begin(); break;
       // I2S1 bus or parellel buses
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: if (_useParallelI2S) (static_cast<B_32_IP_NEO_3*>(busPtr))->Begin(); else (static_cast<B_32_I2_NEO_3*>(busPtr))->Begin(); break;
       case I_32_I2_NEO_4: if (_useParallelI2S) (static_cast<B_32_IP_NEO_4*>(busPtr))->Begin(); else (static_cast<B_32_I2_NEO_4*>(busPtr))->Begin(); break;
       case I_32_I2_400_3: if (_useParallelI2S) (static_cast<B_32_IP_400_3*>(busPtr))->Begin(); else (static_cast<B_32_I2_400_3*>(busPtr))->Begin(); break;
@@ -561,7 +552,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: busPtr = new B_32_RN_TM1914_3(len, pins[0], (NeoBusChannel)_rmtChannel++); break;
       case I_32_RN_SM16825_5: busPtr = new B_32_RN_SM16825_5(len, pins[0], (NeoBusChannel)_rmtChannel++); break;
       // I2S1 bus or paralell buses
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: if (_useParallelI2S) busPtr = new B_32_IP_NEO_3(len, pins[0]); else busPtr = new B_32_I2_NEO_3(len, pins[0]); break;
       case I_32_I2_NEO_4: if (_useParallelI2S) busPtr = new B_32_IP_NEO_4(len, pins[0]); else busPtr = new B_32_I2_NEO_4(len, pins[0]); break;
       case I_32_I2_400_3: if (_useParallelI2S) busPtr = new B_32_IP_400_3(len, pins[0]); else busPtr = new B_32_I2_400_3(len, pins[0]); break;
@@ -660,7 +651,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: (static_cast<B_32_RN_TM1914_3*>(busPtr))->Show(consistent); break;
       case I_32_RN_SM16825_5: (static_cast<B_32_RN_SM16825_5*>(busPtr))->Show(consistent); break;
       // I2S1 bus or paralell buses
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: if (_useParallelI2S) (static_cast<B_32_IP_NEO_3*>(busPtr))->Show(consistent); else (static_cast<B_32_I2_NEO_3*>(busPtr))->Show(consistent); break;
       case I_32_I2_NEO_4: if (_useParallelI2S) (static_cast<B_32_IP_NEO_4*>(busPtr))->Show(consistent); else (static_cast<B_32_I2_NEO_4*>(busPtr))->Show(consistent); break;
       case I_32_I2_400_3: if (_useParallelI2S) (static_cast<B_32_IP_400_3*>(busPtr))->Show(consistent); else (static_cast<B_32_I2_400_3*>(busPtr))->Show(consistent); break;
@@ -756,7 +747,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: return (static_cast<B_32_RN_TM1914_3*>(busPtr))->CanShow(); break;
       case I_32_RN_SM16825_5: return (static_cast<B_32_RN_SM16825_5*>(busPtr))->CanShow(); break;
       // I2S1 bus or paralell buses
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: if (_useParallelI2S) return (static_cast<B_32_IP_NEO_3*>(busPtr))->CanShow(); else return (static_cast<B_32_I2_NEO_3*>(busPtr))->CanShow(); break;
       case I_32_I2_NEO_4: if (_useParallelI2S) return (static_cast<B_32_IP_NEO_4*>(busPtr))->CanShow(); else return (static_cast<B_32_I2_NEO_4*>(busPtr))->CanShow(); break;
       case I_32_I2_400_3: if (_useParallelI2S) return (static_cast<B_32_IP_400_3*>(busPtr))->CanShow(); else return (static_cast<B_32_I2_400_3*>(busPtr))->CanShow(); break;
@@ -878,7 +869,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: (static_cast<B_32_RN_TM1914_3*>(busPtr))->SetPixelColor(pix, RgbColor(col)); break;
       case I_32_RN_SM16825_5: (static_cast<B_32_RN_SM16825_5*>(busPtr))->SetPixelColor(pix, Rgbww80Color(col.R*257, col.G*257, col.B*257, cctWW*257, cctCW*257)); break;
       // I2S1 bus or paralell buses
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: if (_useParallelI2S) (static_cast<B_32_IP_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col)); else (static_cast<B_32_I2_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col)); break;
       case I_32_I2_NEO_4: if (_useParallelI2S) (static_cast<B_32_IP_NEO_4*>(busPtr))->SetPixelColor(pix, col); else (static_cast<B_32_I2_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
       case I_32_I2_400_3: if (_useParallelI2S) (static_cast<B_32_IP_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col)); else (static_cast<B_32_I2_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col)); break;
@@ -975,7 +966,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: col = (static_cast<B_32_RN_TM1914_3*>(busPtr))->GetPixelColor(pix); break;
       case I_32_RN_SM16825_5: { Rgbww80Color c = (static_cast<B_32_RN_SM16825_5*>(busPtr))->GetPixelColor(pix); col = RGBW32(c.R/257,c.G/257,c.B/257,max(c.WW,c.CW)/257); } break; // will not return original W
       // I2S1 bus or paralell buses
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: col = (_useParallelI2S) ? (static_cast<B_32_IP_NEO_3*>(busPtr))->GetPixelColor(pix) : (static_cast<B_32_I2_NEO_3*>(busPtr))->GetPixelColor(pix); break;
       case I_32_I2_NEO_4: col = (_useParallelI2S) ? (static_cast<B_32_IP_NEO_4*>(busPtr))->GetPixelColor(pix) : (static_cast<B_32_I2_NEO_4*>(busPtr))->GetPixelColor(pix); break;
       case I_32_I2_400_3: col = (_useParallelI2S) ? (static_cast<B_32_IP_400_3*>(busPtr))->GetPixelColor(pix) : (static_cast<B_32_I2_400_3*>(busPtr))->GetPixelColor(pix); break;
@@ -1090,7 +1081,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: delete (static_cast<B_32_RN_TM1914_3*>(busPtr)); break;
       case I_32_RN_SM16825_5: delete (static_cast<B_32_RN_SM16825_5*>(busPtr)); break;
       // I2S1 bus or paralell buses
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: if (_useParallelI2S) delete (static_cast<B_32_IP_NEO_3*>(busPtr)); else delete (static_cast<B_32_I2_NEO_3*>(busPtr)); break;
       case I_32_I2_NEO_4: if (_useParallelI2S) delete (static_cast<B_32_IP_NEO_4*>(busPtr)); else delete (static_cast<B_32_I2_NEO_4*>(busPtr)); break;
       case I_32_I2_400_3: if (_useParallelI2S) delete (static_cast<B_32_IP_400_3*>(busPtr)); else delete (static_cast<B_32_I2_400_3*>(busPtr)); break;
@@ -1190,7 +1181,7 @@ class PolyBus {
       case I_32_RN_TM1914_3: size += (static_cast<B_32_RN_TM1914_3*>(busPtr))->PixelsSize()*2; break;
       case I_32_RN_SM16825_5: size += (static_cast<B_32_RN_SM16825_5*>(busPtr))->PixelsSize()*2; break;
       // I2S1 bus or paralell buses (front + DMA; DMA = front * cadence, aligned to 4 bytes) not: for parallel I2S only the largest bus counts for DMA memory, this is not done correctly here, also assumes 3-step cadence
-      #if defined(WLED_HAS_PARALLEL_I2S)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3: size += (_useParallelI2S) ? (static_cast<B_32_IP_NEO_3*>(busPtr))->PixelsSize()*4 : (static_cast<B_32_I2_NEO_3*>(busPtr))->PixelsSize()*4; break;
       case I_32_I2_NEO_4: size += (_useParallelI2S) ? (static_cast<B_32_IP_NEO_4*>(busPtr))->PixelsSize()*4 : (static_cast<B_32_I2_NEO_4*>(busPtr))->PixelsSize()*4; break;
       case I_32_I2_400_3: size += (_useParallelI2S) ? (static_cast<B_32_IP_400_3*>(busPtr))->PixelsSize()*4 : (static_cast<B_32_I2_400_3*>(busPtr))->PixelsSize()*4; break;
@@ -1270,7 +1261,7 @@ class PolyBus {
       case I_32_RN_2805_5   : size = (size + 2*count)*2;   break; // 5 channels
       case I_32_RN_SM16825_5: size = (size + 2*count)*2*2; break; // 16bit, 5 channels
       // I2S bus or paralell I2S buses (1x front, does not include DMA buffer which is front*cadence, a bit(?) more for LCD)
-      #if defined(WLED_HAS_PARALLEL_I2S) || defined(CONFIG_IDF_TARGET_ESP32)
+      #ifndef CONFIG_IDF_TARGET_ESP32C3
       case I_32_I2_NEO_3    : // fallthrough
       case I_32_I2_400_3    : // fallthrough
       case I_32_I2_TM2_3    : // fallthrough

wled00/button.cpp

@@ -109,7 +109,7 @@ bool isButtonPressed(uint8_t b)
       break;
     case BTN_TYPE_TOUCH:
     case BTN_TYPE_TOUCH_SWITCH:
-      #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32C6) && !defined(CONFIG_IDF_TARGET_ESP32C61) && !defined(CONFIG_IDF_TARGET_ESP32P4)
+      #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3)
         #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
@@ -396,9 +396,7 @@ void handleOnOff(bool forceOff)
   }
 }
 
-#ifdef SOC_TOUCH_VERSION_2 //ESP32 S2 and S3 provide a function to check touch state (state is updated in interrupt)
 void IRAM_ATTR touchButtonISR()
 {
   // used for ESP32 S2 and S3: nothing to do, ISR is just used to update registers of HAL driver
 }
-#endif

wled00/cfg.cpp

@@ -159,17 +159,9 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   noWifiSleep = !(wifi[F("sleep")] | !noWifiSleep); // inverted
   //noWifiSleep = !noWifiSleep;
   CJSON(force802_3g, wifi[F("phy")]); //force phy mode g?
-#ifdef SOC_WIFI_SUPPORT_5G
-  CJSON(wifiBandMode, wifi[F("band")]);
-  if (wifiBandMode < WIFI_BAND_MODE_2G_ONLY || wifiBandMode > WIFI_BAND_MODE_AUTO) wifiBandMode = WIFI_BAND_MODE_AUTO;
-#endif
 #ifdef ARDUINO_ARCH_ESP32
   CJSON(txPower, wifi[F("txpwr")]);
-  #if defined(ARDUINO_ARCH_ESP32) && (ESP_IDF_VERSION_MAJOR > 4)
-    txPower = min(max((int)txPower, (int)WIFI_POWER_2dBm), (int)WIFI_POWER_21dBm);  // V5 allows WIFI_POWER_21dBm = 84 ... WIFI_POWER_MINUS_1dBm = -4
-  #else
-    txPower = min(max((int)txPower, (int)WIFI_POWER_2dBm), (int)WIFI_POWER_19_5dBm);
-  #endif
+  txPower = min(max((int)txPower, (int)WIFI_POWER_2dBm), (int)WIFI_POWER_19_5dBm);
 #endif
 
   JsonObject hw = doc[F("hw")];
@@ -669,12 +661,6 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
 
   JsonObject if_ntp = interfaces[F("ntp")];
   CJSON(ntpEnabled, if_ntp["en"]);
-#ifdef CONFIG_IDF_TARGET_ESP32C5 // ToDO: esp32-c5 crashes on NTP requests, see https://github.com/wled/WLED/pull/5048/changes#r3003182550
-  if (ntpEnabled) { DEBUG_PRINTLN("NTP disabled on -C5, as it leads to crashes"); }
-                                 // assert failed: udp_new_ip_type /IDF/components/lwip/lwip/src/core/udp.c:1278 (Required to lock TCPIP core functionality!)
-  ntpEnabled = false;            // --> disable NTP support, until the crash is resolved
-  #warning "enabling NTP lead to crashes on -C5. NTP disabled"
-#endif
   getStringFromJson(ntpServerName, if_ntp[F("host")], 33); // "1.wled.pool.ntp.org"
   CJSON(currentTimezone, if_ntp[F("tz")]);
   CJSON(utcOffsetSecs, if_ntp[F("offset")]);
@@ -923,9 +909,6 @@ void serializeConfig(JsonObject root) {
   JsonObject wifi = root.createNestedObject(F("wifi"));
   wifi[F("sleep")] = !noWifiSleep;
   wifi[F("phy")] = force802_3g;
-#ifdef SOC_WIFI_SUPPORT_5G
-  wifi[F("band")] = wifiBandMode;
-#endif
 #ifdef ARDUINO_ARCH_ESP32
   wifi[F("txpwr")] = txPower;
 #endif

wled00/const.h

@@ -73,18 +73,8 @@ constexpr size_t  WLED_MAX_USERMOD_PALETTES     = WLED_USERMOD_PALETTE_ID_BASE -
   #if !defined(LEDC_CHANNEL_MAX) || !defined(LEDC_SPEED_MODE_MAX)
     #include "driver/ledc.h" // needed for analog/LEDC channel counts
   #endif
-
-  // define -> constexpr to avoid preprocessor errors and enum arithmetic warnings from newer compilers
-  #ifdef WLED_MAX_ANALOG_CHANNELS
-    #undef WLED_MAX_ANALOG_CHANNELS   // avoid clash between macro name and constexpr constant
-  #endif
-  constexpr size_t WLED_MAX_ANALOG_CHANNELS = static_cast<size_t>(LEDC_CHANNEL_MAX) * static_cast<size_t>(LEDC_SPEED_MODE_MAX);
-
-  // ToDO: check if the complete logic below can be replaced by SOC_CAPS_.. macros
-  //       SOC_I2S_NUM, SOC_RMT_CHANNELS_PER_GROUP, etc
-  //       see https://github.com/wled/WLED/pull/5048#issuecomment-3868678248
-
-  #if defined(CONFIG_IDF_TARGET_ESP32C3)
+  #define WLED_MAX_ANALOG_CHANNELS (LEDC_CHANNEL_MAX*LEDC_SPEED_MODE_MAX)
+  #if defined(CONFIG_IDF_TARGET_ESP32C3)    // 2 RMT, 6 LEDC, only has 1 I2S but NPB does not support it ATM
     #define WLED_MAX_RMT_CHANNELS 2         // ESP32-C3 has 2 RMT output channels
     #define WLED_MAX_I2S_CHANNELS 0         // I2S not supported by NPB
     //#define WLED_MAX_ANALOG_CHANNELS 6
@@ -100,32 +90,20 @@ constexpr size_t  WLED_MAX_USERMOD_PALETTES     = WLED_USERMOD_PALETTE_ID_BASE -
     //#define WLED_MAX_ANALOG_CHANNELS 8
     #define WLED_PLATFORM_ID 3       // used in UI to distinguish ESP type in UI, needs a proper fix!
   #else
-    #if defined(CONFIG_IDF_TARGET_ESP32)  // classic esp32
-      #define WLED_MAX_RMT_CHANNELS 8         // ESP32 has 8 RMT output channels
-      #define WLED_MAX_I2S_CHANNELS 8         // I2S parallel output supported by NPB
-      //#define WLED_MAX_ANALOG_CHANNELS 16
-      #define WLED_PLATFORM_ID 4       // used in UI to distinguish ESP type in UI, needs a proper fix!
-    #else // all other risc-v based boards: same as C3
-      #define WLED_MAX_RMT_CHANNELS 2         // ESP32-C3 has 2 RMT output channels
-      #define WLED_MAX_I2S_CHANNELS 0         // I2S not supported by NPB
-      //#define WLED_MAX_ANALOG_CHANNELS 6
-      #define WLED_PLATFORM_ID 1       // used in UI to distinguish ESP types - falls back to "C3" until we have a proper fix!
-    #endif      
+    #define WLED_MAX_RMT_CHANNELS 8         // ESP32 has 8 RMT output channels
+    #define WLED_MAX_I2S_CHANNELS 8         // I2S parallel output supported by NPB
+    //#define WLED_MAX_ANALOG_CHANNELS 16
+    #define WLED_PLATFORM_ID 4       // used in UI to distinguish ESP type in UI, needs a proper fix!
   #endif
   #define WLED_MAX_TIMERS 64                // maximum number of timers
-  #ifndef WLED_MAX_DIGITAL_CHANNELS
-    #define WLED_MAX_DIGITAL_CHANNELS (WLED_MAX_RMT_CHANNELS + WLED_MAX_I2S_CHANNELS)
-  #else
-    #warning "buildenv overrides WLED_MAX_DIGITAL_CHANNELS - please check that the value is correct" 
-  #endif
+  #define WLED_MAX_DIGITAL_CHANNELS (WLED_MAX_RMT_CHANNELS + WLED_MAX_I2S_CHANNELS)
 #endif
 // WLED_MAX_BUSSES was used to define the size of busses[] array which is no longer needed
 // instead it will help determine max number of buses that can be defined at compile time
 #ifdef WLED_MAX_BUSSES
   #undef WLED_MAX_BUSSES
 #endif
-// define -> constexpr to align with definition of WLED_MAX_ANALOG_CHANNELS
-constexpr size_t WLED_MAX_BUSSES = WLED_MAX_DIGITAL_CHANNELS + WLED_MAX_ANALOG_CHANNELS;
+#define WLED_MAX_BUSSES (WLED_MAX_DIGITAL_CHANNELS+WLED_MAX_ANALOG_CHANNELS)
 static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");
 
 // Maximum number of pins per output. 5 for RGBCCT analog LEDs.
@@ -567,10 +545,8 @@ static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");
     #define MAX_LEDS 1536 //can't rely on memory limit to limit this to 1536 LEDs
   #elif defined(CONFIG_IDF_TARGET_ESP32S2)
     #define MAX_LEDS 2048 //due to memory constraints S2
-  #elif defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61)
-    #define MAX_LEDS 4096
   #else
-    #define MAX_LEDS 16384 // classic esp32, S3 and P4 can take more
+    #define MAX_LEDS 16384
   #endif
 #endif
 
@@ -579,15 +555,15 @@ static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");
   #ifdef ESP8266
     #define MAX_LED_MEMORY (8*1024)
   #else
-    #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C61)
+    #if defined(CONFIG_IDF_TARGET_ESP32S2)
       #ifndef BOARD_HAS_PSRAM
         #define MAX_LED_MEMORY (28*1024)  // S2 has ~170k of free heap after boot, using 28k is the absolute limit to keep WLED functional
       #else
         #define MAX_LED_MEMORY (48*1024)  // with PSRAM there is more wiggle room as buffers get moved to PSRAM when needed (prioritize functionality over speed)
       #endif
-    #elif defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32P4)
+    #elif defined(CONFIG_IDF_TARGET_ESP32S3)
       #define MAX_LED_MEMORY (192*1024) // S3 has ~330k of free heap after boot
-    #elif defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C6)
+    #elif defined(CONFIG_IDF_TARGET_ESP32C3)
       #define MAX_LED_MEMORY (100*1024) // C3 has ~240k of free heap after boot, even with 8000 LEDs configured (2D) there is 30k of contiguous heap left
     #else
       #define MAX_LED_MEMORY (85*1024) // ESP32 has ~160k of free heap after boot and an additional 64k of 32bit access memory that is used for pixel buffers
@@ -703,7 +679,7 @@ static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");
 #endif
 
 // Defaults pins, type and counts to configure LED output
-#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61) || defined(CONFIG_IDF_TARGET_ESP32P4)
+#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)
   #ifdef WLED_ENABLE_DMX
     #define DEFAULT_LED_PIN 1
     #warning "Compiling with DMX. The default LED pin has been changed to pin 1."

wled00/data/index.js

@@ -721,7 +721,6 @@ ${urows===""?'':'<tr><td colspan=2><hr style="height:1px;border-width:0;color:gr
 ${i.opt&0x100?inforow("Debug","<button class=\"btn btn-xs\" onclick=\"requestJson({'debug':"+(i.opt&0x0080?"false":"true")+"});\"><i class=\"icons "+(i.opt&0x0080?"on":"off")+"\">&#xe08f;</i></button>"):''}
 ${inforow("Build",i.vid)}
 ${inforow("Signal strength",i.wifi.signal +"% ("+ i.wifi.rssi, " dBm)")}
-${i.wifi.band?inforow("WiFi band",i.wifi.band + " (Ch " + i.wifi.channel + ")"):""}
 ${inforow("Uptime",getRuntimeStr(i.uptime))}
 ${inforow("Time",i.time)}
 ${inforow("Free heap",(i.freeheap/1024).toFixed(1)," kB")}

wled00/data/settings_wifi.htm

@@ -69,7 +69,7 @@
 							const option = cE("option");
 
 							option.setAttribute("value", networks[i].ssid);
-							option.textContent = `${networks[i].ssid} (${networks[i].rssi} dBm, Ch ${networks[i].channel})`; // [${networks[i].bssid.replaceAll(':','')}]
+							option.textContent = `${networks[i].ssid} (${networks[i].rssi} dBm)`; // [${networks[i].bssid.replaceAll(':','')}]
 
 							if (networks[i].ssid === input.value) {
 								option.setAttribute("selected", "selected");
@@ -274,15 +274,7 @@ Static subnet mask:<br>
 		Disable WiFi sleep: <input type="checkbox" name="WS"><br>
 		<i>Disabling WiFi sleep increases power consumption<br>
 		but can help with connectivity issues and sync.</i><br><br>
-		<div id="bm">WiFi band: <select name="BM">
-			<option value="1">2.4 GHz only</option>
-			<option value="2">5 GHz only</option>
-			<option value="3">Auto (both)</option>
-		</select><br></div>
-		<div id="tx">Max. TX power: <select name="TX">  <!-- V5 framework allows  84 = 21dBm ... -4 = Minus_1dBm -->
-			<option value="84">21 dBm</option>
-			<option value="82">20.5 dBm</option>
-			<option value="80">20 dBm</option>
+		<div id="tx">Max. TX power: <select name="TX">
 			<option value="78">19.5 dBm</option>
 			<option value="76">19 dBm</option>
 			<option value="74">18.5 dBm</option>

wled00/dmx_input.cpp

@@ -1,7 +1,6 @@
 #include "wled.h"
 
 #ifdef WLED_ENABLE_DMX_INPUT
-#pragma message "DMX physical input driver enabled"
 
 #ifdef ESP8266
 #error DMX input is only supported on ESP32
@@ -10,8 +9,8 @@
 #include "dmx_input.h"
 #include <rdm/responder.h>
 
-void rdmPersonalityChangedCb(dmx_port_t dmxPort, rdm_header_t *request_header,
-                             rdm_header_t *response_header, void *context)
+void rdmPersonalityChangedCb(dmx_port_t dmxPort, const rdm_header_t *header,
+                             void *context)
 {
   DMXInput *dmx = static_cast<DMXInput *>(context);
 
@@ -20,16 +19,16 @@ void rdmPersonalityChangedCb(dmx_port_t dmxPort, rdm_header_t *request_header,
     return;
   }
 
-  if (response_header->cc == RDM_CC_SET_COMMAND_RESPONSE) {
+  if (header->cc == RDM_CC_SET_COMMAND_RESPONSE) {
     const uint8_t personality = dmx_get_current_personality(dmx->inputPortNum);
     DMXMode = std::min(DMX_MODE_PRESET, std::max(DMX_MODE_SINGLE_RGB, int(personality)));
     configNeedsWrite = true;
-    DEBUG_PRINTF("DMX personality changed to: %d\n", DMXMode);
+    DEBUG_PRINTF("DMX personality changed to to: %d\n", DMXMode);
   }
 }
 
-void rdmAddressChangedCb(dmx_port_t dmxPort, rdm_header_t *request_header,
-                         rdm_header_t *response_header, void *context)
+void rdmAddressChangedCb(dmx_port_t dmxPort, const rdm_header_t *header,
+                         void *context)
 {
   DMXInput *dmx = static_cast<DMXInput *>(context);
 
@@ -38,7 +37,7 @@ void rdmAddressChangedCb(dmx_port_t dmxPort, rdm_header_t *request_header,
     return;
   }
 
-  if (response_header->cc == RDM_CC_SET_COMMAND_RESPONSE) {
+  if (header->cc == RDM_CC_SET_COMMAND_RESPONSE) {
     const uint16_t addr = dmx_get_start_address(dmx->inputPortNum);
     DMXAddress = std::min(512, int(addr));
     configNeedsWrite = true;
@@ -48,13 +47,14 @@ void rdmAddressChangedCb(dmx_port_t dmxPort, rdm_header_t *request_header,
 
 static dmx_config_t createConfig()
 {
-  dmx_config_t config = DMX_CONFIG_DEFAULT;
+  dmx_config_t config;
+  config.pd_size = 255;
+  config.dmx_start_address = DMXAddress;
   config.model_id = 0;
   config.product_category = RDM_PRODUCT_CATEGORY_FIXTURE;
   config.software_version_id = VERSION;
+  strcpy(config.device_label, "WLED_MM");
 
-#if 0
-  // softhack007: ToDO: current code from main does not work in V5 yet
   const std::string dmxWledVersionString = "WLED_V" + std::to_string(VERSION);
   strncpy(config.software_version_label, dmxWledVersionString.c_str(), 32);
   config.software_version_label[32] = '\0'; // zero termination in case versionString string was longer than 32 chars
@@ -83,51 +83,10 @@ static dmx_config_t createConfig()
   config.personality_count = 10;
   // rdm personalities are numbered from 1, thus we can just set the DMXMode directly.
   config.current_personality = DMXMode;
-  #else
-    // fallback code
-    const std::string DmxVersionString = "WLED_V" + std::to_string(VERSION);
-    config.software_version_label = DmxVersionString.c_str();
-  #endif
 
   return config;
 }
 
-static dmx_personality_t personalities[10];
-
-static void createPersonalities()
-{
-  // Initialize personalities array
-  strncpy(personalities[0].description, "SINGLE_RGB", 32);
-  personalities[0].footprint = 3;
-
-  strncpy(personalities[1].description, "SINGLE_DRGB", 32);
-  personalities[1].footprint = 4;
-
-  strncpy(personalities[2].description, "EFFECT", 32);
-  personalities[2].footprint = 15;
-
-  strncpy(personalities[3].description, "MULTIPLE_RGB", 32);
-  personalities[3].footprint = std::min(512, int(strip.getLengthTotal()) * 3);
-
-  strncpy(personalities[4].description, "MULTIPLE_DRGB", 32);
-  personalities[4].footprint = std::min(512, int(strip.getLengthTotal()) * 3 + 1);
-
-  strncpy(personalities[5].description, "MULTIPLE_RGBW", 32);
-  personalities[5].footprint = std::min(512, int(strip.getLengthTotal()) * 4);
-
-  strncpy(personalities[6].description, "EFFECT_W", 32);
-  personalities[6].footprint = 18;
-
-  strncpy(personalities[7].description, "EFFECT_SEGMENT", 32);
-  personalities[7].footprint = std::min(512, strip.getSegmentsNum() * 15);
-
-  strncpy(personalities[8].description, "EFFECT_SEGMENT_W", 32);
-  personalities[8].footprint = std::min(512, strip.getSegmentsNum() * 18);
-
-  strncpy(personalities[9].description, "PRESET", 32);
-  personalities[9].footprint = 1;
-}
-
 void dmxReceiverTask(void *context)
 {
   DMXInput *instance = static_cast<DMXInput *>(context);
@@ -144,11 +103,10 @@ void dmxReceiverTask(void *context)
 
 bool DMXInput::installDriver()
 {
-  const auto config = createConfig();
-  createPersonalities();
 
+  const auto config = createConfig();
   DEBUG_PRINTF("DMX port: %u\n", inputPortNum);
-  if (!dmx_driver_install(inputPortNum, &config, personalities, 10)) {
+  if (!dmx_driver_install(inputPortNum, &config, DMX_INTR_FLAGS_DEFAULT)) {
     DEBUG_PRINTF("Error: Failed to install dmx driver\n");
     return false;
   }
@@ -158,14 +116,8 @@ bool DMXInput::installDriver()
   DEBUG_PRINTF("DMX enable pin is: %u\n", enPin);
   dmx_set_pin(inputPortNum, txPin, rxPin, enPin);
 
-  // Set initial DMX start address and personality
-  dmx_set_start_address(inputPortNum, DMXAddress);
-  dmx_set_current_personality(inputPortNum, DMXMode);
-
-  // Register RDM callbacks for start address and personality changes
   rdm_register_dmx_start_address(inputPortNum, rdmAddressChangedCb, this);
-  rdm_register_dmx_personality(inputPortNum, 10, rdmPersonalityChangedCb, this);
-
+  rdm_register_dmx_personality(inputPortNum, rdmPersonalityChangedCb, this);
   initialized = true;
   return true;
 }
@@ -199,9 +151,9 @@ void DMXInput::init(int8_t rxPin, int8_t txPin, int8_t enPin, uint8_t inputPortN
     const bool pinsAllocated = PinManager::allocateMultiplePins(pins, 3, PinOwner::DMX_INPUT);
     if (!pinsAllocated) {
       DEBUG_PRINTF("DMXInput: Error: Failed to allocate pins for DMX_INPUT. Pins already in use:\n");
-      DEBUG_PRINTF("rx in use by: %hhd\n", PinManager::getPinOwner(rxPin));
-      DEBUG_PRINTF("tx in use by: %hhd\n", PinManager::getPinOwner(txPin));
-      DEBUG_PRINTF("en in use by: %hhd\n", PinManager::getPinOwner(enPin));
+      DEBUG_PRINTF("rx in use by: %s\n", PinManager::getPinOwner(rxPin));
+      DEBUG_PRINTF("tx in use by: %s\n", PinManager::getPinOwner(txPin));
+      DEBUG_PRINTF("en in use by: %s\n", PinManager::getPinOwner(enPin));
       return;
     }
 
@@ -295,11 +247,12 @@ void DMXInput::enable()
 
 bool DMXInput::isIdentifyOn() const
 {
-  bool identify = false;
+
+  uint8_t identify = 0;
   const bool gotIdentify = rdm_get_identify_device(inputPortNum, &identify);
   // gotIdentify should never be false because it is a default parameter in rdm
   // but just in case we check for it anyway
-  return identify && gotIdentify;
+  return bool(identify) && gotIdentify;
 }
 
 void DMXInput::checkAndUpdateConfig()
@@ -324,4 +277,4 @@ void DMXInput::checkAndUpdateConfig()
   }
 }
 
-#endif
+#endif

wled00/dmx_input.h

@@ -42,12 +42,12 @@ private:
   void updateInternal();
 
   // is invoked whenver the dmx start address is changed via rdm
-  friend void rdmAddressChangedCb(dmx_port_t dmxPort, rdm_header_t *request_header,
-                                  rdm_header_t *response_header, void *context);
+  friend void rdmAddressChangedCb(dmx_port_t dmxPort, const rdm_header_t *header,
+                                  void *context);
 
   // is invoked whenever the personality is changed via rdm
-  friend void rdmPersonalityChangedCb(dmx_port_t dmxPort, rdm_header_t *request_header,
-                                      rdm_header_t *response_header, void *context);
+  friend void rdmPersonalityChangedCb(dmx_port_t dmxPort, const rdm_header_t *header,
+                                      void *context);
 
   /// The internal dmx task.
   /// This is the main loop of the dmx receiver. It never returns.

wled00/dmx_output.cpp

@@ -69,7 +69,7 @@ void handleDMXOutput()
 }
 
 void initDMXOutput() {
- #if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61) || defined(CONFIG_IDF_TARGET_ESP32S2)
+ #if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2)
   dmx.init(512);        // initialize with bus length
  #else
   dmx.initWrite(512);  // initialize with bus length

wled00/e131.cpp

@@ -106,17 +106,12 @@ void handleE131Packet(e131_packet_t* p, IPAddress clientIP, byte protocol, size_
       handleArtnetPollReply(clientIP);
       return;
     }
-    if (packetLen < 18) return; // need art_length (offset 16, 2 bytes) for DMX data
     uni = p->art_universe;
     dmxChannels = htons(p->art_length);
-    const int artNetMaxData = (packetLen >= 18) ? (int)(packetLen - 18) : 0; // art_data at offset 18; clamp so e131_data[dmxChannels] stays in bounds
-    if (dmxChannels > artNetMaxData) dmxChannels = artNetMaxData;
-    if (dmxChannels > MAX_CHANNELS_PER_UNIVERSE) dmxChannels = MAX_CHANNELS_PER_UNIVERSE;
     e131_data = p->art_data;
     seq = p->art_sequence_number;
     mde = REALTIME_MODE_ARTNET;
   } else if (protocol == P_E131) {
-    if (packetLen < 126) return; // need up to property_values[0] (offset 125) and property_value_count (offset 123)
     // Ignore PREVIEW data (E1.31: 6.2.6)
     if ((p->options & 0x80) != 0) return;
     dmxChannels = htons(p->property_value_count) - 1; // on malformed packets, this can become negative, checked below
@@ -125,9 +120,6 @@ void handleE131Packet(e131_packet_t* p, IPAddress clientIP, byte protocol, size_
     uni = htons(p->universe);
     e131_data = p->property_values;
     seq = p->sequence_number;
-    const int e131MaxData = (packetLen > 126) ? (int)(packetLen - 126) : 0; // property_values at offset 125; clamp so e131_data[dmxChannels] stays in bounds
-    if (dmxChannels > e131MaxData) dmxChannels = e131MaxData;
-    if (dmxChannels > MAX_CHANNELS_PER_UNIVERSE) dmxChannels = MAX_CHANNELS_PER_UNIVERSE;
     if (e131Priority != 0) {
       if (p->priority < e131Priority ) return;
       // track highest priority & skip all lower priorities
@@ -143,10 +135,8 @@ void handleE131Packet(e131_packet_t* p, IPAddress clientIP, byte protocol, size_
   #ifdef WLED_ENABLE_DMX
   // does not act on out-of-order packets yet
   if (e131ProxyUniverse > 0 && uni == e131ProxyUniverse) {
-    // Art-Net: art_data is 0-indexed (channel 1 at index 0)
-    // E1.31: property_values[0] is start code, (channel 1 at index 1)
     for (uint16_t i = 1; i <= dmxChannels; i++)
-      dmx.write(i, mde == REALTIME_MODE_ARTNET ? e131_data[i-1] : e131_data[i]);
+      dmx.write(i, e131_data[i]);
     dmx.update();
   }
   #endif
@@ -457,7 +447,7 @@ static 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];
   }
@@ -532,7 +522,7 @@ static 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];

wled00/fcn_declare.h

@@ -3,13 +3,6 @@
 #define WLED_FCN_DECLARE_H
 #include <dynarray.h>
 
-// dummy macro for 8266
-#ifndef ARDUINO_ARCH_ESP32
-#ifndef ESP_IDF_VERSION_VAL
-#define ESP_IDF_VERSION_VAL(n1,n2,n3) 500
-#endif
-#endif
-
 #include "colors.h"
 
 /*
@@ -32,9 +25,7 @@ bool isButtonPressed(uint8_t b=0);
 void handleButton();
 void handleOnOff(bool forceOff = false);
 void handleIO();
-#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
 void IRAM_ATTR touchButtonISR();
-#endif
 
 //cfg.cpp
 bool backupConfig();
@@ -460,12 +451,8 @@ uint8_t extractModeSlider(uint8_t mode, uint8_t slider, char *dest, uint8_t maxL
 int16_t extractModeDefaults(uint8_t mode, const char *segVar);
 void checkSettingsPIN(const char *pin);
 uint16_t crc16(const unsigned char* data_p, size_t length);
-
-#if !defined(ARDUINO_ARCH_ESP32) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 0, 0)) // ToDO: verify that this works correctly in V5
 String computeSHA1(const String& input);
 String getDeviceId();
-#endif
-
 uint16_t beat88(uint16_t beats_per_minute_88, uint32_t timebase = 0);
 uint16_t beat16(uint16_t beats_per_minute, uint32_t timebase = 0);
 uint8_t beat8(uint16_t beats_per_minute, uint32_t timebase = 0);

wled00/file.cpp

@@ -188,7 +188,6 @@ static bool appendObjectToFile(const char* key, const JsonDocument* content, uin
   if (f.size() < 3) {
     char init[10];
     strcpy_P(init, PSTR("{\"0\":{}}"));
-    f.seek(0, SeekSet);           // rewind to ensure we overwrite from the start, instead of appending
     f.print(init);
   }
 

wled00/improv.cpp

@@ -10,7 +10,7 @@
   #define DIMPROV_PRINTF(x...)
 #endif
 
-#if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32S3) // ToDO check if C6, C61, P4 support this
+#if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
 #undef WLED_DISABLE_IMPROV_WIFISCAN
 #define WLED_DISABLE_IMPROV_WIFISCAN
 #endif
@@ -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};

wled00/json.cpp

@@ -531,9 +531,7 @@ bool deserializeState(JsonObject root, byte callMode, byte presetId)
     if (root["win"].isNull() && getVal(root["ps"], presetCycCurr, 1, 250) && presetCycCurr > 0 && presetCycCurr < 251 && presetCycCurr != currentPreset) {
       DEBUG_PRINTF_P(PSTR("Preset select: %d\n"), presetCycCurr);
       // b) preset ID only or preset that does not change state (use embedded cycling limits if they exist in getVal())
-      // async load from file system (only preset ID was specified)
-      // avoid propogating CALL_MODE_INIT, which may cause accidental recursion
-      applyPreset(presetCycCurr, callMode == CALL_MODE_INIT ? CALL_MODE_DIRECT_CHANGE : callMode);
+      applyPreset(presetCycCurr, callMode); // async load from file system (only preset ID was specified)
       return stateResponse;
     } else presetCycCurr = currentPreset; // restore presetCycCurr
   }
@@ -710,14 +708,7 @@ void serializeInfo(JsonObject root)
   root[F("cn")] = F(WLED_CODENAME);
   root[F("release")] = releaseString;
   root[F("repo")] = repoString;
-#if !defined(ARDUINO_ARCH_ESP32) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 0, 0)) // ToDO: verify that this works correctly in V5
   root[F("deviceId")] = getDeviceId();
-#else
-  //#if defined(ARDUINO_ARCH_ESP32) && !defined(WLED_DISABLE_OTA)
-  // fake 38char fingerprint from bootloaderSHA1. WARNING: only for testing, not suitable for production!
-  //root[F("deviceId")] = String("0000") + getBootloaderSHA256Hex().substring(4, 34) + String("0000");
-  //#endif
-#endif
 
   JsonObject leds = root.createNestedObject(F("leds"));
   leds[F("count")] = strip.getLengthTotal();
@@ -823,18 +814,7 @@ void serializeInfo(JsonObject root)
   int qrssi = WiFi.RSSI();
   wifi_info[F("rssi")] = qrssi;
   wifi_info[F("signal")] = getSignalQuality(qrssi);
-  int wifiChannel = WiFi.channel();
-  wifi_info[F("channel")] = wifiChannel;
-  if ((wifiChannel > 0) && (unsigned(WiFi.status()) < unsigned(WL_CONNECT_FAILED))) { // Wifi Status > 3 are error statuses (disconnected, stopped, signal lost)
-    #if defined(ARDUINO_ARCH_ESP32) && SOC_WIFI_SUPPORT_5G
-      auto wifiBand = WiFi.getBand();
-      wifi_info[F("band")] = wifiBand == WIFI_BAND_2G ? F("2.4GHz") : (wifiBand == WIFI_BAND_5G ? F("5GHz"): F("(other)"));
-    #else
-      wifi_info[F("band")] = F("2.4GHz");
-    #endif
-  } else {
-    wifi_info[F("band")] = F("not connected");
-  }
+  wifi_info[F("channel")] = WiFi.channel();
   wifi_info[F("ap")] = apActive;
 
   JsonObject fs_info = root.createNestedObject("fs");
@@ -929,9 +909,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;
@@ -1061,9 +1041,6 @@ void serializeNetworks(JsonObject root)
 
   switch (status) {
     case WIFI_SCAN_FAILED:
-      #if defined(SOC_WIFI_SUPPORT_5G) && (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2))
-      if (!WiFi.setBandMode(wifi_band_mode_t(wifiBandMode))) { DEBUG_PRINTLN(F("serializeNetworks(): WiFi band configuration failed!")); }
-      #endif
       WiFi.scanNetworks(true);
       return;
     case WIFI_SCAN_RUNNING:
@@ -1148,21 +1125,6 @@ void serializePins(JsonObject root)
     #elif defined(CONFIG_IDF_TARGET_ESP32) // ESP32 classic
     if (gpio == 0) caps |= PIN_CAP_BOOT; // pull low to enter bootloader mode
     if (gpio == 2 || gpio == 12) caps |= PIN_CAP_BOOTSTRAP; // note: if GPIO12 must be low at boot, (high=1.8V flash mode), GPIO 2 must be low or floating to enter bootloader mode
-    #elif defined(CONFIG_IDF_TARGET_ESP32C5)
-    if (gpio == 28) caps |= PIN_CAP_BOOT;  // pull low to enter bootloader mode
-    if (gpio == 27) caps |= PIN_CAP_BOOTSTRAP; // must be high when GPIO28 is low for download mode
-    if (gpio == 2 || gpio == 3 || gpio == 7 || gpio == 25 || gpio == 26) caps |= PIN_CAP_BOOTSTRAP; // additional C5 strapping pins per Espressif boot configuration docs
-    #elif defined(CONFIG_IDF_TARGET_ESP32C6)
-    if (gpio == 9) caps |= PIN_CAP_BOOT;   // pull low to enter bootloader mode
-    if (gpio == 8) caps |= PIN_CAP_BOOTSTRAP; // must be high when GPIO9 is low for download mode
-    if (gpio == 4 || gpio == 5 || gpio == 15) caps |= PIN_CAP_BOOTSTRAP; // additional C6 strapping pins per Espressif strapping-pin docs
-    #elif defined(CONFIG_IDF_TARGET_ESP32C61)
-    if (gpio == 9) caps |= PIN_CAP_BOOT;   // pull low to enter bootloader mode
-    if (gpio == 8) caps |= PIN_CAP_BOOTSTRAP; // must be high when GPIO9 is low for download mode
-    if (gpio == 7 || gpio == 3 || gpio == 4) caps |= PIN_CAP_BOOTSTRAP; //  GPIO7, MTMS, and MTDI are also strapping pins
-    #elif defined(CONFIG_IDF_TARGET_ESP32P4)
-    if (gpio == 35) caps |= PIN_CAP_BOOT;  // pull low to enter bootloader mode
-    if (gpio == 36) caps |= PIN_CAP_BOOTSTRAP; // must be high when GPIO35 is low for download mode    
     #endif
     #else
     // ESP8266: GPIO 0-16 + GPIO17=A0

wled00/mbedtls_sha1_shim.cpp

@@ -1,51 +0,0 @@
-#include "wled.h"
-#ifdef ESP32
-// ESP32-C5 on pioarduino uses IDF 5.5+ which has SHA1 built-in, skip shim
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 2, 0) && ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 5, 0)
-#include "mbedtls/sha1.h"
-#include "SHA1Builder.h"
-
-// Wrapper functions to map mbedtls SHA1 calls to Arduino SHA1Builder
-// This is needed because ESP-IDF 5.x disables SHA1 in mbedtls by default
-
-struct mbedtls_sha1_context_wrapper {
-    SHA1Builder builder;
-};
-
-extern "C" {
-
-void mbedtls_sha1_init(mbedtls_sha1_context *ctx) {
-    // Allocate wrapper
-    auto* wrapper = new mbedtls_sha1_context_wrapper();
-    *(void**)ctx = wrapper;
-}
-
-int mbedtls_sha1_starts(mbedtls_sha1_context *ctx) {
-    auto* wrapper = *(mbedtls_sha1_context_wrapper**)ctx;
-    wrapper->builder.begin();
-    return 0;
-}
-
-int mbedtls_sha1_update(mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen) {
-    auto* wrapper = *(mbedtls_sha1_context_wrapper**)ctx;
-    wrapper->builder.add((const uint8_t*)input, ilen);
-    return 0;
-}
-
-int mbedtls_sha1_finish(mbedtls_sha1_context *ctx, unsigned char output[20]) {
-    auto* wrapper = *(mbedtls_sha1_context_wrapper**)ctx;
-    wrapper->builder.calculate();
-    wrapper->builder.getBytes(output);
-    return 0;
-}
-
-void mbedtls_sha1_free(mbedtls_sha1_context *ctx) {
-    auto* wrapper = *(mbedtls_sha1_context_wrapper**)ctx;
-    delete wrapper;
-}
-
-} // extern "C"
-
-#endif
-
-#endif

wled00/network.cpp

@@ -4,7 +4,6 @@
 
 
 #if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
-#if CONFIG_IDF_TARGET_ESP32 // these options are only valid for classic esp32
 // The following six pins are neither configurable nor
 // can they be re-assigned through IOMUX / GPIO matrix.
 // See https://docs.espressif.com/projects/esp-idf/en/latest/esp32/hw-reference/esp32/get-started-ethernet-kit-v1.1.html#ip101gri-phy-interface
@@ -149,10 +148,10 @@ const ethernet_settings ethernetBoards[] = {
 
  // Gledopto Series With Ethernet
  {
-    1,                    // eth_address,
-    5,                    // eth_power,
-    23,                   // eth_mdc,
-    33,                   // eth_mdio,
+    1,                    // eth_address, 
+    5,                    // eth_power, 
+    23,                   // eth_mdc, 
+    33,                   // eth_mdio, 
     ETH_PHY_LAN8720,      // eth_type,
     ETH_CLOCK_GPIO0_IN	 // eth_clk_mode
   },
@@ -180,15 +179,6 @@ const ethernet_settings ethernetBoards[] = {
 
 // sanity checks for ethernet config table and WLED_ETH_DEFAULT
 static_assert((sizeof(ethernetBoards)/sizeof(ethernetBoards[0])) == WLED_NUM_ETH_TYPES, "WLED_NUM_ETH_TYPES does not match size of ethernetBoards[] table.");
-
-#elif CONFIG_IDF_TARGET_ESP32P4
-// ToDO: add P4 specific ethernet options
-#error "Ethernet is not yet supported on your ESP32-P4".
-
-#else
-#error "Ethernet is not yet supported on your MCU".
-#endif
-
 #ifdef WLED_ETH_DEFAULT
   static_assert(((WLED_ETH_DEFAULT) >= WLED_ETH_NONE) && ((WLED_ETH_DEFAULT) < WLED_NUM_ETH_TYPES), "WLED_ETH_DEFAULT is out of range.");
 #endif
@@ -267,16 +257,6 @@ bool initEthernet()
   }
   #endif
 
-#if defined(ESP_IDF_VERSION) && (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0))
-  if (!ETH.begin(    // parameter order in V5 has changed
-                (eth_phy_type_t)   es.eth_type,
-                (int32_t) es.eth_address,
-                (int)     es.eth_mdc,
-                (int)     es.eth_mdio,
-                (int)     es.eth_power,
-                (eth_clock_mode_t) es.eth_clk_mode
-                )) {
-#else
   if (!ETH.begin(
                 (uint8_t) es.eth_address,
                 (int)     es.eth_power,
@@ -285,7 +265,6 @@ bool initEthernet()
                 (eth_phy_type_t)   es.eth_type,
                 (eth_clock_mode_t) es.eth_clk_mode
                 )) {
-#endif
     DEBUG_PRINTLN(F("initE: ETH.begin() failed"));
     // de-allocate the allocated pins
     for (managed_pin_type mpt : pinsToAllocate) {
@@ -360,7 +339,7 @@ int findWiFi(bool doScan) {
   } else if (status >= 0) {   // status contains number of found networks (including duplicate SSIDs with different BSSID)
     DEBUG_PRINTF_P(PSTR("WiFi: Found %d SSIDs. @ %lus\n"), status, millis()/1000);
     int rssi = -9999;
-    size_t selected = (static_cast<size_t>(selectedWiFi) < multiWiFi.size()) ? static_cast<size_t>(selectedWiFi) : 0; // ensure valid starting index
+    int selected = selectedWiFi;
     for (int o = 0; o < status; o++) {
       DEBUG_PRINTF_P(PSTR(" SSID: %s (BSSID: %s) RSSI: %ddB\n"), WiFi.SSID(o).c_str(), WiFi.BSSIDstr(o).c_str(), WiFi.RSSI(o));
       for (unsigned n = 0; n < multiWiFi.size(); n++)
@@ -451,7 +430,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

wled00/ntp.cpp

@@ -197,11 +197,7 @@ void handleNetworkTime()
     if (millis() - ntpPacketSentTime > 10000)
     {
       #ifdef ARDUINO_ARCH_ESP32   // I had problems using udp.flush() on 8266
-      #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-        while (ntpUdp.parsePacket() > 0) ntpUdp.clear();  // flush() is deprecated in arduino-esp32 3.x.y
-      #else
-        while (ntpUdp.parsePacket() > 0) ntpUdp.flush(); // flush any existing packets
-      #endif
+      while (ntpUdp.parsePacket() > 0) ntpUdp.flush(); // flush any existing packets
       #endif
       if (!ntpServerIP.fromString(ntpServerName)) // check if server is IP or domain
       {
@@ -290,11 +286,7 @@ static bool checkNTPResponse()
   int cb = ntpUdp.parsePacket();
   if (cb < NTP_MIN_PACKET_SIZE) {
     #ifdef ARDUINO_ARCH_ESP32   // I had problems using udp.flush() on 8266
-    #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-      if (cb > 0) ntpUdp.clear();  // flush() is deprecated in arduino-esp32 3.x.y
-    #else
-      if (cb > 0) ntpUdp.flush();  // this avoids memory leaks on esp32
-    #endif
+    if (cb > 0) ntpUdp.flush();  // this avoids memory leaks on esp32
     #endif
     return false;
   }

wled00/ota_update.cpp

@@ -13,8 +13,8 @@ constexpr size_t METADATA_OFFSET = 256;          // ESP32: metadata appears afte
 
 // Bootloader is at fixed offset 0x1000 (4KB), 0x0000 (0KB), or 0x2000 (8KB), and is typically 32KB
 // Bootloader offsets for different MCUs => see https://github.com/wled/WLED/issues/5064
-#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61)
-constexpr size_t BOOTLOADER_OFFSET = 0x0000; // esp32-S3, esp32-C3, esp32-c6, and (future support) esp32-c61
+#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C6)
+constexpr size_t BOOTLOADER_OFFSET = 0x0000; // esp32-S3, esp32-C3 and (future support) esp32-c6
 constexpr size_t BOOTLOADER_SIZE   = 0x8000; // 32KB, typical bootloader size
 #define BOOTLOADER_OTA_UNSUPPORTED    // still needs validation on these platforms.
 #elif defined(CONFIG_IDF_TARGET_ESP32P4) || defined(CONFIG_IDF_TARGET_ESP32C5)

wled00/pin_manager.cpp

@@ -232,49 +232,6 @@ bool PinManager::isPinOk(byte gpio, bool output)
     if (gpio > 21 && gpio < 33) return false;     // 22 to 32: not connected + SPI FLASH
     // JTAG: GPIO39-42 are usually used for inline debugging
     // GPIO46 is input only and pulled down
-  #elif defined(CONFIG_IDF_TARGET_ESP32C5)
-    // strapping pins: (2), 7, 25, 26, 27, 28 (GPIO2 is not a strapping pin; it's used only for external JTAG when GPIO7 selects it)
-    // GPIO 0-15 directly usable, 16-22 are for SPI flash
-    if (gpio > 15 && gpio < 23) return false;     // 16-22 SPI FLASH
-    #if ARDUINO_USB_CDC_ON_BOOT == 1 || ARDUINO_USB_DFU_ON_BOOT == 1
-    if (gpio == 13 || gpio == 14) return false;   // 13-14 USB-JTAG
-    #endif
-  #elif defined(CONFIG_IDF_TARGET_ESP32C6)
-    // strapping pins: 4, 5, 8, 9, 15  (GPIO4/MTMS and GPIO5/MTDI are also strapping pins)
-    // GPIO 0-23 directly usable, 24-30 are for SPI flash
-    if (gpio > 23 && gpio < 31) return false;     // 24-30 SPI FLASH
-    #if ARDUINO_USB_CDC_ON_BOOT == 1 || ARDUINO_USB_DFU_ON_BOOT == 1
-    if (gpio == 12 || gpio == 13) return false;   // 12-13 USB-JTAG
-    #endif
-  #elif defined(CONFIG_IDF_TARGET_ESP32C61) // prelim. entry for C61. ToDO: Validate pins
-    // strapping pins: MTMS, MTDI, GPIO7, GPIO8, GPIO9
-    // SPI flash/PSRAM interface: GPIO14-17 and GPIO19-21 (GPIO18 is free)
-    if (gpio > 13 && gpio < 18) return false;            // 14-17 SPI FLASH
-    if (gpio > 18 && gpio < 22) return false;            // 19-21 SPI FLASH
-    #if ARDUINO_USB_CDC_ON_BOOT == 1 || ARDUINO_USB_DFU_ON_BOOT == 1
-    if (gpio == 12 || gpio == 13) return false;          // 12-13 USB-JTAG
-    #endif
-  #elif defined(CONFIG_IDF_TARGET_ESP32P4)
-    // based on P4 port by troyhacks https://github.com/troyhacks/WLED/tree/P4_experimental
-    // strapping pins: 34,35,36,37,38
-    // Hide all pins not available on connector except pins we need to assign to things later, like I2S
-    // TODO: this list is over-protective - clean up later.
-    if (             gpio ==  9) return false;     // I2S Sound Output Pin
-    if (gpio > 13 && gpio <  20) return false;     // ESP-Hosted WiFi pins
-    #if ARDUINO_USB_CDC_ON_BOOT == 1 || ARDUINO_USB_DFU_ON_BOOT == 1
-      if (gpio > 23 && gpio <  26) return false;     // USB Pins
-    #endif
-    if (gpio > 27 && gpio <  32) return false;     // Ethernet pins
-    if (gpio > 33 && gpio <  36) return false;     // Ethernet pins - boot button is on 35 and works... but messes with Ethernet if enabled in WLED
-    if (gpio > 38 && gpio <  45) return false;     // SD1 Pins
-    if (gpio > 48 && gpio <  53) return false;     // Ethernet pins & others
-    if (             gpio == 54) return false;     // C6 WiFi EN pin
-    // 
-    // 24-25 is is USB, but so is 26-27 but they're exposed on the header and work OK for pin outout.
-    // 6 is C5 wakeup - but works fine for pin outout.
-    // 45 is SD power but it's NC without hacking the board.
-    // 53 is for PA enable but it's exposed on header and works for WLED pin output. Best to not use it but left available.
-    // 54 is "C6 EN pin" so I guess we shouldn't touch it.
   #else
 
     if ((strncmp_P(PSTR("ESP32-U4WDH"), ESP.getChipModel(), 11) == 0) ||    // this is the correct identifier, but....
@@ -412,20 +369,11 @@ bool PinManager::isAnalogPin(byte gpio) {
   #elif CONFIG_IDF_TARGET_ESP32S3
   // ESP32-S3: ADC1 channels 0-9 (GPIO 1-10)
   int adc_channel = digitalPinToAnalogChannel(gpio);
-  if (adc_channel >= 0 && adc_channel <= 9) return true; // ADC-1
-  // ESP32-S3: ADC2 channels 0-9
-  if ((adc_channel >= SOC_ADC_CHANNEL_NUM(0)) && ((adc_channel - SOC_ADC_CHANNEL_NUM(0)) < SOC_ADC_CHANNEL_NUM(1))) return true; // ADC-2
+  if (adc_channel >= 0 && adc_channel <= 9) return true;
   #elif CONFIG_IDF_TARGET_ESP32C3
   // ESP32-C3: ADC1 channels 0-4 (GPIO 0-4)
   int adc_channel = digitalPinToAnalogChannel(gpio);
   if (adc_channel >= 0 && adc_channel <= 4) return true;
-  #else // C5, C6, C61, P4 - use generic SOC capability macros
-  int adc_channel = digitalPinToAnalogChannel(gpio);
-  if ((adc_channel < 0) || (adc_channel >= (SOC_ADC_PERIPH_NUM * SOC_ADC_MAX_CHANNEL_NUM))) return false; // out of range
-  if (adc_channel < SOC_ADC_CHANNEL_NUM(0)) return true;                                                  // ADC-1
-  #if SOC_ADC_PERIPH_NUM > 1
-  if ((adc_channel >= SOC_ADC_CHANNEL_NUM(0)) && ((adc_channel - SOC_ADC_CHANNEL_NUM(0)) < SOC_ADC_CHANNEL_NUM(1))) return true; // ADC-2
-  #endif 
   #endif
   #endif
   return false; // not an analog pin if it doesn't have ADC capability, ESP8266 has only one ADC pin (A0) which is handled separately in button.cpp, so return false for all pins here

wled00/presets.cpp

@@ -194,8 +194,8 @@ void handlePresets()
     changePreset = true;
   } else {
     if (!fdo["seg"].isNull() || !fdo["on"].isNull() || !fdo["bri"].isNull() || !fdo["nl"].isNull() || !fdo["ps"].isNull() || !fdo[F("playlist")].isNull()) changePreset = true;
-    if (!(tmpMode == CALL_MODE_INIT || (tmpMode == CALL_MODE_BUTTON_PRESET && fdo["ps"].is<const char *>() && strchr(fdo["ps"].as<const char *>(),'~') != strrchr(fdo["ps"].as<const char *>(),'~'))))
-      fdo.remove("ps"); // remove load request for presets to prevent recursive crash (if not called by boot preset or button which contains preset cycling string "1~5~")
+    if (!(tmpMode == CALL_MODE_BUTTON_PRESET && fdo["ps"].is<const char *>() && strchr(fdo["ps"].as<const char *>(),'~') != strrchr(fdo["ps"].as<const char *>(),'~')))
+      fdo.remove("ps"); // remove load request for presets to prevent recursive crash (if not called by button and contains preset cycling string "1~5~")
     deserializeState(fdo, CALL_MODE_NO_NOTIFY, tmpPreset); // may change presetToApply by calling applyPreset()
   }
   if (!errorFlag && tmpPreset < 255 && changePreset) currentPreset = tmpPreset;

wled00/remote.cpp

@@ -1,13 +1,6 @@
 #include "wled.h"
 #ifndef WLED_DISABLE_ESPNOW
 
-// Sanity check: -P4 does not support esp-now
-#if defined(ARDUINO_ARCH_ESP32) && (ESP_IDF_VERSION_MAJOR > 4)
-  #if CONFIG_ESP_WIFI_REMOTE_ENABLED
-    #error "ESP-NOW is not supported on your MCU. Only SoCs with native Wi-Fi support have ESP-NOW."
-  #endif
-#endif
-
 #define ESPNOW_BUSWAIT_TIMEOUT 24 // one frame timeout to wait for bus to finish updating
 
 #define NIGHT_MODE_DEACTIVATED     -1

wled00/set.cpp

@@ -118,27 +118,11 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
 
     #ifdef ARDUINO_ARCH_ESP32
     int tx = request->arg(F("TX")).toInt();
-    #if (ESP_IDF_VERSION_MAJOR > 4)
-      txPower = min(max((int)tx, (int)WIFI_POWER_2dBm), (int)WIFI_POWER_21dBm);  // V5 allows WIFI_POWER_21dBm = 84 ... WIFI_POWER_MINUS_1dBm = -4
-    #else
-      txPower = min(max((int)tx, (int)WIFI_POWER_2dBm), (int)WIFI_POWER_19_5dBm);
-    #endif
+    txPower = min(max(tx, (int)WIFI_POWER_2dBm), (int)WIFI_POWER_19_5dBm);
     #endif
 
     force802_3g = request->hasArg(F("FG"));
     noWifiSleep = request->hasArg(F("WS"));
-    #ifdef SOC_WIFI_SUPPORT_5G
-    if (request->hasArg(F("BM"))) {
-      int bm = request->arg(F("BM")).toInt();
-      if (bm >= WIFI_BAND_MODE_2G_ONLY && bm <= WIFI_BAND_MODE_AUTO) {
-        if (bm != wifiBandMode) { 
-          forceReconnect = true;
-          WiFi.scanDelete();
-        }
-        wifiBandMode = bm;
-      }
-    }
-    #endif
 
     #ifndef WLED_DISABLE_ESPNOW
     bool oldESPNow = enableESPNow;
@@ -356,7 +340,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
             PinManager::deallocatePin(buttons[i].pin, PinOwner::Button);
             buttons[i].type = BTN_TYPE_NONE;
           }
-          #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
+          #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(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
@@ -548,11 +532,6 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
   if (subPage == SUBPAGE_TIME)
   {
     ntpEnabled = request->hasArg(F("NT"));
-#ifdef CONFIG_IDF_TARGET_ESP32C5 // ToDO: esp32-c5 crashes on NTP requests: assert failed: udp_new_ip_type udp.c:1278 (Required to lock TCPIP core functionality!)
-    if (ntpEnabled) { DEBUG_PRINTLN("NTP disabled on -C5, as it leads to crashes"); }
-    ntpEnabled = false;
-    #warning "enabling NTP lead to crashes on -C5. NTP disabled"
-#endif
     strlcpy(ntpServerName, request->arg(F("NS")).c_str(), 33);
     useAMPM = !request->hasArg(F("CF"));
     currentTimezone = request->arg(F("TZ")).toInt();

wled00/src/dependencies/dmx/ESPDMX.cpp

@@ -11,7 +11,7 @@
 // - - - - -
 
 /* ----- LIBRARIES ----- */
-#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61) || defined(CONFIG_IDF_TARGET_ESP32S2)
+#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2)
 
 #include <Arduino.h>
 

wled00/src/dependencies/dmx/SparkFunDMX.cpp

@@ -17,7 +17,7 @@ Distributed as-is; no warranty is given.
 #if defined(ARDUINO_ARCH_ESP32)
 
 #include <Arduino.h>
-#if !defined(ESP8266) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32C6) && !defined(CONFIG_IDF_TARGET_ESP32C61) && !defined(CONFIG_IDF_TARGET_ESP32S2)
+#if !defined(CONFIG_IDF_TARGET_ESP32C3)  && !defined(CONFIG_IDF_TARGET_ESP32S2)
 
 #include "SparkFunDMX.h"
 #include <HardwareSerial.h>

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)
@@ -110,24 +110,24 @@ void ESPAsyncE131::parsePacket(AsyncUDPPacket _packet) {
       protocol = P_E131;
   }
 
-  if (protocol == P_ARTNET) {
-    if (memcmp(sbuff->art_id, ESPAsyncE131::ART_ID, sizeof(sbuff->art_id)))
-      error = true; //not ART_ID = "Art-Net"
-    if (sbuff->art_opcode != ARTNET_OPCODE_OPDMX && sbuff->art_opcode != ARTNET_OPCODE_OPPOLL)
-      error = true; //not a DMX or poll packet
-  } else { //E1.31 error handling
-    if (pktLen < 126) { // need up to property_values[0] at offset 125
-      error = true;
+	if (protocol == P_ARTNET) {
+    if (pktLen < 10) {
+      error = true; // Need at least Art-Net ID (8) + opcode (2)
     } else {
-      if (htonl(sbuff->root_vector) != ESPAsyncE131::VECTOR_ROOT)
-        error = true;
-      if (htonl(sbuff->frame_vector) != ESPAsyncE131::VECTOR_FRAME)
-        error = true;
-      if (sbuff->dmp_vector != ESPAsyncE131::VECTOR_DMP)
-        error = true;
-      if (sbuff->property_values[0] != 0)
-        error = true;
+      if (memcmp(sbuff->art_id, ESPAsyncE131::ART_ID, sizeof(sbuff->art_id)))
+        error = true; //not "Art-Net"
+      if (sbuff->art_opcode != ARTNET_OPCODE_OPDMX && sbuff->art_opcode != ARTNET_OPCODE_OPPOLL)
+        error = true; //not a DMX or poll packet
     }
+  } else { //E1.31 error handling
+    if (htonl(sbuff->root_vector) != ESPAsyncE131::VECTOR_ROOT)
+      error = true;
+    if (htonl(sbuff->frame_vector) != ESPAsyncE131::VECTOR_FRAME)
+      error = true;
+    if (sbuff->dmp_vector != ESPAsyncE131::VECTOR_DMP)
+      error = true;
+    if (sbuff->property_values[0] != 0)
+      error = true;
   }
 
   if (error && _packet.localPort() == DDP_DEFAULT_PORT) { //DDP packet

wled00/src/dependencies/e131/ESPAsyncE131.h

@@ -272,4 +272,4 @@ class E131Priority {
     }
 };
 
-#endif  // ESPASYNCE131_H_
+#endif  // ESPASYNCE131_H_

wled00/src/dependencies/espalexa/Espalexa.h

@@ -1,4 +1,4 @@
-#ifndef Espalexa_h
+#ifndef Espalexa_h
 #define Espalexa_h
 
 /*
@@ -18,14 +18,6 @@
 
 #include "Arduino.h"
 
-// dummy macro for 8266
-#ifndef ARDUINO_ARCH_ESP32
-#ifndef ESP_IDF_VERSION_VAL
-#define ESP_IDF_VERSION_VAL(n1,n2,n3) 500
-#define ESPALEXA_DEFINED_ESP_IDF_VERSION_VAL 1  // remember to undef this later
-#endif
-#endif
-
 //you can use these defines for library config in your sketch. Just use them before #include <Espalexa.h>
 //#define ESPALEXA_ASYNC
 
@@ -224,7 +216,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];
@@ -260,10 +252,10 @@ private:
     #ifdef ESPALEXA_ASYNC
     if (serverAsync == nullptr) {
       serverAsync = new AsyncWebServer(80);
-      serverAsync->onNotFound([this](AsyncWebServerRequest *request){server = request; serveNotFound();}); // fix: implicit capture of "this"
+      serverAsync->onNotFound([=](AsyncWebServerRequest *request){server = request; serveNotFound();});
     }
     
-    serverAsync->onRequestBody([this](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){ // fix: implicit capture of "this"
+    serverAsync->onRequestBody([=](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){
       char b[len +1];
       b[len] = 0;
       memcpy(b, data, len);
@@ -272,9 +264,9 @@ private:
       EA_DEBUGLN(body);
     });
     #ifndef ESPALEXA_NO_SUBPAGE
-    serverAsync->on("/espalexa", HTTP_GET, [this](AsyncWebServerRequest *request){server = request; servePage();});
+    serverAsync->on("/espalexa", HTTP_GET, [=](AsyncWebServerRequest *request){server = request; servePage();});
     #endif
-    serverAsync->on("/description.xml", HTTP_GET, [this](AsyncWebServerRequest *request){server = request; serveDescription();}); // fix: implicit capture of "this"
+    serverAsync->on("/description.xml", HTTP_GET, [=](AsyncWebServerRequest *request){server = request; serveDescription();});
     serverAsync->begin();
     
     #else
@@ -298,7 +290,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]);
 
@@ -358,7 +350,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){
@@ -393,11 +385,7 @@ public:
     espalexaUdp.read(packetBuffer, packetSize);
     packetBuffer[packetSize] = 0;
   
-    #if defined(ARDUINO_ARCH_ESP32) && (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0))
-      espalexaUdp.clear();  // flush() is deprecated in arduino-esp32 3.x.y
-    #else
-      espalexaUdp.flush();
-    #endif
+    espalexaUdp.flush();
     if (!discoverable) return; //do not reply to M-SEARCH if not discoverable
   
     const char* request = (const char *) packetBuffer;
@@ -645,12 +633,4 @@ public:
   ~Espalexa(){} //note: Espalexa is NOT meant to be destructed
 };
 
-// dummy macro cleanup
-#ifndef ARDUINO_ARCH_ESP32
-#ifdef ESPALEXA_DEFINED_ESP_IDF_VERSION_VAL
-#undef ESP_IDF_VERSION_VAL
-#undef ESPALEXA_DEFINED_ESP_IDF_VERSION_VAL
-#endif
-#endif
-
 #endif

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;

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

wled00/udp.cpp

@@ -6,7 +6,7 @@
 
 #define UDP_SEG_SIZE 36
 #define SEG_OFFSET (41)
-static constexpr size_t WLEDPACKETSIZE = 41+(WS2812FX::getMaxSegments()*UDP_SEG_SIZE);  // make sure this is known at compile-time
+#define WLEDPACKETSIZE (41+(WS2812FX::getMaxSegments()*UDP_SEG_SIZE)+0)
 #define UDP_IN_MAXSIZE 1472
 #define PRESUMED_NETWORK_DELAY 3 //how many ms could it take on avg to reach the receiver? This will be added to transmitted times
 
@@ -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();
@@ -268,7 +268,6 @@ static void parseNotifyPacket(const uint8_t *udpIn) {
     size_t inactiveSegs = 0;
     for (size_t i = 0; i < numSrcSegs && i < WS2812FX::getMaxSegments(); i++) {
       unsigned ofs = 41 + i*udpIn[40]; //start of segment offset byte
-      if (ofs + 36 > UDP_IN_MAXSIZE) break; // avoid reading outside of array
       unsigned id = udpIn[0 +ofs];
       DEBUG_PRINTF_P(PSTR("UDP segment received: %u\n"), id);
       if      (id >  strip.getSegmentsNum()) break;
@@ -500,7 +499,7 @@ void handleNotifications()
     packetSize = rgbUdp.parsePacket();
     if (packetSize) {
       if (!receiveDirect) return;
-      if (packetSize > UDP_IN_MAXSIZE || packetSize < 3) return;  // packetSize must not exceed buffersize (UDP_IN_MAXSIZE)
+      if (packetSize > UDP_IN_MAXSIZE || packetSize < 3) return;
       realtimeIP = rgbUdp.remoteIP();
       DEBUG_PRINTLN(rgbUdp.remoteIP());
       uint8_t lbuf[packetSize];
@@ -517,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
@@ -588,9 +587,7 @@ void handleNotifications()
 
       unsigned id = (tpmPayloadFrameSize/3)*(packetNum-1); //start LED
       unsigned totalLen = strip.getLengthTotal();
-      // Clamp to prevent buffer overread: loop accesses up to udpIn[tpmPayloadFrameSize + 5]
-      size_t currentPayloadFrameSize = (packetSize >= 5) ? min(tpmPayloadFrameSize, uint16_t(packetSize - 5)) : 0;
-      for (size_t i = 6; i < currentPayloadFrameSize + 4U && id < totalLen; i += 3, id++) {
+      for (size_t i = 6; i < tpmPayloadFrameSize + 4U && id < totalLen; i += 3, id++) {
         setRealtimePixel(id, udpIn[i], udpIn[i+1], udpIn[i+2], 0);
       }
       if (tpmPacketCount == numPackets) { //reset packet count and show if all packets were received
@@ -701,7 +698,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
@@ -723,7 +720,19 @@ void sendSysInfoUDP()
     data[x + 2] = ip[x];
   }
   memcpy((byte *)data + 6, serverDescription, 32);
-  data[38] = uint8_t(WLED_BOARD); // see wled_boards.h
+  #ifdef ESP8266
+  data[38] = NODE_TYPE_ID_ESP8266;
+  #elif defined(CONFIG_IDF_TARGET_ESP32C3)
+  data[38] = NODE_TYPE_ID_ESP32C3;
+  #elif defined(CONFIG_IDF_TARGET_ESP32S3)
+  data[38] = NODE_TYPE_ID_ESP32S3;
+  #elif defined(CONFIG_IDF_TARGET_ESP32S2)
+  data[38] = NODE_TYPE_ID_ESP32S2;
+  #elif defined(ARDUINO_ARCH_ESP32)
+  data[38] = NODE_TYPE_ID_ESP32;
+  #else
+  data[38] = NODE_TYPE_ID_UNDEFINED;
+  #endif
   if (bri) data[38] |= 0x80U;  // add on/off state
   data[39] = ip[3]; // unit ID == last IP number
 

wled00/util.cpp

@@ -9,20 +9,12 @@
 #include <Update.h>
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
   #include "rom/rtc.h"      // for rtc_get_reset_reason()
-  #if CONFIG_IDF_TARGET_ESP32P4
-    #define RTCWDT_BROWN_OUT_RESET RESET_REASON::BROWN_OUT_RESET    // P4 has BROWN_OUT_RESET instead of RTCWDT_BROWN_OUT_RESET
-  #endif
-  #include "esp32/rtc.h"    // for bootloop detection // ToDO V5: Header file is deprecated, please include esp_rtc_time.h instead
+  #include "esp32/rtc.h"    // for bootloop detection
 #elif ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(3, 3, 0)
   #include "soc/rtc.h"
 #endif
 #include "mbedtls/sha1.h"   // for SHA1 on ESP32
 #include "esp_efuse.h"
-#include "esp_chip_info.h"
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-  #include "SHA1Builder.h"
-  #include <esp_mac.h>      // V5 requirement
-#endif
 #endif
 
 
@@ -772,17 +764,17 @@ int32_t hw_random(int32_t lowerlimit, int32_t upperlimit) {
 
 // PSRAM compile time checks to provide info for misconfigured env
 #if defined(BOARD_HAS_PSRAM)
-#if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(ESP8266)
-    #error "ESP32-C3/C6 and ESP8266 with PSRAM is not supported, please remove BOARD_HAS_PSRAM definition"
+  #if defined(IDF_TARGET_ESP32C3) || defined(ESP8266)
+    #error "ESP32-C3 and ESP8266 with PSRAM is not supported, please remove BOARD_HAS_PSRAM definition"
   #else
-  #if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_IDF_TARGET_ESP32) // PSRAM fix only needed for classic esp32
+  #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32S3) // PSRAM fix only needed for classic esp32
     // BOARD_HAS_PSRAM also means that compiler flag "-mfix-esp32-psram-cache-issue" has to be used for old "rev.1" esp32
     #warning "BOARD_HAS_PSRAM defined, make sure to use -mfix-esp32-psram-cache-issue to prevent issues on rev.1 ESP32 boards \
               see https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/external-ram.html#esp32-rev-v1-0"
   #endif
   #endif
 #else
-  #if !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32C6) && !defined(ESP8266)
+  #if !defined(IDF_TARGET_ESP32C3) && !defined(ESP8266)
     #pragma message("BOARD_HAS_PSRAM not defined, not using PSRAM.")
   #endif
 #endif
@@ -839,7 +831,7 @@ static void *validateFreeHeap(void *buffer) {
 
 void *d_malloc(size_t size) {
   void *buffer = nullptr;
-  #if defined(WLED_HAVE_RTC_MEMORY_HEAP)
+  #if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3)
   // the newer ESP32 variants have byte-accessible fast RTC memory that can be used as heap, access speed is on-par with DRAM
   // the system does prefer normal DRAM until full, since free RTC memory is ~7.5k only, its below the minimum heap threshold and needs to be allocated explicitly
   // use RTC RAM for small allocations or if DRAM is running low to improve fragmentation
@@ -1284,8 +1276,6 @@ uint8_t perlin8(uint16_t x, uint16_t y, uint16_t z) {
   return (((perlin3D_raw((uint32_t)x << 8, (uint32_t)y << 8, (uint32_t)z << 8, true) * 2015) >> 10) + 33168) >> 8; //scale to 16 bit, offset, then scale to 8bit
 }
 
-#if !defined(ARDUINO_ARCH_ESP32) || (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 0, 0))    // ToDO: validate behaviour in V5
-
 // Platform-agnostic SHA1 computation from String input
 String computeSHA1(const String& input) {
   #ifdef ESP8266
@@ -1295,19 +1285,11 @@ String computeSHA1(const String& input) {
     unsigned char shaResult[20]; // SHA1 produces 20 bytes
     mbedtls_sha1_context ctx;
 
-#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
     mbedtls_sha1_init(&ctx);
     mbedtls_sha1_starts_ret(&ctx);
     mbedtls_sha1_update_ret(&ctx, (const unsigned char*)input.c_str(), input.length());
     mbedtls_sha1_finish_ret(&ctx, shaResult);
     mbedtls_sha1_free(&ctx);
-#else
-    mbedtls_sha1_init(&ctx);
-    mbedtls_sha1_starts(&ctx);
-    mbedtls_sha1_update(&ctx, (const unsigned char*)input.c_str(), input.length());
-    mbedtls_sha1_finish(&ctx, shaResult);
-    mbedtls_sha1_free(&ctx);
-#endif
 
     // Convert to hexadecimal string
     char hexString[41];
@@ -1321,32 +1303,20 @@ String computeSHA1(const String& input) {
 }
 
 #ifdef ESP32
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-#include "esp_adc_cal.h"       //  ToDO: deprecated API
-//#include "esp_adc/adc_cali.h"        // new API
-//#include "esp_adc/adc_cali_scheme.h" // new API
-#else
 #include "esp_adc_cal.h"
 #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4,4,7) // backwards compatibility patch
   #define ADC_ATTEN_DB_12 ADC_ATTEN_DB_11
 #endif
-#endif
 String generateDeviceFingerprint() {
   uint32_t fp[2] = {0, 0}; // create 64 bit fingerprint
   esp_chip_info_t chip_info;
   esp_chip_info(&chip_info);
   esp_efuse_mac_get_default((uint8_t*)fp);
   fp[1] ^= ESP.getFlashChipSize();
-#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
   fp[0] ^= chip_info.full_revision | (chip_info.model << 16);
-#else
-  fp[0] ^= chip_info.revision | (chip_info.model << 16);
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3
-  // mix in ADC calibration data - legacy adc calibration API is not supported on new MCUs (-C5, -C6, -C61, -P4)
+  // mix in ADC calibration data:
   esp_adc_cal_characteristics_t ch;
-  #if (SOC_ADC_MAX_BITWIDTH == 13) || (CONFIG_SOC_ADC_RTC_MAX_BITWIDTH == 13) // S2 has 13 bit ADC
+  #if SOC_ADC_MAX_BITWIDTH == 13 // S2 has 13 bit ADC
   constexpr auto myBIT_WIDTH = ADC_WIDTH_BIT_13;
   #else
   constexpr auto myBIT_WIDTH = ADC_WIDTH_BIT_12;
@@ -1364,11 +1334,6 @@ String generateDeviceFingerprint() {
       fp[1] ^= ch.high_curve[i];
     }
   }
-#else
-  // some extra salt, instead of ADC calibration
-  fp[0] ^= chip_info.features | chip_info.cores << 16;
-  fp[1] ^= ESP.getFlashSourceFrequencyMHz() | ESP.getFlashClockDivider() << 8 ;
-#endif
   char fp_string[17];  // 16 hex chars + null terminator
   sprintf(fp_string, "%08X%08X", fp[1], fp[0]);
   return String(fp_string);
@@ -1406,5 +1371,4 @@ String getDeviceId() {
 
   return cachedDeviceId;
 }
-#endif // V5/V6 workaround
 

wled00/wled.cpp

@@ -1,13 +1,6 @@
 #define WLED_DEFINE_GLOBAL_VARS //only in one source file, wled.cpp!
 #include "wled.h"
 #include "wled_ethernet.h"
-#ifdef ARDUINO_ARCH_ESP32
-#include "esp_efuse.h"
-#include "esp_chip_info.h"
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-#include "esp_mac.h"
-#endif
-#endif
 #include "ota_update.h"
 #ifdef WLED_ENABLE_AOTA
   #define NO_OTA_PORT
@@ -19,10 +12,6 @@
 #include "soc/rtc_cntl_reg.h"
 #endif
 
-#if defined(CONFIG_IDF_TARGET_ESP32P4)
-#include "WiFi.h"           // WiFi library for network connectivity
-#include "ESP_HostedOTA.h"  // ESP-Hosted OTA update functionality
-#endif
 extern "C" void usePWMFixedNMI();
 
 /*
@@ -58,11 +47,7 @@ void WLED::loop()
   unsigned long        loopMillis = millis();
   size_t               loopDelay = loopMillis - lastRun;
   if (lastRun == 0) loopDelay=0; // startup - don't have valid data from last run.
-  #if defined(ESP8266) || (SOC_CPU_CORES_NUM < 2)
-    if (loopDelay > 4) DEBUG_PRINTF_P(PSTR("Loop delayed more than %ums.\n"), loopDelay);  // be a bit more relaxed on single-core MCUs
-  #else
-    if (loopDelay > 2) DEBUG_PRINTF_P(PSTR("Loop delayed more than %ums.\n"), loopDelay);
-  #endif
+  if (loopDelay > 2) DEBUG_PRINTF_P(PSTR("Loop delayed more than %ums.\n"), loopDelay);
   static unsigned long maxLoopMillis = 0;
   static size_t        avgLoopMillis = 0;
   static unsigned long maxUsermodMillis = 0;
@@ -125,7 +110,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();
@@ -296,12 +281,11 @@ void WLED::loop()
     DEBUG_PRINTF_P(PSTR("PSRAM:        Free: %7u bytes | Largest block: %6u bytes\n"), psram_free, psram_largest);
     #endif
     #if defined(CONFIG_IDF_TARGET_ESP32)
-    // 32-bit DRAM aka IRAM (not byte accessible, only available on ESP32)
+    // 32-bit DRAM (not byte accessible, only available on ESP32)
     size_t dram32_free = heap_caps_get_free_size(MALLOC_CAP_32BIT | MALLOC_CAP_INTERNAL) - dram_free; // returns all 32bit DRAM, subtract 8bit DRAM
     //size_t dram32_largest = heap_caps_get_largest_free_block(MALLOC_CAP_32BIT | MALLOC_CAP_INTERNAL); // returns largest DRAM block -> not useful
     DEBUG_PRINTF_P(PSTR("DRAM 32-bit:  Free: %7u bytes | Largest block: N/A\n"), dram32_free);
-    #endif
-    #if defined(WLED_HAVE_RTC_MEMORY_HEAP)
+    #else
     // Fast RTC Memory (not available on ESP32)
     size_t rtcram_free = heap_caps_get_free_size(MALLOC_CAP_RTCRAM);
     size_t rtcram_largest = heap_caps_get_largest_free_block(MALLOC_CAP_RTCRAM);
@@ -328,7 +312,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);
@@ -397,7 +381,7 @@ void WLED::setup()
   Serial.setTimeout(50);  // this causes troubles on new MCUs that have a "virtual" USB Serial (HWCDC)
   #else
   #endif
-  #if defined(WLED_DEBUG) && defined(ARDUINO_ARCH_ESP32) && ARDUINO_USB_CDC_ON_BOOT
+  #if defined(WLED_DEBUG) && defined(ARDUINO_ARCH_ESP32) && (defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3) || ARDUINO_USB_CDC_ON_BOOT)
   delay(2500);  // allow CDC USB serial to initialise
   #endif
   #if !defined(WLED_DEBUG) && defined(ARDUINO_ARCH_ESP32) && !defined(WLED_DEBUG_HOST) && ARDUINO_USB_CDC_ON_BOOT
@@ -407,13 +391,13 @@ void WLED::setup()
   DEBUG_PRINTF_P(PSTR("---WLED %s %u INIT---\n"), versionString, VERSION);
   DEBUG_PRINTLN();
 #ifdef ARDUINO_ARCH_ESP32
-  DEBUG_PRINTF_P(PSTR("esp-idf %s\n"), ESP.getSdkVersion());
+  DEBUG_PRINTF_P(PSTR("esp32 %s\n"), ESP.getSdkVersion());
   #if defined(ESP_ARDUINO_VERSION)
     DEBUG_PRINTF_P(PSTR("arduino-esp32 v%d.%d.%d\n"), int(ESP_ARDUINO_VERSION_MAJOR), int(ESP_ARDUINO_VERSION_MINOR), int(ESP_ARDUINO_VERSION_PATCH));  // available since v2.0.0
   #else
     DEBUG_PRINTLN(F("arduino-esp32 v1.0.x\n"));  // we can't say in more detail.
   #endif
-  DEBUG_PRINTF_P(PSTR("\nCPU:   %s rev.%d, %d core(s), %d MHz.\n"), ESP.getChipModel(), (int)ESP.getChipRevision(), ESP.getChipCores(), ESP.getCpuFreqMHz());
+  DEBUG_PRINTF_P(PSTR("CPU:   %s rev.%d, %d core(s), %d MHz.\n"), ESP.getChipModel(), (int)ESP.getChipRevision(), ESP.getChipCores(), ESP.getCpuFreqMHz());
   DEBUG_PRINTF_P(PSTR("FLASH: %d MB, Mode %d "), (ESP.getFlashChipSize()/1024)/1024, (int)ESP.getFlashChipMode());
   #ifdef WLED_DEBUG
   switch (ESP.getFlashChipMode()) {
@@ -437,7 +421,7 @@ void WLED::setup()
   DEBUG_PRINTF_P(PSTR("esp8266 @ %u MHz.\nCore: %s\n"), ESP.getCpuFreqMHz(), ESP.getCoreVersion());
   DEBUG_PRINTF_P(PSTR("FLASH: %u MB\n"), (ESP.getFlashChipSize()/1024)/1024);
 #endif
-  DEBUG_PRINTF_P(PSTR("\nheap %u\n"), getFreeHeapSize());
+  DEBUG_PRINTF_P(PSTR("heap %u\n"), getFreeHeapSize());
 
 #if defined(BOARD_HAS_PSRAM)
   // if JSON buffer allocation fails requestJsonBufferLock() will always return false preventing crashes
@@ -487,23 +471,6 @@ void WLED::setup()
   escapedMac = WiFi.macAddress();
   escapedMac.replace(":", "");
   escapedMac.toLowerCase();
-#ifdef ARDUINO_ARCH_ESP32
-  // WiFi.macAddress() may return all zeros if the WiFi netif is not yet created
-  // (e.g. on ESP32-C5 where WiFi.mode() hasn't been called yet). Fall back to
-  // reading the base MAC directly from eFuse.
-  if (escapedMac == "000000000000") {
-    uint8_t mac[6] = {0};
-    #if defined(CONFIG_IDF_TARGET_ESP32P4)  // P4 does not have on-chip WIFI, use ethernet MAC
-      // ToDo: decide if we prefer to use the WiFi "hosted" MAC, availeable with esp_wifi_remote_get_mac() 
-      esp_read_mac(mac, ESP_MAC_ETH);
-    #else
-      esp_read_mac(mac, ESP_MAC_WIFI_STA);
-    #endif
-    char buf[14] = {'\0'};
-    snprintf(buf, sizeof(buf)-1, "%02x%02x%02x%02x%02x%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-    escapedMac = buf;
-  }
-#endif
 
   WLED_SET_AP_SSID(); // otherwise it is empty on first boot until config is saved
   multiWiFi.push_back(WiFiConfig(CLIENT_SSID,CLIENT_PASS)); // initialise vector with default WiFi
@@ -536,12 +503,6 @@ void WLED::setup()
 
   if (needsCfgSave) serializeConfigToFS(); // usermods required new parameters; need to wait for strip to be initialised #4752
 
-  if (bootPreset > 0) {
-    handlePresets();  // handle boot preset
-    handlePlaylist(); // handle playlist if preset queued one
-    handlePresets();  // handle presets again to give a chance for anything queued by the boot preset or playlist
-  }
-  
   if (strcmp(multiWiFi[0].clientSSID, DEFAULT_CLIENT_SSID) == 0 && !configBackupExists())
     showWelcomePage = true;
 
@@ -557,14 +518,6 @@ void WLED::setup()
   #endif
   WiFi.onEvent(WiFiEvent);
   WiFi.mode(WIFI_STA); // enable scanning
-
-#if defined(ARDUINO_ARCH_ESP32) && (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2))
-  // WiFi.setBandMode(WIFI_BAND_MODE_AUTO) can also be used without SOC_WIFI_SUPPORT_5G
-  if (!WiFi.setBandMode(WIFI_BAND_MODE_AUTO)) {   // WIFI_BAND_MODE_AUTO = 5GHz+2.4GHz; WIFI_BAND_MODE_5G_ONLY, WIFI_BAND_MODE_2G_ONLY
-    DEBUG_PRINTLN(F("setup(): Wifi band configuration failed!\n"));
-  }
-#endif
-
   findWiFi(true);      // start scanning for available WiFi-s
 
   // all GPIOs are allocated at this point
@@ -631,9 +584,7 @@ void WLED::setup()
 #endif
 
 #if defined(ARDUINO_ARCH_ESP32) && defined(LWIP_IPV6)
-#if ESP_IDF_VERSION_MAJOR < 5   // ToDO: clarify if esp-idf v5.x still needs this patch
   installIPv6RABlocker();  // Work around unsolicited RA overwriting IPv4 DNS servers
-#endif
 #endif
 
   #if WLED_WATCHDOG_TIMEOUT > 0
@@ -701,16 +652,6 @@ void WLED::initAP(bool resetAP)
   }
   DEBUG_PRINT(F("Opening access point "));
   DEBUG_PRINTLN(apSSID);
-
-  #ifdef ARDUINO_ARCH_ESP32
-  // reset band mode to "auto" before starting AP
-  #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2)
-  if (!WiFi.setBandMode(WIFI_BAND_MODE_AUTO)) {
-    DEBUG_PRINTLN(F("initAP(): Wifi band configuration failed!\n"));
-  }
-  #endif
-  #endif
-
   WiFi.softAPConfig(IPAddress(4, 3, 2, 1), IPAddress(4, 3, 2, 1), IPAddress(255, 255, 255, 0));
   WiFi.softAP(apSSID, apPass, apChannel, apHide);
   #ifdef ARDUINO_ARCH_ESP32
@@ -775,16 +716,10 @@ void WLED::initConnection()
   WiFi.setHostname(hostname);
 #endif
 
-  if (multiWiFi.empty()) {                       // guard: handle empty WiFi list safely
-    WiFi.config(IPAddress((uint32_t)0), IPAddress((uint32_t)0), IPAddress((uint32_t)0));  
+  if (multiWiFi[selectedWiFi].staticIP != 0U && multiWiFi[selectedWiFi].staticGW != 0U) {
+    WiFi.config(multiWiFi[selectedWiFi].staticIP, multiWiFi[selectedWiFi].staticGW, multiWiFi[selectedWiFi].staticSN, dnsAddress);
   } else {
-    if (selectedWiFi >= multiWiFi.size()) selectedWiFi = 0; // guard: ensure valid index
-    if (multiWiFi[selectedWiFi].staticIP != IPAddress((uint32_t)0) &&
-      multiWiFi[selectedWiFi].staticGW != IPAddress((uint32_t)0)) { // guard: compare as IPAddress to avoid pointer overload
-      WiFi.config(multiWiFi[selectedWiFi].staticIP, multiWiFi[selectedWiFi].staticGW, multiWiFi[selectedWiFi].staticSN, dnsAddress);
-    } else {
-      WiFi.config(IPAddress((uint32_t)0), IPAddress((uint32_t)0), IPAddress((uint32_t)0));
-    }
+    WiFi.config(IPAddress((uint32_t)0), IPAddress((uint32_t)0), IPAddress((uint32_t)0));
   }
 
   lastReconnectAttempt = millis();
@@ -800,11 +735,6 @@ void WLED::initConnection()
       DEBUG_PRINTLN(F("Access point disabled (init)."));
       WiFi.softAPdisconnect(true);
       WiFi.mode(WIFI_STA);
-      #if defined(SOC_WIFI_SUPPORT_5G) && (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 2))
-      if (!WiFi.setBandMode((wifi_band_mode_t)wifiBandMode)) {
-        DEBUG_PRINTLN(F("initConnection(): WiFi band configuration failed!"));
-      }
-      #endif
     }
   }
 
@@ -899,7 +829,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];
@@ -985,7 +915,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
@@ -994,7 +924,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."));
@@ -1038,37 +968,10 @@ void WLED::handleConnection()
   } else if (!interfacesInited) { //newly connected
     DEBUG_PRINTLN();
     DEBUG_PRINT(F("Connected! IP address: "));
-    DEBUG_PRINTLN(WLEDNetwork.localIP());
-
+    DEBUG_PRINTLN(Network.localIP());
     #ifdef ARDUINO_ARCH_ESP32
     esp_wifi_set_storage(WIFI_STORAGE_RAM); // disable further updates of NVM credentials to prevent wear on flash (same as WiFi.persistent(false) but updates immediately, arduino wifi deficiency workaround)
     #endif
-
-    DEBUG_PRINT(F("Channel: ")); DEBUG_PRINT(WiFi.channel());
-    #if defined(ARDUINO_ARCH_ESP32) && SOC_WIFI_SUPPORT_5G
-      auto wifiBand = WiFi.getBand();
-      DEBUG_PRINT(wifiBand == WIFI_BAND_2G ? F(" (2.4GHz)") : (wifiBand == WIFI_BAND_5G ? F("  (5GHz)"): F(" (other)")));
-    #else
-      DEBUG_PRINT(F(" (2.4GHz)"));
-    #endif
-    DEBUG_PRINTLN();
-
-  #if defined(CONFIG_IDF_TARGET_ESP32P4)
-    // directly after connection, attempt to update the ESP-Hosted Wi-Fi co-processor firmware
-    if (!apActive && !improvActive) {
-      // This function will:
-      // - Check if ESP-Hosted is initialized
-      // - Verify if an update is available
-      // - Download and install the firmware update if needed
-      if (updateEspHostedSlave()) {
-        // Restart the host ESP32 after successful update
-        // This is currently required to properly activate the new firmware on the ESP-Hosted co-processor
-        // ESP.restart();
-        doReboot = true; // schedule reboot
-      }
-    }
-  #endif
-
     if (improvActive) {
       if (improvError == 3) sendImprovStateResponse(0x00, true);
       sendImprovStateResponse(0x04);
@@ -1090,7 +993,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)
@@ -1104,7 +1007,7 @@ void WLED::handleStatusLED()
   }
   #endif
 
-  if (WLEDNetwork.isConnected()) {
+  if (Network.isConnected()) {
     c = RGBW32(0,255,0,0);
     ledStatusType = 2;
   } else if (WLED_MQTT_CONNECTED) {

wled00/wled.h

@@ -7,7 +7,7 @@
  */
 
 // version code in format yymmddb (b = daily build)
-#define VERSION 2607012
+#define VERSION 2605010
 
 //uncomment this if you have a "my_config.h" file you'd like to use
 //#define WLED_USE_MY_CONFIG
@@ -75,18 +75,6 @@
 
 // Library inclusions.
 #include <Arduino.h>
-
-// buildenv sanity check
-#if !defined(ESP32) && !defined(ESP8266)
-#error neither ESP32 nor ESP8266 defined. Please fix your build environment.
-#endif
-#if defined(ESP8266) && (defined(ARDUINO_ARCH_ESP32) || defined(ESP32))
-#error both ESP8266 and ESP32/ARDUINO_ARCH_ESP32 defined. Please fix your build environment.
-#endif
-#if (defined(ARDUINO_ARCH_ESP32) && !defined(ESP32)) || (defined(ESP32) && !defined(ARDUINO_ARCH_ESP32))
-#error either ESP32 or ARDUINO_ARCH_ESP32 not defined. Please fix your build environment.
-#endif
-
 #ifdef ESP8266
   #include <ESP8266WiFi.h>
   #ifdef WLED_ENABLE_WPA_ENTERPRISE
@@ -136,8 +124,6 @@
   #include "my_config.h"
 #endif
 
-#include "wled_boards.h"  // pull in board-specific capability defines
-
 #include <ESPAsyncWebServer.h>
 #include <WiFiUdp.h>
 #include <DNSServer.h>
@@ -156,9 +142,7 @@
 #endif
 
 #ifdef WLED_ENABLE_DMX
- #if defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6)  || defined(CONFIG_IDF_TARGET_ESP32C61)  || defined(CONFIG_IDF_TARGET_ESP32P4) 
-  #error "DMX output is not supported on ESP32-C5/C6/P4 (esp_dmx library excluded)"
- #elif defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)|| defined(CONFIG_IDF_TARGET_ESP32S2)
+ #if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2)
   #include "src/dependencies/dmx/ESPDMX.h"
  #else //ESP32
   #include "src/dependencies/dmx/SparkFunDMX.h"
@@ -290,7 +274,7 @@ using PSRAMDynamicJsonDocument = BasicJsonDocument<PSRAM_Allocator>;
 #define STRINGIFY(X) #X
 #define TOSTRING(X) STRINGIFY(X)
 
-#define WLED_CODENAME "Kagayaki"
+#define WLED_CODENAME "Niji"
 
 // AP and OTA default passwords (for maximum security change them!)
 WLED_GLOBAL char apPass[65]  _INIT(WLED_AP_PASS);
@@ -331,9 +315,7 @@ WLED_GLOBAL bool rlyOpenDrain _INIT(RLYODRAIN);
   #define IRTYPE 0
 #endif
 
-// RX and TX: use "default" pins for 8266 and classic esp32
-// except when arduino-esp32 has explicitly defined RX and TX (some arduino variants don't define RX and TX)
-#if defined(ARDUINO_ARCH_ESP32) && (!defined(CONFIG_IDF_TARGET_ESP32) || (defined(RX) && defined(TX)))
+#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2) || (defined(RX) && defined(TX))
   // use RX/TX as set by the framework - these boards do _not_ have RX=3 and TX=1
   constexpr uint8_t hardwareRX = RX;
   constexpr uint8_t hardwareTX = TX;
@@ -393,14 +375,11 @@ WLED_GLOBAL bool noWifiSleep _INIT(false);
   #endif
 WLED_GLOBAL bool force802_3g _INIT(false);
 #endif // WLED_SAVE_RAM
-#ifdef SOC_WIFI_SUPPORT_5G
-WLED_GLOBAL byte wifiBandMode _INIT((byte)WIFI_BAND_MODE_AUTO);  // default for dual-band chips (1=2.4G, 2=5G, 3=Auto)
-#endif
-#if defined(ARDUINO_ARCH_ESP32)
-  #if defined(LOLIN_WIFI_FIX) // extend this fix to all esp32 boards
+#ifdef ARDUINO_ARCH_ESP32
+  #if defined(LOLIN_WIFI_FIX) && (defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3))
 WLED_GLOBAL uint8_t txPower _INIT(WIFI_POWER_8_5dBm);
   #else
-WLED_GLOBAL uint8_t txPower _INIT(WIFI_POWER_19_5dBm);  // ToDO: change to int8_t; V5 allows WIFI_POWER_21dBm = 84 ... WIFI_POWER_MINUS_1dBm = -4. Also check if the UI can handle it.
+WLED_GLOBAL uint8_t txPower _INIT(WIFI_POWER_19_5dBm);
   #endif
 #endif
 #define WLED_WIFI_CONFIGURED isWiFiConfigured()
@@ -475,9 +454,7 @@ WLED_GLOBAL bool arlsDisableGammaCorrection _INIT(true);          // activate if
 WLED_GLOBAL bool arlsForceMaxBri _INIT(false);                    // enable to force max brightness if source has very dark colors that would be black
 
 #ifdef WLED_ENABLE_DMX
- #if defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32C61) || defined(CONFIG_IDF_TARGET_ESP32P4) 
-  #error "DMX output is not supported on ESP32-C5/C6/P4 (esp_dmx library excluded)"
- #elif defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2)
+ #if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2)
   WLED_GLOBAL DMXESPSerial dmx;
  #else //ESP32
   WLED_GLOBAL SparkFunDMX dmx;
@@ -1046,7 +1023,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 { \

wled00/wled_boards.h

@@ -1,152 +0,0 @@
-/*
-  WLED board capabilities: uses CONFIG_IDF_TARGET_... to extract board capability flags.
-  You can still use CONFIG_IDF_TARGET_ in the source code; this file provides shortcuts for repeating capability checks.
-*/
-#pragma once
-
-#ifndef WLED_BOARDS_H
-#define WLED_BOARDS_H
-#include "NodeStruct.h"  // to get generic NODE_TYPE_IDs
-
-/*
- * Structure: the below part uses isolated "#if defined()" instead of a chain of if ... elif ... else
- * so that the constant WLED_BOARD will be set exactly once unless there are conflicting build_flags. 
- * In case that several blocks are active, it causes a compiler error to easily spot the problem
- * "error: redefinition of 'constexpr const unsigned int WLED_BOARD'"
- */
-
-/* TODO: add
-    WLED_HAVE_TOUCH (for button.cpp)
-    WLED_HAVE_I2S0_LEDS (for bus_wrapper.h)
-    WLED_HAVE_I2S1_LEDS (for bus_wrapper.h)
-    (find a name) // On ESP32-C3/C5/C6 only the first 2 RMT channels are usable for transmitting (bus_wrapper.h)
-    (find a name) // ESP32, S3, P4 can use SparkFunDMX (wled.h, dmx_output.cpp)
-    WLED_ALLOW_LOLIN_WIFI_FIX // (wled.h)
- */
-
-
-#if defined(ESP8266)
-// Capabilities of good-old 8266
-  // has no FPU
-  // bitshift with rounding is faster than integer division
-  // no byte-accessible fast RTC memory (newer esp32 variants only)
-  // no parallel I2S LEDs driver
-constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP8266;
-
-  // sanity check for esp32
-  #if defined(ARDUINO_ARCH_ESP32) || defined(ESP32)
-    #error "ARDUINO_ARCH_ESP32 or ESP32 is defined together with ESP8266. Please fix your buildenv."
-  #endif
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32
-// Capabilities of classic ESP32 and classic PICO-D4/D2/D3
-  #define WLED_HAVE_FAST_FLOAT  1     // has an FPU for fast floating point (single precision)
-  #define WLED_HAVE_FAST_int_DIVIDE 1 // integer division is fast (no need to use bitshifts with rounding instead of integer division)
-  // no byte-accessible fast RTC memory (newer esp32 variants only)
-  #define WLED_HAVE_IRAM_32BIT_HEAP 1 // only classic ESP32 has "32bit accessible only" aka IRAM type heap
-
-  #define WLED_HAS_PARALLEL_I2S  1    // classic esp32 has I2S parallel leds driver (NeoPixelBus)
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32;
-  // sanity checks
-  #if (SOC_CPU_CORES_NUM < 2)
-    #error "ESP32 single-core is not supported."
-  #endif
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32S3
-// Capabilities of ESP32-S3
-  #define WLED_HAVE_FAST_FLOAT  1     // has an FPU for fast floating point (single precision)
-  #define WLED_HAVE_FAST_int_DIVIDE 1 // integer division is fast (no need to use bitshifts with rounding instead of integer division)
-  #define WLED_HAVE_RTC_MEMORY_HEAP 1 // has byte-accessible fast RTC memory that can be used as heap
-  // no 4byte-accessible IRAM heap
-
-  #define WLED_HAS_PARALLEL_I2S  1    // esp32-S3 supports I2S parallel leds driver (NeoPixelBus)
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32S3;
-  // sanity checks
-  #if (SOC_CPU_CORES_NUM < 2)
-    #error "ESP32-S3 single-core is not supported."
-  #endif
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32S2
-// Capabilities of ESP32-S2
-  // has no FPU
-  #define WLED_HAVE_FAST_int_DIVIDE 1 // integer division is fast (no need to use bitshifts with rounding instead of integer division)
-  #define WLED_HAVE_RTC_MEMORY_HEAP 1 // has byte-accessible fast RTC memory that can be used as heap
-  // no 4byte-accessible IRAM heap
-
-  #define WLED_HAS_PARALLEL_I2S 1    // esp32-S2 supports I2S parallel leds driver (NeoPixelBus)
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32S2;
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32C3
-// Capabilities of ESP32-C3
-  // has no FPU
-  // bitshift with rounding is faster than integer division
-  #define WLED_HAVE_RTC_MEMORY_HEAP 1 // has byte-accessible fast RTC memory that can be used as heap
-  // no 4byte-accessible IRAM heap
-  // no parallel I2S LEDs driver
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32C3;
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32C5
-// Capabilities of ESP32-C5
-  // has no FPU
-  // bitshift with rounding is faster than integer division
-  #define WLED_HAVE_RTC_MEMORY_HEAP 1 // has byte-accessible fast RTC memory that can be used as heap
-  // no 4byte-accessible IRAM heap
-  // no parallel I2S LEDs driver
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32C5;
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32C6
-// Capabilities of ESP32-C6
-  // has no FPU
-  // bitshift with rounding is faster than integer division
-  #define WLED_HAVE_RTC_MEMORY_HEAP 1 // has byte-accessible fast RTC memory that can be used as heap
-  // no 4byte-accessible IRAM heap
-  // no parallel I2S LEDs driver
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32C6;
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32C61
-// Capabilities of ESP32-C61
-  // has no FPU
-  // bitshift with rounding is faster than integer division
-  #define WLED_HAVE_RTC_MEMORY_HEAP 1  // has byte-accessible fast RTC memory that can be used as heap
-  // no 4byte-accessible IRAM heap
-  // no parallel I2S LEDs driver
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32C61;
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32P4
-// Capabilities of ESP32-P4
-  #define WLED_HAVE_FAST_FLOAT  1     // has an FPU for fast floating point (single precision)
-  // TBC: is bitshift with rounding is faster than integer division ?
-  #define WLED_HAVE_FAST_int_DIVIDE 1 // integer division is fast (no need to use bitshifts with rounding instead of integer division)
-  #define WLED_HAVE_RTC_MEMORY_HEAP 1 // TBC: does it have byte-accessible fast RTC memory that can be used as heap ?
-  // no 4byte-accessible IRAM heap
-  // no parallel I2S LEDs driver
-  #define WLED_HAS_PARALLEL_PARLIO  1  // (unsupported) P4 allows parallel leds driving with PARLIO unit
-
-  constexpr unsigned WLED_BOARD = NODE_TYPE_ID_ESP32P4;
-
-  // sanity checks
-  #if (SOC_CPU_CORES_NUM < 2)
-    #error "ESP32-P4 single-core is not supported."
-  #endif
-#endif
-
-
-// sanity check: the constexpr assignment below will fail when WLED_BOARD is not set by the previous blocks
-constexpr unsigned wled_boards_sanity_check = 0 + WLED_BOARD;
-
-#endif // WLED_BOARDS_H

wled00/wled_metadata.cpp

@@ -4,8 +4,7 @@
 
 #ifndef WLED_VERSION
   #warning WLED_VERSION was not set - using default value of 'dev'
-  //#define WLED_VERSION dev
-  #define WLED_VERSION 17.0.0-devV5  // ToDO: remove once that set_metadata.py is fixed
+  #define WLED_VERSION dev
 #endif
 #ifndef WLED_RELEASE_NAME
   #warning WLED_RELEASE_NAME was not set - using default value of 'Custom'

wled00/wled_server.cpp

@@ -60,7 +60,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) {

wled00/xml.cpp

@@ -275,11 +275,6 @@ void getSettingsJS(byte subPage, Print& settingsScript)
     #endif
     printSetFormCheckbox(settingsScript,PSTR("FG"),force802_3g);
     printSetFormCheckbox(settingsScript,PSTR("WS"),noWifiSleep);
-    #ifdef SOC_WIFI_SUPPORT_5G
-    printSetFormValue(settingsScript,PSTR("BM"),wifiBandMode);
-    #else
-    settingsScript.print(F("gId('bm').style.display='none';"));
-    #endif
 
     #ifndef WLED_DISABLE_ESPNOW
     printSetFormCheckbox(settingsScript,PSTR("RE"),enableESPNow);
@@ -300,14 +295,14 @@ 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)
-      if (WLEDNetwork.isEthernet()) strcat_P(s ,PSTR(" (Ethernet)"));
+      if (Network.isEthernet()) strcat_P(s ,PSTR(" (Ethernet)"));
       #endif
       printSetClassElementHTML(settingsScript,PSTR("sip"),0,s);
     } else