handleHttpApi: Move web response to web context

No need to even consider this for non-web requests.  Move the request
special case to that context as well.

.coderabbit.yaml

@@ -1,113 +0,0 @@
-# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
-#
-# CodeRabbit configuration — references existing guideline files to avoid
-# duplicating conventions.  See:
-#   .github/copilot-instructions.md   — project overview & general rules
-#   docs/cpp.instructions.md          — C++ coding conventions
-#   docs/web.instructions.md          — Web UI coding conventions
-#   docs/cicd.instructions.md         — GitHub Actions / CI-CD conventions
-#
-# NOTE: This file must be committed (tracked by git) for CodeRabbit to read
-# it from the repository.  If it is listed in .gitignore, CodeRabbit will
-# not see it and these settings will have no effect.
-
-language: en-US
-
-reviews:
-  # generic review setting, see https://docs.coderabbit.ai/reference/configuration#reference
-  auto_apply_labels: true
-  # abort_on_close: false
-  high_level_summary: true
-  review_status: true
-  collapse_walkthrough: false
-  poem: false
-  # sequence_diagrams: false
-  auto_review:
-    enabled: true
-    ignore_title_keywords:
-      - WIP
-
-  path_instructions:
-    - path: "**/*.{cpp,h,hpp,ino}"
-      instructions: >
-        Follow the C++ coding conventions documented in docs/cpp.instructions.md
-        and the general project guidelines in .github/copilot-instructions.md.
-
-        Key rules: 2-space indentation (no tabs), camelCase functions/variables,
-        PascalCase classes, UPPER_CASE macros. No C++ exceptions — use return codes and debug macros.
-
-        Hot-path optimization guidelines (attributes, uint_fast types, caching,
-        unsigned range checks) apply from pixel set/get operations and strip.show() downward —
-        NOT to effect functions in FX.cpp, which have diverse contributor styles.
-# disabled - the below instruction has no effect
-# When initially reviewing a PR, summarize good practices (top 5) and create a prioritized list of suggested improvements (focus on major ones).
-
-    - path: "wled00/data/**"
-      instructions: >
-        Follow the web UI conventions documented in docs/web.instructions.md.
-
-        Key rules: indent HTML and JavaScript with tabs, CSS with tabs.
-        Files here are built into wled00/html_*.h and wled00/js_*.h by tools/cdata.js — never
-        edit those generated headers directly.
-# disabled - the below instruction has no effect
-# When initially reviewing a PR, summarize good practices (top 5) and create a prioritized list of suggested improvements (focus on major ones).
-
-    - path: "wled00/html_*.h"
-      instructions: >
-        These files are auto-generated from wled00/data/ by tools/cdata.js.
-        They must never be manually edited or committed. Flag any PR that
-        includes changes to these files.
-
-    - path: "wled00/js_*.h"
-      instructions: >
-        These files are auto-generated from wled00/data/ by tools/cdata.js.
-        They must never be manually edited or committed. Flag any PR that
-        includes changes to these files.
-
-    - path: "usermods/**"
-      instructions: >
-        Usermods are community add-ons.
-        Each usermod lives in its own directory under usermods/ and is implemented
-        as a .cpp file with a dedicated library.json file to manage dependencies. 
-        Follow the same C++ conventions as the core firmware (docs/cpp.instructions.md).
-# disabled - the below instruction has no effect
-# When initially reviewing a PR, summarize good practices (top 6) and create a prioritized list of suggested improvements (skip minor ones).
-
-    - path: ".github/workflows/*.{yml,yaml}"
-      instructions: >
-        Follow the CI/CD conventions documented in docs/cicd.instructions.md.
-
-        Key rules: 2-space indentation, descriptive name: on every workflow/job/step.
-        Third-party actions must be pinned to a specific version tag — branch pins
-        such as @main or @master are not allowed. Declare explicit permissions: blocks
-        scoped to least privilege. Never interpolate github.event.* values directly
-        into run: steps — pass them through an env: variable to prevent script
-        injection. Do not use pull_request_target unless fully justified.
-# disabled - the below instruction has no effect
-# When initially reviewing a PR, summarize good practices (top 6) and create a prioritized list of suggested improvements.
-
-    - path: "**/*.instructions.md"
-      instructions: |
-        This file contains both AI-facing rules and human-only reference sections.
-        Human-only sections are enclosed in `<!-- HUMAN_ONLY_START -->` /
-        `<!-- HUMAN_ONLY_END -->` HTML comment markers and should not be used as
-        actionable review criteria.
-
-        When this file is modified in a PR, perform the following alignment check:
-        1. For each `<!-- HUMAN_ONLY_START --> ... <!-- HUMAN_ONLY_END -->` block,
-           verify that its examples and guidance are consistent with (and do not
-           contradict) the AI-facing rules stated in the same file.
-        2. Flag any HUMAN_ONLY section whose content has drifted from the surrounding
-           AI-facing rules due to edits introduced in this PR.
-        3. If new AI-facing rules were added without updating a related HUMAN_ONLY
-           reference section, note this as a suggestion (not a required fix).
-
-  finishing_touches:
-    # Docstrings | Options for generating Docstrings for your PRs/MRs.
-    docstrings:
-      # Docstrings | Allow CodeRabbit to generate docstrings for PRs/MRs.
-      # default: true - disabled in WLED: has caused confusion in the past
-      enabled: false
-    unit_tests:
-      # default: true - disabled in WLED: we don't have a unit test framework, this option just confuses contributors
-      enabled: false

.devcontainer/Dockerfile

@@ -2,7 +2,12 @@
 
 # [Choice] Python version: 3, 3.9, 3.8, 3.7, 3.6
 ARG VARIANT="3"
-FROM mcr.microsoft.com/devcontainers/python:0-${VARIANT}
+FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT}
+
+# [Option] Install Node.js
+ARG INSTALL_NODE="true"
+ARG NODE_VERSION="lts/*"
+RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "source /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
 
 # [Optional] If your pip requirements rarely change, uncomment this section to add them to the image.
 # COPY requirements.txt /tmp/pip-tmp/

.devcontainer/devcontainer.json

@@ -5,7 +5,10 @@
 		"context": "..",
 		"args": { 
 			// Update 'VARIANT' to pick a Python version: 3, 3.6, 3.7, 3.8, 3.9
-			"VARIANT": "3"
+			"VARIANT": "3",
+			// Options
+			"INSTALL_NODE": "true",
+			"NODE_VERSION": "lts/*"
 		}
 	},
 
@@ -24,35 +27,34 @@
 	// risk to running the build directly on the host.
 	// "runArgs": ["--privileged", "-v", "/dev/bus/usb:/dev/bus/usb", "--group-add", "dialout"],
 
-	"customizations": {
-		"vscode": {
-			"settings": { 
-				"terminal.integrated.shell.linux": "/bin/bash",
-				"python.pythonPath": "/usr/local/bin/python",
-				"python.linting.enabled": true,
-				"python.linting.pylintEnabled": true,
-				"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
-				"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
-				"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
-				"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
-				"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
-				"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
-				"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
-				"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
-				"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint"
-			},
-			"extensions": [
-				"ms-python.python",
-				"platformio.platformio-ide"
-			]
-		}
+	// Set *default* container specific settings.json values on container create.
+	"settings": { 
+		"terminal.integrated.shell.linux": "/bin/bash",
+		"python.pythonPath": "/usr/local/bin/python",
+		"python.linting.enabled": true,
+		"python.linting.pylintEnabled": true,
+		"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
+		"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+		"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
+		"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
+		"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
+		"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
+		"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
+		"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
+		"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint"
 	},
 
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"ms-python.python",
+		"platformio.platformio-ide"
+	],
+
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	// "forwardPorts": [],
 
 	// Use 'postCreateCommand' to run commands after the container is created.
-	"postCreateCommand": "bash -i -c 'nvm install && npm ci'",
+	"postCreateCommand": "npm install",
 
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
 	"remoteUser": "vscode"

.github/FUNDING.yml

@@ -1,2 +1,2 @@
-github: [DedeHai,lost-hope,willmmiles,netmindz,softhack007]
+github: [Aircoookie,blazoncek]
 custom: ['https://paypal.me/Aircoookie','https://paypal.me/blazoncek']

.github/ISSUE_TEMPLATE/bug.yml

@@ -44,10 +44,7 @@ body:
     id: version
     attributes:
       label: What version of WLED?
-      description: |-
-        Find this by going to <kbd><samp>⚙️ Config</samp></kbd> → <kbd><samp>Security & Updates</samp></kbd> → Scroll to Bottom.
-        Copy and paste the rest of the line that begins “<samp>Installed version: </samp>”,
-        or, for older versions, the entire line after “<samp>Server message</samp>”.
+      description: You can find this in by going to Config -> Security & Updates -> Scroll to Bottom. Copy and paste the entire line after "Server message"
       placeholder: "e.g. WLED 0.13.1 (build 2203150)"
     validations:
       required: true
@@ -63,8 +60,6 @@ body:
         - ESP32-S2
         - ESP32-C3
         - Other
-        - ESP32-C6 (experimental)
-        - ESP32-C5 (experimental)
     validations:
       required: true
   - type: textarea
@@ -85,7 +80,7 @@ body:
     id: terms
     attributes:
       label: Code of Conduct
-      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/wled-dev/WLED/blob/main/CODE_OF_CONDUCT.md)
+      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/Aircoookie/WLED/blob/master/CODE_OF_CONDUCT.md)
       options:
         - label: I agree to follow this project's Code of Conduct
           required: true

.github/agent-build.instructions.md

@@ -1,120 +0,0 @@
----
-applyTo: "**"
----
-# Agent-Mode Build & Test Instructions
-
-Detailed build workflow, timeouts, and troubleshooting for making code changes in agent mode. Always reference these instructions first when running builds or validating changes.
-
-## Build Timing and Timeouts
-
-Use these timeout values when running builds:
-
-| Command | Typical Time | Minimum Timeout | Notes |
-|---|---|---|---|
-| `npm run build` | ~3 s | 30 s | Web UI → `wled00/html_*.h` `wled00/js_*.h` headers |
-| `npm test` | ~40 s | 2 min | Validates build system |
-| `npm run dev` | continuous | — | Watch mode, auto-rebuilds on changes |
-| `pio run -e <env>` | 15–20 min | 30 min | First build downloads toolchains; subsequent builds are faster |
-
-**NEVER cancel long-running builds.** PlatformIO downloads and compilation require patience.
-
-## Development Workflow
-
-### Code Style Summary
-- **C++** files in `wled00/` and `usermods/`: 2-space indentation (no tabs), camelCase functions/variables, PascalCase classes, UPPER_CASE macros. No C++ exceptions — use return codes and debug macros.
-- **Web UI** files in `wled00/data`: indent HTML and JavaScript with tabs, CSS with tabs.
-- **CI/CD workflows** in `.github/workflows`: 2-space indentation, descriptive `name:` on every workflow/job/step. Third-party actions must be pinned to a specific version tag — branch pins such as `@main` or `@master` are not allowed. SHA pinning recommended.
-
-### Web UI Changes
-
-1. Edit files in `wled00/data/`
-2. Run `npm run build` to regenerate `wled00/html_*.h` `wled00/js_*.h` headers
-3. Test with local HTTP server (see Manual Testing below)
-4. Run `npm test` to validate
-
-### Firmware Changes
-
-1. Edit files in `wled00/` (but **never** `html_*.h` and `js_*.h` files)
-2. Ensure web UI is built first: `npm run build`
-3. Build firmware: `pio run -e esp32dev` (set timeout ≥ 30 min)
-4. Flash to device: `pio run -e [target] --target upload`
-
-### Combined Web + Firmware Changes
-
-1. Always build web UI first
-2. Test web interface manually
-3. Then build and test firmware
-
-
-## Before Finishing Work - Testing
-
-**You MUST complete ALL of these before marking work as done:**
-
-1. **Run tests**: `npm test` — must pass
-2. **Build firmware**: `pio run -e esp32dev` — must succeed after source code changes, **never skip this step**.
-   - Set timeout to 30+ minutes, **never cancel**
-   - Choose `esp32dev` as a common, representative environment
-   - If the build fails, fix the issue before proceeding
-3. **For web UI changes**: manually test the interface (see below)
-
-If any step fails, fix the issue. **Do NOT mark work complete with failing builds or tests.**
-
-## Manual Web UI Testing
-
-Start a local server:
-
-```sh
-cd wled00/data && python3 -m http.server 8080
-# Open http://localhost:8080/index.htm
-```
-
-Test these scenarios after every web UI change:
-
-- **Load**: `index.htm` loads without JavaScript errors (check browser console)
-- **Navigation**: switching between main page and settings pages works
-- **Color controls**: color picker and brightness controls function correctly
-- **Effects**: effect selection and parameter changes work
-- **Settings**: form submission and validation work
-
-## Troubleshooting
-
-### Common Build Issues
-
-| Problem | Solution |
-|---|---|
-| Missing `html_*.h` | Run `npm ci; npm run build` |
-| Web UI looks broken | Check browser console for JS errors |
-| PlatformIO network errors | Retry — downloads can be flaky |
-| Node.js version mismatch | Ensure Node.js 20+ (check `.nvmrc`) |
-
-### Recovery Steps
-
-- **Force web UI rebuild**: `npm run build -- -f`
-- **Clear generated files**: `rm -f wled00/html_*.h wled00/js_*.h` then `npm run build`
-- **Clean PlatformIO build artifacts**: `pio run --target clean`
-- **Reinstall Node deps**: `rm -rf node_modules && npm ci`
-
-## CI/CD Validation
-
-The GitHub Actions CI workflow will:
-1. Install Node.js and Python dependencies
-2. Run `npm test`
-3. Build web UI (automatic via PlatformIO)
-4. Compile firmware for **all** `default_envs` targets
-
-**To ensure CI success, always validate locally:**
-- Run `npm test` and ensure it passes
-- Run `pio run -e esp32dev` (or another common firmware environment, see next section) and ensure it completes successfully
-- If either fails locally, it WILL fail in CI
-
-Match this workflow in local development to catch failures before pushing.
-
-## Important Reminders
-
-- Always **commit source code**
--  Every pull request MUST include a clear description of *what* changed and *why*.
-- **Never edit or commit** `wled00/html_*.h` and  `wled00/js_*.h` — auto-generated from `wled00/data/`
-- After modifying source code files, check that any **previous comments have been preserved** or updated to reflect the new behaviour.
-- Web UI rebuild is part of the PlatformIO firmware compilation pipeline
-- Common environments:  `nodemcuv2`, `esp32dev`, `esp8266_2m`, `esp32c3dev`, `esp32s3dev_8MB_opi`
-- List all PlatformIO targets: `pio run --list-targets`

.github/copilot-instructions.md

@@ -1,139 +0,0 @@
-# WLED - ESP32/ESP8266 LED Controller Firmware
-
-WLED is a fast and feature-rich implementation of an ESP32 and ESP8266 webserver to control NeoPixel (WS2812B, WS2811, SK6812) LEDs and SPI-based chipsets. The project consists of C++ firmware for microcontrollers and a modern web interface.
-
-Always reference these instructions first and fallback to search or bash commands only when you encounter unexpected information that does not match the info here.
-
-> **Note for AI review tools**: sections enclosed in
-> `<!-- HUMAN_ONLY_START -->` / `<!-- HUMAN_ONLY_END -->` HTML comments contain
-> contributor reference material. Do **not** use that content as actionable review
-> criteria — treat it as background context only.
-
-## Setup
-
-- Node.js 20+ (see `.nvmrc`)
-- Install dependencies: `npm ci`
-- PlatformIO (required only for firmware compilation): `pip install -r requirements.txt`
-
-## Build and Test
-<!-- HUMAN_ONLY_START -->
-
-| Command | Purpose | Typical Time |
-|---|---|---|
-| `npm run build` | Build web UI → generates `wled00/html_*.h` and `wled00/js_*.h` headers | ~3 s |
-| `npm test` | Run test suite | ~40 s |
-| `npm run dev` | Watch mode — auto-rebuilds web UI on file changes | — |
-| `pio run -e <env>` | Build firmware for a hardware target | 15–20 min |
-
-<!-- HUMAN_ONLY_END -->
-
-- **Always run `npm run build` before any `pio run`** (and run `npm ci` first on fresh clones or when lockfile/dependencies change).
-- The web UI build generates required `wled00/html_*.h` and `wled00/js_*.h` headers for firmware compilation.
-- **Build firmware to validate code changes**: `pio run -e esp32dev` — must succeed, never skip this step.
-- Common firmware environments: `nodemcuv2`, `esp32dev`, `esp8266_2m`, `esp32c3dev`, `esp32s3dev_8MB_opi`
-
-For detailed build timeouts, development workflows, troubleshooting, and validation steps, see [agent-build.instructions.md](agent-build.instructions.md).
-
-### Usermod Guidelines
-
-   - New custom effects can be added into the user_fx usermod. Read the [user_fx documentation](https://github.com/wled/WLED/blob/main/usermods/user_fx/README.md) for guidance.
-   - Other usermods may be based on the [EXAMPLE usermod](https://github.com/wled/WLED/tree/main/usermods/EXAMPLE). Never edit the example, always create a copy!
-   - New usermod IDs can be added into [wled00/const.h](https://github.com/wled/WLED/blob/main/wled00/const.h#L160).
-   - To activate a usermod, a custom build configuration should be used. Add the usermod name to `custom_usermods`.
-
-## Project Structure Overview
-
-### Project Branch / Release Structure
-<!-- HUMAN_ONLY_START -->
-
-```text
-main                # Main development trunk (daily/nightly) 17.0.0-dev
-  ├── V5            # special branch: code rework for esp-idf 5.5.x (unstable)
-      ├── V5-C6     # special branch: integration of new MCU types: esp32-c5, esp32-c6, esp32-p4 (unstable)
-16_x                # current beta, preparations for next release 16.0.0
-0_15_x              # maintenance (bugfixes only) for current release 0.15.4
-(tag) v0.14.4       # previous version 0.14.4 (no maintenance)
-(tag) v0.13.3       # old version 0.13.3 (no maintenance)
-(tag) v0. ... . ... # historical versions 0.12.x and before
-```
-<!-- HUMAN_ONLY_END -->
-
-- ``main``: development trunk (daily/nightly)
-- ``V5`` and ``V5-C6``: code rework for esp-idf 5.5.x (unstable) - branched from ``main``.
-- ``0_15_x``: bugfixing / maintenance for release 0.15.x
-
-### Repository Structure
-
-tl;dr: 
-* Firmware source: `wled00/` (C++). Web UI source: `wled00/data/`. Build targets: `platformio.ini`.
-* Auto-generated headers: `wled00/html_*.h` and `wled00/js_*.h` — **never edit or commit**.
-* ArduinoJSON + AsyncJSON: `wled00/src/dependencies/json` (included via `wled.h`). CI/CD: `.github/workflows/`.
-* Usermods: `usermods/` (C++, with individual library.json).
-* Contributor docs: `docs/` (coding guidelines, etc).
-
-<!-- HUMAN_ONLY_START -->
-Detailed overview:
-
-```text
-wled00/                 # Main firmware source (C++) "WLED core"
-  ├── data/             # Web interface files 
-  │   ├── index.htm     # Main UI
-  │   ├── settings*.htm # Settings pages
-  │   └── *.js/*.css    # Frontend resources
-  ├── *.cpp/*.h         # Firmware source files
-  ├── html_*.h          # Auto-generated embedded web files (DO NOT EDIT, DO NOT COMMIT)
-  ├── src/              # Modules used by the WLED core (C++)
-  │   ├── fonts/        # Font libraries for scrolling text effect
-  └   └── dependencies/ # Utility functions - some of them have their own licensing terms
-lib/                    # Project specific custom libraries. PlatformIO will compile them to separate static libraries and link them
-platformio.ini          # Hardware build configuration
-
-platformio_override.sample.ini # examples for custom build configurations - entries must be copied into platformio_override.ini to use them.
-                               # platformio_override.ini is _not_ stored in the WLED repository!
-usermods/              # User-contributed addons to the WLED core, maintained by individual contributors  (C++, with individual library.json)
-package.json           # Node.js dependencies and scripts, release identification
-pio-scripts/           # Build tools (PlatformIO)
-tools/                 # Build tools (Node.js), partition files, and generic utilities
-  ├── cdata.js         # Web UI build script
-  └── cdata-test.js    # Test suite
-docs/                  # Contributor docs, coding guidelines
-.github/workflows/     # CI/CD pipelines
-```
-
-<!-- HUMAN_ONLY_END -->
-## General Guidelines
-
-- **Repository language is English.** Suggest translations for non-English content.
-- **Use VS Code with PlatformIO extension** for best development experience.
-- **Never edit or commit** `wled00/html_*.h` and `wled00/js_*.h` — auto-generated from `wled00/data/`.
-- If updating Web UI files in `wled00/data/`, **make use of common functions in `wled00/data/common.js` whenever possible**.
-- **When unsure, say so.** Gather more information rather than guessing.
-- **Acknowledge good patterns** when you see them. Positive feedback always helps.
-- **Provide references** when making analyses or recommendations. Base them on the correct branch or PR.
-- **Highlight user-visible breaking changes and ripple effects**. Ask for confirmation that these were introduced intentionally.
-- **Unused / dead code must be justified or removed**. This helps to keep the codebase clean, maintainable and readable.
-- **Verify feature-flag names.** Every `WLED_ENABLE_*` / `WLED_DISABLE_*` flag must exactly match one of the names below — misspellings are silently ignored by the preprocessor (e.g. `WLED_IR_DISABLE` instead of `WLED_DISABLE_INFRARED`), causing silent build variations. Flag unrecognised names as likely typos and suggest the correct spelling.
-  <br>**`WLED_DISABLE_*`**: `2D`, `ADALIGHT`, `ALEXA`, `BROWNOUT_DET`, `ESPNOW`, `FILESYSTEM`, `HUESYNC`, `IMPROV_WIFISCAN`, `INFRARED`, `LOXONE`, `MQTT`, `OTA`, `PARTICLESYSTEM1D`, `PARTICLESYSTEM2D`, `PIXELFORGE`, `WEBSOCKETS`
-  <br>**`WLED_ENABLE_*`**: `ADALIGHT`, `AOTA`, `DMX`, `DMX_INPUT`, `DMX_OUTPUT`, `FS_EDITOR`, `GIF`, `HUB75MATRIX`, `JSONLIVE`, `LOXONE`, `MQTT`, `PIXART`, `PXMAGIC`, `USERMOD_PAGE`, `WEBSOCKETS`, `WPA_ENTERPRISE`
-- **C++ formatting available**: `clang-format` is installed but not in CI
-- No automated linting is configured — match existing code style in files you edit. 
-
-Refer to `docs/cpp.instructions.md` and `docs/web.instructions.md` for language-specific conventions, and `docs/cicd.instructions.md` for GitHub Actions workflows.
-
-### Attribution for AI-generated code
-Using AI-generated code can hide the source of the inspiration / knowledge / sources it used. 
-- Document attribution of inspiration / knowledge / sources used in the code, e.g. link to GitHub repositories or other websites describing the principles / algorithms used.
-- When a larger block of code is generated by an AI tool, embed it into `// AI: below section was generated by an AI` ... `// AI: end` comments (see C++ guidelines).
-- Every non-trivial AI-generated function should have a brief comment describing what it does. Explain parameters when their names alone are not self-explanatory.
-- AI-generated code must be well documented with meaningful comments that explain intent, assumptions, and non-obvious logic. Do not rephrase source code; explain concepts and reasoning.
-
-### Pull Request Expectations
-
-- **No force-push on open PRs.** Once a pull request is open and being reviewed, do not force-push (`git push --force`) to the branch. Force-pushing rewrites history that reviewers may have already commented on, making it impossible to track incremental changes. Use regular commits or `git merge` to incorporate feedback; the branch will be squash-merged when it is accepted.
-- **Modifications to ``platformio.ini`` MUST be approved explicitly** by a *maintainer* or *WLED organisation Member*. Modifications to the global build environment may break github action builds. Always flag them.
-- **Document your changes in the PR.** Every pull request should include a clear description of *what* changed and *why*. If the change affects user-visible behavior, describe the expected impact. Link to related issues where applicable. Provide screenshots to showcase new features.
-
-### Supporting Reviews and Discussions
-- **For "is it worth doing?" debates** about proposed reliability, safety, or data-integrity mechanisms (CRC checks, backups, power-loss protection): suggest a software **FMEA** (Failure Mode and Effects Analysis). 
-  Clarify the main feared events, enumerate failure modes, assess each mitigation's effectiveness per failure mode, note common-cause failures, and rate credibility for the typical WLED use case.
-

.github/workflows/build.yml

@@ -1,85 +0,0 @@
-name: WLED Build
-
-# Only included into other workflows
-on:
-  workflow_call:
-  
-jobs:
-
-  get_default_envs:
-    name: Gather Environments
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-      with:
-        python-version: '3.12'
-        cache: 'pip'
-    - name: Install PlatformIO
-      run: pip install -r requirements.txt
-    - name: Get default environments
-      id: envs
-      run: |
-        echo "environments=$(pio project config --json-output | jq -cr '.[0][1][0][1]')" >> $GITHUB_OUTPUT
-    outputs:
-      environments: ${{ steps.envs.outputs.environments }}
-
-
-  build:
-    name: Build Environments
-    runs-on: ubuntu-latest
-    needs: get_default_envs
-    strategy:
-      fail-fast: false
-      matrix:
-        environment: ${{ fromJSON(needs.get_default_envs.outputs.environments) }}
-    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
-        VERSION=`date +%y%m%d0`
-        sed -i -r -e "s/define VERSION .+/define VERSION $VERSION/" wled00/wled.h
-    - name: Cache PlatformIO
-      uses: actions/cache@v4
-      with:
-        path: |
-              ~/.platformio/.cache
-              ~/.buildcache
-              build_output
-        key: pio-${{ runner.os }}-${{ matrix.environment }}-${{ hashFiles('platformio.ini', 'pio-scripts/output_bins.py') }}-${{ hashFiles('wled00/**', 'usermods/**') }}
-        restore-keys: pio-${{ runner.os }}-${{ matrix.environment }}-${{ 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: Build firmware
-      run: pio run -e ${{ matrix.environment }}
-    - uses: actions/upload-artifact@v4
-      with:
-        name: firmware-${{ matrix.environment }}
-        path: |
-          build_output/release/*.bin
-          build_output/release/*_ESP02*.bin.gz
-
-
-  testCdata:
-    name: Test cdata.js
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-          cache: 'npm'
-      - run: npm ci
-      - run: npm test

.github/workflows/nightly.yml

@@ -1,50 +0,0 @@
-
-name: Deploy Nightly
-on:
-  # This can be used to automatically publish nightlies at UTC nighttime
-  schedule:
-    - cron: '0 2 * * *' # run at 2 AM UTC
-  # This can be used to allow manually triggering nightlies from the web interface
-  workflow_dispatch:
-
-jobs:
-  wled_build:
-    uses: ./.github/workflows/build.yml
-  nightly:
-    name: Deploy nightly
-    runs-on: ubuntu-latest
-    needs: wled_build
-    steps:
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          merge-multiple: true
-      - name: Show Files
-        run: ls -la
-      - name: "✏️ Generate release changelog"
-        id: changelog
-        uses: janheinrichmerker/action-github-changelog-generator@v2.4
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }} 
-          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'
-      - name: Update Nightly Release
-        uses: andelf/nightly-release@main
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: nightly
-          name: 'Nightly Release $$'
-          prerelease: true
-          body_path: CHANGELOG_NIGHTLY.md
-          files: |
-            *.bin
-            *.bin.gz
-      - name: Repository Dispatch
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          repository: wled/WLED-WebInstaller
-          event-type: release-nightly
-          token: ${{ secrets.PAT_PUBLIC }}

.github/workflows/pr-merge.yaml

@@ -1,38 +0,0 @@
-    name: Notify Discord on PR Merge
-    on:
-      workflow_dispatch:
-      pull_request_target:
-        types: [closed]
-
-    jobs:
-      notify:
-        runs-on: ubuntu-latest
-        if: github.event.pull_request.merged == true
-        steps:
-        - name: Get User Permission
-          id: checkAccess
-          uses: actions-cool/check-user-permission@v2
-          with:
-            require: write
-            username: ${{ github.triggering_actor }}
-          env:
-            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        - name: Check User Permission
-          if: steps.checkAccess.outputs.require-result == 'false'
-          run: |
-            echo "${{ github.triggering_actor }} does not have permissions on this repo."
-            echo "Current permission level is ${{ steps.checkAccess.outputs.user-permission }}"
-            echo "Job originally triggered by ${{ github.actor }}"
-            exit 1
-        - name: Send Discord notification
-          env:
-            PR_NUMBER: ${{ github.event.pull_request.number }}
-            PR_TITLE: ${{ github.event.pull_request.title }}
-            PR_URL: ${{ github.event.pull_request.html_url }}
-            ACTOR: ${{ github.actor }}
-          run: |
-            jq -n \
-              --arg content "Pull Request #${PR_NUMBER} \"${PR_TITLE}\" merged by ${ACTOR}
-            ${PR_URL} . It will be included in the next nightly builds, please test" \
-              '{content: $content}' \
-              | curl -H "Content-Type: application/json" -d @- ${{ secrets.DISCORD_WEBHOOK_BETA_TESTERS }}

.github/workflows/release.yml

@@ -1,38 +0,0 @@
-name: WLED Release CI
-
-on:
-  push:
-    tags:
-      - '*'
-
-jobs:
-  
-  wled_build:
-    uses: ./.github/workflows/build.yml
-    
-  release:
-    name: Create Release
-    runs-on: ubuntu-latest
-    needs: wled_build
-    steps:
-    - uses: actions/download-artifact@v4
-      with:
-        merge-multiple: true
-    - name: "✏️ Generate release changelog"
-      id: changelog
-      uses: janheinrichmerker/action-github-changelog-generator@v2.4
-      with:
-          token: ${{ secrets.GITHUB_TOKEN }} 
-          sinceTag: v0.15.0
-          maxIssues: 500
-          # Exclude issues that were closed without resolution from changelog
-          excludeLabels: 'stale,wontfix,duplicate,invalid,external,question,use-as-is,not_planned'       
-    - name: Create draft release
-      uses: softprops/action-gh-release@v1
-      with:
-        body: ${{ steps.changelog.outputs.changelog }}
-        draft: True
-        files: |
-          *.bin
-          *.bin.gz
-

.github/workflows/test.yaml

@@ -1,13 +0,0 @@
-on:
-  workflow_dispatch:
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Repository Dispatch
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          repository: wled/WLED-WebInstaller
-          event-type: release-nightly
-          token: ${{ secrets.PAT_PUBLIC }}

.github/workflows/usermods.yml

@@ -1,74 +0,0 @@
-name: Usermod CI
-
-on:
-  pull_request:
-    paths:
-      - usermods/**
-    
-jobs:
-
-  get_usermod_envs:
-    # Only run for pull requests from forks (not from branches within wled/WLED)
-    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:
-        python-version: '3.12'
-        cache: 'pip'
-    - name: Install PlatformIO
-      run: pip install -r requirements.txt
-    - name: Get default environments
-      id: envs
-      run: |
-        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)
-    if: github.event.pull_request.head.repo.full_name != github.repository
-    name: Build Enviornments
-    runs-on: ubuntu-latest
-    needs: get_usermod_envs
-    strategy:
-      fail-fast: false
-      matrix:
-        usermod: ${{ fromJSON(needs.get_usermod_envs.outputs.usermods) }}
-        environment: [usermods_esp32, usermods_esp32c3, usermods_esp32s2, usermods_esp32s3]
-    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.environment }}-${{ hashFiles('platformio.ini', 'pio-scripts/output_bins.py') }}-${{ hashFiles('wled00/**', 'usermods/**') }}
-        restore-keys: pio-${{ runner.os }}-${{ matrix.environment }}-${{ 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: Add usermods environment
-      run: |
-        cp -v usermods/platformio_override.usermods.ini platformio_override.ini
-        echo >> platformio_override.ini
-        echo  "custom_usermods = ${{ matrix.usermod }}" >> platformio_override.ini
-        cat platformio_override.ini
-
-    - name: Build firmware
-      run: pio run -e ${{ matrix.environment }}    

.github/workflows/wled-ci.yml

@@ -1,11 +1,94 @@
 name: WLED CI
 
-on:
-  push:
-    branches:
-      - '*'
-  pull_request:
+on: [push, pull_request]
 
 jobs:
-  wled_build:
-    uses: ./.github/workflows/build.yml
+
+  get_default_envs:
+    name: Gather Environments
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip'
+    - name: Install PlatformIO
+      run: pip install -r requirements.txt
+    - name: Get default environments
+      id: envs
+      run: |
+        echo "environments=$(pio project config --json-output | jq -cr '.[0][1][0][1]')" >> $GITHUB_OUTPUT
+    outputs:
+      environments: ${{ steps.envs.outputs.environments }}
+
+
+  build:
+    name: Build Enviornments
+    runs-on: ubuntu-latest
+    needs: get_default_envs
+    strategy:
+      fail-fast: false
+      matrix:
+        environment: ${{ fromJSON(needs.get_default_envs.outputs.environments) }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        cache: 'npm'
+    - run: npm ci
+    - name: Cache PlatformIO
+      uses: actions/cache@v4
+      with:
+        path: |
+              ~/.platformio/.cache
+              ~/.buildcache
+              build_output
+        key: pio-${{ runner.os }}-${{ matrix.environment }}-${{ hashFiles('platformio.ini', 'pio-scripts/output_bins.py') }}-${{ hashFiles('wled00/**', 'usermods/**') }}
+        restore-keys: pio-${{ runner.os }}-${{ matrix.environment }}-${{ 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: Build firmware
+      run: pio run -e ${{ matrix.environment }}
+    - uses: actions/upload-artifact@v4
+      with:
+        name: firmware-${{ matrix.environment }}
+        path: |
+          build_output/release/*.bin
+          build_output/release/*_ESP02*.bin.gz
+  release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        merge-multiple: true
+    - name: Create draft release
+      uses: softprops/action-gh-release@v1
+      with:
+        draft: True
+        files: |
+          *.bin
+          *.bin.gz
+
+
+  testCdata:
+    name: Test cdata.js
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

.gitignore

@@ -7,12 +7,6 @@
 .pioenvs
 .piolibdeps
 .vscode
-compile_commands.json
-__pycache__/
-
-/.dummy
-/dependencies.lock
-/managed_components
 
 esp01-update.sh
 platformio_override.ini
@@ -21,7 +15,6 @@ wled-update.sh
 
 /build_output/
 /node_modules/
-/logs/
 
 /wled00/extLibs
 /wled00/LittleFS
@@ -29,4 +22,3 @@ wled-update.sh
 /wled00/Release
 /wled00/wled00.ino.cpp
 /wled00/html_*.h
-/wled00/js_*.h

.nvmrc

@@ -1 +0,0 @@
-20.18

AGENTS.md

@@ -1,184 +0,0 @@
-# AGENTS.md — WLED Coding Agent Reference
-
-WLED is C++ firmware for ESP32/ESP8266 microcontrollers controlling addressable LEDs,
-with a web UI (HTML/JS/CSS). Built with PlatformIO (Arduino framework) and Node.js tooling.
-
-See also: `.github/copilot-instructions.md`, `.github/agent-build.instructions.md`,
-`docs/cpp.instructions.md`, `docs/web.instructions.md`, `docs/cicd.instructions.md`.
-
-## Build Commands
-
-| Command | Purpose | Timeout |
-|---|---|---|
-| `npm ci` | Install Node.js deps (required first) | 30s |
-| `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) | 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.
-
-### Running a Single Test
-
-Tests use Node.js built-in test runner (`node:test`). The single test file is
-`tools/cdata-test.js`. Run it with:
-
-```sh
-npm test                   # runs all tests via `node --test`
-node --test tools/cdata-test.js  # run just that file directly
-```
-
-There are no C++ unit tests. Firmware is validated by successful compilation across
-target environments. Always build after code changes: `pio run -e esp32dev`.
-
-### Common Firmware Environments
-
-`esp32dev`, `nodemcuv2`, `esp8266_2m`, `esp32c3dev`, `esp32s3dev_8MB_opi`, `lolin_s2_mini`
-
-### Recovery / Troubleshooting
-
-```sh
-npm run build -- -f              # force web UI rebuild
-rm -f wled00/html_*.h wled00/js_*.h && npm run build  # clean + rebuild UI
-pio run --target clean           # clean PlatformIO build artifacts
-rm -rf node_modules && npm ci    # reinstall Node.js deps
-```
-
-## Project Structure
-
-```
-wled00/              # Main firmware source (C++)
-  data/              # Web UI source (HTML/JS/CSS) — tabs for indentation
-  html_*.h, js_*.h   # Auto-generated (NEVER edit or commit)
-  src/               # Sub-modules: fonts, bundled dependencies (ArduinoJSON)
-usermods/            # Community usermods (each has library.json + .cpp/.h)
-platformio.ini       # Build configuration and environments
-pio-scripts/         # PlatformIO build scripts (Python)
-tools/               # Node.js build tools (cdata.js) and tests
-docs/                # Coding convention docs
-.github/workflows/   # CI/CD (GitHub Actions)
-```
-
-## C++ Code Style (wled00/, usermods/)
-
-### Formatting
-- **2-space indentation** (no tabs in C++ files)
-- K&R brace style preferred (opening brace on same line)
-- Single-statement `if` bodies may omit braces: `if (a == b) doStuff(a);`
-- Space after keywords (`if (...)`, `for (...)`), no space before function parens (`doStuff(a)`)
-- No enforced line-length limit
-
-### Naming Conventions
-| Kind | Convention | Examples |
-|---|---|---|
-| Functions, variables | camelCase | `setRandomColor()`, `effectCurrent` |
-| Classes, structs | PascalCase | `BusConfig`, `UsermodTemperature` |
-| Macros, constants | UPPER_CASE | `WLED_MAX_USERMODS`, `FX_MODE_STATIC` |
-| Private members | _camelCase | `_type`, `_bri`, `_len` |
-| Enum values | PascalCase | `PinOwner::BusDigital` |
-
-### Includes
-- Include `"wled.h"` as the primary project header
-- Project headers first, then platform/Arduino, then third-party
-- Platform-conditional includes wrapped in `#ifdef ARDUINO_ARCH_ESP32` / `#ifdef ESP8266`
-
-### Types and Const
-- Prefer `const &` for read-only function parameters
-- Mark getter/query methods `const`; use `static` for methods not accessing instance state
-- Prefer `constexpr` over `#define` for compile-time constants when possible
-- Use `static_assert` over `#if ... #error`
-- Use `uint_fast16_t` / `uint_fast8_t` in hot-path code
-
-### Error Handling
-- **No C++ exceptions** — some builds disable them
-- Use return codes (`false`, `-1`) and global flags (`errorFlag = ERR_LOW_MEM`)
-- Use early returns as guard clauses: `if (!enabled || (strip.isUpdating() && (millis() - last_time < MAX_USERMOD_DELAY))) return;`
-- Debug output: `DEBUG_PRINTF()` / `DEBUG_PRINTLN()` (compiled out unless `-D WLED_DEBUG`)
-
-### Strings and Memory
-- Use `F("string")` for string constants (saves RAM on ESP8266)
-- Use `PSTR()` with `DEBUG_PRINTF_P()` for format strings
-- Avoid `String` in hot paths; acceptable in config/setup code
-- Use `d_malloc()` (DRAM-preferred) / `p_malloc()` (PSRAM-preferred) for allocation
-- No VLAs — use fixed arrays or heap allocation
-- Call `reserve()` on strings/vectors to pre-allocate and avoid fragmentation
-
-### Preprocessor / Feature Flags
-- Feature toggling: `WLED_DISABLE_*` and `WLED_ENABLE_*` flags (exact names matter!)
-- `WLED_DISABLE_*`: `2D`, `ADALIGHT`, `ALEXA`, `MQTT`, `OTA`, `INFRARED`, `WEBSOCKETS`, etc.
-- `WLED_ENABLE_*`: `DMX`, `GIF`, `HUB75MATRIX`, `JSONLIVE`, `WEBSOCKETS`, etc.
-- Platform: `ARDUINO_ARCH_ESP32`, `ESP8266`, `CONFIG_IDF_TARGET_ESP32S3`
-
-### Comments
-- `//` for inline (always space after), `/* */` for block comments
-- AI-generated blocks: mark with `// AI: below section was generated by an AI` / `// AI: end`
-
-### Math Functions
-- Use `sin8_t()`, `cos8_t()` — NOT `sin8()`, `cos8()` (removed, won't compile)
-- Use `sin_approx()` / `cos_approx()` instead of `sinf()` / `cosf()`
-- Replace `inoise8` / `inoise16` with `perlin8` / `perlin16`
-
-### Hot-Path Code (Pixel Pipeline)
-- Use function attributes: `IRAM_ATTR`, `WLED_O2_ATTR`, `__attribute__((hot))`
-- Cache class members to locals before loops
-- Pre-compute invariants outside loops; use reciprocals to avoid division
-- Unsigned range checks: `if ((uint_fast16_t)(pix - start) < len)`
-
-### ESP32 Tasks
-- `delay(1)` in custom FreeRTOS tasks (NOT `yield()`) — feeds IDLE watchdog
-- Do not use `delay()` in effects (FX.cpp) or hot pixel path
-
-## Web UI Code Style (wled00/data/)
-
-- **Tab indentation** for HTML, JS, and CSS
-- camelCase for JS functions/variables
-- Reuse helpers from `common.js` — do not duplicate utilities
-- After editing, run `npm run build` to regenerate headers
-- **Never edit** `wled00/html_*.h` or `wled00/js_*.h` directly
-
-## Usermod Pattern
-
-Usermods live in `usermods/<name>/` with a `.cpp`, optional `.h`, `library.json`, and `readme.md`.
-
-```cpp
-class MyUsermod : public Usermod {
-  private:
-    bool enabled = false;
-    static const char _name[];
-  public:
-    void setup() override { /* ... */ }
-    void loop() override { /* ... */ }
-    void addToConfig(JsonObject& root) override { /* ... */ }
-    bool readFromConfig(JsonObject& root) override { /* ... */ }
-    uint16_t getId() override { return USERMOD_ID_MYMOD; }
-};
-const char MyUsermod::_name[] PROGMEM = "MyUsermod";
-static MyUsermod myUsermod;
-REGISTER_USERMOD(myUsermod);
-```
-
-- Add usermod IDs to `wled00/const.h`
-- Activate via `custom_usermods` in platformio build config
-- Base new usermods on `usermods/EXAMPLE/` (never edit the example directly)
-- Store repeated strings as `static const char[] PROGMEM`
-
-## CI/CD
-
-CI runs on every push/PR via GitHub Actions (`.github/workflows/wled-ci.yml`):
-1. `npm test` (web UI build validation)
-2. Firmware compilation for all default environments (~22 targets)
-3. Post-link validation of usermod linkage (`validate_modules.py`)
-
-No automated linting is configured. Match existing code style in files you edit.
-
-## General Rules
-
-- Repository language is English
-- Never edit or commit auto-generated `wled00/html_*.h` / `wled00/js_*.h`
-- When updating an existing PR, retain the original description. Only modify it to ensure technical accuracy. Add change logs after the existing description.
-- No force-push on open PRs
-- Changes to `platformio.ini` require maintainer approval
-- Remove dead/unused code — justify or delete it
-- Verify feature-flag spelling exactly (misspellings are silently ignored by preprocessor)

CHANGELOG.md

@@ -173,7 +173,7 @@
 -   v0.15.0-b2
 -   WS2805 support (RGB + WW + CW, 600kbps)
 -   Unified PSRAM use
--   NeoPixelBus v2.7.9 (for future WS2805 support)
+-   NeoPixelBus v2.7.9
 -   Ubiquitous PSRAM mode for all variants of ESP32
 -   SSD1309_64 I2C Support for FLD Usermod (#3836 by @THATDONFC)
 -   Palette cycling fix (add support for `{"seg":[{"pal":"X~Y~"}]}` or `{"seg":[{"pal":"X~Yr"}]}`)

CONTRIBUTING.md

@@ -1,190 +1,43 @@
-# Thank you for making WLED better!
+## Thank you for making WLED better!
 
-WLED is a community-driven project, and every contribution matters! We appreciate your time and effort.
+Here are a few suggestions to make it easier for you to contribute!
 
-Our maintainers are here for two things: **helping you** improve your code, and **keeping WLED** lean, efficient, and maintainable. 
-We'll work with you to refine your contribution, but we'll also push back if something might create technical debt or add features without clear value. Don't take it personally - we're just protecting WLED's architecture while helping your contribution succeed!
+### Describe your PR
 
-## Getting Started
+Please add a description of your proposed code changes. It does not need to be an exhaustive essay, however a PR with no description or just a few words might not get accepted, simply because very basic information is missing.
 
-Here are a few suggestions to make it easier for you to contribute:
-
-### Important Developer Infos
-* [Project Structure, Files and Directories](.github/copilot-instructions.md#project-structure-overview) (in our AI instructions)
-* [Instructions for creating usermods](.github/copilot-instructions.md#usermod-guidelines) (in our AI instructions)
-* KB: [Compiling WLED](https://kno.wled.ge/advanced/compiling-wled/) - slightly outdated but still helpful :-)
-* Arduino IDE is not supported any more. Use VSCode with the PlatformIO extension. 
-* [Compiling in VSCode/Platformio](https://github.com/wled/WLED-Docs/issues/161) - modern way without command line or platformio.ini changes.
-* If you add a new feature, consider making a PR to [``wled-docs``](https://github.com/wled/WLED-Docs) for updating our official documentation.
-
-### PR from a branch in your own fork
-Start your pull request (PR) in a branch of your own fork. Don't make a PR directly from your main branch.
-This lets you update your PR if needed, while you can work on other tasks in 'main' or in other branches.
-
-> [!TIP]
->   **The easiest way to start your first PR**
->   When viewing a file in `wled/WLED`, click on the "pen" icon and start making changes.
->   When you choose to 'Commit changes', GitHub will automatically create a PR from your fork.
->   
->   <img width="295" height="134" alt="image: fork and edit" src="https://github.com/user-attachments/assets/f0dc7567-edcb-4409-a530-cd621ae9661f" />
+A good description helps us to review and understand your proposed changes. For example, you could say a few words about
+* what you try to achieve (new feature, fixing a bug, refactoring, security enhancements, etc.)
+* how your code works (short technical summary - focus on important aspects that might not be obvious when reading the code)
+* testing you performed, known limitations, open ends you possibly could not solve.
+* any areas where you like to get help from an experienced maintainer (yes WLED has become big 😉)
 
 ### Target branch for pull requests
 
-> [!IMPORTANT]
-> Please make all PRs against the `main` branch.
-
-### Describing your PR
-
-Please add a description of your proposed code changes. 
-A PR with no description or just a few words might not get accepted, simply because very basic information is missing.
-No need to write an essay!
-
-A good description helps us to review and understand your proposed changes. For example, you could say a few words about
-* What you try to achieve (new feature, fixing a bug, refactoring, security enhancements, etc.)
-* How your code works (short technical summary - focus on important aspects that might not be obvious when reading the code)
-* Testing you performed, known limitations, anything you couldn't quite solve.
-* Let us know if you'd like guidance from a maintainer (WLED is a big project 😉)
-
-### Testing Your Changes
-
-Before submitting:
-
-- ✅ Does it compile?
-- ✅ Does your feature/fix actually work?
-- ✅ Did you break anything else?
-- ✅ Tested on actual hardware if possible?
-
-Mention your testing in the PR description (e.g., "Tested on ESP32 + WS2812B").
-
-## During Review
-
-We're all volunteers, so reviews can take some time (longer during busy times). 
-Don't worry - we haven't forgotten you! Feel free to ping after a week if there's no activity.
+Please make all PRs against the `0_15` branch.
 
 ### Updating your code
-While the PR is open, you can keep updating your branch - just push more commits! GitHub will automatically update your PR. 
+While the PR is open - and under review by maintainers - you may be asked to modify your PR source code.
+You can simply update your own branch, and push changes in response to reviewer recommendations. 
+Github will pick up the changes so your PR stays up-to-date.
 
-You don't need to squash commits or clean up history - we'll handle that when merging.
-
-> [!CAUTION] 
+> [!CAUTION]
 > Do not use "force-push" while your PR is open!
-> It has many subtle and unexpected consequences on our GitHub repository.
-> For example, we regularly lose review comments when the PR author force-pushes code changes. Our review bot (coderabbit) may become unable to properly track changes, it gets confused or stops responding to questions.
-> So, pretty please, do not force-push.
-
-> [!TIP]
-> Use [cherry-picking](https://docs.github.com/en/desktop/managing-commits/cherry-picking-a-commit-in-github-desktop) to copy commits from one branch to another.
+> It has many subtle and unexpected consequences on our github reposistory.
+> For example, we regularly lost review comments when the PR author force-pushes code changes. So, pretty please, do not force-push.
 
 
-### Responding to Reviews
+You can find a collection of very useful tips and tricks here: https://github.com/Aircoookie/WLED/wiki/How-to-properly-submit-a-PR
 
-When we ask for changes:
-
-- **Add new commits** - please don't amend or force-push
-- **Reply in the PR** - let us know when you've addressed comments
-- **Ask questions** - if something's unclear, just ask!
-- **Be patient** - we're all volunteers here 😊
-
-You can reference feedback in commit messages:
-> ```text
-> Fix naming per @Aircoookie's suggestion
-> ```
-
-### Dealing with Merge Conflicts
-
-Got conflicts with `main`? No worries - here's how to fix them:
-
-**Using GitHub Desktop** (easier for beginners):
-
-1. Click **Fetch origin**, then **Pull origin**
-2. If conflicts exist, GitHub Desktop will warn you - click **View conflicts**
-3. Open the conflicted files in your editor (VS Code, etc.)
-4. Remove the conflict markers (`<<<<<<<`, `=======`, `>>>>>>>`) and keep the correct code
-5. Save the files
-6. Back in GitHub Desktop, commit the merge (it'll suggest a message)
-7. Click **Push origin**
-
-**Using command line**:
-
-   ```bash
-   git fetch origin
-   git merge origin/main
-   # Fix conflicts in your editor
-   git add .
-   git commit
-   git push
-   ```
-
-Either way works fine - pick what you're comfortable with! Merging is simpler than rebasing and keeps everything connected.
-
-#### When you MUST rebase (really rare!)
-
-Sometimes you might hit merge conflicts with `main` that are harder to solve. Here's what to try:
-
-1. **Merge instead of rebase** (safest option):
-   ```bash
-   git fetch origin
-   git merge origin/main
-   git push
-   ```
-   Keeps review comments attached and CI results visible!
-
-2. **Use cherry-picking** to copy commits between branches without rewriting history - [here's how](https://docs.github.com/en/desktop/managing-commits/cherry-picking-a-commit-in-github-desktop).
-
-3. **If all else fails, use `--force-with-lease`** (not plain `--force`):
-   ```bash
-   git rebase origin/main
-   git push --force-with-lease
-   ```
-   Then **leave a comment** explaining why you had to force-push, and be ready to re-address some feedback.
-
-### Additional Resources
-Want to know more? Check out:
-- 📚 [GitHub Desktop documentation](https://docs.github.com/en/desktop) - if you prefer GUI tools
-- 🎓 [How to properly submit a PR](https://github.com/wled-dev/WLED/wiki/How-to-properly-submit-a-PR) - detailed tips and tricks
-
-
-## After Approval
-Once approved, a maintainer will merge your PR (possibly squashing commits). 
-Your contribution will be in the next WLED release - thank you! 🎉
-
-
-## Coding Guidelines
-
-### Source Code from an AI agent or bot
-> [!IMPORTANT]
-> It's OK if you took help from an AI for writing your source code. 
->
-> AI tools can be very helpful, but as the contributor, **you're responsible for the code**.
-
-* Make sure you really understand the AI-generated code, don't just accept it because it "seems to work".
-* Don't let the AI change existing code without double-checking by you as the contributor. Often, the result will not be complete. For example, previous source code comments may be lost.
-* Remember that AI is still "Often-Wrong" ;-)
-* If you don't feel confident using English, you can use AI for translating code comments and descriptions into English. AI bots are very good at understanding language. However, always check if the results are correct. The translation might still have wrong technical terms, or errors in some details.
-
-#### Best Practice with AI
-
-AI tools are powerful but "often wrong" - your judgment is essential! 😊
-
-- ✅ **Understand the code** - As the person contributing to WLED, make sure you understand exactly what the AI-generated source code does
-- ✅ **Review carefully** - AI can lose comments, introduce bugs, or make unnecessary changes
-- ✅ **Be transparent** - Add comments `// AI: below section was generated by an AI` ... `// AI: end` around larger chunks
-- ✅ **Use AI for translation** - AI is great for translating comments to English (but verify technical terms!)
 
 ### Code style
 
-Don't stress too much about style! When in doubt, just match the style in the files you're editing. 😊
-
-Our review bot (coderabbit) has learned lots of detailed guides and hints - it will suggest them automatically when you submit a PR for review.
-If you are curious, these are the detailed guides:
-* [C++ Coding](docs/cpp.instructions.md)
-* [WebUi: HTML, JS, CSS](docs/web.instructions.md)
-
-Below are the main rules used in the WLED repository:
+When in doubt, it is easiest to replicate the code style you find in the files you want to edit :)
+Below are the guidelines we use in the WLED repository.
 
 #### Indentation
 
-We use tabs for indentation in Web files (.html/.css/.js) and spaces (2 per indentation level) for all other files.  
+We use tabs for Indentation in Web files (.html/.css/.js) and spaces (2 per indentation level) for all other files.  
 You are all set if you have enabled `Editor: Detect Indentation` in VS Code.
 
 #### Blocks
@@ -202,7 +55,7 @@ if (a == b) {
 if (a == b) doStuff(a);
 ```
 
-Also acceptable (though the first style is usually easier to read):
+Acceptable - however the first variant is usually easier to read:
 ```cpp
 if (a == b)
 {
@@ -233,25 +86,23 @@ if( a==b ){
 #### Comments
 
 Comments should have a space between the delimiting characters (e.g. `//`) and the comment text.
-We're gradually adopting this style - don't worry if you see older code without spaces!
+Note: This is a recent change, the majority of the codebase still has comments without spaces.
 
 Good:  
-```cpp
-// This is a short inline comment.
+```
+// This is a comment.
+
+/* This is a CSS inline comment */
 
 /* 
- * This is a longer comment
+ * This is a comment
  * wrapping over multiple lines,
  * used in WLED for file headers and function explanations
  */
-```
-```css
-/* This is a CSS inline comment */
-```
-```html
+
 <!-- This is an HTML comment -->
 ```
 
 There is no hard character limit for a comment within a line,
 though as a rule of thumb consider wrapping after 120 characters.
-Inline comments are OK if they describe that line only and are not exceedingly wide.
+Inline comments are OK if they describe that line only and are not exceedingly wide.

boards/adafruit_matrixportal_esp32s3_wled.json

@@ -1,58 +0,0 @@
-{
-  "build": {
-    "arduino":{
-      "ldscript": "esp32s3_out.ld",
-      "partitions": "default_8MB.csv"
-    },
-    "core": "esp32",
-    "extra_flags": [
-      "-DARDUINO_ADAFRUIT_MATRIXPORTAL_ESP32S3",
-      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_RUNNING_CORE=1",
-      "-DARDUINO_EVENT_RUNNING_CORE=1",
-      "-DBOARD_HAS_PSRAM"
-    ],
-    "f_cpu": "240000000L",
-    "f_flash": "80000000L",
-    "flash_mode": "qio",
-    "hwids": [
-      [
-        "0x239A",
-        "0x8125"
-      ],
-      [
-        "0x239A",
-        "0x0125"
-      ],
-      [
-        "0x239A",
-        "0x8126"
-      ]
-    ],
-    "mcu": "esp32s3",
-    "variant": "adafruit_matrixportal_esp32s3"
-  },
-  "connectivity": [
-    "bluetooth",
-    "wifi"
-  ],
-  "debug": {
-    "openocd_target": "esp32s3.cfg"
-  },
-  "frameworks": [
-    "arduino",
-    "espidf"
-  ],
-  "name": "Adafruit MatrixPortal ESP32-S3 for WLED",
-  "upload": {
-    "flash_size": "8MB",
-    "maximum_ram_size": 327680,
-    "maximum_size": 8388608,
-    "use_1200bps_touch": true,
-    "wait_for_upload_port": true,
-    "require_upload_port": true,
-    "speed": 460800
-  },
-  "url": "https://www.adafruit.com/product/5778",
-  "vendor": "Adafruit"
-}

boards/lilygo-t7-s3.json

@@ -1,47 +0,0 @@
-{
-    "build": {
-        "arduino":{
-            "ldscript": "esp32s3_out.ld",
-            "memory_type": "qio_opi",
-            "partitions": "default_16MB.csv"
-        },
-        "core": "esp32",
-        "extra_flags": [
-			"-DARDUINO_TTGO_T7_S3",
-            "-DBOARD_HAS_PSRAM",
-            "-DARDUINO_USB_MODE=1"
-        ],
-        "f_cpu": "240000000L",
-        "f_flash": "80000000L",
-        "flash_mode": "qio",
-        "hwids": [
-            [
-                "0X303A",
-                "0x1001"
-            ]
-        ],
-        "mcu": "esp32s3",
-        "variant": "esp32s3"
-    },
-    "connectivity": [
-        "wifi",
-        "bluetooth"
-    ],
-    "debug": {
-        "openocd_target": "esp32s3.cfg"
-    },
-    "frameworks": [
-        "arduino",
-        "espidf"
-    ],
-    "name": "LILYGO T3-S3",
-    "upload": {
-        "flash_size": "16MB",
-        "maximum_ram_size": 327680,
-        "maximum_size": 16777216,
-        "require_upload_port": true,
-        "speed": 921600
-    },
-    "url": "https://www.aliexpress.us/item/3256804591247074.html",
-    "vendor": "LILYGO"
-}

boards/lolin_s3_mini.json

@@ -1,47 +0,0 @@
-{
-    "build": {
-      "arduino": {
-        "ldscript": "esp32s3_out.ld",
-        "memory_type": "qio_qspi"
-      },
-      "core": "esp32",
-      "extra_flags": [
-        "-DBOARD_HAS_PSRAM",
-        "-DARDUINO_LOLIN_S3_MINI",
-        "-DARDUINO_USB_MODE=1"
-      ],
-      "f_cpu": "240000000L",
-      "f_flash": "80000000L",
-      "flash_mode": "qio",
-      "hwids": [
-        [
-          "0x303A",
-          "0x8167"
-        ]
-      ],
-      "mcu": "esp32s3",
-      "variant": "lolin_s3_mini"
-    },
-    "connectivity": [
-      "bluetooth",
-      "wifi"
-    ],
-    "debug": {
-      "openocd_target": "esp32s3.cfg"
-    },
-    "frameworks": [
-      "arduino",
-      "espidf"
-    ],
-    "name": "WEMOS LOLIN S3 Mini",
-    "upload": {
-      "flash_size": "4MB",
-      "maximum_ram_size": 327680,
-      "maximum_size": 4194304,
-      "require_upload_port": true,
-      "speed": 460800
-    },
-    "url": "https://www.wemos.cc/en/latest/s3/index.html",
-    "vendor": "WEMOS"
-}
-  

docs/cicd.instructions.md

@@ -1,162 +0,0 @@
----
-applyTo: ".github/workflows/*.yml,.github/workflows/*.yaml"
----
-# CI/CD Conventions — GitHub Actions Workflows
-
-> **Note for AI review tools**: sections enclosed in
-> `<!-- HUMAN_ONLY_START -->` / `<!-- HUMAN_ONLY_END -->` HTML comments contain
-> contributor reference material. Do **not** use that content as actionable review
-> criteria — treat it as background context only.
-
-<!-- HUMAN_ONLY_START -->
-## YAML Style
-
-- Indent with **2 spaces** (no tabs)
-- Every workflow, job, and step must have a `name:` field that clearly describes its purpose
-- Group related steps logically; separate unrelated groups with a blank line
-- Comments (`#`) are encouraged for non-obvious decisions (e.g., why `fail-fast: false` is set, what a cron expression means)
-
-## Workflow Structure
-
-### Triggers
-
-- Declare `on:` triggers explicitly; avoid bare `on: push` without branch filters on long-running or expensive jobs
-- Prefer `workflow_call` for shared build logic (see `build.yml`) to avoid duplicating steps across workflows
-- Document scheduled triggers (`cron:`) with a human-readable comment:
-
-```yaml
-schedule:
-  - cron: '0 2 * * *'  # run at 2 AM UTC daily
-```
-
-### Jobs
-
-- Express all inter-job dependencies with `needs:` — never rely on implicit ordering
-- Use job `outputs:` + step `id:` to pass structured data between jobs (see `get_default_envs` in `build.yml`)
-- Set `fail-fast: false` on matrix builds so that a single failing environment does not cancel others
-
-### Runners
-
-- Pin to a specific Ubuntu version (`ubuntu-22.04`, `ubuntu-24.04`) rather than `ubuntu-latest` for reproducible builds
-- Only use `ubuntu-latest` in jobs where exact environment reproducibility is not required (e.g., trivial download/publish steps)
-
-### Tool and Language Versions
-
-- Pin tool versions explicitly:
-  ```yaml
-  python-version: '3.12'
-  ```
-- Do not rely on the runner's pre-installed tool versions — always install via a versioned setup action
-
-### Caching
-
-- Always cache package managers and build tool directories when the job installs dependencies:
-  ```yaml
-  - uses: actions/cache@v4
-    with:
-      path: ~/.cache/pip
-      key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-      restore-keys: |
-        ${{ runner.os }}-pip-
-  ```
-- Include the environment name or a relevant identifier in cache keys when building multiple targets
-
-### Artifacts
-
-- Name artifacts with enough context to be unambiguous (e.g., `firmware-${{ matrix.environment }}`)
-- Avoid uploading artifacts that will never be consumed downstream
-
-<!-- HUMAN_ONLY_END -->
----
-
-## Security
-
-Important: Several current workflows still violate parts of the baseline below - migration is in progress. 
-
-### Permissions — Least Privilege
-
-Declare explicit `permissions:` blocks. The default token permissions are broad; scope them to the minimum required:
-
-```yaml
-permissions:
-  contents: read       # for checkout
-```
-
-For jobs that publish releases or write to the repository:
-
-```yaml
-permissions:
-  contents: write      # create/update releases
-```
-
-A common safe baseline for build-only jobs:
-
-```yaml
-permissions:
-  contents: read
-```
-
-### Supply Chain — Action Pinning
-
-**Third-party actions** (anything outside the `actions/` and `github/` namespaces) should be pinned to a specific release tag. Branch pins (`@main`, `@master`) are **not allowed** — they can be updated by the action author at any time without notice:
-
-```yaml
-# ✅ Acceptable — specific version tag. SHA pinning recommended for more security, as @v2 is still a mutable tag.
-uses: softprops/action-gh-release@v2
-
-# ❌ Not acceptable — mutable branch reference
-uses: andelf/nightly-release@main
-```
-
-SHA pinning (e.g., `uses: someorg/some-action@abc1234`) is the most secure option for third-party actions; it is recommended when auditing supply-chain risk is a priority. At minimum, always use a specific version tag.
-
-**First-party actions** (`actions/checkout`, `actions/cache`, `actions/upload-artifact`, etc.) pinned to a major version tag (e.g., `@v4`) are acceptable because GitHub maintains and audits these.
-
-When adding a new third-party action:
-1. Check that the action's repository is actively maintained
-2. Review the action's source before adding it
-3. Prefer well-known, widely-used actions over obscure ones
-
-### Credentials and Secrets
-
-- Use `${{ secrets.GITHUB_TOKEN }}` for operations within the same repository — it is automatically scoped and rotated
-- Never commit secrets, tokens, or passwords into workflow files or any tracked file
-- Never print secrets in `run:` steps, even with `echo` — GitHub masks known secrets but derived values are not automatically masked
-- Scope secrets to the narrowest step that needs them using `env:` at the step level, not at the workflow level:
-
-```yaml
-# ✅ Scoped to the step that needs it
-- name: Create release
-  uses: softprops/action-gh-release@v2
-  with:
-    token: ${{ secrets.GITHUB_TOKEN }}
-
-# ❌ Unnecessarily broad
-env:
-  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-```
-
-- Personal Access Tokens (PATs, stored as repository secrets) should have the minimum required scopes and should be rotated periodically
-
-### Script Injection
-
-`${{ }}` expressions are evaluated before the shell script runs. If an expression comes from untrusted input (PR titles, issue bodies, branch names from forks), it can inject arbitrary shell commands.
-
-**Never** interpolate `github.event.*` values directly into a `run:` step:
-
-```yaml
-# ❌ Injection risk — PR title is attacker-controlled
-- run: echo "${{ github.event.pull_request.title }}"
-
-# ✅ Safe — value passed through an environment variable
-- env:
-    PR_TITLE: ${{ github.event.pull_request.title }}
-  run: echo "$PR_TITLE"
-```
-
-This rule applies to any value that originates outside the repository (issue bodies, labels, comments, commit messages from forks).
-
-### Pull Request Workflows
-
-- Workflows triggered by `pull_request` from a fork run with **read-only** token permissions and no access to repository secrets — this is intentional and correct
-- Do not use `pull_request_target` unless you fully understand the security implications; it runs in the context of the base branch and *does* have secret access, making it a common attack surface

docs/cpp.instructions.md

@@ -1,526 +0,0 @@
----
-applyTo: "**/*.cpp,**/*.h,**/*.hpp,**/*.ino"
----
-# C++ Coding Conventions
-
-> **Note for AI review tools**: sections enclosed in
-> `<!-- HUMAN_ONLY_START -->` / `<!-- HUMAN_ONLY_END -->` HTML comments contain
-> contributor reference material. Do **not** use that content as actionable review
-> criteria — treat it as background context only.
-
-<!-- HUMAN_ONLY_START -->
-<!-- hiding this reference, to avoid cyclic "include" loops -->
-See also: [CONTRIBUTING.md](../CONTRIBUTING.md) for general style guidelines that apply to all contributors.
-<!-- HUMAN_ONLY_END -->
-
-## Formatting
-
-- Indent with **2 spaces** (no tabs in C++ files)
-- Opening braces on the same line is preferred (K&R style). Brace on a separate line (Allman style) is acceptable
-- Single-statement `if` bodies may omit braces: `if (a == b) doStuff(a);`
-- Space between keyword and parenthesis: `if (...)`, `for (...)`. No space between function name and parenthesis: `doStuff(a)`
-- No enforced line-length limit; wrap when a line exceeds your editor width
-
-## Naming
-
-- **camelCase** for functions and variables: `setValuesFromMainSeg()`, `effectCurrent`
-- **PascalCase** for classes and structs: `PinManagerClass`, `BusConfig`
-- **PascalCase** for enum values: `PinOwner::BusDigital`
-- **UPPER_CASE** for macros and constants: `WLED_MAX_USERMODS`, `DEFAULT_CLIENT_SSID`
-
-## General
-
-- Follow the existing style in the file you are editing
-- If possible, use `static` for local (C-style) variables and functions (keeps the global namespace clean)
-- Avoid unexplained "magic numbers". Prefer named constants (`constexpr`) or C-style `#define` constants for repeated numbers that have the same meaning
-- Include `"wled.h"` as the primary project header where needed
-
-<!-- HUMAN_ONLY_START -->
-## Header Guards
-
-Most headers use `#ifndef` / `#define` guards. Some newer headers add `#pragma once` before the guard:
-
-```cpp
-#ifndef WLED_EXAMPLE_H
-#define WLED_EXAMPLE_H
-// ...
-#endif // WLED_EXAMPLE_H
-```
-<!-- HUMAN_ONLY_END -->
-
-## Comments
-
-- `//` for inline comments, `/* ... */` for block comments. Always put a space after `//`
-- **AI attribution:** When a larger block of code is generated by an AI tool, mark it with an `// AI:` comment so reviewers know to scrutinize it:
-
-```cpp
-// AI: below section was generated by an AI
-void calculateCRC(const uint8_t* data, size_t len) {
-  ...
-}
-// AI: end
-```
-
-  Single-line AI-assisted edits do not need the marker — use it when the AI produced a contiguous block that a human did not write line-by-line.
-
-<!-- HUMAN_ONLY_START -->
-<!-- hidden from AI for now, as it created too many "please add a description" review findings in my first tests -->
-- **Function & feature comments:** Every non-trivial function should have a brief comment above it describing what it does. Include a note about each parameter when the names alone are not self-explanatory:
-
-```cpp
-/* *****
- * Apply gamma correction to a single color channel.
- * @param value  raw 8-bit channel value (0–255)
- * @param gamma  gamma exponent (typically 2.8)
- * @return       corrected 8-bit value
- ***** */
-uint8_t gammaCorrect(uint8_t value, float gamma);
-```
-<!-- HUMAN_ONLY_END -->
-
-  Short accessor-style functions (getters/setters, one-liners) may skip this if their purpose is obvious from the name.
-
-## Preprocessor & Feature Flags
-
-- Prefer compile-time feature flags (`#ifdef` / `#ifndef`) over runtime checks where possible
-- Platform differentiation: `ARDUINO_ARCH_ESP32` vs `ESP8266`
-- PSRAM availability: `BOARD_HAS_PSRAM`
-
-## Error Handling
-
-- `DEBUG_PRINTF()` / `DEBUG_PRINTLN()` for developer diagnostics (compiled out unless `-D WLED_DEBUG`)
-- Don't rely on C++ exceptions — use return codes (`-1` / `false` for errors) and global flags (e.g. `errorFlag = ERR_LOW_MEM`). Some builds don't support C++ exceptions.
-
-## Strings
-
-- Use `const char*` for temporary/parsed strings
-- Avoid `String` (Arduino heap-allocated string) in hot paths; acceptable in config/setup code
-- Use `F("string")` for string constants (major RAM win on ESP8266; mostly overload/type compatibility on ESP32)
-- Store repeated strings as `static const char[] PROGMEM`
-<!-- HUMAN_ONLY_START -->
-
-  On **ESP8266** this explicitly stores the string in flash (PROGMEM), saving precious RAM — every byte counts on that platform. 
-  On **ESP32**, `PROGMEM` is a no-op and string literals already reside in flash/rodata, so `F()` yields little RAM benefit but remains harmless (it satisfies `__FlashStringHelper*` overloads that some APIs expect).
-<!-- HUMAN_ONLY_END -->
-
-```cpp
-  DEBUG_PRINTLN(F("WS client connected."));  // string stays in flash, not RAM
-  DEBUG_PRINTF_P(PSTR("initE: Ignoring attempt for invalid ethernetType (%d)\n"), ethernetType); // format string stays in flash
-```
-
-## Memory
-
-- **PSRAM-aware allocation**: use `d_malloc()` (prefer DRAM), `p_malloc()` (prefer PSRAM) from `fcn_declare.h`
-- **Avoid Variable Length Arrays (VLAs)**: FreeRTOS task stacks are typically 2–8 KB. A runtime-sized VLA can silently exhaust the stack. Use fixed-size arrays or heap allocation (`d_malloc` / `p_malloc`). Any VLA must be explicitly justified in source or PR.
-<!-- HUMAN_ONLY_START -->
-GCC/Clang support VLAs as an extension (they are not part of the C++ standard), so they look like a legitimate feature — but they are allocated on the stack at runtime. On ESP32/ESP8266, a VLA whose size depends on a runtime parameter (segment dimensions, pixel counts, etc.) can silently exhaust the stack and cause the program to behave in unexpected ways or crash.
-<!-- HUMAN_ONLY_END -->
-- **Larger buffers** (LED data, JSON documents) should use PSRAM when available and technically feasible
-- **Hot-path**: some data should stay in DRAM or IRAM for performance reasons
-- Memory efficiency matters, but is less critical on boards with PSRAM
-
-Heap fragmentation is a concern:
-<!-- HUMAN_ONLY_START -->
-   - Fragmentation can lead to crashes, even when the overall amount of available heap is still good. The C++ runtime doesn't do any "garbage collection".
-<!-- HUMAN_ONLY_END -->
-   - Avoid frequent `d_malloc` and `d_free` inside a function, especially for small sizes.
-   - Avoid frequent creation / destruction of objects.
-   - Allocate buffers early, and try to re-use them.
-   - Instead of incrementally appending to a `String`,  reserve the expected max buffer upfront by using the `reserve()` method.
-<!-- HUMAN_ONLY_START -->
-
-```cpp
-  String result;
-  result.reserve(65);  // pre-allocate to avoid realloc fragmentation
-```
-
-```cpp
-  // prefer DRAM; falls back gracefully and enforces MIN_HEAP_SIZE guard
-  _ledsDirty = (byte*) d_malloc(getBitArrayBytes(_len));
-```
-
-```cpp
-  _mode.reserve(_modeCount);     // allocate memory to prevent initial fragmentation - does not increase size()
-  _modeData.reserve(_modeCount); // allocate memory to prevent initial fragmentation - does not increase size()
-```
-<!-- HUMAN_ONLY_END -->
-
-## `const` and `constexpr`
-<!-- HUMAN_ONLY_START -->
-`const` is a promise to the compiler that a value (or object) will not change - a function declared with a `const char* message` parameter is not allowed to modify the content of `message`.
-This pattern enables optimizations and makes intent clear to reviewers.
-
-`constexpr` allows to define constants that are *guaranteed* to be evaluated by the compiler (zero run-time costs).
-
-<!-- HUMAN_ONLY_END -->
-- For function parameters that are read-only, prefer `const &` or `const`.
-
-### `const` locals
-<!-- HUMAN_ONLY_START -->
-* Adding `const` to a local variable that is only assigned once is optional, but *not* strictly necessary.
-<!-- HUMAN_ONLY_END -->
-* In hot-path code, `const` on cached locals may help the compiler keep values in registers.
-  ```cpp
-  const uint_fast16_t cols = vWidth();
-  const uint_fast16_t rows = vHeight();
-  ```
-
-### `const` references to avoid copies
-- Pass objects by `const &` (or `&`) instead of copying them implicitly.
-- Use `const &` (or `&`)  inside loops - This avoids constructing temporary objects on every access.
-
-<!-- HUMAN_ONLY_START -->
-```cpp
-const auto &m = _mappings[i];                        // reference, not a copy (bus_manager.cpp)
-Segment& sourcesegment = strip.getSegment(sourceid); // alias — avoids creating a temporary Segment instance
-```
-
-For function parameters that are read-only, prefer `const &`:
-```cpp
-BusManager::add(const BusConfig &bc, bool placeholder) {
-```
-
-<!-- HUMAN_ONLY_END -->
-- Class **Data Members:** Avoid reference data members (`T&` or `const T&`) in a class. 
-  A reference member can outlive the object it refers to, causing **dangling reference** bugs that are hard to diagnose. Prefer value storage or use a pointer and document the expected lifetime.
-
-<!-- HUMAN_ONLY_START -->
-<!-- hidden from AI for now - codebase is not compliant to this rule (slowly migrating) -->
-### `constexpr` over `#define`
-
-- Prefer `constexpr` for compile-time constants. Unlike `#define`, `constexpr` respects scope and type safety, keeping the global namespace clean.
-
-```cpp
-// Prefer:
-constexpr uint32_t TWO_CHANNEL_MASK = 0x00FF00FF;
-constexpr int WLED_MAX_BUSSES = WLED_MAX_DIGITAL_CHANNELS + WLED_MAX_ANALOG_CHANNELS;
-
-// Avoid (when possible):
-#define TWO_CHANNEL_MASK 0x00FF00FF
-```
-<!-- HUMAN_ONLY_END -->
-
-### `static_assert` over `#error`
-
-- Use `static_assert` instead of the C-style `#if … #error … #endif` pattern when validating compile-time constants. It provides a clear message and works with `constexpr` values.
-- `#define` and `#if ... #else ... #endif` is still needed for conditional-compilation guards and build-flag-overridable values.
-
-<!-- HUMAN_ONLY_START -->
-```cpp
-// Prefer:
-constexpr int WLED_MAX_BUSSES = WLED_MAX_DIGITAL_CHANNELS + WLED_MAX_ANALOG_CHANNELS;
-static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");
-
-// Avoid:
-#if (WLED_MAX_BUSSES > 32)
-  #error "WLED_MAX_BUSSES exceeds hard limit"
-#endif
-```
-
-```cpp
-  // using static_assert() to validate enumerated types (zero cost at runtime)
-  static_assert(0u == static_cast<uint8_t>(PinOwner::None),
-               "PinOwner::None must be zero, so default array initialization works as expected");
-```
-
-<!-- HUMAN_ONLY_END -->
-### `static` and `const` class methods
-
-#### `const` member functions
-
-Marking a member function `const` tells the compiler that it does not modify the object's state:
-
-```cpp
-uint16_t length() const { return _len; }
-bool     isActive() const { return _active; }
-```
-<!-- HUMAN_ONLY_START -->
-Benefits for GCC/Xtensa/RISC-V:
-- The compiler knows the method cannot write to `this`, so it is free to **keep member values in registers** across the call and avoid reload barriers.
-- `const` methods can be called on `const` objects and `const` references — essential when passing large objects as `const &` to avoid copying.
-- `const` allows the compiler to **eliminate redundant loads**: if a caller already has a member value cached, the compiler can prove the `const` call cannot invalidate it.
-<!-- HUMAN_ONLY_END -->
-
-Declare getter, query, or inspection methods `const`. If you need to mark a member `mutable` to work around this (e.g. for a cache or counter), document the reason.
-
-#### `static` member functions
-
-<!-- HUMAN_ONLY_START -->
-A `static` member function has no implicit `this` pointer. This has two distinct advantages:
-
-1. **Smaller code, faster calls**: no `this` is passed in a register. On Xtensa and RISC-V, this removes one register argument from every call site and prevents the compiler from emitting `this`-preservation code around inlined blocks.
-2. **Better inlining**: GCC can inline a `static` method with more certainty because it cannot be overridden by a derived class (no virtual dispatch ambiguity) and has no aliasing concern through `this`.
-
-Use `static` for any method that does not need access to instance members:
-
-```cpp
-// Factory / utility — no instance needed:
-static BusConfig fromJson(JsonObject obj);
-
-// Pure computation helpers:
-static uint8_t  gamma8(uint8_t val);
-static uint32_t colorBalance(uint32_t color, uint8_t r, uint8_t g, uint8_t b);
-```
-<!-- HUMAN_ONLY_END -->
-
-`static` communicates intent clearly: a reviewer immediately knows the method is stateless and safe to call without a fully constructed object.
-
-> **Rule of thumb**: if a method does not read or write any member variable, make it `static`. If it only reads member variables, make it `const`. Note: `static` methods cannot also be `const`-qualified because there is no implicit `this` pointer to be const — just use `static`. Both qualifiers reduce coupling and improve generated code on all ESP32 targets.
-
----
-
-## Hot-Path Optimization
-
-The hot path is the per-frame pixel pipeline: **Segment → Strip → BusManager → Bus(Digital,HUB75,Network) or PolyBus → LED driver, plus ``WS2812FX::show()`` and below**.
-Speed is the priority here. The patterns below are taken from existing hot-path code (`FX_fcn.cpp`, `FX_2Dfcn.cpp`, `bus_manager.cpp`, `colors.cpp`) and should be followed when modifying these files.
-
-Note: `FX.cpp` (effect functions) is written by many contributors and has diverse styles — that is acceptable. 
-
-### Function Attributes
-
-Stack the appropriate attributes on hot-path functions. Defined in `const.h`:
-
-| Attribute | Meaning | When to use |
-|---|---|---|
-| `__attribute__((hot))` | Branch-prediction hint | hot-path functions with complex logic |
-| `IRAM_ATTR` | Place in fast IRAM (ESP32) | Critical per-pixel functions (e.g. `BusDigital::setPixelColor`) |
-| `IRAM_ATTR_YN` | IRAM on ESP32, no-op on ESP8266 | Hot functions that ESP8266 can't fit in IRAM |
-| `WLED_O2_ATTR` | Force `-O2` optimization | Most hot-path functions |
-| `WLED_O3_ATTR` | Force `-O3,fast-math` | Innermost color math (e.g. `color_blend`) |
-| `[[gnu::hot]] inline` | Modern C++ attribute + inline | Header-defined accessors (e.g. `progress()`, `currentBri()`) |
-
-Note: `WLED_O3_ATTR` sometimes causes performance loss compared to `WLED_O2_ATTR`. Choose optimization levels based on test results.
-
-Example signature:
-
-```cpp
-void IRAM_ATTR_YN WLED_O2_ATTR __attribute__((hot)) Segment::setPixelColor(unsigned i, uint32_t c)
-```
-
-<!-- HUMAN_ONLY_START -->
-### Cache Members to Locals Before Loops
-
-Copy class members and virtual-call results to local variables before entering a loop:
-
-```cpp
-uint_fast8_t count = numBusses;          // avoid repeated member access
-for (uint_fast8_t i = 0; i < count; i++) {
-  Bus* const b = busses[i];              // const pointer hints to compiler
-  uint_fast16_t bstart = b->getStart();
-  uint_fast16_t blen = b->getLength();
-  ...
-}
-```
-<!-- HUMAN_ONLY_END -->
-
-### Unsigned Range Check
-
-Replace two-comparison range tests with a single unsigned subtraction:
-
-```cpp
-// Instead of: if (pix >= bstart && pix < bstart + blen)
-if ((uint_fast16_t)(pix - bstart) < blen)  // also catches negative pix via unsigned underflow
-```
-
-### Early Returns
-
-Guard every hot-path function with the cheapest necessary checks first:
-
-```cpp
-if (!isActive()) return;                 // inactive segment
-if (unsigned(i) >= vLength()) return;    // bounds check (catches negative i too)
-```
-
-### Avoid Nested Calls — Fast Path / Complex Path
-
-Avoid calling non-inline functions or making complex decisions inside per-pixel hot-path code. When a function has both a common simple case and a rare complex case, split it into two variants and choose once per frame rather than per pixel.
-
-General rules:
-- Keep fast-path functions free of non-inline calls, multi-way branches, and complex switch-case decisions. 
-- Hoist per-frame decisions (e.g. simple vs. complex segment) out of the per-pixel loop. 
-- Code duplication between fast/slow variants is acceptable to keep the fast path lean.
-
-### Function Pointers to Eliminate Repeated Decisions
-
-When the same decision (e.g. "which drawing routine?") would be evaluated for every pixel, assign the chosen variant to a function pointer once and let the inner loop call through the pointer. This removes the branch entirely — the calling code (e.g. the GIF decoder loop) only ever invokes one function per frame, with no per-pixel decision.
-
-<!-- HUMAN_ONLY_START -->
-`image_loader.cpp` demonstrates the pattern: `calculateScaling()` picks the best drawing callback once per frame based on segment dimensions and GIF size, then passes it to the decoder via `setDrawPixelCallback()`:
-
-```cpp
-// calculateScaling() — called once per frame
-if ((perPixelX < 2) && (perPixelY < 2))
-  decoder.setDrawPixelCallback(drawPixelCallbackDownScale2D);   // downscale-only variant
-else
-  decoder.setDrawPixelCallback(drawPixelCallback2D);            // full-scaling variant
-```
-
-Each callback is a small, single-purpose function with no internal branching — the decoder's per-pixel loop never re-evaluates which strategy to use.
-<!-- HUMAN_ONLY_END -->
-<!-- HUMAN_ONLY_START -->
-### Template Specialization (Advanced)
-
-Templates can eliminate runtime decisions by generating separate code paths at compile time. For example, a pixel setter could be templated on color order or channel count so the compiler removes dead branches and produces tight, specialized machine code:
-
-```cpp
-template<bool hasWhite>
-void setChannel(uint8_t* out, uint32_t col) {
-  out[0] = R(col); out[1] = G(col); out[2] = B(col);
-  if constexpr (hasWhite) out[3] = W(col);  // compiled out when hasWhite==false
-}
-```
-
-Use sparingly — each instantiation duplicates code in flash. On ESP8266 and small-flash ESP32 boards this can exhaust IRAM/flash. Prefer templates only when the hot path is measurably faster and the number of instantiations is small (2–4).
-
-### RAII Lock-Free Synchronization (Advanced)
-
-Where contention is rare and the critical section is short, consider replacing mutex-based locking with lock-free techniques using `std::atomic` and RAII scoped guards. A scoped guard sets a flag on construction and clears it on destruction, guaranteeing cleanup even on early return:
-
-```cpp
-struct ScopedBusyFlag {
-  std::atomic<bool>& flag;
-  bool acquired;
-  ScopedBusyFlag(std::atomic<bool>& f) : flag(f), acquired(false) {
-    bool expected = false;
-    acquired = flag.compare_exchange_strong(expected, true);
-  }
-  ~ScopedBusyFlag() { if (acquired) flag.store(false); }
-  explicit operator bool() const { return acquired; }
-};
-
-// Usage
-static std::atomic<bool> busySending{false};
-ScopedBusyFlag guard(busySending);
-if (!guard) return;  // another task is already sending
-// ... do work — flag auto-clears when guard goes out of scope
-```
-
-This avoids FreeRTOS semaphore overhead and the risk of forgetting to return a semaphore. There are no current examples of this pattern in the codebase — consult with maintainers before introducing it in new code, to ensure it aligns with the project's synchronization conventions.
-
-<!-- HUMAN_ONLY_END -->
-### Pre-Compute Outside Loops
-
-Move invariant calculations before the loop. Pre-compute reciprocals to replace division with multiplication.
-<!-- HUMAN_ONLY_START -->
-```cpp
-const uint_fast16_t cols = virtualWidth();
-const uint_fast16_t rows = virtualHeight();
-uint_fast8_t fadeRate = (255U - rate) >> 1;
-float mappedRate_r = 1.0f / (float(fadeRate) + 1.1f);  // reciprocal — avoid division inside loop
-```
-
-<!-- HUMAN_ONLY_END -->
-### Parallel Channel Processing
-
-Process R+B and W+G channels simultaneously using the two-channel mask pattern:
-
-```cpp
-constexpr uint32_t TWO_CHANNEL_MASK = 0x00FF00FF;
-uint32_t rb = (((c1 & TWO_CHANNEL_MASK) * amount) >> 8) & TWO_CHANNEL_MASK;
-uint32_t wg = (((c1 >> 8) & TWO_CHANNEL_MASK) * amount) & ~TWO_CHANNEL_MASK;
-return rb | wg;
-```
-
-### Bit Shifts Over Division (mainly for RISC-V boards)
-
-ESP32 and ESP32-S3 (Xtensa core) have a fast "integer divide" instruction, so manual shifts rarely help. 
-On RISC-V targets (ESP32-C3/C6/P4) and ESP8266, prefer explicit bit-shifts for power-of-two arithmetic — the compiler does **not** always convert divisions to shifts. 
-Always use unsigned operands for right shifts; signed right-shift is implementation-defined.
-
-<!-- HUMAN_ONLY_START -->
-On RISC-V-based boards (ESP32-C3, ESP32-C6, ESP32-C5) explicit shifts can be beneficial.
-```cpp
-position >> 3     // instead of position / 8
-(255U - rate) >> 1 // instead of (255 - rate) / 2
-i & 0x0007        // instead of i % 8
-```
-
-**Important**: The bit-shifted expression should be unsigned. On some MCUs, "signed right-shift" is implemented by an "arithmetic shift right" that duplicates the sign bit: ``0b1010 >> 1 = 0b1101``.
-
-<!-- HUMAN_ONLY_END -->
-### Static Caching for Expensive Computations
-
-Cache results in static locals when the input rarely changes between calls:
-
-```cpp
-static uint16_t lastKelvin = 0;
-static byte correctionRGB[4] = {255,255,255,0};
-if (lastKelvin != kelvin) {
-  colorKtoRGB(kelvin, correctionRGB);  // expensive — only recalculate when input changes
-  lastKelvin = kelvin;
-}
-```
-
-### Inlining Strategy
-
-- Move frequently-called small functions to headers for inlining (e.g. `Segment::setPixelColorRaw` is in `FX.h`)
-- Use `static inline` for file-local helpers
-
-### Math & Trigonometric Functions
-
-- WLED uses a custom `fastled_slim` library. The old FastLED trig aliases (`sin8`, `cos8`, `sin16`, `cos16`) **no longer exist and cause a compile error** — use `sin8_t()`, `cos8_t()`, `sin16_t()`, `cos16_t()` instead. For float approximations use `sin_approx()` / `cos_approx()` instead of `sinf()` / `cosf()`. Replace FastLED noise aliases (`inoise8`, `inoise16`) with `perlin8`, `perlin16`.
-<!-- HUMAN_ONLY_START -->
-
-| ❌ Do not use (compile error) | ✅ Use instead | Source |
-|---|---|---|
-| `sin8()`, `cos8()` | `sin8_t()`, `cos8_t()` | `fastled_slim.h` → `wled_math.cpp` |
-| `sin16()`, `cos16()` | `sin16_t()`, `cos16_t()` | `fastled_slim.h` → `wled_math.cpp` |
-| `sinf()`, `cosf()` | `sin_approx()`, `cos_approx()` | `wled_math.cpp` |
-| `atan2f()`, `atan2()` | `atan2_t()` | `wled_math.cpp` |
-| `sqrt()` on integers | `sqrt32_bw()` | `fcn_declare.h` → `wled_math.cpp` |
-| `sqrtf()` on floats | `sqrtf()` (acceptable) | — no WLED replacement |
-<!-- HUMAN_ONLY_END -->
-
----
-
-## `delay()` vs `yield()` in ESP32 Tasks
-<!-- HUMAN_ONLY_START -->
-* On ESP32, `delay(ms)` calls `vTaskDelay(ms / portTICK_PERIOD_MS)`, which **suspends only the calling task**. The FreeRTOS scheduler immediately runs all other ready tasks. 
-* The Arduino `loop()` function runs inside `loopTask`. Calling `delay()` there does *not* block the network stack, audio FFT, LED DMA, nor any other FreeRTOS task.
-* This differs from ESP8266, where `delay()` stalls the entire system unless `yield()` was called inside.
-<!-- HUMAN_ONLY_END -->
-
-- On ESP32, `delay()` is generally allowed, as it helps to efficiently manage CPU usage of all tasks.
-- On ESP8266, only use `delay()` and `yield()` in the main `loop()` context. If not sure, protect with `if (can_yield()) ...`.
-- Do *not* use `delay()` in effects (FX.cpp) or in the hot pixel path.
-- `delay()` on the bus-level is allowed, it might be needed to achieve exact timing in LED drivers.
-
-### IDLE Watchdog and Custom Tasks on ESP32
-
-- In arduino-esp32, `yield()` calls `vTaskDelay(0)`, which only switches to tasks at equal or higher priority — the IDLE task (priority 0) is never reached. 
-- **Do not use `yield()` to pace ESP32 tasks or assume it feeds any watchdog**.
-- **Custom `xTaskCreate()` tasks must call `delay(1)` in their loop, not `yield()`.** Without a real blocking call, the IDLE task is starved. The IDLE watchdog panic is the first visible symptom — but the damage starts earlier: deleted task memory leaks, software timers stop firing, light sleep is disabled, and Wi-Fi/BT idle hooks don't run. Structure custom tasks like this:
-```cpp
-// WRONG — IDLE task is never scheduled; yield() does not feed the idle task watchdog.
-void myTask(void*) {
-  for (;;) {
-    doWork();
-    yield();
-  }
-}
-
-// CORRECT — delay(1) suspends the task for ≥1 ms, IDLE task runs, IDLE watchdog is fed
-void myTask(void*) {
-  for (;;) {
-    doWork();
-    delay(1);  // DO NOT REMOVE — lets IDLE(0) run and feeds its watchdog
-  }
-}
-```
-
-- Prefer blocking FreeRTOS primitives (`xQueueReceive`, `ulTaskNotifyTake`, `vTaskDelayUntil`) over `delay(1)` polling where precise timing or event-driven behaviour is needed.
-- **Watchdog note.** WLED disables the Task Watchdog by default (`WLED_WATCHDOG_TIMEOUT 0` in `wled.h`). When enabled, `esp_task_wdt_reset()` is called at the end of each `loop()` iteration. Long blocking operations inside `loop()` — such as OTA downloads or slow file I/O — must call `esp_task_wdt_reset()` periodically, or be restructured so the main loop is not blocked for longer than the configured timeout.
-
-## Caveats and Pitfalls
-
-- **LittleFS filenames**: File paths passed to `file.open()` must not exceed 255 bytes (`LFS_NAME_MAX`). Validate constructed paths (e.g., `/ledmap_` + segment name + `.json`) stay within this limit (assume standard configurations, like WLED_MAX_SEGNAME_LEN = 64).
-
-- **Float-to-unsigned conversion is undefined behavior when the value is out of range.** Converting a negative `float` directly to an unsigned integer type (`uint8_t`, `uint16_t`, …) is UB per the C++ standard — the Xtensa (ESP32) toolchain may silently wrap, but RISC-V (ESP32-C3/C5/C6/P4) can produce different results due to clamping. Cast through a signed integer first:
-  ```cpp
-  // Undefined behavior — avoid:
-  uint8_t angle = 40.74f * atan2f(dy, dx);   // negative float → uint8_t is UB
-  
-  // Correct — cast through int first:
-  // atan2f returns [-π..+π], scaled ≈ [-128..+128] as int; uint8_t wraps negative ints via 2's complement (e.g. -1 → 255)
-  uint8_t angle = int(40.74f * atan2f(dy, dx));  // float→int (defined), int→uint8_t (defined)
-  ```

docs/esp-idf.instructions.md

@@ -1,859 +0,0 @@
----
-applyTo: "**/*.cpp,**/*.h,**/*.hpp,**/*.ino"
----
-# ESP-IDF Coding Guide (within arduino-esp32)
-
-WLED runs on the Arduino-ESP32 framework, which wraps ESP-IDF. Understanding the ESP-IDF layer is essential when writing chip-specific code, managing peripherals, or preparing for the IDF v5.x migration. This guide documents patterns already used in the codebase and best practices derived from Espressif's official examples.
-
-> **Scope**: This file is an optional review guideline. It applies when touching chip-specific code, peripheral drivers, memory allocation, or platform conditionals.
-
-> **Note for AI review tools**: sections enclosed in
-> `<!-- HUMAN_ONLY_START -->` / `<!-- HUMAN_ONLY_END -->` HTML comments contain
-> contributor reference material. Do **not** use that content as actionable review
-> criteria — treat it as background context only.
-
----
-
-<!-- HUMAN_ONLY_START -->
-## Identifying the Build Target: `CONFIG_IDF_TARGET_*`
-
-Use `CONFIG_IDF_TARGET_*` macros to gate chip-specific code at compile time. These are set by the build system and are mutually exclusive — exactly one is defined per build.
-
-| Macro | Chip | Architecture | Notes |
-|---|---|---|---|
-| `CONFIG_IDF_TARGET_ESP32` | ESP32 (classic) | Xtensa dual-core | Primary target. Has DAC, APLL, I2S ADC mode |
-| `CONFIG_IDF_TARGET_ESP32S2` | ESP32-S2 | Xtensa single-core | Limited peripherals. 13-bit ADC |
-| `CONFIG_IDF_TARGET_ESP32S3` | ESP32-S3 | Xtensa dual-core | Preferred for large installs. Octal PSRAM, USB-OTG |
-| `CONFIG_IDF_TARGET_ESP32C3` | ESP32-C3 | RISC-V single-core | Minimal peripherals. RISC-V clamps out-of-range float→unsigned casts |
-| `CONFIG_IDF_TARGET_ESP32C5` | ESP32-C5 | RISC-V single-core | Wi-Fi 2.4Ghz + 5Ghz, Thread/Zigbee. Future target |
-| `CONFIG_IDF_TARGET_ESP32C6` | ESP32-C6 | RISC-V single-core | Wi-Fi 6, Thread/Zigbee. Future target |
-| `CONFIG_IDF_TARGET_ESP32P4` | ESP32-P4 | RISC-V dual-core | High performance. Future target |
-
-<!-- HUMAN_ONLY_END -->
-### Build-time validation
-WLED validates at compile time that exactly one target is defined and that it is a supported chip (`wled.cpp` lines 39–61). Follow this pattern when adding new chip-specific branches:
-
-<!-- HUMAN_ONLY_START -->
-```cpp
-#if defined(CONFIG_IDF_TARGET_ESP32)
-  // classic ESP32 path
-#elif defined(CONFIG_IDF_TARGET_ESP32S3)
-  // S3-specific path
-#elif defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32P4)
-  // RISC-V common path
-#else
-  #warning "Untested chip — review peripheral availability"
-#endif
-```
-
-<!-- HUMAN_ONLY_END -->
-### Guidelines
-
-- **Always test on the actual chip** before claiming support. Simulators and cross-compilation can hide peripheral differences.
-- **Prefer `#elif` chains** over nested `#ifdef` for readability.
-- **Do not use `CONFIG_IDF_TARGET_*` for feature detection.** Use `SOC_*` capability macros instead (see next section). For example, use `SOC_I2S_SUPPORTS_ADC` instead of `CONFIG_IDF_TARGET_ESP32` to check for I2S ADC support.
-- When a feature must be disabled on certain chips, use explicit `static_assert()` or `#warning` directives so the build clearly reports what is missing.
-
----
-
-## Hardware Capability Detection: `SOC_*` Macros
-
-`SOC_*` macros (from `soc/soc_caps.h`) describe what the current chip supports. They are the correct way to check for peripheral features — they stay accurate when new chips are added, unlike `CONFIG_IDF_TARGET_*` checks.
-
-<!-- HUMAN_ONLY_START -->
-### Important `SOC_*` macros used in WLED
-
-| Macro | Type | Used in | Purpose |
-|---|---|---|---|
-| `SOC_I2S_NUM` | `int` | `audio_source.h` | Number of I2S peripherals (1 or 2) |
-| `SOC_I2S_SUPPORTS_ADC` | `bool` | `usermods/audioreactive/audio_source.h` | I2S ADC sampling mode (ESP32 only) |
-| `SOC_I2S_SUPPORTS_APLL` | `bool` | `usermods/audioreactive/audio_source.h` | Audio PLL for precise sample rates |
-| `SOC_I2S_SUPPORTS_PDM_RX` | `bool` | `usermods/audioreactive/audio_source.h` | PDM microphone input |
-| `SOC_ADC_MAX_BITWIDTH` | `int` | `util.cpp` | ADC resolution (12 or 13 bits). Renamed to `CONFIG_SOC_ADC_RTC_MAX_BITWIDTH` in IDF v5 |
-| `SOC_ADC_CHANNEL_NUM(unit)` | `int` | `pin_manager.cpp` | ADC channels per unit |
-| `SOC_UART_NUM` | `int` | `dmx_input.cpp` | Number of UART peripherals |
-| `SOC_DRAM_LOW` / `SOC_DRAM_HIGH` | `addr` | `util.cpp` | DRAM address boundaries for validation |
-
-<!-- HUMAN_ONLY_END -->
-### Key pitfall
-`SOC_ADC_MAX_BITWIDTH` (ADC resolution 12 or 13 bits) was renamed to `CONFIG_SOC_ADC_RTC_MAX_BITWIDTH` in IDF v5.
-
-<!-- HUMAN_ONLY_START -->
-### Less commonly used but valuable
-
-| Macro | Purpose |
-|---|---|
-| `SOC_RMT_TX_CANDIDATES_PER_GROUP` | Number of RMT TX channels (varies 2–8 by chip) |
-| `SOC_LEDC_CHANNEL_NUM` | Number of LEDC (PWM) channels |
-| `SOC_GPIO_PIN_COUNT` | Total GPIO pin count |
-| `SOC_DAC_SUPPORTED` | Whether the chip has a DAC (ESP32/S2 only) |
-| `SOC_SPIRAM_SUPPORTED` | Whether PSRAM interface exists |
-| `SOC_CPU_CORES_NUM` | Core count (1 or 2) — useful for task pinning decisions |
-
-<!-- HUMAN_ONLY_END -->
-
-### Best practices
-
-```cpp
-// Good: feature-based detection
-#if SOC_I2S_SUPPORTS_PDM_RX
-  _config.mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_PDM);
-#else
-  #warning "PDM microphones not supported on this chip"
-#endif
-
-// Avoid: chip-name-based detection
-#if defined(CONFIG_IDF_TARGET_ESP32) || defined(CONFIG_IDF_TARGET_ESP32S3)
-  // happens to be correct today, but breaks when a new chip adds PDM support
-#endif
-```
-
-<!-- HUMAN_ONLY_START -->
-### PSRAM capability macros
-
-For PSRAM presence, mode, and DMA access patterns:
-
-| Macro | Meaning |
-|---|---|
-| `CONFIG_SPIRAM` / `BOARD_HAS_PSRAM` | PSRAM is present in the build configuration |
-| `CONFIG_SPIRAM_MODE_QUAD` | Quad-SPI PSRAM (standard, used on ESP32 classic and some S2/S3 boards) |
-| `CONFIG_SPIRAM_MODE_OCT` | Octal-SPI PSRAM — 8 data lines, DTR mode. Used on ESP32-S3 with octal PSRAM (e.g. N8R8 / N16R8 modules). Reserves GPIO 33–37 for the PSRAM bus — **do not allocate these pins** when this macro is defined. `wled.cpp` uses this to gate GPIO reservation. |
-| `CONFIG_SPIRAM_MODE_HEX` | Hex-SPI (16-line) PSRAM — future interface on ESP32-P4 running at up to 200 MHz. Used in `json.cpp` to report the PSRAM mode. |
-| `CONFIG_SOC_PSRAM_DMA_CAPABLE` | PSRAM buffers can be used with DMA (ESP32-S3 with octal PSRAM) |
-| `CONFIG_SOC_MEMSPI_FLASH_PSRAM_INDEPENDENT` | SPI flash and PSRAM on separate buses (no speed contention) |
-
-<!-- HUMAN_ONLY_END -->
-
-#### Detecting octal/hex flash
-
-On ESP32-S3 modules with OPI flash (e.g. N8R8 modules where the SPI flash itself runs in Octal-PI mode), the build system sets:
-
-| Macro | Meaning |
-|---|---|
-| `CONFIG_ESPTOOLPY_FLASHMODE_OPI` | Octal-PI flash mode. On S3, implies GPIO 33–37 are used by the flash/PSRAM interface — the same GPIO block as octal PSRAM. `wled.cpp` uses `CONFIG_ESPTOOLPY_FLASHMODE_OPI \|\| (CONFIG_SPIRAM_MODE_OCT && BOARD_HAS_PSRAM)` to decide whether to reserve these GPIOs. `json.cpp` uses this to report the flash mode string as `"🚀OPI"`. |
-| `CONFIG_ESPTOOLPY_FLASHMODE_HEX` | Hex flash mode (ESP32-P4). Reported as `"🚀🚀HEX"` in `json.cpp`. |
-
-**Pattern used in WLED** (from `wled.cpp`) to reserve the octal-bus GPIOs on S3:
-```cpp
-#if defined(CONFIG_IDF_TARGET_ESP32S3)
-  #if CONFIG_ESPTOOLPY_FLASHMODE_OPI || (CONFIG_SPIRAM_MODE_OCT && defined(BOARD_HAS_PSRAM))
-    // S3: GPIO 33-37 are used by the octal PSRAM/flash bus
-    managed_pin_type pins[] = { {33, true}, {34, true}, {35, true}, {36, true}, {37, true} };
-    pinManager.allocateMultiplePins(pins, sizeof(pins)/sizeof(managed_pin_type), PinOwner::SPI_RAM);
-  #endif
-#endif
-```
-
----
-
-## ESP-IDF Version Conditionals
-
-<!-- HUMAN_ONLY_START -->
-### Checking the IDF version
-
-```cpp
-#include <esp_idf_version.h>
-
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-  // IDF v5+ code path
-#elif ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
-  // IDF v4.4+ code path
-#else
-  // Legacy IDF v3/v4.x path
-#endif
-```
-
-### Key ESP-IDF version thresholds for WLED
-
-| Version | What changed |
-|---|---|
-| **4.0.0** | Filesystem API (`SPIFFS`/`LittleFS`), GPIO driver overhaul |
-| **4.2.0** | ADC/GPIO API updates; `esp_adc_cal` introduced |
-| **4.4.0** | I2S driver refactored (legacy API remains); `adc_deprecated.h` headers appear for newer targets |
-| **4.4.4–4.4.8** | Known I2S channel-swap regression on ESP32 (workaround in `audio_source.h`) |
-| **5.0.0** | **Major breaking changes** — RMT, I2S, ADC, SPI flash APIs replaced (see migration section) |
-| **5.1.0** | Matter protocol support; new `esp_flash` API stable |
-| **5.3+** | arduino-esp32 v3.x compatibility; C6/P4 support |
-
-<!-- HUMAN_ONLY_END -->
-### Guidelines
-
-- When adding a version guard, **always include a comment** explaining *what* changed and *why* the guard is needed.
-- Avoid version ranges that silently break — prefer `>=` over exact version matches.
-- Known regressions should use explicit range guards:
-  ```cpp
-  // IDF 4.4.4–4.4.8 swapped I2S left/right channels (fixed in 4.4.9)
-  #if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 4)) && \
-      (ESP_IDF_VERSION <= ESP_IDF_VERSION_VAL(4, 4, 8))
-    #define I2S_CHANNELS_SWAPPED
-  #endif
-  ```
-
----
-
-## Migrating from ESP-IDF v4.4.x to v5.x
-
-The jump from IDF v4.4 (arduino-esp32 v2.x) to IDF v5.x (arduino-esp32 v3.x) is the largest API break in ESP-IDF history. This section documents the critical changes and recommended migration patterns based on the upstream WLED `V5-C6` branch (`https://github.com/wled/WLED/tree/V5-C6`). Note: WLED has not yet migrated to IDF v5 — these patterns prepare for the future migration.
-
-<!-- HUMAN_ONLY_START -->
-### Compiler changes
-
-IDF v5.x ships a much newer GCC toolchain. Key versions:
-
-| ESP-IDF | GCC | C++ default | Notes |
-|---|---|---|---|
-| 4.4.x (current) | **8.4.0** | C++17 (gnu++17) | Xtensa + RISC-V |
-| 5.1–5.3 | **13.2** | C++20 (gnu++2b) | Significant warning changes |
-| 5.4–5.5 | **14.2** | C++23 (gnu++2b) | Latest; stricter diagnostics |
-
-Notable behavioral differences:
-
-| Change | Impact | Action |
-|---|---|---|
-| Stricter `-Werror=enum-conversion` | Implicit int-to-enum casts now error | Use explicit `static_cast<>` or typed enums |
-| C++20/23 features available | `consteval`, `concepts`, `std::span`, `std::expected` | Use judiciously — ESP8266 builds still require GCC 10.x with C++17 |
-| `-Wdeprecated-declarations` enforced | Deprecated API calls become warnings/errors | Migrate to new APIs (see below) |
-| `-Wdangling-reference` (GCC 13+) | Warns when a reference binds to a temporary that will be destroyed | Fix the lifetime issue; do not suppress the warning |
-| `-fno-common` default (GCC 12+) | Duplicate tentative definitions across translation units cause linker errors | Use `extern` declarations in headers, define in exactly one `.cpp` |
-| RISC-V codegen improvements | C3/C6/P4 benefit from better register allocation | No action needed — automatic |
-
-### C++ language features: GCC 8 → GCC 14
-
-The jump from GCC 8.4 to GCC 14.2 spans six major compiler releases. This section lists features that become available and patterns that need updating.
-
-#### Features safe to use after migration
-
-These work in GCC 13+/14+ but **not** in GCC 8.4. Guard with `#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)` if the code must compile on both IDF v4 and v5.
-
-| Feature | Standard | Example | Benefit |
-|---|---|---|---|
-| Designated initializers (C++20) | C++20 | `gpio_config_t cfg = { .mode = GPIO_MODE_OUTPUT };` | Already used as a GNU extension in GCC 8; becomes standard and portable in C++20 |
-| `[[likely]]` / `[[unlikely]]` | C++20 | `if (err != ESP_OK) [[unlikely]] { ... }` | Hints for branch prediction; useful in hot paths |
-| `[[nodiscard("reason")]]` | C++20 | `[[nodiscard("leak if ignored")]] void* allocBuffer();` | Enforces checking return values — helpful for `esp_err_t` wrappers |
-| `std::span<T>` | C++20 | `void process(std::span<uint8_t> buf)` | Safe, non-owning view of contiguous memory — replaces raw pointer + length pairs |
-| `consteval` | C++20 | `consteval uint32_t packColor(...)` | Guarantees compile-time evaluation; useful for color constants |
-| `constinit` | C++20 | `constinit static int counter = 0;` | Prevents static initialization order fiasco |
-| Concepts / `requires` | C++20 | `template<typename T> requires std::integral<T>` | Clearer constraints than SFINAE; improves error messages |
-| Three-way comparison (`<=>`) | C++20 | `auto operator<=>(const Version&) const = default;` | Less boilerplate for comparable types |
-| `std::bit_cast` | C++20 | `float f = std::bit_cast<float>(uint32_val);` | Type-safe reinterpretation — replaces `memcpy` or `union` tricks |
-| `if consteval` | C++23 | `if consteval { /* compile-time */ } else { /* runtime */ }` | Cleaner than `std::is_constant_evaluated()` |
-| `std::expected<T, E>` | C++23 | `std::expected<int, esp_err_t> readSensor()` | Monadic error handling — cleaner than returning error codes |
-| `std::to_underlying` | C++23 | `auto val = std::to_underlying(myEnum);` | Replaces `static_cast<int>(myEnum)` |
-
-#### Features already available in GCC 8 (C++17)
-
-These work on both IDF v4.4 and v5.x — prefer them now:
-
-| Feature | Example | Notes |
-|---|---|---|
-| `if constexpr` | `if constexpr (sizeof(T) == 4) { ... }` | Compile-time branching; already used in WLED |
-| `std::optional<T>` | `std::optional<uint8_t> pin;` | Nullable value without sentinel values like `-1` |
-| `std::string_view` | `void log(std::string_view msg)` | Non-owning, non-allocating string reference |
-| Structured bindings | `auto [err, value] = readSensor();` | Useful with `std::pair` / `std::tuple` returns |
-| Fold expressions | `(addSegment(args), ...);` | Variadic template expansion |
-| Inline variables | `inline constexpr int MAX_PINS = 50;` | Avoids ODR issues with header-defined constants |
-| `[[maybe_unused]]` | `[[maybe_unused]] int debug_only = 0;` | Suppresses unused-variable warnings cleanly |
-| `[[fallthrough]]` | `case 1: doA(); [[fallthrough]]; case 2:` | Documents intentional switch fallthrough |
-| Nested namespaces | `namespace wled::audio { }` | Shorter than nested `namespace` blocks |
-
-#### Patterns that break or change behavior
-
-| Pattern | GCC 8 behavior | GCC 14 behavior | Fix |
-|---|---|---|---|
-| `int x; enum E e = x;` | Warning (often ignored) | Error with `-Werror=enum-conversion` | `E e = static_cast<E>(x);` |
-| `int g;` in two `.cpp` files | Both compile, linker merges (tentative definition) | Error: multiple definitions (`-fno-common`) | `extern int g;` in header, `int g;` in one `.cpp` |
-| `const char* ref = std::string(...).c_str();` | Silent dangling pointer | Warning (`-Wdangling-reference`) | Extend lifetime: store the `std::string` in a local variable |
-| `register int x;` | Accepted (ignored) | Warning or error (`register` removed in C++17) | Remove `register` keyword |
-| Narrowing in aggregate init | Warning | Error | Use explicit cast or wider type |
-| Implicit `this` capture in lambdas | Accepted in `[=]` | Deprecated warning; error in C++20 mode | Use `[=, this]` or `[&]` |
-
-<!-- HUMAN_ONLY_END -->
-#### Recommendations
-
-- **Do not raise the minimum C++ standard yet.** WLED must still build on IDF v4.4 (GCC 8.4, C++17). Use `#if __cplusplus > 201703L` to gate C++20 features.
-- **Mark intentional fallthrough** with `[[fallthrough]]` — GCC 14 warns on unmarked fallthrough by default.
-<!-- HUMAN_ONLY_START -->
-- **Prefer `std::optional` over sentinel values** (e.g., `-1` for "no pin") in new code — it works on both compilers.
-- **Use `std::string_view`** for read-only string parameters instead of `const char*` or `const String&` — zero-copy and works on GCC 8+.
-- **Avoid raw `union` type punning** — prefer `memcpy` (GCC 8) or `std::bit_cast` (GCC 13+) for strict-aliasing safety.
-
-<!-- HUMAN_ONLY_END -->
-### Deprecated and removed APIs
-
-#### RMT (Remote Control Transceiver)
-
-The legacy `rmt_*` functions are removed in IDF v5. Do not introduce new legacy RMT calls.
-
-<!-- HUMAN_ONLY_START -->
-The new API is channel-based:
-
-| IDF v4 (legacy) | IDF v5 (new) | Notes |
-|---|---|---|
-| `rmt_config()` + `rmt_driver_install()` | `rmt_new_tx_channel()` / `rmt_new_rx_channel()` | Channels are now objects |
-| `rmt_write_items()` | `rmt_transmit()` with encoder | Requires `rmt_encoder_t` |
-| `rmt_set_idle_level()` | Configure in channel config | Set at creation time |
-| `rmt_item32_t` | `rmt_symbol_word_t` | Different struct layout |
-
-<!-- HUMAN_ONLY_END -->
-**WLED impact**: NeoPixelBus LED output and IR receiver both use legacy RMT. The upstream `V5-C6` branch adds `-D WLED_USE_SHARED_RMT` and disables IR until the library is ported.
-
-#### I2S (Inter-IC Sound)
-
-Legacy `i2s_driver_install()` + `i2s_read()` API is deprecated. When touching audio source code, wrap legacy I2S init and reading in `#if ESP_IDF_VERSION_MAJOR < 5` / `#else`.
-
-<!-- HUMAN_ONLY_START -->
- The new API uses channel handles:
-| IDF v4 (legacy) | IDF v5 (new) | Notes |
-|---|---|---|
-| `i2s_driver_install()` | `i2s_channel_init_std_mode()` | Separate STD/PDM/TDM modes |
-| `i2s_set_pin()` | Pin config in `i2s_std_gpio_config_t` | Set at init time |
-| `i2s_read()` | `i2s_channel_read()` | Uses channel handle |
-| `i2s_set_clk()` | `i2s_channel_reconfig_std_clk()` | Reconfigure running channel |
-| `i2s_config_t` | `i2s_std_config_t` | Separate config for each mode |
-
-**Migration pattern** (from Espressif examples):
-```cpp
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-  #include "driver/i2s_std.h"
-  i2s_chan_handle_t rx_handle;
-  i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);
-  i2s_new_channel(&chan_cfg, NULL, &rx_handle);
-
-  i2s_std_config_t std_cfg = {
-    .clk_cfg  = I2S_STD_CLK_DEFAULT_CONFIG(22050),
-    .slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_32BIT, I2S_SLOT_MODE_MONO),
-    .gpio_cfg = { .din = GPIO_NUM_32, .mclk = I2S_GPIO_UNUSED, ... },
-  };
-  i2s_channel_init_std_mode(rx_handle, &std_cfg);
-  i2s_channel_enable(rx_handle);
-#else
-  // Legacy i2s_driver_install() path
-#endif
-```
-<!-- HUMAN_ONLY_END -->
-**WLED impact**: The audioreactive usermod (`audio_source.h`) heavily uses legacy I2S. Migration requires rewriting the `I2SSource` class for channel-based API.
-
-<!-- HUMAN_ONLY_START -->
-#### ADC (Analog-to-Digital Converter)
-
-Legacy `adc1_get_raw()` and `esp_adc_cal_*` are deprecated:
-
-| IDF v4 (legacy) | IDF v5 (new) | Notes |
-|---|---|---|
-| `adc1_config_width()` + `adc1_get_raw()` | `adc_oneshot_new_unit()` + `adc_oneshot_read()` | Object-based API |
-| `esp_adc_cal_characterize()` | `adc_cali_create_scheme_*()` | Calibration is now scheme-based |
-| `adc_continuous_*` (old) | `adc_continuous_*` (restructured) | Config struct changes |
-
-#### SPI Flash
-
-| IDF v4 (legacy) | IDF v5 (new) |
-|---|---|
-| `spi_flash_read()` | `esp_flash_read()` |
-| `spi_flash_write()` | `esp_flash_write()` |
-| `spi_flash_erase_range()` | `esp_flash_erase_region()` |
-
-WLED already has a compatibility shim in `ota_update.cpp` that maps old names to new ones.
-
-#### GPIO
-
-| IDF v4 (legacy) | IDF v5 (recommended) |
-|---|---|
-| `gpio_pad_select_gpio()` | `esp_rom_gpio_pad_select_gpio()` (or use `gpio_config()`) |
-| `gpio_set_direction()` + `gpio_set_pull_mode()` | `gpio_config()` with `gpio_config_t` struct |
-
-### Features disabled in IDF v5 builds
-
-The upstream `V5-C6` branch explicitly disables features with incompatible library dependencies:
-
-```ini
-# platformio.ini [esp32_idf_V5]
--D WLED_DISABLE_INFRARED       # IR library uses legacy RMT
--D WLED_DISABLE_MQTT            # AsyncMqttClient incompatible with IDF v5
--D ESP32_ARDUINO_NO_RGB_BUILTIN # Prevents RMT driver conflict with built-in LED
--D WLED_USE_SHARED_RMT          # Use new shared RMT driver for NeoPixel output
-```
-
-<!-- HUMAN_ONLY_END -->
-### Migration checklist for new code
-
-1. **Never use a removed API without a version guard.** Always provide both old and new paths, or disable the feature on IDF v5.
-2. **Test on both IDF v4.4 and v5.x builds** if the code must be backward-compatible.
-3. **Prefer the newer API** when writing new code — wrap the old API in an `#else` block.
-4. **Mark migration TODOs** with `// TODO(idf5):` so they are easy to find later.
-
----
-
-## Memory Management: `heap_caps_*` Best Practices
-
-ESP32 has multiple memory regions with different capabilities. Using the right allocator is critical for performance and stability.
-
-<!-- HUMAN_ONLY_START -->
-### Memory regions
-
-| Region | Flag | Speed | DMA | Size | Use for |
-|---|---|---|---|---|---|
-| DRAM | `MALLOC_CAP_INTERNAL \| MALLOC_CAP_8BIT` | Fast | Yes (ESP32) | 200–320 KB | Hot-path buffers, task stacks, small allocations |
-| IRAM | `MALLOC_CAP_EXEC` | Fastest | No | 32–128 KB | Code (automatic via `IRAM_ATTR`) |
-| PSRAM (SPIRAM) | `MALLOC_CAP_SPIRAM \| MALLOC_CAP_8BIT` | Slower | Chip-dependent | 2–16 MB | Large buffers, JSON documents, image data |
-| RTC RAM | `MALLOC_CAP_RTCRAM` | Moderate | No | 8 KB | Data surviving deep sleep; small persistent buffers |
-
-<!-- HUMAN_ONLY_END -->
-
-### WLED allocation wrappers
-
-WLED provides convenience wrappers with automatic fallback. **Always prefer these over raw `heap_caps_*` calls**:
-
-| Function | Allocation preference | Use case |
-|---|---|---|
-| `d_malloc(size)` | RTC → DRAM → PSRAM | General-purpose; prefers fast memory |
-| `d_calloc(n, size)` | Same as `d_malloc`, zero-initialized | Arrays, structs |
-| `p_malloc(size)` | PSRAM → DRAM | Large buffers; prefers abundant memory |
-| `p_calloc(n, size)` | Same as `p_malloc`, zero-initialized | Large arrays |
-| `d_malloc_only(size)` | RTC → DRAM (no PSRAM fallback) | DMA buffers, time-critical data |
-
-### PSRAM guidelines
-
-- **Check availability**: always test `psramFound()` before assuming PSRAM is present.
-- **DMA compatibility**: on ESP32 (classic), PSRAM buffers are **not DMA-capable** — use `d_malloc_only()` to allocate DMA buffers in DRAM only. On ESP32-S3 with octal PSRAM (`CONFIG_SPIRAM_MODE_OCT`), PSRAM buffers *can* be used with DMA when `CONFIG_SOC_PSRAM_DMA_CAPABLE` is defined.
-- **JSON documents**: use the `PSRAMDynamicJsonDocument` allocator (defined in `wled.h`) to put large JSON documents in PSRAM:
-  ```cpp
-  PSRAMDynamicJsonDocument doc(16384);  // allocated in PSRAM if available
-  ```
-- **Fragmentation**: PSRAM allocations fragment less than DRAM because the region is larger. But avoid mixing small and large allocations in PSRAM — small allocations waste the MMU page granularity.
-- **Heap validation**: use `d_measureHeap()` and `d_measureContiguousFreeHeap()` to monitor remaining DRAM. Allocations that would drop free DRAM below `MIN_HEAP_SIZE` should go to PSRAM instead.
-- **Performance**: Keep hot-path data in DRAM. Prefer PSRAM for capacity-oriented buffers and monitor contiguous DRAM headroom.
-<!-- HUMAN_ONLY_START -->
-   PSRAM access is up to 15× slower than DRAM on ESP32, 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 at 80 MHz (120 MHz is possible with CONFIG_SPIRAM_SPEED_120M, which requires enabling experimental ESP-IDF features). 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. Keep hot-path data in DRAM regardless, but consider that ESP32 often crashes when the largest DRAM chunk gets below 10 KB.
-<!-- HUMAN_ONLY_END -->
-
-<!-- HUMAN_ONLY_START -->
-### Pattern: preference-based allocation
-
-When you need a buffer that works on boards with or without PSRAM:
-
-```cpp
-// Prefer PSRAM for large buffers, fall back to DRAM
-uint8_t* buf = (uint8_t*)heap_caps_malloc_prefer(bufSize, 2,
-    MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT,   // first choice: PSRAM
-    MALLOC_CAP_DEFAULT);                    // fallback: any available
-// Or simply:
-uint8_t* buf = (uint8_t*)p_malloc(bufSize);
-```
-
-<!-- HUMAN_ONLY_END -->
----
-
-## I2S Audio: Best Practices
-
-The audioreactive usermod uses I2S for microphone input. Key patterns:
-
-### Port selection
-
-```cpp
-constexpr i2s_port_t AR_I2S_PORT = I2S_NUM_0;
-// I2S_NUM_1 has limitations: no MCLK routing, no ADC support, no PDM support
-```
-
-Always use `I2S_NUM_0` unless you have a specific reason and have verified support on all target chips.
-
-### DMA buffer tuning
-
-DMA buffer size controls latency vs. reliability:
-
-| Scenario | `dma_buf_count` | `dma_buf_len` | Latency | Notes |
-|---|---|---|---|---|
-| With HUB75 matrix | 18 | 128 | ~100 ms | Higher count prevents I2S starvation during matrix DMA |
-| Without PSRAM | 24 | 128 | ~140 ms | More buffers compensate for slower interrupt response |
-| Default | 8 | 128 | ~46 ms | Acceptable for most setups |
-
-### Interrupt priority
-
-Choose interrupt priority based on coexistence with other drivers:
-
-```cpp
-#ifdef WLED_ENABLE_HUB75MATRIX
-  .intr_alloc_flags = ESP_INTR_FLAG_IRAM | ESP_INTR_FLAG_LEVEL1,  // level 1 (lowest) to avoid starving HUB75
-#else
-  .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2 | ESP_INTR_FLAG_LEVEL3,  // accept level 2 or 3 (allocator picks available)
-#endif
-```
-
-### APLL (Audio PLL) usage
-
-The ESP32 has an audio PLL for precise sample rates. Rules:
-
-- Enable APLL when an MCLK pin is provided and precision matters.
-- **Disable APLL** when Ethernet or HUB75 is active — they also use the APLL.
-- APLL is broken on ESP32 revision 0 silicon.
-- Not all chips have APLL — gate with `SOC_I2S_SUPPORTS_APLL`.
-
-```cpp
-#if !defined(SOC_I2S_SUPPORTS_APLL)
-  _config.use_apll = false;
-#elif defined(WLED_USE_ETHERNET) || defined(WLED_ENABLE_HUB75MATRIX)
-  _config.use_apll = false;  // APLL conflict
-#endif
-```
-
-### PDM microphone caveats
-
-- Not supported on ESP32-C3 (`SOC_I2S_SUPPORTS_PDM_RX` not defined).
-- ESP32-S3 PDM has known issues: sample rate at 50% of expected, very low amplitude.
-  - **16-bit data width**: Espressif's IDF documentation states that in PDM mode the data unit width is always 16 bits, regardless of the configured `bits_per_sample`.
-  - See [espressif/esp-idf#8660](https://github.com/espressif/esp-idf/issues/8660) for the upstream issue.
-  - **Flag `bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT` in PDM mode** — this causes the S3 low-amplitude symptom.
-- No clock pin (`I2S_CKPIN = -1`) triggers PDM mode in WLED.
-
----
-
-## HUB75 LED Matrix: Best Practices
-
-WLED uses the `ESP32-HUB75-MatrixPanel-I2S-DMA` library for HUB75 matrix output.
-
-### Chip-specific panel limits
-
-```cpp
-#if defined(CONFIG_IDF_TARGET_ESP32S3) && defined(BOARD_HAS_PSRAM)
-  maxChainLength = 6;   // S3 + PSRAM: up to 6 panels (DMA-capable PSRAM)
-#elif defined(CONFIG_IDF_TARGET_ESP32S2)
-  maxChainLength = 2;   // S2: limited DMA channels
-#else
-  maxChainLength = 4;   // Classic ESP32: default
-#endif
-```
-
-### Color depth vs. pixel count
-
-The driver dynamically reduces color depth for larger displays to stay within DMA buffer limits:
-
-| Pixel count | Color depth | Bits per pixel |
-|---|---|---|
-| ≤ `MAX_PIXELS_10BIT` | 10-bit (30-bit color) | High quality (experimental) |
-| ≤ `MAX_PIXELS_8BIT` | 8-bit (24-bit color) | Full quality |
-| ≤ `MAX_PIXELS_6BIT` | 6-bit (18-bit color) | Slight banding |
-| ≤ `MAX_PIXELS_4BIT` | 4-bit (12-bit color) | Visible banding |
-| larger | 3-bit (9-bit color) | Minimal color range |
-
-### Resource conflicts
-
-- **APLL**: HUB75 I2S DMA uses the APLL. Disable APLL in the audio I2S driver when HUB75 is active.
-- **I2S peripheral**: HUB75 uses `I2S_NUM_1` (or `I2S_NUM_0` on single-I2S chips). Audio must use the other port.
-- **Pin count**: HUB75 requires 13–14 GPIO pins. On ESP32-S2 this severely limits remaining GPIO.
-- **Reboot required**: on ESP32-S3, changing HUB75 driver options requires a full reboot — the I2S DMA cannot be reconfigured at runtime.
-
----
-
-<!-- HUMAN_ONLY_START -->
-## GPIO Best Practices
-
-### Prefer `gpio_config()` over individual calls
-
-```cpp
-// Preferred: single struct-based configuration
-gpio_config_t io_conf = {
-  .pin_bit_mask = (1ULL << pin),
-  .mode         = GPIO_MODE_OUTPUT,
-  .pull_up_en   = GPIO_PULLUP_DISABLE,
-  .pull_down_en = GPIO_PULLDOWN_DISABLE,
-  .intr_type    = GPIO_INTR_DISABLE,
-};
-gpio_config(&io_conf);
-
-// Avoid: multiple separate calls (more error-prone, deprecated in IDF v5)
-gpio_set_direction(pin, GPIO_MODE_OUTPUT);
-gpio_set_pull_mode(pin, GPIO_FLOATING);
-```
-<!-- HUMAN_ONLY_END -->
-
-### Pin manager integration
-
-Always allocate pins through WLED's `pinManager` before using GPIO APIs:
-
-```cpp
-if (!pinManager.allocatePin(myPin, true, PinOwner::UM_MyUsermod)) {
-  return;  // pin in use by another module
-}
-// Now safe to configure
-```
-
----
-
-## Timer Best Practices
-
-### Microsecond timing
-
-For high-resolution timing, prefer `esp_timer_get_time()` (microsecond resolution, 64-bit) over `millis()` or `micros()`.
-<!-- HUMAN_ONLY_START -->
-
-```cpp
-#include <esp_timer.h>
-int64_t now_us = esp_timer_get_time();  // monotonic, not affected by NTP
-```
-
-> **Note**: In arduino-esp32, both `millis()` and `micros()` are thin wrappers around `esp_timer_get_time()` — they share the same monotonic clock source. Prefer the direct call when you need the full 64-bit value or ISR-safe access without truncation:
-> ```cpp
-> // arduino-esp32 internals (cores/esp32/esp32-hal-misc.c):
-> // unsigned long micros() { return (unsigned long)(esp_timer_get_time()); }
-> // unsigned long millis() { return (unsigned long)(esp_timer_get_time() / 1000ULL); }
-> ```
-<!-- HUMAN_ONLY_END -->
-<!-- HUMAN_ONLY_START -->
-### Periodic timers
-
-For periodic tasks with sub-millisecond precision, use `esp_timer`:
-
-```cpp
-esp_timer_handle_t timer;
-esp_timer_create_args_t args = {
-  .callback = myCallback,
-  .arg = nullptr,
-  .dispatch_method = ESP_TIMER_TASK,  // run in timer task (not ISR)
-  .name = "my_timer",
-};
-esp_timer_create(&args, &timer);
-esp_timer_start_periodic(timer, 1000);  // 1 ms period
-```
-<!-- HUMAN_ONLY_END -->
-
-Always prefer `ESP_TIMER_TASK` dispatch over `ESP_TIMER_ISR` unless you need ISR-level latency — ISR callbacks have severe restrictions (no logging, no heap allocation, no FreeRTOS API calls).
-
-### Precision waiting: coarse delay then spin-poll
-
-When waiting for a precise future deadline (e.g., FPS limiting, protocol timing), avoid spinning the entire duration — that wastes CPU and starves other tasks. Instead, yield to FreeRTOS while time allows, then spin only for the final window.
-<!-- HUMAN_ONLY_START -->
-```cpp
-// Wait until 'target_us' (a micros() / esp_timer_get_time() timestamp)
-long time_to_wait = (long)(target_us - micros());
-// Coarse phase: yield to FreeRTOS while we have more than ~2 ms remaining.
-// vTaskDelay(1) suspends the task for one RTOS tick, letting other task run freely.
-while (time_to_wait > 2000) {
-  vTaskDelay(1);
-  time_to_wait = (long)(target_us - micros());
-}
-// Fine phase: busy-poll the last ≤2 ms for microsecond accuracy.
-// micros() wraps esp_timer_get_time() so this is low-overhead.
-while ((long)(target_us - micros()) > 0) { /* spin */ }
-```
-<!-- HUMAN_ONLY_END -->
-
-> The threshold (2000 µs as an example) should be at least one RTOS tick (default 1 ms on ESP32) plus some margin. A value of 1500–3000 µs works well in practice.
-
----
-
-## ADC Best Practices
-
-<!-- HUMAN_ONLY_START -->
-### Version-aware ADC code
-
-ADC is one of the most fragmented APIs across IDF versions:
-
-```cpp
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-  // IDF v5: oneshot driver
-  #include "esp_adc/adc_oneshot.h"
-  #include "esp_adc/adc_cali.h"
-  adc_oneshot_unit_handle_t adc_handle;
-  adc_oneshot_unit_init_cfg_t unit_cfg = { .unit_id = ADC_UNIT_1 };
-  adc_oneshot_new_unit(&unit_cfg, &adc_handle);
-#else
-  // IDF v4: legacy driver
-  #include "driver/adc.h"
-  #include "esp_adc_cal.h"
-  adc1_config_width(ADC_WIDTH_BIT_12);
-  int raw = adc1_get_raw(ADC1_CHANNEL_0);
-#endif
-```
-<!-- HUMAN_ONLY_END -->
-
-### Bit width portability
-
-Not all chips have 12-bit ADC. `SOC_ADC_MAX_BITWIDTH` reports the maximum resolution (12 or 13 bits). Note that in IDF v5, this macro was renamed to `CONFIG_SOC_ADC_RTC_MAX_BITWIDTH`. Write version-aware guards:
-
-```cpp
-// IDF v4: SOC_ADC_MAX_BITWIDTH   IDF v5: CONFIG_SOC_ADC_RTC_MAX_BITWIDTH
-#if defined(CONFIG_SOC_ADC_RTC_MAX_BITWIDTH)   // IDF v5+
-  #define MY_ADC_MAX_BITWIDTH CONFIG_SOC_ADC_RTC_MAX_BITWIDTH
-#elif defined(SOC_ADC_MAX_BITWIDTH)             // IDF v4
-  #define MY_ADC_MAX_BITWIDTH SOC_ADC_MAX_BITWIDTH
-#else
-  #define MY_ADC_MAX_BITWIDTH 12                // safe fallback
-#endif
-
-#if MY_ADC_MAX_BITWIDTH == 13
-  adc1_config_width(ADC_WIDTH_BIT_13);  // ESP32-S2
-#else
-  adc1_config_width(ADC_WIDTH_BIT_12);  // ESP32, S3, C3, etc.
-#endif
-```
-
-WLED's `util.cpp` uses the IDF v4 form (`SOC_ADC_MAX_BITWIDTH`) — this will need updating when the codebase migrates to IDF v5.
-
----
-
-<!-- HUMAN_ONLY_START -->
-## RMT Best Practices
-
-### Current usage in WLED
-
-RMT drives NeoPixel LED output (via NeoPixelBus) and IR receiver input. Both use the legacy API that is removed in IDF v5.
-
-### Migration notes
-
-- The upstream `V5-C6` branch uses `-D WLED_USE_SHARED_RMT` to switch to the new RMT driver for NeoPixel output.
-- IR is disabled on IDF v5 until the IR library is ported.
-- New chips (C6, P4) have different RMT channel counts — use `SOC_RMT_TX_CANDIDATES_PER_GROUP` to check availability.
-- The new RMT API requires an "encoder" object (`rmt_encoder_t`) to translate data formats — this is more flexible but requires more setup code.
-
-<!-- HUMAN_ONLY_END -->
----
-
-## Espressif Best Practices (from official examples)
-
-### Error handling
-
-Always check `esp_err_t` return values. Use `ESP_ERROR_CHECK()` in initialization code, but handle errors gracefully in runtime code.
-<!-- HUMAN_ONLY_START -->
-```cpp
-// Initialization — crash early on failure
-ESP_ERROR_CHECK(i2s_driver_install(I2S_NUM_0, &config, 0, nullptr));
-
-// Runtime — log and recover
-esp_err_t err = i2s_read(I2S_NUM_0, buf, len, &bytes_read, portMAX_DELAY);
-if (err != ESP_OK) {
-  DEBUGSR_PRINTF("I2S read failed: %s\n", esp_err_to_name(err));
-  return;
-}
-```
-<!-- HUMAN_ONLY_END -->
-
-For situations between these two extremes — where you want the `ESP_ERROR_CHECK` formatted log message (file, line, error name) but must not abort — use `ESP_ERROR_CHECK_WITHOUT_ABORT()`.
-
-<!-- HUMAN_ONLY_START -->
-```cpp
-// Logs in the same format as ESP_ERROR_CHECK, but returns the error code instead of aborting.
-// Useful for non-fatal driver calls where you want visibility without crashing.
-esp_err_t err = ESP_ERROR_CHECK_WITHOUT_ABORT(i2s_set_clk(AR_I2S_PORT, rate, bits, ch));
-if (err != ESP_OK) return;  // handle as needed
-```
-
-<!-- HUMAN_ONLY_END -->
-### Logging
-
-WLED uses its own logging macros — **not** `ESP_LOGx()`. For application-level code, always use the WLED macros defined in `wled.h`:
-
-| Macro family | Defined in | Controlled by | Use for |
-|---|---|---|---|
-| `DEBUG_PRINT` / `DEBUG_PRINTLN` / `DEBUG_PRINTF` | `wled.h` | `WLED_DEBUG` build flag | Development/diagnostic output; compiled out in release builds |
-
-All of these wrap `Serial` output through the `DEBUGOUT` / `DEBUGOUTLN` / `DEBUGOUTF` macros.
-
-**Exception — low-level driver code**: When writing code that interacts directly with ESP-IDF APIs (e.g., I2S initialization, RMT setup), use `ESP_LOGx()` macros instead. They support tag-based filtering and compile-time log level control:
-
-<!-- HUMAN_ONLY_START -->
-```cpp
-static const char* TAG = "my_module";
-ESP_LOGI(TAG, "Initialized with %d buffers", count);
-ESP_LOGW(TAG, "PSRAM not available, falling back to DRAM");
-ESP_LOGE(TAG, "Failed to allocate %u bytes", size);
-```
-<!-- HUMAN_ONLY_END -->
-### Task creation and pinning
-
-<!-- HUMAN_ONLY_START -->
-On dual-core chips (ESP32, S3, P4), pin latency-sensitive tasks to a specific core:
-
-```cpp
-xTaskCreatePinnedToCore(
-  audioTask,        // function
-  "audio",          // name
-  4096,             // stack size
-  nullptr,          // parameter
-  5,                // priority (higher = more important)
-  &audioTaskHandle, // handle
-  0                 // core ID (0 = protocol core, 1 = app core)
-);
-```
-<!-- HUMAN_ONLY_END -->
-
-Guidelines:
-- Pin network/protocol tasks to core 0 (where Wi-Fi runs).
-- Pin real-time tasks (audio, LED output) to core 1.
-- On single-core chips (S2, C3, C5, C6), only core 0 exists — pinning to core 1 will fail. Use `SOC_CPU_CORES_NUM > 1` guards or `tskNO_AFFINITY`.
-- Use `SOC_CPU_CORES_NUM` to conditionally pin tasks:
-  ```cpp
-  #if SOC_CPU_CORES_NUM > 1
-    xTaskCreatePinnedToCore(audioTask, "audio", 4096, nullptr, 5, &handle, 1);
-  #else
-    xTaskCreate(audioTask, "audio", 4096, nullptr, 5, &handle);
-  #endif
-  ```
-
-**Tip: use xTaskCreateUniversal()** - from arduino-esp32 - to avoid the conditional on `SOC_CPU_CORES_NUM`. This function has the same signature as ``xTaskCreatePinnedToCore()``, but automatically falls back to ``xTaskCreate()`` on single-core MCUs.
-
-### `delay()`, `yield()`, and the IDLE task
-
-FreeRTOS on ESP32 is **preemptive** — all tasks are scheduled by priority regardless of `yield()` calls. This is fundamentally different from ESP8266 cooperative multitasking.
-
-<!-- HUMAN_ONLY_START -->
-| Call | What it does | Reaches IDLE (priority 0)? |
-|---|---|---|
-| `delay(ms)` / `vTaskDelay(ticks)` | Suspends calling task; scheduler runs all other ready tasks | ✅ Yes |
-| `yield()` / `vTaskDelay(0)` | Hint to switch to tasks at **equal or higher** priority only | ❌ No |
-| `taskYIELD()` | Same as `vTaskDelay(0)` | ❌ No |
-| Blocking API (`xQueueReceive`, `ulTaskNotifyTake`, `vTaskDelayUntil`) | Suspends task until event or timeout; IDLE runs freely | ✅ Yes |
-
-<!-- HUMAN_ONLY_END -->
-
-**`delay()` in `loopTask` is safe.** Arduino's `loop()` runs inside `loopTask`. Calling `delay()` suspends only `loopTask` — all other FreeRTOS tasks (Wi-Fi stack, audio FFT, LED DMA) continue uninterrupted on either core.
-
-**`yield()` does not yield to IDLE.** Any task that loops with only `yield()` calls will starve the IDLE task, causing the IDLE watchdog to fire. Always use `delay(1)` (or a blocking FreeRTOS call) in tight task loops. Note: WLED redefines `yield()` as an empty macro on ESP32 WLEDMM_FASTPATH builds.
-
-#### Why the IDLE task is not optional
-<!-- HUMAN_ONLY_START -->
-
-The FreeRTOS IDLE task (one per core on dual-core ESP32 and ESP32-S3; single instance on single-core chips) is not idle in the casual sense — it performs essential system housekeeping:
-
-- **Frees deleted task memory**: when a task calls `vTaskDelete()`, the IDLE task reclaims its TCB and stack. Without IDLE running, deleted tasks leak memory permanently.
-- **Runs the idle hook**: when `configUSE_IDLE_HOOK = 1`, the IDLE task calls `vApplicationIdleHook()` on every iteration — some ESP-IDF components register low-priority background work here.
-- **Implements tickless idle / light sleep**: on battery-powered devices, IDLE is the entry point for low-power sleep. A permanently starved IDLE task disables light sleep entirely.
-- **Runs registered idle hooks**: ESP-IDF components register callbacks via `esp_register_freertos_idle_hook()` (e.g., Wi-Fi background maintenance, Bluetooth housekeeping). These only fire when IDLE runs.
-
-<!-- HUMAN_ONLY_END -->
-
-In short: **starving IDLE corrupts memory cleanup, breaks background activities, disables low-power sleep, and prevents Wi-Fi/BT maintenance.** The IDLE watchdog panic is a symptom — the real damage happens before the watchdog fires.
-
-### Watchdog management
-
-Long-running operations may trigger the task watchdog. Feed it explicitly:
-
-```cpp
-#include <esp_task_wdt.h>
-esp_task_wdt_reset();  // feed the watchdog in long loops
-```
-
-For tasks that intentionally block for extended periods, consider subscribing/unsubscribing from the TWDT:
-
-```cpp
-esp_task_wdt_delete(NULL);  // remove current task from TWDT (IDF v4.4)
-// ... long blocking operation ...
-esp_task_wdt_add(NULL);     // re-register
-```
-
-> **IDF v5 note**: In IDF v5, `esp_task_wdt_add()` and `esp_task_wdt_delete()` require an explicit `TaskHandle_t`. Use `xTaskGetCurrentTaskHandle()` instead of `NULL`.
-
-<!-- HUMAN_ONLY_START -->
----
-
-## Quick Reference: IDF v4 → v5 API Mapping
-
-| Component | IDF v4 Header | IDF v5 Header | Key Change |
-|---|---|---|---|
-| I2S | `driver/i2s.h` | `driver/i2s_std.h` | Channel-based API |
-| ADC (oneshot) | `driver/adc.h` | `esp_adc/adc_oneshot.h` | Unit/channel handles |
-| ADC (calibration) | `esp_adc_cal.h` | `esp_adc/adc_cali.h` | Scheme-based calibration |
-| RMT | `driver/rmt.h` | `driver/rmt_tx.h` / `rmt_rx.h` | Encoder-based transmit |
-| SPI Flash | `spi_flash.h` | `esp_flash.h` | `esp_flash_*` functions |
-| GPIO | `driver/gpio.h` | `driver/gpio.h` | `gpio_pad_select_gpio()` removed |
-| Timer | `driver/timer.h` | `driver/gptimer.h` | General-purpose timer handles |
-| PCNT | `driver/pcnt.h` | `driver/pulse_cnt.h` | Handle-based API |
-<!-- HUMAN_ONLY_END -->

docs/web.instructions.md

@@ -1,30 +0,0 @@
----
-applyTo: "wled00/data/**"
----
-# Web UI Coding Conventions
-
-## Formatting
-
-- Indent **HTML and JavaScript** with **tabs**
-- Indent **CSS** with **tabs**
-
-## JavaScript Style
-
-- **camelCase** for functions and variables: `gId()`, `selectedFx`, `currentPreset`
-- Abbreviated helpers are common: `d` for `document`, `gId()` for `getElementById()`
-
-## Key Files
-
-- `index.htm` — main interface
-- `index.js` — functions that manage / update the main interface
-- `settings*.htm` — configuration pages
-- `*.css` — stylesheets (inlined during build)
-- `common.js` — helper functions 
-
-**Reuse shared helpers from `common.js` whenever possible** instead of duplicating utilities in page-local scripts.
-
-## Build Integration
-
-Files in this directory are processed by `tools/cdata.js` into generated headers
-(`wled00/html_*.h`, `wled00/js_*.h`).
-Run `npm run build` after any change. **Never edit generated headers directly.**

lib/ESP8266PWM/src/core_esp8266_waveform_phase.cpp

@@ -1,504 +0,0 @@
-/* esp8266_waveform imported from platform source code
-   Modified for WLED to work around a fault in the NMI handling,
-   which can result in the system locking up and hard WDT crashes.
-
-   Imported from https://github.com/esp8266/Arduino/blob/7e0d20e2b9034994f573a236364e0aef17fd66de/cores/esp8266/core_esp8266_waveform_phase.cpp
-*/
-
-
-/*
-  esp8266_waveform - General purpose waveform generation and control,
-                     supporting outputs on all pins in parallel.
-
-  Copyright (c) 2018 Earle F. Philhower, III.  All rights reserved.
-  Copyright (c) 2020 Dirk O. Kaar.
-
-  The core idea is to have a programmable waveform generator with a unique
-  high and low period (defined in microseconds or CPU clock cycles).  TIMER1 is
-  set to 1-shot mode and is always loaded with the time until the next edge
-  of any live waveforms.
-
-  Up to one waveform generator per pin supported.
-
-  Each waveform generator is synchronized to the ESP clock cycle counter, not the
-  timer.  This allows for removing interrupt jitter and delay as the counter
-  always increments once per 80MHz clock.  Changes to a waveform are
-  contiguous and only take effect on the next waveform transition,
-  allowing for smooth transitions.
-
-  This replaces older tone(), analogWrite(), and the Servo classes.
-
-  Everywhere in the code where "ccy" or "ccys" is used, it means ESP.getCycleCount()
-  clock cycle time, or an interval measured in clock cycles, but not TIMER1
-  cycles (which may be 2 CPU clock cycles @ 160MHz).
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#include "core_esp8266_waveform.h"
-#include <Arduino.h>
-#include "debug.h"
-#include "ets_sys.h"
-#include <atomic>
-
-
-// ----- @willmmiles begin patch -----
-// Linker magic
-extern "C" void usePWMFixedNMI(void) {};
-
-// NMI crash workaround
-// Sometimes the NMI fails to return, stalling the CPU.  When this happens,
-// the next NMI gets a return address /inside the NMI handler function/.
-// We work around this by caching the last NMI return address, and restoring
-// the epc3 and eps3 registers to the previous values if the observed epc3
-// happens to be pointing to the _NMILevelVector function.
-extern "C" void _NMILevelVector();
-extern "C" void _UserExceptionVector_1(); // the next function after _NMILevelVector
-static inline IRAM_ATTR void nmiCrashWorkaround() {
-  static uintptr_t epc3_backup, eps3_backup;
-
-  uintptr_t epc3, eps3;
-  __asm__ __volatile__("rsr %0,epc3; rsr %1,eps3":"=a"(epc3),"=a" (eps3));
-  if ((epc3 < (uintptr_t) &_NMILevelVector) || (epc3 >= (uintptr_t) &_UserExceptionVector_1)) {
-    // Address is good; save backup
-    epc3_backup = epc3;
-    eps3_backup = eps3;
-  } else {
-    // Address is inside the NMI handler -- restore from backup
-    __asm__ __volatile__("wsr %0,epc3; wsr %1,eps3"::"a"(epc3_backup),"a"(eps3_backup));
-  }
-}
-// ----- @willmmiles end patch -----
-
-
-// No-op calls to override the PWM implementation
-extern "C" void _setPWMFreq_weak(uint32_t freq) { (void) freq; }
-extern "C" IRAM_ATTR bool _stopPWM_weak(int pin) { (void) pin; return false; }
-extern "C" bool _setPWM_weak(int pin, uint32_t val, uint32_t range) { (void) pin; (void) val; (void) range; return false; }
-
-
-// Timer is 80MHz fixed. 160MHz CPU frequency need scaling.
-constexpr bool ISCPUFREQ160MHZ = clockCyclesPerMicrosecond() == 160;
-// Maximum delay between IRQs, Timer1, <= 2^23 / 80MHz
-constexpr int32_t MAXIRQTICKSCCYS = microsecondsToClockCycles(10000);
-// Maximum servicing time for any single IRQ
-constexpr uint32_t ISRTIMEOUTCCYS = microsecondsToClockCycles(18);
-// The latency between in-ISR rearming of the timer and the earliest firing
-constexpr int32_t IRQLATENCYCCYS = microsecondsToClockCycles(2);
-// The SDK and hardware take some time to actually get to our NMI code
-constexpr int32_t DELTAIRQCCYS = ISCPUFREQ160MHZ ?
-  microsecondsToClockCycles(2) >> 1 : microsecondsToClockCycles(2);
-
-// for INFINITE, the NMI proceeds on the waveform without expiry deadline.
-// for EXPIRES, the NMI expires the waveform automatically on the expiry ccy.
-// for UPDATEEXPIRY, the NMI recomputes the exact expiry ccy and transitions to EXPIRES.
-// for UPDATEPHASE, the NMI recomputes the target timings
-// for INIT, the NMI initializes nextPeriodCcy, and if expiryCcy != 0 includes UPDATEEXPIRY.
-enum class WaveformMode : uint8_t {INFINITE = 0, EXPIRES = 1, UPDATEEXPIRY = 2, UPDATEPHASE = 3, INIT = 4};
-
-// Waveform generator can create tones, PWM, and servos
-typedef struct {
-  uint32_t nextPeriodCcy; // ESP clock cycle when a period begins.
-  uint32_t endDutyCcy;    // ESP clock cycle when going from duty to off
-  int32_t dutyCcys;       // Set next off cycle at low->high to maintain phase
-  int32_t adjDutyCcys;    // Temporary correction for next period
-  int32_t periodCcys;     // Set next phase cycle at low->high to maintain phase
-  uint32_t expiryCcy;     // For time-limited waveform, the CPU clock cycle when this waveform must stop. If WaveformMode::UPDATE, temporarily holds relative ccy count
-  WaveformMode mode;
-  bool autoPwm;           // perform PWM duty to idle cycle ratio correction under high load at the expense of precise timings
-} Waveform;
-
-namespace {
-
-  static struct {
-    Waveform pins[17];             // State of all possible pins
-    uint32_t states = 0;           // Is the pin high or low, updated in NMI so no access outside the NMI code
-    uint32_t enabled = 0; // Is it actively running, updated in NMI so no access outside the NMI code
-
-    // Enable lock-free by only allowing updates to waveform.states and waveform.enabled from IRQ service routine
-    int32_t toSetBits = 0;     // Message to the NMI handler to start/modify exactly one waveform
-    int32_t toDisableBits = 0; // Message to the NMI handler to disable exactly one pin from waveform generation
-
-    // toSetBits temporaries
-    // cheaper than packing them in every Waveform, since we permit only one use at a time
-    uint32_t phaseCcy;      // positive phase offset ccy count  
-    int8_t alignPhase;      // < 0 no phase alignment, otherwise starts waveform in relative phase offset to given pin
-
-    uint32_t(*timer1CB)() = nullptr;
-
-    bool timer1Running = false;
-
-    uint32_t nextEventCcy;
-  } waveform;
-
-}
-
-// Interrupt on/off control
-static IRAM_ATTR void timer1Interrupt();
-
-// Non-speed critical bits
-#pragma GCC optimize ("Os")
-
-static void initTimer() {
-  timer1_disable();
-  ETS_FRC_TIMER1_INTR_ATTACH(NULL, NULL);
-  ETS_FRC_TIMER1_NMI_INTR_ATTACH(timer1Interrupt);
-  timer1_enable(TIM_DIV1, TIM_EDGE, TIM_SINGLE);
-  waveform.timer1Running = true;
-  timer1_write(IRQLATENCYCCYS); // Cause an interrupt post-haste
-}
-
-static void IRAM_ATTR deinitTimer() {
-  ETS_FRC_TIMER1_NMI_INTR_ATTACH(NULL);
-  timer1_disable();
-  timer1_isr_init();
-  waveform.timer1Running = false;
-}
-
-extern "C" {
-
-// Set a callback.  Pass in NULL to stop it
-void setTimer1Callback_weak(uint32_t (*fn)()) {
-  waveform.timer1CB = fn;
-  std::atomic_thread_fence(std::memory_order_acq_rel);
-  if (!waveform.timer1Running && fn) {
-    initTimer();
-  } else if (waveform.timer1Running && !fn && !waveform.enabled) {
-    deinitTimer();
-  }
-}
-
-// Start up a waveform on a pin, or change the current one.  Will change to the new
-// waveform smoothly on next low->high transition.  For immediate change, stopWaveform()
-// first, then it will immediately begin.
-int startWaveformClockCycles_weak(uint8_t pin, uint32_t highCcys, uint32_t lowCcys,
-  uint32_t runTimeCcys, int8_t alignPhase, uint32_t phaseOffsetCcys, bool autoPwm) {
-  uint32_t periodCcys = highCcys + lowCcys;
-  if (periodCcys < MAXIRQTICKSCCYS) {
-    if (!highCcys) {
-      periodCcys = (MAXIRQTICKSCCYS / periodCcys) * periodCcys;
-    }
-    else if (!lowCcys) {
-      highCcys = periodCcys = (MAXIRQTICKSCCYS / periodCcys) * periodCcys;
-    }
-  }
-  // sanity checks, including mixed signed/unsigned arithmetic safety
-  if ((pin > 16) || isFlashInterfacePin(pin) || (alignPhase > 16) ||
-    static_cast<int32_t>(periodCcys) <= 0 ||
-    static_cast<int32_t>(highCcys) < 0 || static_cast<int32_t>(lowCcys) < 0) {
-    return false;
-  }
-  Waveform& wave = waveform.pins[pin];
-  wave.dutyCcys = highCcys;
-  wave.adjDutyCcys = 0;
-  wave.periodCcys = periodCcys;
-  wave.autoPwm = autoPwm;
-  waveform.alignPhase = (alignPhase < 0) ? -1 : alignPhase;
-  waveform.phaseCcy = phaseOffsetCcys;
-
-  std::atomic_thread_fence(std::memory_order_acquire);
-  const uint32_t pinBit = 1UL << pin;
-  if (!(waveform.enabled & pinBit)) {
-    // wave.nextPeriodCcy and wave.endDutyCcy are initialized by the ISR
-    wave.expiryCcy = runTimeCcys; // in WaveformMode::INIT, temporarily hold relative cycle count
-    wave.mode = WaveformMode::INIT;
-    if (!wave.dutyCcys) {
-      // If initially at zero duty cycle, force GPIO off
-      if (pin == 16) {
-        GP16O = 0;
-      }
-      else {
-        GPOC = pinBit;
-      }
-    }
-    std::atomic_thread_fence(std::memory_order_release);
-    waveform.toSetBits = 1UL << pin;
-    std::atomic_thread_fence(std::memory_order_release);
-    if (!waveform.timer1Running) {
-      initTimer();
-    }
-    else if (T1V > IRQLATENCYCCYS) {
-      // Must not interfere if Timer is due shortly
-      timer1_write(IRQLATENCYCCYS);
-    }
-  }
-  else {
-    wave.mode = WaveformMode::INFINITE; // turn off possible expiry to make update atomic from NMI
-    std::atomic_thread_fence(std::memory_order_release);
-    if (runTimeCcys) {
-      wave.expiryCcy = runTimeCcys; // in WaveformMode::UPDATEEXPIRY, temporarily hold relative cycle count
-      wave.mode = WaveformMode::UPDATEEXPIRY;
-      std::atomic_thread_fence(std::memory_order_release);
-      waveform.toSetBits = 1UL << pin;
-    } else if (alignPhase >= 0) {
-      // @willmmiles new feature
-      wave.mode = WaveformMode::UPDATEPHASE; // recalculate start
-      std::atomic_thread_fence(std::memory_order_release);
-      waveform.toSetBits = 1UL << pin;
-    }
-  }
-  std::atomic_thread_fence(std::memory_order_acq_rel);
-  while (waveform.toSetBits) {
-    esp_yield(); // Wait for waveform to update
-    std::atomic_thread_fence(std::memory_order_acquire);
-  }
-  return true;
-}
-
-// Stops a waveform on a pin
-IRAM_ATTR int stopWaveform_weak(uint8_t pin) {
-  // Can't possibly need to stop anything if there is no timer active
-  if (!waveform.timer1Running) {
-    return false;
-  }
-  // If user sends in a pin >16 but <32, this will always point to a 0 bit
-  // If they send >=32, then the shift will result in 0 and it will also return false
-  std::atomic_thread_fence(std::memory_order_acquire);
-  const uint32_t pinBit = 1UL << pin;
-  if (waveform.enabled & pinBit) {
-    waveform.toDisableBits = 1UL << pin;
-    std::atomic_thread_fence(std::memory_order_release);
-    // Must not interfere if Timer is due shortly
-    if (T1V > IRQLATENCYCCYS) {
-      timer1_write(IRQLATENCYCCYS);
-    }
-    while (waveform.toDisableBits) {
-      /* no-op */ // Can't delay() since stopWaveform may be called from an IRQ
-      std::atomic_thread_fence(std::memory_order_acquire);
-    }
-  }
-  if (!waveform.enabled && !waveform.timer1CB) {
-    deinitTimer();
-  }
-  return true;
-}
-
-};
-
-// Speed critical bits
-#pragma GCC optimize ("O2")
-
-// For dynamic CPU clock frequency switch in loop the scaling logic would have to be adapted.
-// Using constexpr makes sure that the CPU clock frequency is compile-time fixed.
-static inline IRAM_ATTR int32_t scaleCcys(const int32_t ccys, const bool isCPU2X) {
-  if (ISCPUFREQ160MHZ) {
-    return isCPU2X ? ccys : (ccys >> 1);
-  }
-  else {
-    return isCPU2X ? (ccys << 1) : ccys;
-  }
-}
-
-static IRAM_ATTR void timer1Interrupt() {
-  const uint32_t isrStartCcy = ESP.getCycleCount();
-  //int32_t clockDrift = isrStartCcy - waveform.nextEventCcy;
-
-  // ----- @willmmiles begin patch -----
-  nmiCrashWorkaround();
-  // ----- @willmmiles end patch -----
-
-  const bool isCPU2X = CPU2X & 1;
-  if ((waveform.toSetBits && !(waveform.enabled & waveform.toSetBits)) || waveform.toDisableBits) {
-    // Handle enable/disable requests from main app.
-    waveform.enabled = (waveform.enabled & ~waveform.toDisableBits) | waveform.toSetBits; // Set the requested waveforms on/off
-    // Find the first GPIO being generated by checking GCC's find-first-set (returns 1 + the bit of the first 1 in an int32_t)
-    waveform.toDisableBits = 0;
-  }
-
-  if (waveform.toSetBits) {
-    const int toSetPin = __builtin_ffs(waveform.toSetBits) - 1;
-    Waveform& wave = waveform.pins[toSetPin];
-    switch (wave.mode) {
-    case WaveformMode::INIT:
-      waveform.states &= ~waveform.toSetBits; // Clear the state of any just started
-      if (waveform.alignPhase >= 0 && waveform.enabled & (1UL << waveform.alignPhase)) {
-        wave.nextPeriodCcy = waveform.pins[waveform.alignPhase].nextPeriodCcy + scaleCcys(waveform.phaseCcy, isCPU2X);
-      }
-      else {
-        wave.nextPeriodCcy = waveform.nextEventCcy;
-      }
-      if (!wave.expiryCcy) {
-        wave.mode = WaveformMode::INFINITE;
-        break;
-      }
-      // fall through
-    case WaveformMode::UPDATEEXPIRY:
-      // in WaveformMode::UPDATEEXPIRY, expiryCcy temporarily holds relative CPU cycle count
-      wave.expiryCcy = wave.nextPeriodCcy + scaleCcys(wave.expiryCcy, isCPU2X);
-      wave.mode = WaveformMode::EXPIRES;
-      break;
-    // @willmmiles new feature
-    case WaveformMode::UPDATEPHASE:
-      // in WaveformMode::UPDATEPHASE, we recalculate the targets
-      if ((waveform.alignPhase >= 0) && (waveform.enabled & (1UL << waveform.alignPhase))) {
-        // Compute phase shift to realign with target
-        auto const newPeriodCcy = waveform.pins[waveform.alignPhase].nextPeriodCcy + scaleCcys(waveform.phaseCcy, isCPU2X);
-        auto const period = scaleCcys(wave.periodCcys, isCPU2X);
-        auto shift = ((static_cast<int32_t> (newPeriodCcy - wave.nextPeriodCcy) + period/2) % period) - (period/2);
-        wave.nextPeriodCcy += static_cast<uint32_t>(shift);
-        if (static_cast<int32_t>(wave.endDutyCcy - wave.nextPeriodCcy) > 0) {
-          wave.endDutyCcy = wave.nextPeriodCcy;
-        }
-      }
-    default:
-      break;
-    }
-    waveform.toSetBits = 0;
-  }
-
-  // Exit the loop if the next event, if any, is sufficiently distant.
-  const uint32_t isrTimeoutCcy = isrStartCcy + ISRTIMEOUTCCYS;
-  uint32_t busyPins = waveform.enabled;
-  waveform.nextEventCcy = isrStartCcy + MAXIRQTICKSCCYS;
-
-  uint32_t now = ESP.getCycleCount();
-  uint32_t isrNextEventCcy = now;
-  while (busyPins) {
-    if (static_cast<int32_t>(isrNextEventCcy - now) > IRQLATENCYCCYS) {
-      waveform.nextEventCcy = isrNextEventCcy;
-      break;
-    }
-    isrNextEventCcy = waveform.nextEventCcy;
-    uint32_t loopPins = busyPins;
-    while (loopPins) {
-      const int pin = __builtin_ffsl(loopPins) - 1;
-      const uint32_t pinBit = 1UL << pin;
-      loopPins ^= pinBit;
-
-      Waveform& wave = waveform.pins[pin];
-
-/* @willmmiles - wtf?  We don't want to accumulate drift
-      if (clockDrift) {
-        wave.endDutyCcy += clockDrift;
-        wave.nextPeriodCcy += clockDrift;
-        wave.expiryCcy += clockDrift;
-      }
-*/          
-
-      uint32_t waveNextEventCcy = (waveform.states & pinBit) ? wave.endDutyCcy : wave.nextPeriodCcy;
-      if (WaveformMode::EXPIRES == wave.mode &&
-        static_cast<int32_t>(waveNextEventCcy - wave.expiryCcy) >= 0 &&
-        static_cast<int32_t>(now - wave.expiryCcy) >= 0) {
-        // Disable any waveforms that are done
-        waveform.enabled ^= pinBit;
-        busyPins ^= pinBit;
-      }
-      else {
-        const int32_t overshootCcys = now - waveNextEventCcy;
-        if (overshootCcys >= 0) {
-          const int32_t periodCcys = scaleCcys(wave.periodCcys, isCPU2X);
-          if (waveform.states & pinBit) {
-            // active configuration and forward are 100% duty
-            if (wave.periodCcys == wave.dutyCcys) {
-              wave.nextPeriodCcy += periodCcys;
-              wave.endDutyCcy = wave.nextPeriodCcy;
-            }
-            else {
-              if (wave.autoPwm) {
-                wave.adjDutyCcys += overshootCcys;
-              }
-              waveform.states ^= pinBit;
-              if (16 == pin) {
-                GP16O = 0;
-              }
-              else {
-                GPOC = pinBit;
-              }
-            }
-            waveNextEventCcy = wave.nextPeriodCcy;
-          }
-          else {
-            wave.nextPeriodCcy += periodCcys;
-            if (!wave.dutyCcys) {
-              wave.endDutyCcy = wave.nextPeriodCcy;
-            }
-            else {
-              int32_t dutyCcys = scaleCcys(wave.dutyCcys, isCPU2X);
-              if (dutyCcys <= wave.adjDutyCcys) {
-                dutyCcys >>= 1;
-                wave.adjDutyCcys -= dutyCcys;
-              }
-              else if (wave.adjDutyCcys) {
-                dutyCcys -= wave.adjDutyCcys;
-                wave.adjDutyCcys = 0;
-              }
-              wave.endDutyCcy = now + dutyCcys;
-              if (static_cast<int32_t>(wave.endDutyCcy - wave.nextPeriodCcy) > 0) {
-                wave.endDutyCcy = wave.nextPeriodCcy;
-              }
-              waveform.states |= pinBit;
-              if (16 == pin) {
-                GP16O = 1;
-              }
-              else {
-                GPOS = pinBit;
-              }
-            }
-            waveNextEventCcy = wave.endDutyCcy;
-          }
-
-          if (WaveformMode::EXPIRES == wave.mode && static_cast<int32_t>(waveNextEventCcy - wave.expiryCcy) > 0) {
-            waveNextEventCcy = wave.expiryCcy;
-          }
-        }
-
-        if (static_cast<int32_t>(waveNextEventCcy - isrTimeoutCcy) >= 0) {
-          busyPins ^= pinBit;
-          if (static_cast<int32_t>(waveform.nextEventCcy - waveNextEventCcy) > 0) {
-            waveform.nextEventCcy = waveNextEventCcy;
-          }
-        }
-        else if (static_cast<int32_t>(isrNextEventCcy - waveNextEventCcy) > 0) {
-          isrNextEventCcy = waveNextEventCcy;
-        }
-      }
-      now = ESP.getCycleCount();
-    }
-    //clockDrift = 0;
-  }
-
-  int32_t callbackCcys = 0;
-  if (waveform.timer1CB) {
-    callbackCcys = scaleCcys(waveform.timer1CB(), isCPU2X);
-  }
-  now = ESP.getCycleCount();
-  int32_t nextEventCcys = waveform.nextEventCcy - now;
-  // Account for unknown duration of timer1CB().
-  if (waveform.timer1CB && nextEventCcys > callbackCcys) {
-    waveform.nextEventCcy = now + callbackCcys;
-    nextEventCcys = callbackCcys;
-  }
-
-  // Timer is 80MHz fixed. 160MHz CPU frequency need scaling.
-  int32_t deltaIrqCcys = DELTAIRQCCYS;
-  int32_t irqLatencyCcys = IRQLATENCYCCYS;
-  if (isCPU2X) {
-    nextEventCcys >>= 1;
-    deltaIrqCcys >>= 1;
-    irqLatencyCcys >>= 1;
-  }
-
-  // Firing timer too soon, the NMI occurs before ISR has returned.
-  if (nextEventCcys < irqLatencyCcys + deltaIrqCcys) {
-    waveform.nextEventCcy = now + IRQLATENCYCCYS + DELTAIRQCCYS;
-    nextEventCcys = irqLatencyCcys;
-  }
-  else {
-    nextEventCcys -= deltaIrqCcys;
-  }
-
-  // Register access is fast and edge IRQ was configured before.
-  T1L = nextEventCcys;
-}

lib/ESP8266PWM/src/core_esp8266_waveform_pwm.cpp

@@ -0,0 +1,717 @@
+/* esp8266_waveform imported from platform source code
+   Modified for WLED to work around a fault in the NMI handling,
+   which can result in the system locking up and hard WDT crashes.
+
+   Imported from https://github.com/esp8266/Arduino/blob/7e0d20e2b9034994f573a236364e0aef17fd66de/cores/esp8266/core_esp8266_waveform_pwm.cpp
+*/
+
+/*
+  esp8266_waveform - General purpose waveform generation and control,
+                     supporting outputs on all pins in parallel.
+
+  Copyright (c) 2018 Earle F. Philhower, III.  All rights reserved.
+
+  The core idea is to have a programmable waveform generator with a unique
+  high and low period (defined in microseconds or CPU clock cycles).  TIMER1
+  is set to 1-shot mode and is always loaded with the time until the next
+  edge of any live waveforms.
+
+  Up to one waveform generator per pin supported.
+
+  Each waveform generator is synchronized to the ESP clock cycle counter, not
+  the timer.  This allows for removing interrupt jitter and delay as the
+  counter always increments once per 80MHz clock.  Changes to a waveform are
+  contiguous and only take effect on the next waveform transition,
+  allowing for smooth transitions.
+
+  This replaces older tone(), analogWrite(), and the Servo classes.
+
+  Everywhere in the code where "cycles" is used, it means ESP.getCycleCount()
+  clock cycle count, or an interval measured in CPU clock cycles, but not
+  TIMER1 cycles (which may be 2 CPU clock cycles @ 160MHz).
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+
+#include <Arduino.h>
+#include <coredecls.h>
+#include "ets_sys.h"
+#include "core_esp8266_waveform.h"
+#include "user_interface.h"
+
+extern "C" {
+
+// Linker magic
+void usePWMFixedNMI() {};
+
+// Maximum delay between IRQs
+#define MAXIRQUS (10000)
+
+// Waveform generator can create tones, PWM, and servos
+typedef struct {
+  uint32_t nextServiceCycle;   // ESP cycle timer when a transition required
+  uint32_t expiryCycle;        // For time-limited waveform, the cycle when this waveform must stop
+  uint32_t timeHighCycles;     // Actual running waveform period (adjusted using desiredCycles)
+  uint32_t timeLowCycles;      //
+  uint32_t desiredHighCycles;  // Ideal waveform period to drive the error signal
+  uint32_t desiredLowCycles;   //
+  uint32_t lastEdge;           // Cycle when this generator last changed
+} Waveform;
+
+class WVFState {
+public:
+  Waveform waveform[17];        // State of all possible pins
+  uint32_t waveformState = 0;   // Is the pin high or low, updated in NMI so no access outside the NMI code
+  uint32_t waveformEnabled = 0; // Is it actively running, updated in NMI so no access outside the NMI code
+
+  // Enable lock-free by only allowing updates to waveformState and waveformEnabled from IRQ service routine
+  uint32_t waveformToEnable = 0;  // Message to the NMI handler to start a waveform on a inactive pin
+  uint32_t waveformToDisable = 0; // Message to the NMI handler to disable a pin from waveform generation
+
+  uint32_t waveformToChange = 0; // Mask of pin to change. One bit set in main app, cleared when effected in the NMI
+  uint32_t waveformNewHigh = 0;
+  uint32_t waveformNewLow = 0;
+
+  uint32_t (*timer1CB)() = NULL;
+
+  // Optimize the NMI inner loop by keeping track of the min and max GPIO that we
+  // are generating.  In the common case (1 PWM) these may be the same pin and
+  // we can avoid looking at the other pins.
+  uint16_t startPin = 0;
+  uint16_t endPin = 0;
+};
+static WVFState wvfState;
+
+
+// Ensure everything is read/written to RAM
+#define MEMBARRIER() { __asm__ volatile("" ::: "memory"); }
+
+// Non-speed critical bits
+#pragma GCC optimize ("Os")
+
+// Interrupt on/off control
+static IRAM_ATTR void timer1Interrupt();
+static bool timerRunning = false;
+
+static __attribute__((noinline)) void initTimer() {
+  if (!timerRunning) {
+    timer1_disable();
+    ETS_FRC_TIMER1_INTR_ATTACH(NULL, NULL);
+    ETS_FRC_TIMER1_NMI_INTR_ATTACH(timer1Interrupt);
+    timer1_enable(TIM_DIV1, TIM_EDGE, TIM_SINGLE);
+    timerRunning = true;
+    timer1_write(microsecondsToClockCycles(10));
+  }
+}
+
+static IRAM_ATTR void forceTimerInterrupt() {
+  if (T1L > microsecondsToClockCycles(10)) {
+    T1L = microsecondsToClockCycles(10);
+  }
+}
+
+// PWM implementation using special purpose state machine
+//
+// Keep an ordered list of pins with the delta in cycles between each
+// element, with a terminal entry making up the remainder of the PWM
+// period.  With this method sum(all deltas) == PWM period clock cycles.
+//
+// At t=0 set all pins high and set the timeout for the 1st edge.
+// On interrupt, if we're at the last element reset to t=0 state
+// Otherwise, clear that pin down and set delay for next element
+// and so forth.
+
+constexpr int maxPWMs = 8;
+
+// PWM machine state
+typedef struct PWMState {
+  uint32_t mask; // Bitmask of active pins
+  uint32_t cnt;  // How many entries
+  uint32_t idx;  // Where the state machine is along the list
+  uint8_t  pin[maxPWMs + 1];
+  uint32_t delta[maxPWMs + 1];
+  uint32_t nextServiceCycle;  // Clock cycle for next step
+  struct PWMState *pwmUpdate; // Set by main code, cleared by ISR
+} PWMState;
+
+static PWMState pwmState;
+static uint32_t _pwmFreq = 1000;
+static uint32_t _pwmPeriod = microsecondsToClockCycles(1000000UL) / _pwmFreq;
+
+
+// If there are no more scheduled activities, shut down Timer 1.
+// Otherwise, do nothing.
+static IRAM_ATTR void disableIdleTimer() {
+ if (timerRunning && !wvfState.waveformEnabled && !pwmState.cnt && !wvfState.timer1CB) {
+    ETS_FRC_TIMER1_NMI_INTR_ATTACH(NULL);
+    timer1_disable();
+    timer1_isr_init();
+    timerRunning = false;
+  }
+}
+
+// Notify the NMI that a new PWM state is available through the mailbox.
+// Wait for mailbox to be emptied (either busy or delay() as needed)
+static IRAM_ATTR void _notifyPWM(PWMState *p, bool idle) {
+  p->pwmUpdate = nullptr;
+  pwmState.pwmUpdate = p;
+  MEMBARRIER();
+  forceTimerInterrupt();
+  while (pwmState.pwmUpdate) {
+    if (idle) {
+      esp_yield();
+    }
+    MEMBARRIER();
+  }
+}
+
+static void _addPWMtoList(PWMState &p, int pin, uint32_t val, uint32_t range);
+
+
+// Called when analogWriteFreq() changed to update the PWM total period
+//extern void _setPWMFreq_weak(uint32_t freq) __attribute__((weak)); 
+void _setPWMFreq_weak(uint32_t freq) {
+  _pwmFreq = freq;
+
+  // Convert frequency into clock cycles
+  uint32_t cc = microsecondsToClockCycles(1000000UL) / freq;
+
+  // Simple static adjustment to bring period closer to requested due to overhead
+  // Empirically determined as a constant PWM delay and a function of the number of PWMs
+#if F_CPU == 80000000
+  cc -= ((microsecondsToClockCycles(pwmState.cnt) * 13) >> 4) + 110;
+#else
+  cc -= ((microsecondsToClockCycles(pwmState.cnt) * 10) >> 4) + 75;
+#endif
+
+  if (cc == _pwmPeriod) {
+    return; // No change
+  }
+
+  _pwmPeriod = cc;
+
+  if (pwmState.cnt) {
+    PWMState p;  // The working copy since we can't edit the one in use
+    p.mask = 0;
+    p.cnt = 0;
+    for (uint32_t i = 0; i < pwmState.cnt; i++) {
+      auto pin = pwmState.pin[i];
+      _addPWMtoList(p, pin, wvfState.waveform[pin].desiredHighCycles, wvfState.waveform[pin].desiredLowCycles);
+    }
+    // Update and wait for mailbox to be emptied
+    initTimer();
+    _notifyPWM(&p, true);
+    disableIdleTimer();
+  }
+}
+/*
+static void _setPWMFreq_bound(uint32_t freq) __attribute__((weakref("_setPWMFreq_weak")));
+void _setPWMFreq(uint32_t freq) { 
+  _setPWMFreq_bound(freq);
+}
+*/
+
+// Helper routine to remove an entry from the state machine
+// and clean up any marked-off entries
+static void _cleanAndRemovePWM(PWMState *p, int pin) {
+  uint32_t leftover = 0;
+  uint32_t in, out;
+  for (in = 0, out = 0; in < p->cnt; in++) {
+    if ((p->pin[in] != pin) && (p->mask & (1<<p->pin[in]))) {
+        p->pin[out] = p->pin[in];
+        p->delta[out] = p->delta[in] + leftover;
+        leftover = 0;
+        out++;
+    } else {
+        leftover += p->delta[in];
+        p->mask &= ~(1<<p->pin[in]);
+    }
+  }
+  p->cnt = out;
+  // Final pin is never used: p->pin[out] = 0xff;
+  p->delta[out] = p->delta[in] + leftover;
+}
+
+
+// Disable PWM on a specific pin (i.e. when a digitalWrite or analogWrite(0%/100%))
+//extern bool _stopPWM_weak(uint8_t pin) __attribute__((weak));
+IRAM_ATTR bool _stopPWM_weak(uint8_t pin) {
+  if (!((1<<pin) & pwmState.mask)) {
+    return false; // Pin not actually active
+  }
+
+  PWMState p;  // The working copy since we can't edit the one in use
+  p = pwmState;
+
+  // In _stopPWM we just clear the mask but keep everything else
+  // untouched to save IRAM.  The main startPWM will handle cleanup.
+  p.mask &= ~(1<<pin);
+  if (!p.mask) {
+    // If all have been stopped, then turn PWM off completely
+    p.cnt = 0;
+  }
+
+  // Update and wait for mailbox to be emptied, no delay (could be in ISR)
+  _notifyPWM(&p, false);
+  // Possibly shut down the timer completely if we're done
+  disableIdleTimer();
+  return true;
+}
+/*
+static bool _stopPWM_bound(uint8_t pin) __attribute__((weakref("_stopPWM_weak")));
+IRAM_ATTR bool _stopPWM(uint8_t pin) {
+  return _stopPWM_bound(pin);
+}
+*/
+
+static void _addPWMtoList(PWMState &p, int pin, uint32_t val, uint32_t range) {
+  // Stash the val and range so we can re-evaluate the fraction
+  // should the user change PWM frequency.  This allows us to
+  // give as great a precision as possible.  We know by construction
+  // that the waveform for this pin will be inactive so we can borrow
+  // memory from that structure.
+  wvfState.waveform[pin].desiredHighCycles = val;  // Numerator == high
+  wvfState.waveform[pin].desiredLowCycles = range; // Denominator == low
+
+  uint32_t cc = (_pwmPeriod * val) / range;
+
+  // Clip to sane values in the case we go from OK to not-OK when adjusting frequencies
+  if (cc == 0) {
+    cc = 1;
+  } else if (cc >= _pwmPeriod) {
+    cc = _pwmPeriod - 1;
+  }
+
+  if (p.cnt == 0) {
+    // Starting up from scratch, special case 1st element and PWM period
+    p.pin[0] = pin;
+    p.delta[0] = cc;
+   // Final pin is never used: p.pin[1] = 0xff;
+    p.delta[1] = _pwmPeriod - cc;
+  } else {
+    uint32_t ttl = 0;
+    uint32_t i;
+    // Skip along until we're at the spot to insert
+    for (i=0; (i <= p.cnt) && (ttl + p.delta[i] < cc); i++) {
+      ttl += p.delta[i];
+    }
+    // Shift everything out by one to make space for new edge
+    for (int32_t j = p.cnt; j >= (int)i; j--) {
+      p.pin[j + 1] = p.pin[j];
+      p.delta[j + 1] = p.delta[j];
+    }
+    int off = cc - ttl; // The delta from the last edge to the one we're inserting
+    p.pin[i] = pin;
+    p.delta[i] = off; // Add the delta to this new pin
+    p.delta[i + 1] -= off; // And subtract it from the follower to keep sum(deltas) constant
+  }
+  p.cnt++;
+  p.mask |= 1<<pin;
+}
+
+// Called by analogWrite(1...99%) to set the PWM duty in clock cycles
+//extern bool _setPWM_weak(int pin, uint32_t val, uint32_t range) __attribute__((weak));
+bool _setPWM_weak(int pin, uint32_t val, uint32_t range) {
+  stopWaveform(pin);
+  PWMState p;  // Working copy
+  p = pwmState;
+  // Get rid of any entries for this pin
+  _cleanAndRemovePWM(&p, pin);
+  // And add it to the list, in order
+  if (p.cnt >= maxPWMs) {
+    return false; // No space left
+  }
+
+  // Sanity check for all-on/off
+  uint32_t cc = (_pwmPeriod * val) / range;
+  if ((cc == 0) || (cc >= _pwmPeriod)) {
+    digitalWrite(pin, cc ? HIGH : LOW);
+    return true;
+  }
+
+  _addPWMtoList(p, pin, val, range);
+
+  // Set mailbox and wait for ISR to copy it over
+  initTimer();
+  _notifyPWM(&p, true);
+  disableIdleTimer();
+
+  // Potentially recalculate the PWM period if we've added another pin
+  _setPWMFreq(_pwmFreq);
+
+  return true;
+}
+/*
+static bool _setPWM_bound(int pin, uint32_t val, uint32_t range) __attribute__((weakref("_setPWM_weak")));
+bool _setPWM(int pin, uint32_t val, uint32_t range) {
+  return _setPWM_bound(pin, val, range);
+}
+*/
+
+// Start up a waveform on a pin, or change the current one.  Will change to the new
+// waveform smoothly on next low->high transition.  For immediate change, stopWaveform()
+// first, then it will immediately begin.
+//extern int startWaveformClockCycles_weak(uint8_t pin, uint32_t timeHighCycles, uint32_t timeLowCycles, uint32_t runTimeCycles, int8_t alignPhase, uint32_t phaseOffsetUS, bool autoPwm)  __attribute__((weak));
+int startWaveformClockCycles_weak(uint8_t pin, uint32_t timeHighCycles, uint32_t timeLowCycles, uint32_t runTimeCycles,
+                             int8_t alignPhase, uint32_t phaseOffsetUS, bool autoPwm) {
+  (void) alignPhase;
+  (void) phaseOffsetUS;
+  (void) autoPwm;
+
+   if ((pin > 16) || isFlashInterfacePin(pin) || (timeHighCycles == 0)) {
+    return false;
+  }
+  Waveform *wave = &wvfState.waveform[pin];
+  wave->expiryCycle = runTimeCycles ? ESP.getCycleCount() + runTimeCycles : 0;
+  if (runTimeCycles && !wave->expiryCycle) {
+    wave->expiryCycle = 1; // expiryCycle==0 means no timeout, so avoid setting it
+  }
+
+  _stopPWM(pin); // Make sure there's no PWM live here
+
+  uint32_t mask = 1<<pin;
+  MEMBARRIER();
+  if (wvfState.waveformEnabled & mask) {
+    // Make sure no waveform changes are waiting to be applied
+    while (wvfState.waveformToChange) {
+      esp_yield(); // Wait for waveform to update
+      MEMBARRIER();
+    }
+    wvfState.waveformNewHigh = timeHighCycles;
+    wvfState.waveformNewLow = timeLowCycles;
+    MEMBARRIER();
+    wvfState.waveformToChange = mask;
+    // The waveform will be updated some time in the future on the next period for the signal
+  } else { //  if (!(wvfState.waveformEnabled & mask)) {
+    wave->timeHighCycles = timeHighCycles;
+    wave->desiredHighCycles = timeHighCycles;
+    wave->timeLowCycles = timeLowCycles;
+    wave->desiredLowCycles = timeLowCycles;
+    wave->lastEdge = 0;
+    wave->nextServiceCycle = ESP.getCycleCount() + microsecondsToClockCycles(1);
+    wvfState.waveformToEnable |= mask;
+    MEMBARRIER();
+    initTimer();
+    forceTimerInterrupt();
+    while (wvfState.waveformToEnable) {
+      esp_yield(); // Wait for waveform to update
+      MEMBARRIER();
+    }
+  }
+
+  return true;
+}
+/*
+static int startWaveformClockCycles_bound(uint8_t pin, uint32_t timeHighCycles, uint32_t timeLowCycles, uint32_t runTimeCycles, int8_t alignPhase, uint32_t phaseOffsetUS, bool autoPwm) __attribute__((weakref("startWaveformClockCycles_weak")));
+int startWaveformClockCycles(uint8_t pin, uint32_t timeHighCycles, uint32_t timeLowCycles, uint32_t runTimeCycles, int8_t alignPhase, uint32_t phaseOffsetUS, bool autoPwm) {
+  return startWaveformClockCycles_bound(pin, timeHighCycles, timeLowCycles, runTimeCycles, alignPhase, phaseOffsetUS, autoPwm);
+}
+
+
+// This version falls-thru to the proper startWaveformClockCycles call and is invariant across waveform generators
+int startWaveform(uint8_t pin, uint32_t timeHighUS, uint32_t timeLowUS, uint32_t runTimeUS,
+                  int8_t alignPhase, uint32_t phaseOffsetUS, bool autoPwm) {
+  return startWaveformClockCycles_bound(pin,
+    microsecondsToClockCycles(timeHighUS), microsecondsToClockCycles(timeLowUS),
+    microsecondsToClockCycles(runTimeUS), alignPhase, microsecondsToClockCycles(phaseOffsetUS), autoPwm);
+}
+*/
+
+// Set a callback.  Pass in NULL to stop it
+//extern void setTimer1Callback_weak(uint32_t (*fn)()) __attribute__((weak));
+void setTimer1Callback_weak(uint32_t (*fn)()) {
+  wvfState.timer1CB = fn;
+  if (fn) {
+    initTimer();
+    forceTimerInterrupt();
+  }
+  disableIdleTimer();
+}
+/*
+static void setTimer1Callback_bound(uint32_t (*fn)()) __attribute__((weakref("setTimer1Callback_weak")));
+void setTimer1Callback(uint32_t (*fn)()) {
+  setTimer1Callback_bound(fn);
+}
+*/
+
+// Stops a waveform on a pin
+//extern int stopWaveform_weak(uint8_t pin) __attribute__((weak));
+IRAM_ATTR int stopWaveform_weak(uint8_t pin) {
+  // Can't possibly need to stop anything if there is no timer active
+  if (!timerRunning) {
+    return false;
+  }
+  // If user sends in a pin >16 but <32, this will always point to a 0 bit
+  // If they send >=32, then the shift will result in 0 and it will also return false
+  uint32_t mask = 1<<pin;
+  if (wvfState.waveformEnabled & mask) {
+    wvfState.waveformToDisable = mask;
+    // Cancel any pending updates for this waveform, too.
+    if (wvfState.waveformToChange & mask) {
+        wvfState.waveformToChange = 0;
+    }
+    forceTimerInterrupt();
+    while (wvfState.waveformToDisable) {
+      MEMBARRIER(); // If it wasn't written yet, it has to be by now
+      /* no-op */ // Can't delay() since stopWaveform may be called from an IRQ
+    }
+  }
+  disableIdleTimer();
+  return true;
+}
+/*
+static int stopWaveform_bound(uint8_t pin) __attribute__((weakref("stopWaveform_weak")));
+IRAM_ATTR int stopWaveform(uint8_t pin) {
+  return stopWaveform_bound(pin);
+}
+*/
+
+// Speed critical bits
+#pragma GCC optimize ("O2")
+
+// Normally would not want two copies like this, but due to different
+// optimization levels the inline attribute gets lost if we try the
+// other version.
+static inline IRAM_ATTR uint32_t GetCycleCountIRQ() {
+  uint32_t ccount;
+  __asm__ __volatile__("rsr %0,ccount":"=a"(ccount));
+  return ccount;
+}
+
+// Find the earliest cycle as compared to right now
+static inline IRAM_ATTR uint32_t earliest(uint32_t a, uint32_t b) {
+    uint32_t now = GetCycleCountIRQ();
+    int32_t da = a - now;
+    int32_t db = b - now;
+    return (da < db) ? a : b;
+}
+
+// ----- @willmmiles begin patch -----
+// NMI crash workaround
+// Sometimes the NMI fails to return, stalling the CPU.  When this happens,
+// the next NMI gets a return address /inside the NMI handler function/.
+// We work around this by caching the last NMI return address, and restoring
+// the epc3 and eps3 registers to the previous values if the observed epc3
+// happens to be pointing to the _NMILevelVector function.
+extern void _NMILevelVector();
+extern void _UserExceptionVector_1(); // the next function after _NMILevelVector
+static inline IRAM_ATTR void nmiCrashWorkaround() {
+  static uintptr_t epc3_backup, eps3_backup;
+
+  uintptr_t epc3, eps3;
+  __asm__ __volatile__("rsr %0,epc3; rsr %1,eps3":"=a"(epc3),"=a" (eps3));
+  if ((epc3 < (uintptr_t) &_NMILevelVector) || (epc3 >= (uintptr_t) &_UserExceptionVector_1)) {
+    // Address is good; save backup
+    epc3_backup = epc3;
+    eps3_backup = eps3;
+  } else {
+    // Address is inside the NMI handler -- restore from backup
+    __asm__ __volatile__("wsr %0,epc3; wsr %1,eps3"::"a"(epc3_backup),"a"(eps3_backup));
+  }
+}
+// ----- @willmmiles end patch -----
+
+
+// The SDK and hardware take some time to actually get to our NMI code, so
+// decrement the next IRQ's timer value by a bit so we can actually catch the
+// real CPU cycle counter we want for the waveforms.
+
+// The SDK also sometimes is running at a different speed the the Arduino core
+// so the ESP cycle counter is actually running at a variable speed.
+// adjust(x) takes care of adjusting a delta clock cycle amount accordingly.
+#if F_CPU == 80000000
+  #define DELTAIRQ (microsecondsToClockCycles(9)/4)
+  #define adjust(x) ((x) << (turbo ? 1 : 0))
+#else
+  #define DELTAIRQ (microsecondsToClockCycles(9)/8)
+  #define adjust(x) ((x) >> 0)
+#endif
+
+// When the time to the next edge is greater than this, RTI and set another IRQ to minimize CPU usage
+#define MINIRQTIME microsecondsToClockCycles(6)
+
+static IRAM_ATTR void timer1Interrupt() {
+  // ----- @willmmiles begin patch -----
+  nmiCrashWorkaround();
+  // ----- @willmmiles end patch -----
+
+  // Flag if the core is at 160 MHz, for use by adjust()
+  bool turbo = (*(uint32_t*)0x3FF00014) & 1 ? true : false;
+
+  uint32_t nextEventCycle = GetCycleCountIRQ() + microsecondsToClockCycles(MAXIRQUS);
+  uint32_t timeoutCycle = GetCycleCountIRQ() + microsecondsToClockCycles(14);
+
+  if (wvfState.waveformToEnable || wvfState.waveformToDisable) {
+    // Handle enable/disable requests from main app
+    wvfState.waveformEnabled = (wvfState.waveformEnabled & ~wvfState.waveformToDisable) | wvfState.waveformToEnable; // Set the requested waveforms on/off
+    wvfState.waveformState &= ~wvfState.waveformToEnable;  // And clear the state of any just started
+    wvfState.waveformToEnable = 0;
+    wvfState.waveformToDisable = 0;
+    // No mem barrier.  Globals must be written to RAM on ISR exit.
+    // Find the first GPIO being generated by checking GCC's find-first-set (returns 1 + the bit of the first 1 in an int32_t)
+    wvfState.startPin = __builtin_ffs(wvfState.waveformEnabled) - 1;
+    // Find the last bit by subtracting off GCC's count-leading-zeros (no offset in this one)
+    wvfState.endPin = 32 - __builtin_clz(wvfState.waveformEnabled);
+  } else if (!pwmState.cnt && pwmState.pwmUpdate) {
+    // Start up the PWM generator by copying from the mailbox
+    pwmState.cnt = 1;
+    pwmState.idx = 1; // Ensure copy this cycle, cause it to start at t=0
+    pwmState.nextServiceCycle = GetCycleCountIRQ(); // Do it this loop!
+    // No need for mem barrier here.  Global must be written by IRQ exit
+  }
+
+  bool done = false;
+  if (wvfState.waveformEnabled || pwmState.cnt) {
+    do {
+      nextEventCycle = GetCycleCountIRQ() + microsecondsToClockCycles(MAXIRQUS);
+
+      // PWM state machine implementation
+      if (pwmState.cnt) {
+        int32_t cyclesToGo;
+        do {
+            cyclesToGo = pwmState.nextServiceCycle - GetCycleCountIRQ();
+            if (cyclesToGo < 0) {
+                if (pwmState.idx == pwmState.cnt) { // Start of pulses, possibly copy new
+                  if (pwmState.pwmUpdate) {
+                    // Do the memory copy from temp to global and clear mailbox
+                    pwmState = *(PWMState*)pwmState.pwmUpdate;
+                  }
+                  GPOS = pwmState.mask; // Set all active pins high
+                  if (pwmState.mask & (1<<16)) {
+                    GP16O = 1;
+                  }
+                  pwmState.idx = 0;
+                } else {
+                  do {
+                    // Drop the pin at this edge
+                    if (pwmState.mask & (1<<pwmState.pin[pwmState.idx])) {
+                      GPOC = 1<<pwmState.pin[pwmState.idx];
+                      if (pwmState.pin[pwmState.idx] == 16) {
+                        GP16O = 0;
+                      }
+                    }
+                    pwmState.idx++;
+                    // Any other pins at this same PWM value will have delta==0, drop them too.
+                  } while (pwmState.delta[pwmState.idx] == 0);
+                }
+                // Preserve duty cycle over PWM period by using now+xxx instead of += delta
+                cyclesToGo = adjust(pwmState.delta[pwmState.idx]);
+                pwmState.nextServiceCycle = GetCycleCountIRQ() + cyclesToGo;
+            }
+            nextEventCycle = earliest(nextEventCycle, pwmState.nextServiceCycle);
+        } while (pwmState.cnt && (cyclesToGo < 100));
+      }
+
+      for (auto i = wvfState.startPin; i <= wvfState.endPin; i++) {
+        uint32_t mask = 1<<i;
+
+        // If it's not on, ignore!
+        if (!(wvfState.waveformEnabled & mask)) {
+          continue;
+        }
+
+        Waveform *wave = &wvfState.waveform[i];
+        uint32_t now = GetCycleCountIRQ();
+
+        // Disable any waveforms that are done
+        if (wave->expiryCycle) {
+          int32_t expiryToGo = wave->expiryCycle - now;
+          if (expiryToGo < 0) {
+              // Done, remove!
+              if (i == 16) {
+                GP16O = 0;
+              } 
+              GPOC = mask;
+              wvfState.waveformEnabled &= ~mask;
+              continue;
+            }
+        }
+
+        // Check for toggles
+        int32_t cyclesToGo = wave->nextServiceCycle - now;
+        if (cyclesToGo < 0) {
+          uint32_t nextEdgeCycles;
+          uint32_t desired = 0;
+          uint32_t *timeToUpdate;
+          wvfState.waveformState ^= mask;
+          if (wvfState.waveformState & mask) {
+            if (i == 16) {
+              GP16O = 1;
+            }
+            GPOS = mask;
+
+            if (wvfState.waveformToChange & mask) {
+              // Copy over next full-cycle timings
+              wave->timeHighCycles = wvfState.waveformNewHigh;
+              wave->desiredHighCycles = wvfState.waveformNewHigh;
+              wave->timeLowCycles = wvfState.waveformNewLow;
+              wave->desiredLowCycles = wvfState.waveformNewLow;
+              wave->lastEdge = 0;
+              wvfState.waveformToChange = 0;
+            }
+            if (wave->lastEdge) {
+              desired = wave->desiredLowCycles;
+              timeToUpdate = &wave->timeLowCycles;
+            }
+            nextEdgeCycles = wave->timeHighCycles;
+          } else {
+            if (i == 16) {
+              GP16O = 0;
+            }
+            GPOC = mask;
+            desired = wave->desiredHighCycles;
+            timeToUpdate = &wave->timeHighCycles;
+            nextEdgeCycles = wave->timeLowCycles;
+          }
+          if (desired) {
+            desired = adjust(desired);
+            int32_t err = desired - (now - wave->lastEdge);
+            if (abs(err) < desired) { // If we've lost > the entire phase, ignore this error signal
+                err /= 2;
+                *timeToUpdate += err;
+            }
+          }
+          nextEdgeCycles = adjust(nextEdgeCycles);
+          wave->nextServiceCycle = now + nextEdgeCycles;
+          wave->lastEdge = now;
+        }
+        nextEventCycle = earliest(nextEventCycle, wave->nextServiceCycle);
+      }
+
+      // Exit the loop if we've hit the fixed runtime limit or the next event is known to be after that timeout would occur
+      uint32_t now = GetCycleCountIRQ();
+      int32_t cycleDeltaNextEvent = nextEventCycle - now;
+      int32_t cyclesLeftTimeout = timeoutCycle - now;
+      done = (cycleDeltaNextEvent > MINIRQTIME) || (cyclesLeftTimeout < 0);
+    } while (!done);
+  } // if (wvfState.waveformEnabled)
+
+  if (wvfState.timer1CB) {
+    nextEventCycle = earliest(nextEventCycle, GetCycleCountIRQ() + wvfState.timer1CB());
+  }
+
+  int32_t nextEventCycles = nextEventCycle - GetCycleCountIRQ();
+
+  if (nextEventCycles < MINIRQTIME) {
+    nextEventCycles = MINIRQTIME;
+  }
+  nextEventCycles -= DELTAIRQ;
+
+  // Do it here instead of global function to save time and because we know it's edge-IRQ
+  T1L = nextEventCycles >> (turbo ? 1 : 0);
+}
+
+};

lib/NeoESP32RmtHI/include/NeoEsp32RmtHIMethod.h

@@ -1,469 +0,0 @@
-/*-------------------------------------------------------------------------
-NeoPixel driver for ESP32 RMTs using High-priority Interrupt
-
-(NB. This cannot be mixed with the non-HI driver.)
-
-Written by Will M. Miles.
-
-I invest time and resources providing this open source code,
-please support me by donating (see https://github.com/Makuna/NeoPixelBus)
-
--------------------------------------------------------------------------
-This file is part of the Makuna/NeoPixelBus library.
-
-NeoPixelBus is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as
-published by the Free Software Foundation, either version 3 of
-the License, or (at your option) any later version.
-
-NeoPixelBus is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public
-License along with NeoPixel.  If not, see
-<http://www.gnu.org/licenses/>.
--------------------------------------------------------------------------*/
-
-#pragma once
-
-#if defined(ARDUINO_ARCH_ESP32)
-
-// Use the NeoEspRmtSpeed types from the driver-based implementation
-#include <NeoPixelBus.h>
-
-
-namespace NeoEsp32RmtHiMethodDriver {
-    // Install the driver for a specific channel, specifying timing properties
-    esp_err_t Install(rmt_channel_t channel, uint32_t rmtBit0, uint32_t rmtBit1, uint32_t resetDuration);
-
-    // Remove the driver on a specific channel
-    esp_err_t Uninstall(rmt_channel_t channel);
-
-    // Write a buffer of data to a specific channel.
-    // Buffer reference is held until write completes.
-    esp_err_t Write(rmt_channel_t channel, const uint8_t *src, size_t src_size);
-
-    // Wait until transaction is complete.
-    esp_err_t WaitForTxDone(rmt_channel_t channel, TickType_t wait_time);
-};
-
-template<typename T_SPEED, typename T_CHANNEL> class NeoEsp32RmtHIMethodBase
-{
-public:
-    typedef NeoNoSettings SettingsObject;
-
-    NeoEsp32RmtHIMethodBase(uint8_t pin, uint16_t pixelCount, size_t elementSize, size_t settingsSize)  :
-        _sizeData(pixelCount * elementSize + settingsSize),
-        _pin(pin)
-    {
-        construct();
-    }
-
-    NeoEsp32RmtHIMethodBase(uint8_t pin, uint16_t pixelCount, size_t elementSize, size_t settingsSize, NeoBusChannel channel) :
-        _sizeData(pixelCount* elementSize + settingsSize),
-        _pin(pin),
-        _channel(channel)
-    {
-        construct();
-    }
-
-    ~NeoEsp32RmtHIMethodBase()
-    {
-        // wait until the last send finishes before destructing everything
-        // arbitrary time out of 10 seconds
-        ESP_ERROR_CHECK_WITHOUT_ABORT(NeoEsp32RmtHiMethodDriver::WaitForTxDone(_channel.RmtChannelNumber, 10000 / portTICK_PERIOD_MS));
-
-        ESP_ERROR_CHECK(NeoEsp32RmtHiMethodDriver::Uninstall(_channel.RmtChannelNumber));
-
-        gpio_matrix_out(_pin, SIG_GPIO_OUT_IDX, false, false);
-        pinMode(_pin, INPUT);
-
-        free(_dataEditing);
-        free(_dataSending);
-    }
-
-    bool IsReadyToUpdate() const
-    {
-        return (ESP_OK == ESP_ERROR_CHECK_WITHOUT_ABORT_SILENT_TIMEOUT(NeoEsp32RmtHiMethodDriver::WaitForTxDone(_channel.RmtChannelNumber, 0)));
-    }
-
-    void Initialize()
-    {
-        rmt_config_t config = {};
-
-        config.rmt_mode = RMT_MODE_TX;
-        config.channel = _channel.RmtChannelNumber;
-        config.gpio_num = static_cast<gpio_num_t>(_pin);
-        config.mem_block_num = 1;
-        config.tx_config.loop_en = false;
-
-        config.tx_config.idle_output_en = true;
-        config.tx_config.idle_level = T_SPEED::IdleLevel;
-
-        config.tx_config.carrier_en = false;
-        config.tx_config.carrier_level = RMT_CARRIER_LEVEL_LOW;
-
-        config.clk_div = T_SPEED::RmtClockDivider;
-
-        ESP_ERROR_CHECK(rmt_config(&config));   // Uses ESP library
-        ESP_ERROR_CHECK(NeoEsp32RmtHiMethodDriver::Install(_channel.RmtChannelNumber, T_SPEED::RmtBit0, T_SPEED::RmtBit1, T_SPEED::RmtDurationReset));
-    }
-
-    void Update(bool maintainBufferConsistency)
-    {
-        // wait for not actively sending data
-        // this will time out at 10 seconds, an arbitrarily long period of time
-        // and do nothing if this happens
-        if (ESP_OK == ESP_ERROR_CHECK_WITHOUT_ABORT(NeoEsp32RmtHiMethodDriver::WaitForTxDone(_channel.RmtChannelNumber, 10000 / portTICK_PERIOD_MS)))
-        {
-            // now start the RMT transmit with the editing buffer before we swap
-            ESP_ERROR_CHECK_WITHOUT_ABORT(NeoEsp32RmtHiMethodDriver::Write(_channel.RmtChannelNumber, _dataEditing, _sizeData));
-
-            if (maintainBufferConsistency)
-            {
-                // copy editing to sending,
-                // this maintains the contract that "colors present before will
-                // be the same after", otherwise GetPixelColor will be inconsistent
-                memcpy(_dataSending, _dataEditing, _sizeData);
-            }
-
-            // swap so the user can modify without affecting the async operation
-            std::swap(_dataSending, _dataEditing);
-        }
-    }
-
-    bool AlwaysUpdate()
-    {
-        // this method requires update to be called only if changes to buffer
-        return false;
-    }
-
-    bool SwapBuffers()
-    {
-        std::swap(_dataSending, _dataEditing);
-        return true;
-    }
-
-    uint8_t* getData() const
-    {
-        return _dataEditing;
-    };
-
-    size_t getDataSize() const
-    {
-        return _sizeData;
-    }
-
-    void applySettings([[maybe_unused]] const SettingsObject& settings)
-    {
-    }
-
-private:
-    const size_t  _sizeData;      // Size of '_data*' buffers
-    const uint8_t _pin;            // output pin number
-    const T_CHANNEL _channel; // holds instance for multi channel support
-
-    // Holds data stream which include LED color values and other settings as needed
-    uint8_t*  _dataEditing;   // exposed for get and set
-    uint8_t*  _dataSending;   // used for async send using RMT
-
-
-    void construct()
-    {
-        _dataEditing = static_cast<uint8_t*>(malloc(_sizeData));
-        // data cleared later in Begin()
-
-        _dataSending = static_cast<uint8_t*>(malloc(_sizeData));
-        // no need to initialize it, it gets overwritten on every send
-    }
-};
-
-// normal
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannelN> NeoEsp32RmtHINSk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannelN> NeoEsp32RmtHINTm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannelN> NeoEsp32RmtHINTm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannelN> NeoEsp32RmtHINTm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannelN> NeoEsp32RmtHINApa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannelN> NeoEsp32RmtHINTx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannelN> NeoEsp32RmtHINGs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannelN> NeoEsp32RmtHIN800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannelN> NeoEsp32RmtHIN400KbpsMethod;
-typedef NeoEsp32RmtHINWs2805Method NeoEsp32RmtHINWs2814Method;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel0> NeoEsp32RmtHI0800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel0> NeoEsp32RmtHI0400KbpsMethod;
-typedef NeoEsp32RmtHI0Ws2805Method NeoEsp32RmtHI0Ws2814Method;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel1> NeoEsp32RmtHI1800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel1> NeoEsp32RmtHI1400KbpsMethod;
-typedef NeoEsp32RmtHI1Ws2805Method NeoEsp32RmtHI1Ws2814Method;
-
-#if !defined(CONFIG_IDF_TARGET_ESP32C3)
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel2>  NeoEsp32RmtHI2Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel2> NeoEsp32RmtHI2800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel2> NeoEsp32RmtHI2400KbpsMethod;
-typedef NeoEsp32RmtHI2Ws2805Method NeoEsp32RmtHI2Ws2814Method;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel3>  NeoEsp32RmtHI3Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel3> NeoEsp32RmtHI3800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel3> NeoEsp32RmtHI3400KbpsMethod;
-typedef NeoEsp32RmtHI3Ws2805Method NeoEsp32RmtHI3Ws2814Method;
-
-#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32S3)
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel4>  NeoEsp32RmtHI4Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel4> NeoEsp32RmtHI4800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel4> NeoEsp32RmtHI4400KbpsMethod;
-typedef NeoEsp32RmtHI4Ws2805Method NeoEsp32RmtHI4Ws2814Method;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel5>  NeoEsp32RmtHI5Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel5> NeoEsp32RmtHI5800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel5> NeoEsp32RmtHI5400KbpsMethod;
-typedef NeoEsp32RmtHI5Ws2805Method NeoEsp32RmtHI5Ws2814Method;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel6>  NeoEsp32RmtHI6Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel6> NeoEsp32RmtHI6800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel6> NeoEsp32RmtHI6400KbpsMethod;
-typedef NeoEsp32RmtHI6Ws2805Method NeoEsp32RmtHI6Ws2814Method;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2811, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2811Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2812xMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2812x, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2816Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedWs2805, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2805Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedSk6812, NeoEsp32RmtChannel7>  NeoEsp32RmtHI7Sk6812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1814, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tm1814Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1829, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tm1829Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTm1914, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tm1914Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedApa106, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Apa106Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedTx1812, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tx1812Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeedGs1903, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Gs1903Method;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed800Kbps, NeoEsp32RmtChannel7> NeoEsp32RmtHI7800KbpsMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtSpeed400Kbps, NeoEsp32RmtChannel7> NeoEsp32RmtHI7400KbpsMethod;
-typedef NeoEsp32RmtHI7Ws2805Method NeoEsp32RmtHI7Ws2814Method;
-
-#endif // !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32S3)
-#endif // !defined(CONFIG_IDF_TARGET_ESP32C3)
-
-// inverted
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannelN> NeoEsp32RmtHINWs2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannelN> NeoEsp32RmtHINSk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannelN> NeoEsp32RmtHINTm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannelN> NeoEsp32RmtHINTm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannelN> NeoEsp32RmtHINTm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannelN> NeoEsp32RmtHINApa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannelN> NeoEsp32RmtHINTx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannelN> NeoEsp32RmtHINGs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannelN> NeoEsp32RmtHIN800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannelN> NeoEsp32RmtHIN400KbpsInvertedMethod;
-typedef NeoEsp32RmtHINWs2805InvertedMethod NeoEsp32RmtHINWs2814InvertedMethod;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel0> NeoEsp32RmtHI0Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel0> NeoEsp32RmtHI0800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel0> NeoEsp32RmtHI0400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI0Ws2805InvertedMethod NeoEsp32RmtHI0Ws2814InvertedMethod;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel1> NeoEsp32RmtHI1Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel1> NeoEsp32RmtHI1800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel1> NeoEsp32RmtHI1400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI1Ws2805InvertedMethod NeoEsp32RmtHI1Ws2814InvertedMethod;
-
-#if !defined(CONFIG_IDF_TARGET_ESP32C3)
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel2>  NeoEsp32RmtHI2Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel2> NeoEsp32RmtHI2Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel2> NeoEsp32RmtHI2800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel2> NeoEsp32RmtHI2400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI2Ws2805InvertedMethod NeoEsp32RmtHI2Ws2814InvertedMethod;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel3>  NeoEsp32RmtHI3Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel3> NeoEsp32RmtHI3Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel3> NeoEsp32RmtHI3800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel3> NeoEsp32RmtHI3400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI3Ws2805InvertedMethod NeoEsp32RmtHI3Ws2814InvertedMethod;
-
-#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32S3)
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel4>  NeoEsp32RmtHI4Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel4> NeoEsp32RmtHI4Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel4> NeoEsp32RmtHI4800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel4> NeoEsp32RmtHI4400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI4Ws2805InvertedMethod NeoEsp32RmtHI4Ws2814InvertedMethod;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel5>  NeoEsp32RmtHI5Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel5> NeoEsp32RmtHI5Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel5> NeoEsp32RmtHI5800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel5> NeoEsp32RmtHI5400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI5Ws2805InvertedMethod NeoEsp32RmtHI5Ws2814InvertedMethod;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel6>  NeoEsp32RmtHI6Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel6> NeoEsp32RmtHI6Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel6> NeoEsp32RmtHI6800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel6> NeoEsp32RmtHI6400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI6Ws2805InvertedMethod NeoEsp32RmtHI6Ws2814InvertedMethod;
-
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2811, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2811InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2812xInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2812x, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2816InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedWs2805, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Ws2805InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedSk6812, NeoEsp32RmtChannel7>  NeoEsp32RmtHI7Sk6812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1814, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tm1814InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1829, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tm1829InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTm1914, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tm1914InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedApa106, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Apa106InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedTx1812, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Tx1812InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeedGs1903, NeoEsp32RmtChannel7> NeoEsp32RmtHI7Gs1903InvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed800Kbps, NeoEsp32RmtChannel7> NeoEsp32RmtHI7800KbpsInvertedMethod;
-typedef NeoEsp32RmtHIMethodBase<NeoEsp32RmtInvertedSpeed400Kbps, NeoEsp32RmtChannel7> NeoEsp32RmtHI7400KbpsInvertedMethod;
-typedef NeoEsp32RmtHI7Ws2805InvertedMethod NeoEsp32RmtHI7Ws2814InvertedMethod;
-
-#endif // !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32S3)
-#endif // !defined(CONFIG_IDF_TARGET_ESP32C3)
-
-#endif

lib/NeoESP32RmtHI/library.json

@@ -1,12 +0,0 @@
-{
-  "name": "NeoESP32RmtHI",
-  "build": { "libArchive": false },
-  "platforms": ["espressif32"],
-  "dependencies": [
-    {
-      "owner": "makuna",      
-      "name": "NeoPixelBus",
-      "version": "^2.8.3"
-    }
-  ]
-}  

lib/NeoESP32RmtHI/src/NeoEsp32RmtHI.S

@@ -1,263 +0,0 @@
-/* RMT ISR shim
- * Bridges from a high-level interrupt to the C++ code.
- *
- * This code is largely derived from Espressif's 'hli_vector.S' Bluetooth ISR.
- *
- */
-
-#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
-   - S2: 5
-   - S3: 5
-*/
-
-#if CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_5
-/* Use level 4 */
-#define RFI_X               4
-#define xt_highintx         xt_highint4
-#else /* !CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_5 */
-/* Use level 5 */
-#define RFI_X               5
-#define xt_highintx         xt_highint5
-#endif /* CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_5 */
-
-// Register map, based on interrupt level
-#define EPC_X               (EPC + RFI_X)
-#define EXCSAVE_X           (EXCSAVE + RFI_X)
-
-// The sp mnemonic is used all over in ESP's assembly, though I'm not sure where it's expected to be defined?
-#define sp a1
-
-/* Interrupt stack size, for C code. */
-#define RMT_INTR_STACK_SIZE  512
-
-/* Save area for the CPU state:
- * - 64 words for the general purpose registers
- * - 7 words for some of the special registers:
- *   - WINDOWBASE, WINDOWSTART — only WINDOWSTART is truly needed
- *   - SAR, LBEG, LEND, LCOUNT — since the C code might use these
- *   - EPC1 — since the C code might cause window overflow exceptions
- * This is not laid out as standard exception frame structure
- * for simplicity of the save/restore code.
- */
-#define REG_FILE_SIZE         (64 * 4)
-#define SPECREG_OFFSET        REG_FILE_SIZE
-#define SPECREG_SIZE          (7 * 4)
-#define REG_SAVE_AREA_SIZE    (SPECREG_OFFSET + SPECREG_SIZE)
-
-    .data
-_rmt_intr_stack:
-    .space      RMT_INTR_STACK_SIZE
-_rmt_save_ctx:
-    .space      REG_SAVE_AREA_SIZE
-
-    .section .iram1,"ax"
-    .global     xt_highintx
-    .type       xt_highintx,@function
-    .align      4
-
-xt_highintx:
-
-    movi    a0, _rmt_save_ctx
-    /* save 4 lower registers */
-    s32i    a1, a0, 4
-    s32i    a2, a0, 8
-    s32i    a3, a0, 12
-    rsr     a2, EXCSAVE_X  /* holds the value of a0 */
-    s32i    a2, a0, 0
-
-    /* Save special registers */
-    addi    a0, a0, SPECREG_OFFSET
-    rsr     a2, WINDOWBASE
-    s32i    a2, a0, 0
-    rsr     a2, WINDOWSTART
-    s32i    a2, a0, 4
-    rsr     a2, SAR
-    s32i    a2, a0, 8
-    #if XCHAL_HAVE_LOOPS
-    rsr     a2, LBEG
-    s32i    a2, a0, 12
-    rsr     a2, LEND
-    s32i    a2, a0, 16
-    rsr     a2, LCOUNT
-    s32i    a2, a0, 20
-    #endif
-    rsr     a2, EPC1
-    s32i    a2, a0, 24
-
-    /* disable exception mode, window overflow */
-    movi    a0, PS_INTLEVEL(RFI_X+1) | PS_EXCM
-    wsr     a0, PS
-    rsync
-
-    /* Save the remaining physical registers.
-     * 4 registers are already saved, which leaves 60 registers to save.
-     * (FIXME: consider the case when the CPU is configured with physical 32 registers)
-     * These 60 registers are saved in 5 iterations, 12 registers at a time.
-     */
-    movi    a1, 5
-    movi    a3, _rmt_save_ctx + 4 * 4
-
-    /* This is repeated 5 times, each time the window is shifted by 12 registers.
-     * We come here with a1 = downcounter, a3 = save pointer, a2 and a0 unused.
-     */
-1:
-    s32i    a4, a3, 0
-    s32i    a5, a3, 4
-    s32i    a6, a3, 8
-    s32i    a7, a3, 12
-    s32i    a8, a3, 16
-    s32i    a9, a3, 20
-    s32i    a10, a3, 24
-    s32i    a11, a3, 28
-    s32i    a12, a3, 32
-    s32i    a13, a3, 36
-    s32i    a14, a3, 40
-    s32i    a15, a3, 44
-
-    /* We are about to rotate the window, so that a12-a15 will become the new a0-a3.
-     * Copy a0-a3 to a12-15 to still have access to these values.
-     * At the same time we can decrement the counter and adjust the save area pointer
-     */
-
-    /* a0 is constant (_rmt_save_ctx), no need to copy */
-    addi    a13, a1, -1  /* copy and decrement the downcounter */
-    /* a2 is scratch so no need to copy */
-    addi    a15, a3, 48  /* copy and adjust the save area pointer */
-    beqz    a13, 2f      /* have saved all registers ? */
-    rotw    3            /* rotate the window and go back */
-    j       1b
-
-    /* the loop is complete */
-2:
-    rotw 4      /* this brings us back to the original window */
-    /* a0 still points to _rmt_save_ctx */
-
-    /* Can clear WINDOWSTART now, all registers are saved */
-    rsr     a2, WINDOWBASE
-    /* WINDOWSTART = (1 << WINDOWBASE) */
-    movi    a3, 1
-    ssl     a2
-    sll     a3, a3
-    wsr     a3, WINDOWSTART
-
-_highint_stack_switch:
-    movi    a0, 0
-    movi    sp, _rmt_intr_stack + RMT_INTR_STACK_SIZE - 16
-    s32e    a0, sp, -12         /* For GDB: set null SP */
-    s32e    a0, sp, -16         /* For GDB: set null PC */
-    movi    a0, _highint_stack_switch     /* For GDB: cosmetics, for the frame where stack switch happened */
-
-    /* Set up PS for C, disable all interrupts except NMI and debug, and clear EXCM. */
-    movi    a6, PS_INTLEVEL(RFI_X) | PS_UM | PS_WOE
-    wsr     a6, PS
-    rsync
-
-    /* Call C handler */
-    mov     a6, sp
-    call4   NeoEsp32RmtMethodIsr
-
-    l32e    sp, sp, -12                     /* switch back to the original stack */
-
-    /* Done with C handler; re-enable exception mode, disabling window overflow */
-    movi    a2, PS_INTLEVEL(RFI_X+1) | PS_EXCM    /* TOCHECK */
-    wsr     a2, PS
-    rsync
-
-    /* Restore the special registers.
-     * WINDOWSTART will be restored near the end.
-     */
-    movi    a0, _rmt_save_ctx + SPECREG_OFFSET
-    l32i    a2, a0, 8
-    wsr     a2, SAR
-    #if XCHAL_HAVE_LOOPS
-    l32i    a2, a0, 12
-    wsr     a2, LBEG
-    l32i    a2, a0, 16
-    wsr     a2, LEND
-    l32i    a2, a0, 20
-    wsr     a2, LCOUNT
-    #endif
-    l32i    a2, a0, 24
-    wsr     a2, EPC1
-
-    /* Restoring the physical registers.
-     * This is the reverse to the saving process above.
-     */
-
-    /* Rotate back to the final window, then start loading 12 registers at a time,
-     * in 5 iterations.
-     * Again, a1 is the downcounter and a3 is the save area pointer.
-     * After each rotation, a1 and a3 are copied from a13 and a15.
-     * To simplify the loop, we put the initial values into a13 and a15.
-     */
-    rotw     -4
-    movi    a15, _rmt_save_ctx + 64 * 4  /* point to the end of the save area */
-    movi    a13, 5
-
-1:
-    /* Copy a1 and a3 from their previous location,
-     * at the same time decrementing and adjusting the save area pointer.
-     */
-    addi    a1, a13, -1
-    addi    a3, a15, -48
-
-    /* Load 12 registers */
-    l32i    a4, a3, 0
-    l32i    a5, a3, 4
-    l32i    a6, a3, 8
-    l32i    a7, a3, 12
-    l32i    a8, a3, 16
-    l32i    a9, a3, 20
-    l32i    a10, a3, 24
-    l32i    a11, a3, 28                                /* ensure PS and EPC written */
-    l32i    a12, a3, 32
-    l32i    a13, a3, 36
-    l32i    a14, a3, 40
-    l32i    a15, a3, 44
-
-    /* Done with the loop? */
-    beqz    a1, 2f
-    /* If no, rotate the window and repeat */
-    rotw    -3
-    j       1b
-
-2:
-    /* Done with the loop. Only 4 registers (a0-a3 in the original window) remain
-     * to be restored. Also need to restore WINDOWSTART, since all the general
-     * registers are now in place.
-     */
-    movi    a0, _rmt_save_ctx
-
-    l32i    a2, a0, SPECREG_OFFSET + 4
-    wsr     a2, WINDOWSTART
-
-    l32i    a1, a0, 4
-    l32i    a2, a0, 8
-    l32i    a3, a0, 12
-    rsr     a0, EXCSAVE_X  /* holds the value of a0 before the interrupt handler */
-
-    /* Return from the interrupt, restoring PS from EPS_X */
-    rfi     RFI_X
-
-
-/* The linker has no reason to link in this file; all symbols it exports are already defined
-   (weakly!) in the default int handler. Define a symbol here so we can use it to have the
-   linker inspect this anyway. */
-
-    .global ld_include_hli_vectors_rmt
-ld_include_hli_vectors_rmt:
-
-
-#endif // CONFIG_BTDM_CTRL_HLI
-#endif // XTensa

lib/NeoESP32RmtHI/src/NeoEsp32RmtHIMethod.cpp

@@ -1,507 +0,0 @@
-/*-------------------------------------------------------------------------
-NeoPixel library helper functions for Esp32.
-
-A BIG thanks to Andreas Merkle for the investigation and implementation of
-a workaround to the GCC bug that drops method attributes from template methods
-
-Written by Michael C. Miller.
-
-I invest time and resources providing this open source code,
-please support me by donating (see https://github.com/Makuna/NeoPixelBus)
-
--------------------------------------------------------------------------
-This file is part of the Makuna/NeoPixelBus library.
-
-NeoPixelBus is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as
-published by the Free Software Foundation, either version 3 of
-the License, or (at your option) any later version.
-
-NeoPixelBus is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public
-License along with NeoPixel.  If not, see
-<http://www.gnu.org/licenses/>.
--------------------------------------------------------------------------*/
-
-#include <Arduino.h>
-
-#if defined(ARDUINO_ARCH_ESP32)
-
-#include <algorithm>  
-#include "esp_idf_version.h"
-#include "NeoEsp32RmtHIMethod.h"
-#include "soc/soc.h"
-#include "soc/rmt_reg.h"
-
-#ifdef __riscv
-#include "riscv/interrupt.h"
-#endif
-
-
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0)
-#include "hal/rmt_ll.h"
-#else
-/* Shims for older ESP-IDF v3; we can safely assume original ESP32 */
-#include "soc/rmt_struct.h"
-
-// Selected RMT API functions borrowed from ESP-IDF v4.4.8
-// components/hal/esp32/include/hal/rmt_ll.h
-// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-__attribute__((always_inline))
-static inline void rmt_ll_tx_reset_pointer(rmt_dev_t *dev, uint32_t channel)
-{
-    dev->conf_ch[channel].conf1.mem_rd_rst = 1;
-    dev->conf_ch[channel].conf1.mem_rd_rst = 0;
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_tx_start(rmt_dev_t *dev, uint32_t channel)
-{
-    dev->conf_ch[channel].conf1.tx_start = 1;
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_tx_stop(rmt_dev_t *dev, uint32_t channel)
-{
-    RMTMEM.chan[channel].data32[0].val = 0;
-    dev->conf_ch[channel].conf1.tx_start = 0;
-    dev->conf_ch[channel].conf1.mem_rd_rst = 1;
-    dev->conf_ch[channel].conf1.mem_rd_rst = 0;
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_tx_enable_pingpong(rmt_dev_t *dev, uint32_t channel, bool enable)
-{
-    dev->apb_conf.mem_tx_wrap_en = enable;
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_tx_enable_loop(rmt_dev_t *dev, uint32_t channel, bool enable)
-{
-    dev->conf_ch[channel].conf1.tx_conti_mode = enable;
-}
-
-__attribute__((always_inline))
-static inline uint32_t rmt_ll_tx_get_channel_status(rmt_dev_t *dev, uint32_t channel)
-{
-    return dev->status_ch[channel];
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_tx_set_limit(rmt_dev_t *dev, uint32_t channel, uint32_t limit)
-{
-    dev->tx_lim_ch[channel].limit = limit;
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_enable_interrupt(rmt_dev_t *dev, uint32_t mask, bool enable)
-{
-    if (enable) {
-        dev->int_ena.val |= mask;
-    } else {
-        dev->int_ena.val &= ~mask;
-    }
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_enable_tx_end_interrupt(rmt_dev_t *dev, uint32_t channel, bool enable)
-{
-    dev->int_ena.val &= ~(1 << (channel * 3));
-    dev->int_ena.val |= (enable << (channel * 3));
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_enable_tx_err_interrupt(rmt_dev_t *dev, uint32_t channel, bool enable)
-{
-    dev->int_ena.val &= ~(1 << (channel * 3 + 2));
-    dev->int_ena.val |= (enable << (channel * 3 + 2));
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_enable_tx_thres_interrupt(rmt_dev_t *dev, uint32_t channel, bool enable)
-{
-    dev->int_ena.val &= ~(1 << (channel + 24));
-    dev->int_ena.val |= (enable << (channel + 24));
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_clear_tx_end_interrupt(rmt_dev_t *dev, uint32_t channel)
-{
-    dev->int_clr.val = (1 << (channel * 3));
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_clear_tx_err_interrupt(rmt_dev_t *dev, uint32_t channel)
-{
-    dev->int_clr.val = (1 << (channel * 3 + 2));
-}
-
-__attribute__((always_inline))
-static inline void rmt_ll_clear_tx_thres_interrupt(rmt_dev_t *dev, uint32_t channel)
-{
-    dev->int_clr.val = (1 << (channel + 24));
-}
-
-
-__attribute__((always_inline))
-static inline uint32_t rmt_ll_get_tx_thres_interrupt_status(rmt_dev_t *dev)
-{
-    uint32_t status =  dev->int_st.val;
-    return (status & 0xFF000000) >> 24;
-}
-#endif
-
-
-// *********************************
-// Select method for binding interrupt
-//
-// - If the Bluetooth driver has registered a high-level interrupt, piggyback on that API
-// - If we're on a modern core, allocate the interrupt with the API (old cores are bugged)
-// - Otherwise use the low-level hardware API to manually bind the interrupt
-
-
-#if defined(CONFIG_BTDM_CTRL_HLI)
-// Espressif's bluetooth driver offers a helpful sharing layer; bring in the interrupt management calls
-#include "hal/interrupt_controller_hal.h"
-extern "C" esp_err_t hli_intr_register(intr_handler_t handler, void* arg, uint32_t intr_reg, uint32_t intr_mask);
-
-#else /* !CONFIG_BTDM_CTRL_HLI*/
-
-// Declare the our high-priority ISR handler
-extern "C" void ld_include_hli_vectors_rmt();   // an object with an address, but no space
-
-#if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C3)
-#include "soc/periph_defs.h"
-#endif
-
-// Select level flag
-#if defined(__riscv)
-// RISCV chips don't block interrupts while scheduling; all we need to do is be higher than the WiFi ISR
-#define INT_LEVEL_FLAG ESP_INTR_FLAG_LEVEL3
-#elif defined(CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_5)
-#define INT_LEVEL_FLAG ESP_INTR_FLAG_LEVEL4
-#else
-#define INT_LEVEL_FLAG ESP_INTR_FLAG_LEVEL5
-#endif
-
-// ESP-IDF v3 cannot enable high priority interrupts through the API at all;
-// and ESP-IDF v4 on XTensa cannot enable Level 5 due to incorrect interrupt descriptor tables
-#if !defined(__XTENSA__) || (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)) || ((ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0) && CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_5))
-#define NEOESP32_RMT_CAN_USE_INTR_ALLOC
-
-// XTensa cores require the assembly bridge
-#ifdef __XTENSA__
-#define HI_IRQ_HANDLER nullptr
-#define HI_IRQ_HANDLER_ARG ld_include_hli_vectors_rmt
-#else
-#define HI_IRQ_HANDLER NeoEsp32RmtMethodIsr
-#define HI_IRQ_HANDLER_ARG nullptr
-#endif
-
-#else
-/* !CONFIG_BTDM_CTRL_HLI && !NEOESP32_RMT_CAN_USE_INTR_ALLOC */
-// This is the index of the LV5 interrupt vector - see interrupt descriptor table in idf components/hal/esp32/interrupt_descriptor_table.c
-#define ESP32_LV5_IRQ_INDEX 26
-
-#endif  /* NEOESP32_RMT_CAN_USE_INTR_ALLOC */
-#endif  /* CONFIG_BTDM_CTRL_HLI */
-
-
-// RMT driver implementation
-struct NeoEsp32RmtHIChannelState {
-    uint32_t rmtBit0, rmtBit1;
-    uint32_t resetDuration;
-
-    const byte* txDataStart;    // data array
-    const byte* txDataEnd;      // one past end
-    const byte* txDataCurrent;      // current location
-    size_t rmtOffset;
-};
-
-// Global variables
-#if defined(NEOESP32_RMT_CAN_USE_INTR_ALLOC)
-static intr_handle_t isrHandle = nullptr;
-#endif
-
-static NeoEsp32RmtHIChannelState** driverState = nullptr;
-constexpr size_t rmtBatchSize =  RMT_MEM_ITEM_NUM / 2;
-
-// Fill the RMT buffer memory
-// This is implemented using many arguments instead of passing the structure object to ensure we do only one lookup
-// All the arguments are passed in registers, so they don't need to be looked up again
-static void IRAM_ATTR RmtFillBuffer(uint8_t channel, const byte** src_ptr, const byte* end, uint32_t bit0, uint32_t bit1, size_t* offset_ptr, size_t reserve) {
-    // We assume that (rmtToWrite % 8) == 0
-    size_t rmtToWrite = rmtBatchSize - reserve;
-    rmt_item32_t* dest =(rmt_item32_t*)  &RMTMEM.chan[channel].data32[*offset_ptr + reserve]; // write directly in to RMT memory
-    const byte* psrc = *src_ptr;
-
-    *offset_ptr ^= rmtBatchSize;
-
-    if (psrc != end) {
-        while (rmtToWrite > 0) {
-            uint8_t data = *psrc;
-            for (uint8_t bit = 0; bit < 8; bit++)
-            {
-                dest->val = (data & 0x80) ? bit1 : bit0;
-                dest++;
-                data <<= 1;
-            }
-            rmtToWrite -= 8;
-            psrc++;
-
-            if (psrc == end) {
-                break;
-            }
-        }
-
-        *src_ptr = psrc;
-    }
-
-    if (rmtToWrite > 0) {
-        // Add end event
-        rmt_item32_t bit0_val = {{.val = bit0 }};
-        *dest = rmt_item32_t {{{ .duration0 = 0, .level0 = bit0_val.level1, .duration1 = 0, .level1 = bit0_val.level1 }}};
-    }
-}
-
-static void IRAM_ATTR RmtStartWrite(uint8_t channel, NeoEsp32RmtHIChannelState& state) {
-    // Reset context state
-    state.rmtOffset = 0;
-
-    // Fill the first part of the buffer with a reset event
-    // FUTURE: we could do timing analysis with the last interrupt on this channel
-    // Use 8 words to stay aligned with the buffer fill logic
-    rmt_item32_t bit0_val = {{.val = state.rmtBit0 }};
-    rmt_item32_t fill = {{{ .duration0 = 100, .level0 = bit0_val.level1, .duration1 = 100, .level1 = bit0_val.level1 }}};
-    rmt_item32_t* dest = (rmt_item32_t*) &RMTMEM.chan[channel].data32[0];
-    for (auto i = 0; i < 7; ++i) dest[i] = fill;
-    fill.duration1 = state.resetDuration > 1400 ? (state.resetDuration - 1400) : 100;
-    dest[7] = fill;
-
-    // Fill the remaining buffer with real data
-    RmtFillBuffer(channel, &state.txDataCurrent, state.txDataEnd, state.rmtBit0, state.rmtBit1, &state.rmtOffset, 8);
-    RmtFillBuffer(channel, &state.txDataCurrent, state.txDataEnd, state.rmtBit0, state.rmtBit1, &state.rmtOffset, 0);
-
-    // Start operation
-    rmt_ll_clear_tx_thres_interrupt(&RMT, channel);
-    rmt_ll_tx_reset_pointer(&RMT, channel);
-    rmt_ll_tx_start(&RMT, channel);
-}
-
-extern "C" void IRAM_ATTR NeoEsp32RmtMethodIsr(void *arg) {
-    // Tx threshold interrupt
-    uint32_t status = rmt_ll_get_tx_thres_interrupt_status(&RMT);
-    while (status) {
-        uint8_t channel = __builtin_ffs(status) - 1;                
-        if (driverState[channel]) {            
-            // Normal case
-            NeoEsp32RmtHIChannelState& state = *driverState[channel];
-            RmtFillBuffer(channel, &state.txDataCurrent, state.txDataEnd, state.rmtBit0, state.rmtBit1, &state.rmtOffset, 0);
-        } else {
-            // Danger - another driver got invoked?
-            rmt_ll_tx_stop(&RMT, channel);
-        }
-        rmt_ll_clear_tx_thres_interrupt(&RMT, channel);
-        status = rmt_ll_get_tx_thres_interrupt_status(&RMT);
-    }
-};
-
-// Wrapper around the register analysis defines
-// For all currently supported chips, this is constant for all channels; but this is not true of *all* ESP32
-static inline bool _RmtStatusIsTransmitting(rmt_channel_t channel, uint32_t status) {
-    uint32_t v;
-    switch(channel) {
-#ifdef RMT_STATE_CH0        
-        case 0: v = (status >> RMT_STATE_CH0_S) & RMT_STATE_CH0_V; break;
-#endif
-#ifdef RMT_STATE_CH1
-        case 1: v = (status >> RMT_STATE_CH1_S) & RMT_STATE_CH1_V; break;
-#endif
-#ifdef RMT_STATE_CH2
-        case 2: v = (status >> RMT_STATE_CH2_S) & RMT_STATE_CH2_V; break;
-#endif
-#ifdef RMT_STATE_CH3        
-        case 3: v = (status >> RMT_STATE_CH3_S) & RMT_STATE_CH3_V; break;
-#endif        
-#ifdef RMT_STATE_CH4
-        case 4: v = (status >> RMT_STATE_CH4_S) & RMT_STATE_CH4_V; break;
-#endif
-#ifdef RMT_STATE_CH5
-        case 5: v = (status >> RMT_STATE_CH5_S) & RMT_STATE_CH5_V; break;
-#endif
-#ifdef RMT_STATE_CH6
-        case 6: v = (status >> RMT_STATE_CH6_S) & RMT_STATE_CH6_V; break;
-#endif
-#ifdef RMT_STATE_CH7
-        case 7: v = (status >> RMT_STATE_CH7_S) & RMT_STATE_CH7_V; break;
-#endif
-        default: v = 0;
-    }
-
-    return v != 0;
-}
-
-
-esp_err_t NeoEsp32RmtHiMethodDriver::Install(rmt_channel_t channel, uint32_t rmtBit0, uint32_t rmtBit1, uint32_t reset) {
-    // Validate channel number
-    if (channel >= RMT_CHANNEL_MAX) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    esp_err_t err = ESP_OK;
-    if (!driverState) {
-        // First time init
-        driverState = reinterpret_cast<NeoEsp32RmtHIChannelState**>(heap_caps_calloc(RMT_CHANNEL_MAX, sizeof(NeoEsp32RmtHIChannelState*), MALLOC_CAP_INTERNAL));
-        if (!driverState) return ESP_ERR_NO_MEM;
-        
-        // Ensure all interrupts are cleared before binding
-        RMT.int_ena.val = 0;
-        RMT.int_clr.val = 0xFFFFFFFF;
-
-        // Bind interrupt handler
-#if defined(CONFIG_BTDM_CTRL_HLI)
-        // Bluetooth driver has taken the empty high-priority interrupt.  Fortunately, it allows us to
-        // hook up another handler.
-        err = hli_intr_register(NeoEsp32RmtMethodIsr, nullptr, (uintptr_t) &RMT.int_st, 0xFF000000);
-        // 25 is the magic number of the bluetooth ISR on ESP32 - see soc/soc.h.
-        intr_matrix_set(cpu_hal_get_core_id(), ETS_RMT_INTR_SOURCE, 25);
-        intr_cntrl_ll_enable_interrupts(1<<25);
-#elif defined(NEOESP32_RMT_CAN_USE_INTR_ALLOC)
-        // Use the platform code to allocate the interrupt
-        // If we need the additional assembly bridge, we pass it as the "arg" to the IDF so it gets linked in       
-        err = esp_intr_alloc(ETS_RMT_INTR_SOURCE, INT_LEVEL_FLAG | ESP_INTR_FLAG_IRAM, HI_IRQ_HANDLER, (void*) HI_IRQ_HANDLER_ARG, &isrHandle);
-        //err = ESP_ERR_NOT_FINISHED;
-#else
-        // Broken IDF API does not allow us to reserve the interrupt; do it manually
-        static volatile const void*  __attribute__((used)) pleaseLinkAssembly = (void*) ld_include_hli_vectors_rmt;
-        intr_matrix_set(xPortGetCoreID(), ETS_RMT_INTR_SOURCE, ESP32_LV5_IRQ_INDEX);
-        ESP_INTR_ENABLE(ESP32_LV5_IRQ_INDEX);
-#endif
-
-        if (err != ESP_OK) {
-            heap_caps_free(driverState);
-            driverState = nullptr;
-            return err;
-        }
-    }
-
-    if (driverState[channel] != nullptr) {
-        return ESP_ERR_INVALID_STATE;   // already in use
-    }
-
-    NeoEsp32RmtHIChannelState* state = reinterpret_cast<NeoEsp32RmtHIChannelState*>(heap_caps_calloc(1, sizeof(NeoEsp32RmtHIChannelState), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT));
-    if (state == nullptr) {
-        return ESP_ERR_NO_MEM;
-    }
-
-    // Store timing information
-    state->rmtBit0 = rmtBit0;
-    state->rmtBit1 = rmtBit1;
-    state->resetDuration = reset;
-
-    // Initialize hardware
-    rmt_ll_tx_stop(&RMT, channel);
-    rmt_ll_tx_reset_pointer(&RMT, channel);
-    rmt_ll_enable_tx_err_interrupt(&RMT, channel, false);
-    rmt_ll_enable_tx_end_interrupt(&RMT, channel, false);
-    rmt_ll_enable_tx_thres_interrupt(&RMT, channel, false);
-    rmt_ll_clear_tx_err_interrupt(&RMT, channel);
-    rmt_ll_clear_tx_end_interrupt(&RMT, channel);
-    rmt_ll_clear_tx_thres_interrupt(&RMT, channel);
-    
-    rmt_ll_tx_enable_loop(&RMT, channel, false);
-    rmt_ll_tx_enable_pingpong(&RMT, channel, true);
-    rmt_ll_tx_set_limit(&RMT, channel, rmtBatchSize);
-
-    driverState[channel] = state;
-
-    rmt_ll_enable_tx_thres_interrupt(&RMT, channel, true);
-
-    return err;
-}
-
-esp_err_t  NeoEsp32RmtHiMethodDriver::Uninstall(rmt_channel_t channel) {
-    if ((channel >= RMT_CHANNEL_MAX) || !driverState || !driverState[channel]) return ESP_ERR_INVALID_ARG;
-
-    NeoEsp32RmtHIChannelState* state = driverState[channel];
-
-    WaitForTxDone(channel, 10000 / portTICK_PERIOD_MS);
-
-    // Done or not, we're out of here
-    rmt_ll_tx_stop(&RMT, channel);
-    rmt_ll_enable_tx_thres_interrupt(&RMT, channel, false);
-    driverState[channel] = nullptr;
-    heap_caps_free(state);
-
-#if !defined(CONFIG_BTDM_CTRL_HLI)  /* Cannot unbind from bluetooth ISR */
-    // Turn off the driver ISR and release global state if none are left
-    for (uint8_t channelIndex = 0; channelIndex < RMT_CHANNEL_MAX; ++channelIndex) {
-        if (driverState[channelIndex]) return ESP_OK; // done
-    }
-
-#if defined(NEOESP32_RMT_CAN_USE_INTR_ALLOC)
-    esp_intr_free(isrHandle);
-#else
-    ESP_INTR_DISABLE(ESP32_LV5_IRQ_INDEX);
-#endif
-
-    heap_caps_free(driverState);
-    driverState = nullptr;
-#endif /* !defined(CONFIG_BTDM_CTRL_HLI) */
-
-    return ESP_OK;
-}
-
-esp_err_t  NeoEsp32RmtHiMethodDriver::Write(rmt_channel_t channel, const uint8_t *src, size_t src_size) {
-    if ((channel >= RMT_CHANNEL_MAX) || !driverState || !driverState[channel]) return ESP_ERR_INVALID_ARG;
-
-    NeoEsp32RmtHIChannelState& state = *driverState[channel];
-    esp_err_t result = WaitForTxDone(channel, 10000 / portTICK_PERIOD_MS);
-
-    if (result == ESP_OK) {
-        state.txDataStart = src;
-        state.txDataCurrent = src;
-        state.txDataEnd = src + src_size;
-        RmtStartWrite(channel, state);
-    }
-    return result;
-}
-
-esp_err_t NeoEsp32RmtHiMethodDriver::WaitForTxDone(rmt_channel_t channel, TickType_t wait_time) {
-    if ((channel >= RMT_CHANNEL_MAX) || !driverState || !driverState[channel]) return ESP_ERR_INVALID_ARG;
-
-    NeoEsp32RmtHIChannelState& state = *driverState[channel];
-    // yield-wait until wait_time
-    esp_err_t rv = ESP_OK;
-    uint32_t status;
-    while(1) {
-        status = rmt_ll_tx_get_channel_status(&RMT, channel);
-        if (!_RmtStatusIsTransmitting(channel, status)) break;
-        if (wait_time == 0) { rv = ESP_ERR_TIMEOUT; break; };
-
-        TickType_t sleep = std::min(wait_time, (TickType_t) 5);
-        vTaskDelay(sleep);
-        wait_time -= sleep;
-    };
-
-    return rv;
-}
-
-#endif

package.json

@@ -1,6 +1,6 @@
 {
   "name": "wled",
-  "version": "16.0.0-beta",
+  "version": "0.15.0-b7",
   "description": "Tools for WLED project",
   "main": "tools/cdata.js",
   "directories": {
@@ -14,21 +14,18 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/wled/WLED.git"
+    "url": "git+https://github.com/Aircoookie/WLED.git"
   },
   "author": "",
   "license": "ISC",
   "bugs": {
-    "url": "https://github.com/wled/WLED/issues"
+    "url": "https://github.com/Aircoookie/WLED/issues"
   },
-  "homepage": "https://github.com/wled/WLED#readme",
+  "homepage": "https://github.com/Aircoookie/WLED#readme",
   "dependencies": {
     "clean-css": "^5.3.3",
     "html-minifier-terser": "^7.2.0",
-    "web-resource-inliner": "^7.0.0",
-    "nodemon": "^3.1.14"
-  },
-  "engines": {
-    "node": ">=20.0.0"
+    "inliner": "^1.13.1",
+    "nodemon": "^3.1.7"
   }
 }

pio-scripts/build_ui.py

@@ -1,21 +1,3 @@
-Import("env")
-import shutil
+Import('env')
 
-node_ex = shutil.which("node")
-# Check if Node.js is installed and present in PATH if it failed, abort the build
-if node_ex is None:
-    print('\x1b[0;31;43m' + 'Node.js is not installed or missing from PATH html css js will not be processed check https://kno.wled.ge/advanced/compiling-wled/' + '\x1b[0m')
-    exitCode = env.Execute("null")
-    exit(exitCode)
-else:
-    # Install the necessary node packages for the pre-build asset bundling script
-    print('\x1b[6;33;42m' + 'Installing node packages' + '\x1b[0m')
-    env.Execute("npm ci")
-
-    # Call the bundling script
-    exitCode = env.Execute("npm run build")
-
-    # If it failed, abort the build
-    if (exitCode):
-      print('\x1b[0;31;43m' + 'npm run build fails check https://kno.wled.ge/advanced/compiling-wled/' + '\x1b[0m')
-      exit(exitCode)
+env.Execute("npm run build")

pio-scripts/dynarray.py

@@ -1,80 +0,0 @@
-# Add a section to the linker script to store our dynamic arrays
-# 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")
-from pathlib import Path
-
-# Linker script fragment injected into the rodata output section of whichever
-# platform we're building for.  Placed just before the end-of-rodata marker so
-# that the dynarray entries land in flash rodata and are correctly sorted.
-DYNARRAY_INJECTION = (
-    "\n    /* dynarray: WLED dynamic module arrays */\n"
-    "    . = ALIGN(0x10);\n"
-    "    KEEP(*(SORT_BY_INIT_PRIORITY(.dynarray.*)))\n"
-    "    "
-)
-
-
-def inject_before_marker(path, marker):
-    """Patch a linker script file in-place, inserting DYNARRAY_INJECTION before marker."""
-    original = path.read_text()
-    path.write_text(original.replace(marker, DYNARRAY_INJECTION + marker, 1))
-
-
-if env.get("PIOPLATFORM") == "espressif32":
-    # Find sections.ld on the linker search path (LIBPATH).
-    sections_ld_path = None
-    for ld_dir in env.get("LIBPATH", []):
-        candidate = Path(str(ld_dir)) / "sections.ld"
-        if candidate.exists():
-            sections_ld_path = candidate
-            break
-
-    if sections_ld_path is not None:
-        # Inject inside the existing .flash.rodata output section, just before
-        # _rodata_end.  IDF v5 enforces zero gaps between adjacent output
-        # sections via ASSERT statements, so INSERT AFTER .flash.rodata would
-        # fail.  Injecting inside the section creates no new output section and
-        # 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(.);")
-
-        # Replace "sections.ld" in LINKFLAGS with an absolute path to our
-        # patched copy.  The flag may appear as a bare token, combined as
-        # "-Tsections.ld", or split across two tokens ("-T", "sections.ld").
-        patched_str = str(patched_path)
-        new_flags = []
-        skip_next = False
-        for flag in env.get("LINKFLAGS", []):
-            if skip_next:
-                new_flags.append(patched_str if flag == "sections.ld" else flag)
-                skip_next = False
-            elif flag == "-T":
-                new_flags.append(flag)
-                skip_next = True
-            else:
-                new_flags.append(flag.replace("sections.ld", patched_str))
-        env.Replace(LINKFLAGS=new_flags)
-    else:
-        # Assume sections.ld will be built (ESP-IDF format); add a post-action to patch it
-        # TODO: consider using ESP-IDF linker fragment (https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/linker-script-generation.html)
-        # For now, patch after building
-        sections_ld = Path(env.subst("$BUILD_DIR")) / "sections.ld"
-        def patch_sections_ld(target, source, env):
-            inject_before_marker(sections_ld, "_rodata_end = ABSOLUTE(.);")
-        env.AddPostAction(str(sections_ld), patch_sections_ld)
-    
-elif env.get("PIOPLATFORM") == "espressif8266":
-    # The ESP8266 framework preprocesses eagle.app.v6.common.ld.h into
-    # local.eagle.app.v6.common.ld in $BUILD_DIR/ld/ at build time.  Register
-    # a post-action on that generated file so the injection happens after
-    # C-preprocessing but before linking.
-    build_ld = Path(env.subst("$BUILD_DIR")) / "ld" / "local.eagle.app.v6.common.ld"
-
-    def patch_esp8266_ld(target, source, env):
-        inject_before_marker(build_ld, "_irom0_text_end = ABSOLUTE(.);")
-
-    env.AddPostAction(str(build_ld), patch_esp8266_ld)

pio-scripts/load_usermods.py

@@ -1,210 +0,0 @@
-Import('env')
-from collections import deque
-from pathlib import Path   # For OS-agnostic path manipulation
-import re
-from urllib.parse import urlparse
-from click import secho
-from SCons.Script import Exit
-from platformio.builder.tools.piolib import LibBuilderBase
-
-usermod_dir = Path(env["PROJECT_DIR"]).resolve() / "usermods"
-
-# Utility functions
-def find_usermod(mod: str) -> Path:
-  """Locate this library in the usermods folder.
-     We do this to avoid needing to rename a bunch of folders;
-     this could be removed later
-  """
-  # Check name match
-  mp = usermod_dir / mod
-  if mp.exists():
-    return mp
-  mp = usermod_dir / f"{mod}_v2"
-  if mp.exists():
-    return mp
-  mp = usermod_dir / f"usermod_v2_{mod}"
-  if mp.exists():
-    return mp
-  raise RuntimeError(f"Couldn't locate module {mod} in usermods directory!")
-
-# Names of external/registry deps listed in custom_usermods.
-# Populated during parsing below; read by is_wled_module() at configure time.
-_custom_usermod_names: set[str] = set()
-
-# Matches any RFC-valid URL scheme (http, https, git, git+https, symlink, file, hg+ssh, etc.)
-_URL_SCHEME_RE = re.compile(r'^[a-zA-Z][a-zA-Z0-9+.-]*://')
-# SSH git URL: user@host:path  (e.g. git@github.com:user/repo.git#tag)
-_SSH_URL_RE = re.compile(r'^[^@\s]+@[^@:\s]+:[^:\s]')
-# Explicit custom name: "LibName = <spec>"  (PlatformIO [<name>=]<spec> form)
-_NAME_EQ_RE = re.compile(r'^([A-Za-z0-9_.-]+)\s*=\s*(\S.*)')
-
-
-def _is_external_entry(line: str) -> bool:
-  """Return True if line is a lib_deps-style external/registry entry."""
-  if _NAME_EQ_RE.match(line):              # "LibName = <spec>"
-    return True
-  if _URL_SCHEME_RE.match(line):           # https://, git://, symlink://, etc.
-    return True
-  if _SSH_URL_RE.match(line):              # git@github.com:user/repo.git
-    return True
-  if '@' in line:                          # "owner/Name @ ^1.0.0"
-    return True
-  if re.match(r'^[^/\s]+/[^/\s]+$', line):  # "owner/Name"
-    return True
-  return False
-
-
-def _predict_dep_name(entry: str) -> str | None:
-  """Predict the library name PlatformIO will assign to this dep (best-effort).
-
-  Accuracy relies on the library's manifest "name" matching the repo/package
-  name in the spec. This holds for well-authored libraries; the libArchive
-  check (which requires library.json) provides an early-failure safety net.
-  """
-  entry = entry.strip()
-  # "LibName = <spec>" — name is given explicitly; always use it
-  m = _NAME_EQ_RE.match(entry)
-  if m:
-    return m.group(1).strip()
-  # URL scheme: extract name from path
-  if _URL_SCHEME_RE.match(entry):
-    parsed = urlparse(entry)
-    if parsed.netloc in ('github.com', 'gitlab.com', 'bitbucket.com'):
-      parts = [p for p in parsed.path.split('/') if p]
-      if len(parts) >= 2:
-        name = parts[1]
-      else:
-        name = Path(parsed.path.rstrip('/')).name.strip()
-      if name.endswith('.git'):
-        name = name[:-4]
-      return name or None
-  # SSH git URL: git@github.com:user/repo.git#tag → repo
-  if _SSH_URL_RE.match(entry):
-    path_part = entry.split(':', 1)[1].split('#')[0].rstrip('/')
-    name = Path(path_part).name
-    return (name[:-4] if name.endswith('.git') else name) or None
-  # Versioned registry: "owner/Name @ version" → Name
-  if '@' in entry:
-    name_part = entry.split('@')[0].strip()
-    return name_part.split('/')[-1].strip() if '/' in name_part else name_part
-  # Plain registry: "owner/Name" → Name
-  if re.match(r'^[^/\s]+/[^/\s]+$', entry):
-    return entry.split('/')[-1].strip()
-  return None
-
-
-def is_wled_module(dep: LibBuilderBase) -> bool:
-  """Returns true if the specified library is a wled module."""
-  return (
-    usermod_dir in Path(dep.src_dir).parents
-    or str(dep.name).startswith("wled-")
-    or dep.name in _custom_usermod_names
-  )
-
-
-## Script starts here — parse custom_usermods
-raw_usermods = env.GetProjectOption("custom_usermods", "")
-usermods_libdeps: list[str] = []
-
-for line in raw_usermods.splitlines():
-  line = line.strip()
-  if not line or line.startswith('#') or line.startswith(';'):
-    continue
-
-  if _is_external_entry(line):
-    # External URL or registry entry: pass through to lib_deps unchanged.
-    predicted = _predict_dep_name(line)
-    if predicted:
-      _custom_usermod_names.add(predicted)
-    else:
-      secho(
-        f"WARNING: Cannot determine library name for custom_usermods entry "
-        f"{line!r}. If it is not recognised as a WLED module at build time, "
-        f"ensure its library.json 'name' matches the repo name.",
-        fg="yellow", err=True)
-    usermods_libdeps.append(line)
-  else:
-    # Bare name(s): split on whitespace for backwards compatibility.
-    for token in line.split():
-      if token == '*':
-        for mod_path in sorted(usermod_dir.iterdir()):
-          if mod_path.is_dir() and (mod_path / 'library.json').exists():
-            _custom_usermod_names.add(mod_path.name)
-            usermods_libdeps.append(f"symlink://{mod_path.resolve()}")
-      else:
-        resolved = find_usermod(token)
-        _custom_usermod_names.add(resolved.name)
-        usermods_libdeps.append(f"symlink://{resolved.resolve()}")
-
-if usermods_libdeps:
-  env.GetProjectConfig().set("env:" + env['PIOENV'], 'lib_deps', env.GetProjectOption('lib_deps') + usermods_libdeps)
-
-# Utility function for assembling usermod include paths
-def cached_add_includes(dep, dep_cache: set, includes: deque):
-  """ Add dep's include paths to includes if it's not in the cache """
-  if dep not in dep_cache:
-    dep_cache.add(dep)
-    for include in dep.get_include_dirs():
-      if include not in includes:
-        includes.appendleft(include)
-      if usermod_dir not in Path(dep.src_dir).parents:
-        # Recurse, but only for NON-usermods
-        for subdep in dep.depbuilders:
-          cached_add_includes(subdep, dep_cache, includes)
-
-# Monkey-patch ConfigureProjectLibBuilder to mark up the dependencies
-# Save the old value
-old_ConfigureProjectLibBuilder = env.ConfigureProjectLibBuilder
-
-# Our new wrapper
-def wrapped_ConfigureProjectLibBuilder(xenv):
-  # Call the wrapped function
-  result = old_ConfigureProjectLibBuilder.clone(xenv)()
-
-  # Fix up include paths
-  # In PlatformIO >=6.1.17, this could be done prior to ConfigureProjectLibBuilder
-  wled_dir = xenv["PROJECT_SRC_DIR"]
-  # Build a list of dependency include dirs
-  # TODO: Find out if this is the order that PlatformIO/SCons puts them in??
-  processed_deps = set()
-  extra_include_dirs = deque()  # Deque used for fast prepend
-  for dep in result.depbuilders:
-     cached_add_includes(dep, processed_deps, extra_include_dirs)
-
-  wled_deps = [dep for dep in result.depbuilders if is_wled_module(dep)]
-
-  broken_usermods = []
-  for dep in wled_deps:
-    # Add the wled folder to the include path
-    dep.env.PrependUnique(CPPPATH=str(wled_dir))
-    # Add WLED's own dependencies
-    for dir in extra_include_dirs:
-      dep.env.PrependUnique(CPPPATH=str(dir))
-    # Ensure debug info is emitted for this module's source files.
-    # validate_modules.py uses `nm --defined-only -l` on the final ELF to check
-    # that each module has at least one symbol placed in the binary.  The -l flag
-    # reads DWARF debug sections to map placed symbols back to their original source
-    # files; without -g those sections are absent and the check cannot attribute any
-    # symbol to a specific module.  We scope this to usermods only — the main WLED
-    # build and other libraries are unaffected.
-    dep.env.AppendUnique(CCFLAGS=["-g"])
-    # Enforce that libArchive is not set; we must link them directly to the executable
-    if dep.lib_archive:
-      broken_usermods.append(dep)
-
-  if broken_usermods:
-    broken_usermods = [usermod.name for usermod in broken_usermods]
-    secho(
-      f"ERROR: libArchive=false is missing on usermod(s) {' '.join(broken_usermods)} -- "
-      f"modules will not compile in correctly. Add '\"build\": {{\"libArchive\": false}}' "
-      f"to their library.json.",
-      fg="red", err=True)
-    Exit(1)
-
-  # Save the depbuilders list for later validation
-  xenv.Replace(WLED_MODULES=wled_deps)
-
-  return result
-
-# Apply the wrapper
-env.AddMethod(wrapped_ConfigureProjectLibBuilder, "ConfigureProjectLibBuilder")

pio-scripts/output_bins.py

@@ -2,7 +2,6 @@ Import('env')
 import os
 import shutil
 import gzip
-import json
 
 OUTPUT_DIR = "build_output{}".format(os.path.sep)
 #OUTPUT_DIR = os.path.join("build_output")
@@ -20,11 +19,9 @@ def _create_dirs(dirs=["map", "release", "firmware"]):
         os.makedirs(os.path.join(OUTPUT_DIR, d), exist_ok=True)
 
 def create_release(source):
-    release_name_def = _get_cpp_define_value(env, "WLED_RELEASE_NAME")
-    if release_name_def:
-        release_name = release_name_def.replace("\\\"", "")
-        with open("package.json", "r") as package:
-            version = json.load(package)["version"]        
+    release_name = _get_cpp_define_value(env, "WLED_RELEASE_NAME")
+    if release_name:
+        version = _get_cpp_define_value(env, "WLED_VERSION")
         release_file = os.path.join(OUTPUT_DIR, "release", f"WLED_{version}_{release_name}.bin")
         release_gz_file = release_file + ".gz"
         print(f"Copying {source} to {release_file}")

pio-scripts/set_metadata.py

@@ -1,116 +0,0 @@
-Import('env')
-import subprocess
-import json
-import re
-
-def get_github_repo():
-    """Extract GitHub repository name from git remote URL.
-    
-    Uses the remote that the current branch tracks, falling back to 'origin'.
-    This handles cases where repositories have multiple remotes or where the
-    main remote is not named 'origin'.
-    
-    Returns:
-        str: Repository name in 'owner/repo' format for GitHub repos,
-             'unknown' for non-GitHub repos, missing git CLI, or any errors.
-    """
-    try:
-        remote_name = 'origin'  # Default fallback
-        
-        # Try to get the remote for the current branch
-        try:
-            # Get current branch name
-            branch_result = subprocess.run(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], 
-                                         capture_output=True, text=True, check=True)
-            current_branch = branch_result.stdout.strip()
-            
-            # Get the remote for the current branch
-            remote_result = subprocess.run(['git', 'config', f'branch.{current_branch}.remote'], 
-                                         capture_output=True, text=True, check=True)
-            tracked_remote = remote_result.stdout.strip()
-            
-            # Use the tracked remote if we found one
-            if tracked_remote:
-                remote_name = tracked_remote
-        except subprocess.CalledProcessError:
-            # If branch config lookup fails, continue with 'origin' as fallback
-            pass
-        
-        # Get the remote URL for the determined remote
-        result = subprocess.run(['git', 'remote', 'get-url', remote_name], 
-                              capture_output=True, text=True, check=True)
-        remote_url = result.stdout.strip()
-        
-        # Check if it's a GitHub URL
-        if 'github.com' not in remote_url.lower():
-            return None
-        
-        # Parse GitHub URL patterns:
-        # https://github.com/owner/repo.git
-        # git@github.com:owner/repo.git
-        # https://github.com/owner/repo
-        
-        # Remove .git suffix if present
-        if remote_url.endswith('.git'):
-            remote_url = remote_url[:-4]
-        
-        # Handle HTTPS URLs
-        https_match = re.search(r'github\.com/([^/]+/[^/]+)', remote_url, re.IGNORECASE)
-        if https_match:
-            return https_match.group(1)
-        
-        # Handle SSH URLs
-        ssh_match = re.search(r'github\.com:([^/]+/[^/]+)', remote_url, re.IGNORECASE)
-        if ssh_match:
-            return ssh_match.group(1)
-        
-        return None
-        
-    except FileNotFoundError:
-        # Git CLI is not installed or not in PATH
-        return None
-    except subprocess.CalledProcessError:
-        # Git command failed (e.g., not a git repo, no remote, etc.)
-        return None
-    except Exception:
-        # Any other unexpected error
-        return None
-
-# WLED version is managed by package.json; this is picked up in several places
-# - It's integrated in to the UI code
-# - Here, for wled_metadata.cpp
-# - The output_bins script
-# We always take it from package.json to ensure consistency
-with open("package.json", "r") as package:
-    WLED_VERSION = json.load(package)["version"]
-
-def has_def(cppdefs, name):
-    """ Returns true if a given name is set in a CPPDEFINES collection """
-    for f in cppdefs:
-        if isinstance(f, tuple):
-            f = f[0]
-        if f == name:
-            return True
-    return False
-
-
-def add_wled_metadata_flags(env, node):    
-    cdefs = env["CPPDEFINES"].copy()
-
-    if not has_def(cdefs, "WLED_REPO"):
-        repo = get_github_repo()
-        if repo:
-            cdefs.append(("WLED_REPO", f"\\\"{repo}\\\""))
-
-    cdefs.append(("WLED_VERSION", WLED_VERSION))
-
-    # This transforms the node in to a Builder; it cannot be modified again
-    return env.Object(
-        node,
-        CPPDEFINES=cdefs
-    )
-   
-env.AddBuildMiddleware(
-    add_wled_metadata_flags,
-    "*/wled_metadata.cpp"
-)

pio-scripts/set_version.py

@@ -0,0 +1,8 @@
+Import('env')
+import json
+
+PACKAGE_FILE = "package.json"
+
+with open(PACKAGE_FILE, "r") as package:
+    version = json.load(package)["version"]
+    env.Append(BUILD_FLAGS=[f"-DWLED_VERSION={version}"])

pio-scripts/validate_modules.py

@@ -1,170 +0,0 @@
-import re
-import subprocess
-from pathlib import Path
-from click import secho
-from SCons.Script import Action, Exit
-Import("env")
-
-_ATTR = re.compile(r'\bDW_AT_(name|comp_dir)\b')
-
-
-def read_lines(p: Path):
-    """ Read in the contents of a file for analysis """
-    with p.open("r", encoding="utf-8", errors="ignore") as f:
-        return f.readlines()
-
-
-def _get_readelf_path(env) -> str:
-    """ Derive the readelf tool path from the build environment """
-    # Derive from the C compiler: xtensa-esp32-elf-gcc → xtensa-esp32-elf-readelf
-    cc = Path(env.subst("$CC"))
-    return str(cc.with_name(re.sub(r'(gcc|g\+\+)$', 'readelf', cc.name)))
-
-
-def check_elf_modules(elf_path: Path, env, module_lib_builders) -> set[str]:
-    """ Check which modules have at least one compilation unit in the ELF.
-
-        The map file is not a reliable source for this: with LTO, original object
-        file paths are replaced by temporary ltrans.o partitions in all output
-        sections, making per-module attribution impossible from the map alone.
-        Instead we invoke readelf --debug-dump=info --dwarf-depth=1 on the ELF,
-        which reads only the top-level compilation-unit DIEs from .debug_info.
-        Each CU corresponds to one source file; matching DW_AT_comp_dir +
-        DW_AT_name against the module src_dirs is sufficient to confirm a module
-        was compiled into the ELF.  The output volume is proportional to the
-        number of source files, not the number of symbols.
-
-        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
-    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
-
-    remaining = {Path(str(b.src_dir)): Path(b.build_dir).name for b in module_lib_builders}
-    found = set()
-    project_dir = Path(env.subst("$PROJECT_DIR"))
-
-    def _flush_cu(comp_dir: str | None, name: str | None) -> None:
-        """Match one completed CU against remaining builders."""
-        if not name or not remaining:
-            return
-        p = Path(name)
-        src_path = (Path(comp_dir) / p) if (comp_dir and not p.is_absolute()) else p
-        # In arduino+espidf dual-framework builds the IDF toolchain sets DW_AT_comp_dir
-        # to the virtual path "/IDF_PROJECT" rather than the real project root, so
-        # src_path won't match.  Pre-compute a fallback using $PROJECT_DIR and check
-        # both candidates in a single pass.
-        use_fallback = not p.is_absolute() and comp_dir and Path(comp_dir) != project_dir
-        src_path_real = project_dir / p if use_fallback else None
-        for src_dir in list(remaining):
-            if src_path.is_relative_to(src_dir) or (src_path_real and src_path_real.is_relative_to(src_dir)):
-                found.add(remaining.pop(src_dir))
-                return
-
-    # readelf emits one DW_TAG_compile_unit DIE per source file.  Attributes
-    # of interest:
-    #   DW_AT_name     — source file (absolute, or relative to comp_dir)
-    #   DW_AT_comp_dir — compile working directory
-    # Both appear as either a direct string or an indirect string:
-    #   DW_AT_name     : foo.cpp
-    #   DW_AT_name     : (indirect string, offset: 0x…): foo.cpp
-    # Taking the portion after the *last* ": " on the line handles both forms.
-
-    comp_dir = name = None
-    for line in output.splitlines():
-        if 'Compilation Unit @' in line:
-            _flush_cu(comp_dir, name)
-            comp_dir = name = None
-            continue
-        if not remaining:
-            break  # all builders matched
-        m = _ATTR.search(line)
-        if m:
-            _, _, val = line.rpartition(': ')
-            val = val.strip()
-            if m.group(1) == 'name':
-                name = val
-            else:
-                comp_dir = val
-    _flush_cu(comp_dir, name)  # flush the last CU
-
-    return found
-
-
-def count_usermod_objects(map_file: list[str]) -> int:
-    """ Returns the number of usermod objects in the usermod list.
-
-    Computes the count from the address span between the .dynarray.usermods.0
-    and .dynarray.usermods.99999 sentinel sections.  This mirrors the
-    DYNARRAY_LENGTH macro and is reliable under LTO, where all entries are
-    merged into a single ltrans partition so counting section occurrences
-    always yields 1 regardless of the true count.
-    """
-    ENTRY_SIZE = 4  # sizeof(Usermod*) on 32-bit targets
-    addr_begin = None
-    addr_end = None
-
-    for i, line in enumerate(map_file):
-        stripped = line.strip()
-        if stripped == '.dynarray.usermods.0':
-            if i + 1 < len(map_file):
-                m = re.search(r'0x([0-9a-fA-F]+)', map_file[i + 1])
-                if m:
-                    addr_begin = int(m.group(1), 16)
-        elif stripped == '.dynarray.usermods.99999':
-            if i + 1 < len(map_file):
-                m = re.search(r'0x([0-9a-fA-F]+)', map_file[i + 1])
-                if m:
-                    addr_end = int(m.group(1), 16)
-        if addr_begin is not None and addr_end is not None:
-            break
-
-    if addr_begin is None or addr_end is None:
-        return 0
-    return (addr_end - addr_begin) // ENTRY_SIZE
-
-
-def validate_map_file(source, target, env):
-    """ Validate that all modules appear in the output build """
-    build_dir = Path(env.subst("$BUILD_DIR"))
-    map_file_path = build_dir / env.subst("${PROGNAME}.map")
-
-    if not map_file_path.exists():
-        secho(f"ERROR: Map file not found: {map_file_path}", fg="red", err=True)
-        Exit(1)
-
-    # Identify the WLED module builders, set by load_usermods.py
-    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 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")
-
-    elf_path = build_dir / env.subst("${PROGNAME}.elf")
-
-    confirmed_modules = check_elf_modules(elf_path, env, module_lib_builders)
-
-    missing_modules = [modname for mdir, modname in modules.items() if mdir not in confirmed_modules]
-    if missing_modules:
-        secho(
-            f"ERROR: No symbols from {missing_modules} found in linked output!",
-            fg="red",
-            err=True)
-        Exit(1)
-
-env.Append(LINKFLAGS=[env.subst("-Wl,--Map=${BUILD_DIR}/${PROGNAME}.map")])
-env.AddPostAction("$BUILD_DIR/${PROGNAME}.elf", Action(validate_map_file, cmdstr='Checking linked optional modules (usermods) in map file'))

platformio.ini

@@ -10,28 +10,7 @@
 # ------------------------------------------------------------------------------
 
 # CI/release binaries
-default_envs = nodemcuv2
-               esp8266_2m
-               esp01_1m_full
-               nodemcuv2_160
-               esp8266_2m_160
-               esp01_1m_full_160
-               nodemcuv2_compat
-               esp8266_2m_compat
-               esp01_1m_full_compat
-               esp32dev
-               esp32dev_debug
-               esp32_eth
-               esp32_wrover
-               lolin_s2_mini
-               esp32c3dev
-               esp32c3dev_qio
-               esp32S3_wroom2
-               esp32s3dev_16MB_opi
-               esp32s3dev_8MB_opi
-               esp32s3dev_8MB_qspi
-               esp32s3_4M_qspi
-               usermods
+default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, nodemcuv2_160, esp8266_2m_160, esp01_1m_full_160, nodemcuv2_compat, esp8266_2m_compat, esp01_1m_full_compat, esp32dev, esp32_eth, lolin_s2_mini, esp32c3dev, esp32s3dev_16MB_opi, esp32s3dev_8MB_opi, esp32s3_4M_qspi, esp32_wrover
 
 src_dir  = ./wled00
 data_dir = ./wled00/data
@@ -121,7 +100,6 @@ build_flags =
   -D DECODE_SAMSUNG=true
   -D DECODE_LG=true
   -DWLED_USE_MY_CONFIG
-  -D WLED_PS_DONT_REPLACE_FX ; PS replacement FX are purely a flash memory saving feature, do not replace classic FX until we run out of flash
 
 build_unflags =
 
@@ -132,14 +110,11 @@ ldscript_4m1m = eagle.flash.4m1m.ld
 
 [scripts_defaults]
 extra_scripts =
-  pre:pio-scripts/set_metadata.py
+  pre:pio-scripts/set_version.py
   post:pio-scripts/output_bins.py
   post:pio-scripts/strip-floats.py
-  post:pio-scripts/dynarray.py
   pre:pio-scripts/user_config_copy.py
-  pre:pio-scripts/load_usermods.py
   pre:pio-scripts/build_ui.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)
 
 # ------------------------------------------------------------------------------
@@ -161,10 +136,11 @@ upload_speed = 115200
 # ------------------------------------------------------------------------------
 lib_compat_mode = strict
 lib_deps =
+    fastled/FastLED @ 3.6.0
     IRremoteESP8266 @ 2.8.2
-    https://github.com/Makuna/NeoPixelBus.git#a0919d1c10696614625978dd6fb750a1317a14ce
-    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.2
-    marvinroger/AsyncMqttClient @ 0.9.0
+    makuna/NeoPixelBus @ 2.8.0
+    #https://github.com/makuna/NeoPixelBus.git#CoreShaderBeta
+    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.2.1
   # for I2C interface
     ;Wire
   # ESP-NOW library
@@ -181,18 +157,25 @@ lib_deps =
     ;adafruit/Adafruit BMP280 Library @ 2.1.0
     ;adafruit/Adafruit CCS811 Library @ 1.0.4
     ;adafruit/Adafruit Si7021 Library @ 1.4.0
+  #For ADS1115 sensor uncomment following
+    ;adafruit/Adafruit BusIO @ 1.13.2
+    ;adafruit/Adafruit ADS1X15 @ 2.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
+  # For -D USERMOD_ANIMARTRIX
+  # CC BY-NC 3.0 licensed effects by Stefan Petrick, include this usermod only if you accept the terms!
+    ;https://github.com/netmindz/animartrix.git#18bf17389e57c69f11bc8d04ebe1d215422c7fb7
   # SHT85
     ;robtillaart/SHT85@~0.3.3
+  # Audioreactive usermod
+    ;kosme/arduinoFFT @ 2.0.1
 
 extra_scripts = ${scripts_defaults.extra_scripts}
 
 [esp8266]
-build_unflags = ${common.build_unflags}
 build_flags =
   -DESP8266
   -DFP_IN_IROM
@@ -248,117 +231,108 @@ lib_deps_compat =
   ESPAsyncTCP @ 1.2.2
   ESPAsyncUDP
   ESP8266PWM
+  fastled/FastLED @ 3.6.0
   IRremoteESP8266 @ 2.8.2
   makuna/NeoPixelBus @ 2.7.9
   https://github.com/blazoncek/QuickESPNow.git#optional-debug
-  https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.0
+  https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.2.1
 
-[esp32_all_variants]
-lib_deps =
-  esp32async/AsyncTCP @ 3.4.7
-  bitbank2/AnimatedGIF@^1.4.7
-  https://github.com/Aircoookie/GifDecoder.git#bc3af189b6b1e06946569f6b4287f0b79a860f8e
-build_flags =
-  -D CONFIG_ASYNC_TCP_USE_WDT=0
-  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
-  -D WLED_ENABLE_GIF
 
 [esp32]
-platform = ${esp32_idf_V4.platform}
-platform_packages =
-build_unflags = ${common.build_unflags}
-build_flags = ${esp32_idf_V4.build_flags}
-lib_deps = ${esp32_idf_V4.lib_deps}
-
+#platform = https://github.com/tasmota/platform-espressif32/releases/download/v2.0.2.3/platform-espressif32-2.0.2.3.zip
+platform = espressif32@3.5.0
+platform_packages = framework-arduinoespressif32 @ https://github.com/Aircoookie/arduino-esp32.git#1.0.6.4
+build_flags = -g
+  -DARDUINO_ARCH_ESP32
+  #-DCONFIG_LITTLEFS_FOR_IDF_3_2
+  -D CONFIG_ASYNC_TCP_USE_WDT=0
+  #use LITTLEFS library by lorol in ESP32 core 1.x.x instead of built-in in 2.x.x
+  -D LOROL_LITTLEFS
+  ; -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
 tiny_partitions = tools/WLED_ESP32_2MB_noOTA.csv
 default_partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
 extended_partitions = tools/WLED_ESP32_4MB_700k_FS.csv
 big_partitions = tools/WLED_ESP32_4MB_256KB_FS.csv     ;; 1.8MB firmware, 256KB filesystem, coredump support
 large_partitions = tools/WLED_ESP32_8MB.csv
 extreme_partitions = tools/WLED_ESP32_16MB_9MB_FS.csv
-
-board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
-# additional build flags for audioreactive - must be applied globally
-AR_build_flags = ;; -fsingle-precision-constant ;; forces ArduinoFFT to use float math (2x faster)
-AR_lib_deps =  ;; for pre-usermod-library platformio_override compatibility
-
+lib_deps =
+  https://github.com/lorol/LITTLEFS.git
+  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  ${env.lib_deps}
+# additional build flags for audioreactive
+AR_build_flags = -D USERMOD_AUDIOREACTIVE 
+  -D sqrt_internal=sqrtf ;; -fsingle-precision-constant ;; forces ArduinoFFT to use float math (2x faster)
+AR_lib_deps = kosme/arduinoFFT @ 2.0.1
 
 [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
+;; experimental build environment for ESP32 using ESP-IDF 4.4.x / arduino-esp32 v2.0.5
+;; very similar to the normal ESP32 flags, but omitting Lorol LittleFS, as littlefs is included in the new framework already.
 ;;
 ;; please note that you can NOT update existing ESP32 installs with a "V4" build. Also updating by OTA will not work properly.
 ;; You need to completely erase your device (esptool erase_flash) first, then install the "V4" build from VSCode+platformio.
-
-platform = https://github.com/tasmota/platform-espressif32/releases/download/2024.06.00/platform-espressif32.zip ;; Tasmota Arduino Core 2.0.18 with IPv6 support, based on IDF 4.4.8
-platform_packages =
-build_unflags = ${common.build_unflags}
+platform = espressif32@ ~6.3.2
+platform_packages = platformio/framework-arduinoespressif32 @ 3.20009.0    ;; select arduino-esp32 v2.0.9 (arduino-esp32 2.0.10 thru 2.0.14 are buggy so avoid them)
 build_flags = -g
   -Wshadow=compatible-local ;; emit warning in case a local variable "shadows" another local one
   -DARDUINO_ARCH_ESP32 -DESP32
-  ${esp32_all_variants.build_flags}
-  -D WLED_ENABLE_DMX_INPUT
+  -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
 lib_deps =
-  ${esp32_all_variants.lib_deps}
-  https://github.com/someweisguy/esp_dmx.git#47db25d8c515e76fabcf5fc5ab0b786f98eeade0
+  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
   ${env.lib_deps}
 
 [esp32s2]
 ;; generic definitions for all ESP32-S2 boards
-platform = ${esp32_idf_V4.platform}
-platform_packages = ${esp32_idf_V4.platform_packages}
-build_unflags = ${common.build_unflags}
+platform = espressif32@ ~6.3.2
+platform_packages = platformio/framework-arduinoespressif32 @ 3.20009.0    ;; select arduino-esp32 v2.0.9 (arduino-esp32 2.0.10 thru 2.0.14 are buggy so avoid them)
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32S2
   -DCONFIG_IDF_TARGET_ESP32S2=1
+  -D CONFIG_ASYNC_TCP_USE_WDT=0
   -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_USB_DFU_ON_BOOT=0
   -DCO
   -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_V4.build_flags}
 lib_deps =
-  ${esp32_idf_V4.lib_deps}
-board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
+  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  ${env.lib_deps}
 
 [esp32c3]
 ;; generic definitions for all ESP32-C3 boards
-platform = ${esp32_idf_V4.platform}
-platform_packages = ${esp32_idf_V4.platform_packages}
-build_unflags = ${common.build_unflags}
+platform = espressif32@ ~6.3.2
+platform_packages = platformio/framework-arduinoespressif32 @ 3.20009.0    ;; select arduino-esp32 v2.0.9 (arduino-esp32 2.0.10 thru 2.0.14 are buggy so avoid them)
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32C3
   -DCONFIG_IDF_TARGET_ESP32C3=1
+  -D CONFIG_ASYNC_TCP_USE_WDT=0
   -DCO
   -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_V4.build_flags}
 lib_deps =
-  ${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
+  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  ${env.lib_deps}
 
 [esp32s3]
 ;; generic definitions for all ESP32-S3 boards
-platform = ${esp32_idf_V4.platform}
-platform_packages = ${esp32_idf_V4.platform_packages}
-build_unflags = ${common.build_unflags}
+platform = espressif32@ ~6.3.2
+platform_packages = platformio/framework-arduinoespressif32 @ 3.20009.0    ;; select arduino-esp32 v2.0.9 (arduino-esp32 2.0.10 thru 2.0.14 are buggy so avoid them)
 build_flags = -g
   -DESP32
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32S3
   -DCONFIG_IDF_TARGET_ESP32S3=1
+  -D CONFIG_ASYNC_TCP_USE_WDT=0
   -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_DFU_ON_BOOT=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_V4.build_flags}
 lib_deps =
-  ${esp32_idf_V4.lib_deps}
-board_build.partitions = ${esp32.large_partitions}   ;; default partioning for 8MB flash - can be overridden in build envs
+  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  ${env.lib_deps}
 
 
 # ------------------------------------------------------------------------------
@@ -371,8 +345,7 @@ 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
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=ESP8266 #-DWLED_DISABLE_2D
 lib_deps = ${esp8266.lib_deps}
 monitor_filters = esp8266_exception_decoder
 
@@ -381,16 +354,14 @@ extends = env:nodemcuv2
 ;; using platform version and build options from WLED 0.14.0
 platform = ${esp8266.platform_compat}
 platform_packages = ${esp8266.platform_packages_compat}
-build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=\"ESP8266_compat\" #-DWLED_DISABLE_2D
-  -D WLED_DISABLE_PARTICLESYSTEM2D
+build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=ESP8266_compat #-DWLED_DISABLE_2D
 ;; lib_deps = ${esp8266.lib_deps_compat} ;; experimental - use older NeoPixelBus 2.7.9
 
 [env:nodemcuv2_160]
 extends = env:nodemcuv2
 board_build.f_cpu = 160000000L
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP8266_160\" #-DWLED_DISABLE_2D
-  -D WLED_DISABLE_PARTICLESYSTEM2D
-custom_usermods = audioreactive
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=ESP8266_160 #-DWLED_DISABLE_2D
+  -D USERMOD_AUDIOREACTIVE
 
 [env:esp8266_2m]
 board = esp_wroom_02
@@ -398,9 +369,7 @@ 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
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=ESP02
 lib_deps = ${esp8266.lib_deps}
 
 [env:esp8266_2m_compat]
@@ -408,17 +377,13 @@ extends = env:esp8266_2m
 ;; using platform version and build options from WLED 0.14.0
 platform = ${esp8266.platform_compat}
 platform_packages = ${esp8266.platform_packages_compat}
-build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=\"ESP02_compat\" #-DWLED_DISABLE_2D
-  -D WLED_DISABLE_PARTICLESYSTEM1D
-  -D WLED_DISABLE_PARTICLESYSTEM2D
+build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=ESP02_compat #-DWLED_DISABLE_2D
 
 [env:esp8266_2m_160]
 extends = env:esp8266_2m
 board_build.f_cpu = 160000000L
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP02_160\"
-  -D WLED_DISABLE_PARTICLESYSTEM1D
-  -D WLED_DISABLE_PARTICLESYSTEM2D
-custom_usermods = audioreactive
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=ESP02_160
+  -D USERMOD_AUDIOREACTIVE
 
 [env:esp01_1m_full]
 board = esp01_1m
@@ -426,11 +391,8 @@ 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
+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]
@@ -438,66 +400,52 @@ extends = env:esp01_1m_full
 ;; using platform version and build options from WLED 0.14.0
 platform = ${esp8266.platform_compat}
 platform_packages = ${esp8266.platform_packages_compat}
-build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=\"ESP01_compat\" -D WLED_DISABLE_OTA #-DWLED_DISABLE_2D
-  -D WLED_DISABLE_PARTICLESYSTEM1D
-  -D WLED_DISABLE_PARTICLESYSTEM2D
-  -D WLED_DISABLE_PIXELFORGE
+build_flags = ${common.build_flags} ${esp8266.build_flags_compat} -D WLED_RELEASE_NAME=ESP01_compat -D WLED_DISABLE_OTA #-DWLED_DISABLE_2D
 
 [env:esp01_1m_full_160]
 extends = env:esp01_1m_full
 board_build.f_cpu = 160000000L
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP01_160\" -D WLED_DISABLE_OTA
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=ESP01_160 -D WLED_DISABLE_OTA
+  -D USERMOD_AUDIOREACTIVE
   ; -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
-custom_usermods = audioreactive
 
 [env:esp32dev]
 board = esp32dev
-platform = ${esp32_idf_V4.platform}
-platform_packages = ${esp32_idf_V4.platform_packages}
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
 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
-lib_deps = ${esp32_idf_V4.lib_deps}
+build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=ESP32 #-D WLED_DISABLE_BROWNOUT_DET
+  ${esp32.AR_build_flags}
+lib_deps = ${esp32.lib_deps}
+  ${esp32.AR_lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.default_partitions}
-board_build.flash_mode = dio
-
-[env:esp32dev_debug]
-extends = env:esp32dev
-upload_speed = 921600
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags}
-              -D WLED_DEBUG
-              -D WLED_RELEASE_NAME=\"ESP32_DEBUG\"
 
 [env:esp32dev_8M]
 board = esp32dev
 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
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=ESP32_8M #-D WLED_DISABLE_BROWNOUT_DET
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32_idf_V4.lib_deps}
+  ${esp32.AR_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
+; board_build.flash_mode = qio
 
 [env:esp32dev_16M]
 board = esp32dev
 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
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=ESP32_16M #-D WLED_DISABLE_BROWNOUT_DET
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32_idf_V4.lib_deps}
+  ${esp32.AR_lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.extreme_partitions}
 board_upload.flash_size = 16MB
@@ -505,36 +453,49 @@ board_upload.maximum_size = 16777216
 board_build.f_flash = 80000000L
 board_build.flash_mode = dio
 
+;[env:esp32dev_audioreactive]
+;board = esp32dev
+;platform = ${esp32.platform}
+;platform_packages = ${esp32.platform_packages}
+;build_unflags = ${common.build_unflags}
+;build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=ESP32_audioreactive #-D WLED_DISABLE_BROWNOUT_DET
+;  ${esp32.AR_build_flags}
+;lib_deps = ${esp32.lib_deps}
+;  ${esp32.AR_lib_deps}
+;monitor_filters = esp32_exception_decoder
+;board_build.partitions = ${esp32.default_partitions}
+;; board_build.f_flash = 80000000L
+;; board_build.flash_mode = dio
+
 [env:esp32_eth]
 board = esp32-poe
-platform = ${esp32_idf_V4.platform}
-platform_packages = ${esp32_idf_V4.platform_packages}
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
 upload_speed = 921600
-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
+build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_RELEASE_NAME=ESP32_Ethernet -D RLYPIN=-1 -D WLED_USE_ETHERNET -D BTNPIN=-1
+;  -D WLED_DISABLE_ESPNOW ;; ESP-NOW requires wifi, may crash with ethernet only
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32.lib_deps}
+  ${esp32.AR_lib_deps}
 board_build.partitions = ${esp32.default_partitions}
-board_build.flash_mode = dio
 
 [env:esp32_wrover]
 extends = esp32_idf_V4
+platform = ${esp32_idf_V4.platform}
+platform_packages = ${esp32_idf_V4.platform_packages}
 board = ttgo-t7-v14-mini32
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 board_build.partitions = ${esp32.extended_partitions}
-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
+build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=ESP32_WROVER
   -DBOARD_HAS_PSRAM -mfix-esp32-psram-cache-issue ;; Older ESP32 (rev.<3) need a PSRAM fix (increases static RAM used) https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/external-ram.html
   -D DATA_PINS=25
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32_idf_V4.lib_deps}
-  
+  ${esp32.AR_lib_deps}
+
 [env:esp32c3dev]
 extends = esp32c3
 platform = ${esp32c3.platform}
@@ -542,8 +503,7 @@ 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\"
+build_flags = ${common.build_flags} ${esp32c3.build_flags} -D WLED_RELEASE_NAME=ESP32-C3
   -D WLED_WATCHDOG_TIMEOUT=0
   -DLOLIN_WIFI_FIX ; seems to work much better with this
   -DARDUINO_USB_CDC_ON_BOOT=1 ;; for virtual CDC USB
@@ -551,12 +511,6 @@ build_flags = ${common.build_flags} ${esp32c3.build_flags} -D WLED_RELEASE_NAME=
 upload_speed = 460800
 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!)
-
-[env:esp32c3dev_qio]
-extends = env:esp32c3dev
-build_flags = ${common.build_flags} ${esp32c3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-C3-QIO\"
-board_build.flash_mode = qio ; qio is faster and works on almost all boards (some boards may use dio to get 2 extra pins)
 
 [env:esp32s3dev_16MB_opi]
 ;; ESP32-S3 development board, with 16MB FLASH and >= 8MB PSRAM (memory_type: qio_opi)
@@ -565,14 +519,15 @@ 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 = 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
+build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_16MB_opi
+  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
   ;-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")
+  -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
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32s3.lib_deps}
+  ${esp32.AR_lib_deps}
 board_build.partitions = ${esp32.extreme_partitions}
 board_upload.flash_size = 16MB
 board_upload.maximum_size = 16777216
@@ -587,32 +542,20 @@ 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 = 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
+build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_8MB_opi
+  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
   ;-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")
+  -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
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32s3.lib_deps}
+  ${esp32.AR_lib_deps}
 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
-extends = env:esp32s3dev_8MB_opi
-board_build.arduino.memory_type = qio_qspi
-board_build.flash_mode = qio
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_8MB_qspi\"
-  -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
-  ;; -DLOLIN_WIFI_FIX ;; uncomment if you have WiFi connectivity problems
-monitor_filters = esp32_exception_decoder
-
 [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)
@@ -621,55 +564,40 @@ 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 = 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
+build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_WROOM-2
+  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
   -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")
+  ;; -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
   -D LEDPIN=38 -D DATA_PINS=38 ;; buildin WS2812b LED
   -D BTNPIN=0 -D RLYPIN=16 -D IRPIN=17 -D AUDIOPIN=-1
-  ;;-D WLED_DEBUG
+  -D WLED_DEBUG
+  ${esp32.AR_build_flags}
   -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}
+  ${esp32.AR_lib_deps}
 
 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)
-extends = env:esp32S3_wroom2
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_WROOM-2_32MB\"
-  -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
-  -D LEDPIN=38 -D DATA_PINS=38 ;; buildin WS2812b LED
-  -D BTNPIN=0 -D RLYPIN=16 -D IRPIN=17 -D AUDIOPIN=-1
-  ;;-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
-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)
 board = lolin_s3_mini ;; -S3 mini, 4MB flash 2MB PSRAM 
 platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
-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")
+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
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32s3.lib_deps}
+  ${esp32.AR_lib_deps}
 board_build.partitions = ${esp32.default_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
@@ -682,15 +610,15 @@ board = lolin_s2_mini
 board_build.partitions = ${esp32.default_partitions}
 board_build.flash_mode = qio
 board_build.f_flash = 80000000L
-custom_usermods = audioreactive
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32s2.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S2\"
+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
   -DARDUINO_USB_DFU_ON_BOOT=0
   -DBOARD_HAS_PSRAM
   -DLOLIN_WIFI_FIX ; seems to work much better with this
   -D WLED_WATCHDOG_TIMEOUT=0
+  -D CONFIG_ASYNC_TCP_USE_WDT=0
   -D DATA_PINS=16
   -D HW_PIN_SCL=35
   -D HW_PIN_SDA=33
@@ -698,18 +626,6 @@ build_flags = ${common.build_flags} ${esp32s2.build_flags} -D WLED_RELEASE_NAME=
   -D HW_PIN_DATASPI=11
   -D HW_PIN_MISOSPI=9
 ;  -D STATUSLED=15
+  ${esp32.AR_build_flags}
 lib_deps = ${esp32s2.lib_deps}
-
-
-[env:usermods]
-board = esp32dev
-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_V4.lib_deps}
-monitor_filters = esp32_exception_decoder
-board_build.flash_mode = dio
-custom_usermods = *   ; Expands to all usermods in usermods folder
-board_build.partitions = ${esp32.extreme_partitions}  ; We're gonna need a bigger boat
+  ${esp32.AR_lib_deps}

platformio_override.sample.ini

@@ -5,7 +5,7 @@
 # Please visit documentation: https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = WLED_generic8266_1M, esp32dev_V4_dio80  # put the name(s) of your own build environment here. You can define as many as you need
+default_envs = WLED_tasmota_1M  # define as many as you need
 
 #----------
 # SAMPLE
@@ -28,14 +28,16 @@ lib_deps = ${esp8266.lib_deps}
 ;  robtillaart/SHT85@~0.3.3
 ;  ;gmag11/QuickESPNow @ ~0.7.0 # will also load QuickDebug
 ;  https://github.com/blazoncek/QuickESPNow.git#optional-debug  ;; exludes debug library
+;  ${esp32.AR_lib_deps} ;; used for USERMOD_AUDIOREACTIVE
+;  bitbank2/PNGdec@^1.0.1 ;; used for POV display uncomment following
 
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;
-; *** To use the below defines/overrides, copy and paste each onto its own line just below build_flags in the section above.
+; *** To use the below defines/overrides, copy and paste each onto it's own line just below build_flags in the section above.
 ; 
 ; Set a release name that may be used to distinguish required binary for flashing
-;   -D WLED_RELEASE_NAME=\"ESP32_MULTI_USREMODS\"
+;   -D WLED_RELEASE_NAME=ESP32_MULTI_USREMODS
 ;
 ; disable specific features
 ;   -D WLED_DISABLE_OTA
@@ -47,7 +49,7 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;   -D WLED_DISABLE_MQTT
 ;   -D WLED_DISABLE_ADALIGHT
 ;   -D WLED_DISABLE_2D
-;   -D WLED_DISABLE_PIXELFORGE
+;   -D WLED_DISABLE_PXMAGIC
 ;   -D WLED_DISABLE_ESPNOW
 ;   -D WLED_DISABLE_BROWNOUT_DET
 ;
@@ -109,6 +111,7 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;
 ; Use 4 Line Display usermod with SPI display
 ;   -D USERMOD_FOUR_LINE_DISPLAY
+;   -D USE_ALT_DISPlAY # mandatory
 ;   -DFLD_SPI_DEFAULT
 ;   -D FLD_TYPE=SSD1306_SPI64
 ;   -D FLD_PIN_CLOCKSPI=14
@@ -139,6 +142,7 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;   -D PIR_SENSOR_MAX_SENSORS=2 # max allowable sensors (uses OR logic for triggering)
 ;
 ; Use Audioreactive usermod and configure I2S microphone
+;   -D USERMOD_AUDIOREACTIVE
 ;   -D AUDIOPIN=-1
 ;   -D DMTYPE=1     # 0-analog/disabled, 1-I2S generic, 2-ES7243, 3-SPH0645, 4-I2S+mclk, 5-I2S PDM
 ;   -D I2S_SDPIN=36
@@ -154,22 +158,17 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;   -D USERMOD_POV_DISPLAY
 ; Use built-in or custom LED as a status indicator (assumes LED is connected to GPIO16)
 ;   -D STATUSLED=16
-;
+;   
 ; set the name of the module - make sure there is a quote-backslash-quote before the name and a backslash-quote-quote after the name
 ;   -D SERVERNAME="\"WLED\""
-;
+;   
 ; set the number of LEDs
-;   -D PIXEL_COUNTS=30
+;   -D DEFAULT_LED_COUNT=30
 ; or this for multiple outputs
 ;   -D PIXEL_COUNTS=30,30
 ;
 ; set the default LED type
-;   -D LED_TYPES=22    # see const.h (TYPE_xxxx)
-; or this for multiple outputs
-;   -D LED_TYPES=TYPE_SK6812_RGBW,TYPE_WS2812_RGB
-;
-; set default color order of your led strip
-;   -D DEFAULT_LED_COLOR_ORDER=COL_ORDER_GRB
+;   -D DEFAULT_LED_TYPE=22    # see const.h (TYPE_xxxx)
 ;
 ; set milliampere limit when using ESP power pin (or inadequate PSU) to power LEDs
 ;   -D ABL_MILLIAMPS_DEFAULT=850
@@ -177,6 +176,9 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;
 ; enable IR by setting remote type
 ;   -D IRTYPE=0   # 0 Remote disabled | 1 24-key RGB | 2 24-key with CT | 3 40-key blue | 4 40-key RGB | 5 21-key RGB | 6 6-key black | 7 9-key red | 8 JSON remote
+;   
+; set default color order of your led strip
+;   -D DEFAULT_LED_COLOR_ORDER=COL_ORDER_GRB
 ;
 ; use PSRAM on classic ESP32 rev.1 (rev.3 or above has no issues)
 ;   -DBOARD_HAS_PSRAM -mfix-esp32-psram-cache-issue   # needed only for classic ESP32 rev.1
@@ -191,22 +193,6 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;   -D HW_PIN_MISOSPI=9
 
 
-# ------------------------------------------------------------------------------
-# Optional: build flags for speed, instead of optimising for size.
-# Example of usage: see [env:esp32S3_PSRAM_HUB75]
-# ------------------------------------------------------------------------------
-
-[Speed_Flags]
-build_unflags = -Os ;; to disable standard optimization for small size
-build_flags =
-  -O2 ;; optimize for speed
-  -free -fipa-pta ;; very useful, too
-  ;;-fsingle-precision-constant ;; makes all floating point literals "float" (default is "double")
-  ;;-funsafe-math-optimizations ;; less dangerous than -ffast-math; still allows the compiler to exploit FMA and reciprocals (up to 10% faster on -S3)
-  # Important: we need to explicitly switch off some "-O2" optimizations
-  -fno-jump-tables -fno-tree-switch-conversion                 ;; needed - firmware may crash otherwise
-  -freorder-blocks -Wwrite-strings -fstrict-volatile-bitfields ;; needed - recommended by espressif
-
 
 # ------------------------------------------------------------------------------
 # PRE-CONFIGURED DEVELOPMENT BOARDS AND CONTROLLERS
@@ -251,11 +237,14 @@ build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=1 -D WLE
 lib_deps = ${esp8266.lib_deps}
 
 [env:esp32dev_qio80]
-extends = env:esp32dev  # we want to extend the existing esp32dev environment (and define only updated options)
 board = esp32dev
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
+build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32.build_flags} #-D WLED_DISABLE_BROWNOUT_DET
 lib_deps = ${esp32.lib_deps}
 monitor_filters = esp32_exception_decoder
+board_build.partitions = ${esp32.default_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 
@@ -263,23 +252,26 @@ board_build.flash_mode = qio
 ;; experimental ESP32 env using ESP-IDF V4.4.x
 ;; Warning: this build environment is not stable!!
 ;; please erase your device before installing.
-extends = esp32_idf_V4  # based on newer "esp-idf V4" platform environment
 board = esp32dev
+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_DISABLE_BROWNOUT_DET
 lib_deps = ${esp32_idf_V4.lib_deps}
 monitor_filters = esp32_exception_decoder
-board_build.partitions = ${esp32.default_partitions}  ;; if you get errors about "out of program space", change this to ${esp32.extended_partitions} or even ${esp32.big_partitions}
+board_build.partitions = ${esp32_idf_V4.default_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = dio
 
 [env:esp32s2_saola]
-extends = esp32s2
 board = esp32-s2-saola-1
 platform = ${esp32s2.platform}
 platform_packages = ${esp32s2.platform_packages}
 framework = arduino
+board_build.partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
 board_build.flash_mode = qio
 upload_speed = 460800
+build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s2.build_flags}
   ;-DLOLIN_WIFI_FIX ;; try this in case Wifi does not work
   -DARDUINO_USB_CDC_ON_BOOT=1
@@ -288,7 +280,7 @@ lib_deps = ${esp32s2.lib_deps}
 [env:esp32s3dev_8MB_PSRAM_qspi]
 ;; ESP32-TinyS3 development board, with 8MB FLASH and PSRAM (memory_type: qio_qspi)
 extends = env:esp32s3dev_8MB_PSRAM_opi
-;board = um_tinys3 ;    -> needs workaround from https://github.com/wled-dev/WLED/pull/2905#issuecomment-1328049860
+;board = um_tinys3 ;    -> needs workaround from https://github.com/Aircoookie/WLED/pull/2905#issuecomment-1328049860
 board = esp32-s3-devkitc-1 ;; generic dev board; the next line adds PSRAM support
 board_build.arduino.memory_type = qio_qspi ;; use with PSRAM: 2MB or  4MB
 
@@ -316,7 +308,7 @@ 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.
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_USE_SHOJO_PCB
 lib_deps = ${esp8266.lib_deps}
 
 [env:d1_mini_debug]
@@ -371,44 +363,36 @@ board_upload.flash_size = 2MB
 board_upload.maximum_size = 2097152
 
 [env:wemos_shield_esp32]
-extends = esp32              ;; use default esp32 platform
 board = esp32dev
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
 upload_speed = 460800
+build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32.build_flags}
-  -D WLED_RELEASE_NAME=\"ESP32_wemos_shield\"
   -D DATA_PINS=16
   -D RLYPIN=19
   -D BTNPIN=17
   -D IRPIN=18
-  -UWLED_USE_MY_CONFIG
+  -D UWLED_USE_MY_CONFIG
   -D USERMOD_DALLASTEMPERATURE
   -D USERMOD_FOUR_LINE_DISPLAY
   -D TEMPERATURE_PIN=23
+  -D USE_ALT_DISPlAY ; new versions of USERMOD_FOUR_LINE_DISPLAY and USERMOD_ROTARY_ENCODER_UI
+  -D USERMOD_AUDIOREACTIVE
 lib_deps = ${esp32.lib_deps}
-  OneWire@~2.3.5          ;; needed for USERMOD_DALLASTEMPERATURE
-  olikraus/U8g2 @ ^2.28.8 ;; needed for USERMOD_FOUR_LINE_DISPLAY
+  OneWire@~2.3.5
+  olikraus/U8g2 @ ^2.28.8
+  https://github.com/blazoncek/arduinoFFT.git
 board_build.partitions = ${esp32.default_partitions}
 
-[env:esp32_pico-D4]
-extends = esp32              ;; use default esp32 platform
-board = pico32               ;; pico32-D4 is different from the standard esp32dev
-                             ;; hardware details from https://github.com/srg74/WLED-ESP32-pico
-build_flags = ${common.build_flags} ${esp32.build_flags}
-  -D WLED_RELEASE_NAME=\"pico32-D4\" -D SERVERNAME='"WLED-pico32"'
-  -D WLED_DISABLE_ADALIGHT   ;; no serial-to-USB chip on this board - better to disable serial protocols
-  -D DATA_PINS=2,18          ;; LED pins
-  -D RLYPIN=19 -D BTNPIN=0 -D IRPIN=-1 ;; no default pin for IR
-  -D UM_AUDIOREACTIVE_ENABLE ;; enable AR by default
-  ;; Audioreactive settings for on-board microphone (ICS-43432)
-  -D SR_DMTYPE=1 -D I2S_SDPIN=25 -D I2S_WSPIN=15 -D I2S_CKPIN=14
-  -D SR_SQUELCH=5 -D SR_GAIN=30
-lib_deps = ${esp32.lib_deps}
-board_build.partitions = ${esp32.default_partitions}
-board_build.f_flash = 80000000L
-
 [env:m5atom]
-extends = env:esp32dev  # we want to extend the existing esp32dev environment (and define only updated options)
+board = esp32dev
+build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32.build_flags} -D DATA_PINS=27 -D BTNPIN=39
+lib_deps = ${esp32.lib_deps}
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
+board_build.partitions = ${esp32.default_partitions}
 
 [env:sp501e]
 board = esp_wroom_02
@@ -431,7 +415,7 @@ 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
-                                            -D LED_TYPES=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0
+                                            -D DEFAULT_LED_TYPE=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_15w_RGBCW]        ;15w bulb
@@ -441,7 +425,7 @@ 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
-                                            -D LED_TYPES=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0 -D WLED_USE_IC_CCT
+                                            -D DEFAULT_LED_TYPE=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0 -D WLED_USE_IC_CCT
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_3Pin_Controller]        ;small controller with only data
@@ -507,15 +491,17 @@ lib_deps = ${esp8266.lib_deps}
 # EleksTube-IPS
 # ------------------------------------------------------------------------------
 [env:elekstube_ips]
-extends = esp32              ;; use default esp32 platform
 board = esp32dev
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
 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 USERMOD_RTC
+  -D USERMOD_ELEKSTUBE_IPS
   -D DATA_PINS=12
   -D RLYPIN=27
   -D BTNPIN=34
-  -D PIXEL_COUNTS=6
+  -D DEFAULT_LED_COUNT=6
   # Display config
   -D ST7789_DRIVER
   -D TFT_WIDTH=135
@@ -529,127 +515,7 @@ build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_DISABLE_BROWNOU
   -D SPI_FREQUENCY=40000000
   -D USER_SETUP_LOADED
 monitor_filters = esp32_exception_decoder
-
-
-# ------------------------------------------------------------------------------
-# Usermod examples
-# ------------------------------------------------------------------------------
-
-# 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}`.
-# The name PlatformIO assigns is taken from the library's `library.json` "name" field.
-# If that name doesn't match the repo name in the URL, use the "LibName = URL" form
-# shown in the commented-out line below to supply the name explicitly.
-[env:esp32dev_external_usermod]
-extends = env:esp32dev
-custom_usermods =
-  ${env:esp32dev.custom_usermods}
-  https://github.com/wled/wled-usermod-example.git#main
-
-
-# ------------------------------------------------------------------------------
-# Hub75 examples
-# ------------------------------------------------------------------------------
-# Note: some panels may experience ghosting with default full brightness. use -D WLED_HUB75_MAX_BRIGHTNESS=239 or lower to fix it.
-
-[env:esp32dev_hub75]
-board = esp32dev
-upload_speed = 921600
-platform = ${esp32_idf_V4.platform}
-platform_packages =
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags}
-  -D WLED_RELEASE_NAME=\"ESP32_hub75\"
-  -D WLED_ENABLE_HUB75MATRIX -D NO_GFX
-  -D WLED_DEBUG_BUS
-  ; -D WLED_DEBUG
-  -D SR_DMTYPE=1 -D I2S_SDPIN=-1 -D I2S_CKPIN=-1 -D I2S_WSPIN=-1 -D MCLK_PIN=-1  ;; Disable to prevent pin clash
-
-lib_deps = ${esp32_idf_V4.lib_deps}
-  https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-DMA.git#3.0.11
-
-monitor_filters = esp32_exception_decoder
+lib_deps =
+  ${esp32.lib_deps}
+  TFT_eSPI @ ^2.3.70
 board_build.partitions = ${esp32.default_partitions}
-board_build.flash_mode = dio
-custom_usermods = audioreactive
-
-[env:esp32dev_hub75_forum_pinout]
-extends = env:esp32dev_hub75
-build_flags = ${common.build_flags}
-              -D WLED_RELEASE_NAME=\"ESP32_hub75_forum_pinout\"
-              -D WLED_ENABLE_HUB75MATRIX -D NO_GFX 
-              -D ESP32_FORUM_PINOUT ;; enable for SmartMatrix default pins
-              -D WLED_DEBUG_BUS
-              -D SR_DMTYPE=1 -D I2S_SDPIN=-1 -D I2S_CKPIN=-1 -D I2S_WSPIN=-1 -D MCLK_PIN=-1  ;; Disable to prevent pin clash
-; -D WLED_DEBUG
-
-
-[env:adafruit_matrixportal_esp32s3]
-; ESP32-S3 processor, 8 MB flash, 2 MB of PSRAM, dedicated driver pins for HUB75
-board = adafruit_matrixportal_esp32s3_wled ; modified board definition: removed flash section that causes FS erase on upload
-;; adafruit recommends to use arduino-esp32 2.0.14
-;;platform = espressif32@ ~6.5.0
-;;platform_packages = platformio/framework-arduinoespressif32 @ 3.20014.231204 ;; arduino-esp32 2.0.14
-platform = ${esp32s3.platform}
-platform_packages =
-upload_speed = 921600
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_8M_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 (sets lower TX power)
-  -D WLED_WATCHDOG_TIMEOUT=0
-  -D WLED_ENABLE_HUB75MATRIX -D NO_GFX
-  -D S3_LCD_DIV_NUM=20 ;; Attempt to fix wifi performance issue when panel active with S3 chips
-  -D ARDUINO_ADAFRUIT_MATRIXPORTAL_ESP32S3
-  -D WLED_DEBUG_BUS
-  -D SR_DMTYPE=1 -D I2S_SDPIN=-1 -D I2S_CKPIN=-1 -D I2S_WSPIN=-1 -D MCLK_PIN=-1  ;; Disable to prevent pin clash
-
-
-lib_deps = ${esp32s3.lib_deps}
-  https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-DMA.git#aa28e2a ;; S3_LCD_DIV_NUM fix
-
-board_build.partitions = ${esp32.large_partitions}                  ;; standard bootloader and 8MB Flash partitions
-;; board_build.partitions = tools/partitions-8MB_spiffs-tinyuf2.csv ;; supports adafruit UF2 bootloader
-board_build.f_flash = 80000000L
-board_build.flash_mode = qio
-monitor_filters = esp32_exception_decoder
-custom_usermods = audioreactive
-
-[env:esp32S3_PSRAM_HUB75]
-;; MOONHUB HUB75 adapter board (lilygo T7-S3 with 16MB flash and PSRAM)
-board = lilygo-t7-s3
-platform = ${esp32s3.platform}
-platform_packages =
-upload_speed = 921600
-build_unflags = ${common.build_unflags}
-              ${Speed_Flags.build_unflags}    ;; optional: removes "-Os" so we can override with "-O2" in build_flags
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"esp32S3_16MB_PSRAM_HUB75\"
-              ${Speed_Flags.build_flags}      ;; optional: -O2 -> optimize for speed instead of size
-              -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 (sets lower TX power)
-              -D WLED_WATCHDOG_TIMEOUT=0
-              -D WLED_ENABLE_HUB75MATRIX -D NO_GFX 
-              -D S3_LCD_DIV_NUM=20 ;; Attempt to fix wifi performance issue when panel active with S3 chips
-              -D MOONHUB_S3_PINOUT ;; HUB75 pinout
-              -D WLED_DEBUG_BUS
-              -D LEDPIN=14 -D BTNPIN=0 -D RLYPIN=15 -D IRPIN=-1 -D AUDIOPIN=-1 ;; defaults that avoid pin conflicts with HUB75
-              -D SR_DMTYPE=1 -D I2S_SDPIN=10 -D I2S_CKPIN=11 -D I2S_WSPIN=12 -D MCLK_PIN=-1  ;; I2S mic
-
-lib_deps = ${esp32s3.lib_deps}
-           https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-DMA.git#aa28e2a ;; S3_LCD_DIV_NUM fix
-
-;;board_build.partitions = ${esp32.large_partitions}               ;; for 8MB flash
-board_build.partitions = ${esp32.extreme_partitions}               ;; for 16MB flash
-board_build.f_flash = 80000000L
-board_build.flash_mode = qio
-monitor_filters = esp32_exception_decoder
-custom_usermods = audioreactive

readme.md

@@ -1,20 +1,18 @@
 <p align="center">
   <img src="/images/wled_logo_akemi.png">
-  <a href="https://github.com/wled-dev/WLED/releases"><img src="https://img.shields.io/github/release/wled-dev/WLED.svg?style=flat-square"></a>
-  <a href="https://raw.githubusercontent.com/wled-dev/WLED/main/LICENSE"><img src="https://img.shields.io/github/license/wled-dev/wled?color=blue&style=flat-square"></a>
+  <a href="https://github.com/Aircoookie/WLED/releases"><img src="https://img.shields.io/github/release/Aircoookie/WLED.svg?style=flat-square"></a>
+  <a href="https://raw.githubusercontent.com/Aircoookie/WLED/master/LICENSE"><img src="https://img.shields.io/github/license/Aircoookie/wled?color=blue&style=flat-square"></a>
   <a href="https://wled.discourse.group"><img src="https://img.shields.io/discourse/topics?colorB=blue&label=forum&server=https%3A%2F%2Fwled.discourse.group%2F&style=flat-square"></a>
   <a href="https://discord.gg/QAh7wJHrRM"><img src="https://img.shields.io/discord/473448917040758787.svg?colorB=blue&label=discord&style=flat-square"></a>
   <a href="https://kno.wled.ge"><img src="https://img.shields.io/badge/quick_start-wiki-blue.svg?style=flat-square"></a>
   <a href="https://github.com/Aircoookie/WLED-App"><img src="https://img.shields.io/badge/app-wled-blue.svg?style=flat-square"></a>
-  <a href="https://gitpod.io/#https://github.com/wled-dev/WLED"><img src="https://img.shields.io/badge/Gitpod-ready--to--code-blue?style=flat-square&logo=gitpod"></a>
+  <a href="https://gitpod.io/#https://github.com/Aircoookie/WLED"><img src="https://img.shields.io/badge/Gitpod-ready--to--code-blue?style=flat-square&logo=gitpod"></a>
 
   </p>
 
-# Welcome to WLED! ✨
+# Welcome to my project WLED! ✨
 
-A fast and feature-rich implementation of an ESP32 and ESP8266 webserver to control NeoPixel (WS2812B, WS2811, SK6812) LEDs or also SPI based chipsets like the WS2801 and APA102!
-
-Originally created by [Aircoookie](https://github.com/Aircoookie)
+A fast and feature-rich implementation of an ESP8266/ESP32 webserver to control NeoPixel (WS2812B, WS2811, SK6812) LEDs or also SPI based chipsets like the WS2801 and APA102!
 
 ## ⚙️ Features
 - WS2812FX library with more than 100 special effects  
@@ -23,7 +21,7 @@ Originally created by [Aircoookie](https://github.com/Aircoookie)
 - Segments to set different effects and colors to user defined parts of the LED string  
 - Settings page - configuration via the network  
 - Access Point and station mode - automatic failsafe AP  
-- [Up to 10 LED outputs](https://kno.wled.ge/features/multi-strip/#esp32) per instance
+- Up to 10 LED outputs per instance
 - Support for RGBW strips  
 - Up to 250 user presets to save and load colors/effects easily, supports cycling through them.  
 - Presets can be used to automatically execute API calls  
@@ -34,7 +32,7 @@ Originally created by [Aircoookie](https://github.com/Aircoookie)
 - Filesystem-based config for easier backup of presets and settings  
 
 ## 💡 Supported light control interfaces
-- WLED app for [Android](https://play.google.com/store/apps/details?id=ca.cgagnier.wlednativeandroid) and [iOS](https://apps.apple.com/gb/app/wled-native/id6446207239)
+- WLED app for [Android](https://play.google.com/store/apps/details?id=com.aircoookie.WLED) and [iOS](https://apps.apple.com/us/app/wled/id1475695033)
 - JSON and HTTP request APIs  
 - MQTT   
 - E1.31, Art-Net, DDP and TPM2.net
@@ -65,7 +63,6 @@ See [here](https://kno.wled.ge/basics/compatible-hardware)!
 
 Licensed under the EUPL v1.2 license  
 Credits [here](https://kno.wled.ge/about/contributors/)!
-CORS proxy by [Corsfix](https://corsfix.com/)
 
 Join the Discord server to discuss everything about WLED!
 

requirements.in

@@ -1 +1 @@
-platformio>=6.1.17
+platformio

requirements.txt

@@ -1,26 +1,28 @@
 #
-# This file is autogenerated by pip-compile with Python 3.11
+# This file is autogenerated by pip-compile with Python 3.12
 # by the following command:
 #
-#    pip-compile requirements.in
+#    pip-compile
 #
 ajsonrpc==1.2.0
     # via platformio
-anyio==4.8.0
+anyio==4.6.0
     # via starlette
-bottle==0.13.2
+bottle==0.13.1
     # via platformio
-certifi==2025.1.31
+certifi==2024.8.30
     # via requests
-charset-normalizer==3.4.1
+charset-normalizer==3.3.2
     # via requests
-click==8.1.8
+click==8.1.7
     # via
     #   platformio
     #   uvicorn
 colorama==0.4.6
-    # via platformio
-h11==0.16.0
+    # via
+    #   click
+    #   platformio
+h11==0.14.0
     # via
     #   uvicorn
     #   wsproto
@@ -28,31 +30,29 @@ idna==3.10
     # via
     #   anyio
     #   requests
-marshmallow==3.26.1
+marshmallow==3.22.0
     # via platformio
-packaging==24.2
+packaging==24.1
     # via marshmallow
-platformio==6.1.17
+platformio==6.1.16
     # via -r requirements.in
-pyelftools==0.32
+pyelftools==0.31
     # via platformio
 pyserial==3.5
     # via platformio
-requests==2.32.4
+requests==2.32.3
     # via platformio
 semantic-version==2.10.0
     # via platformio
 sniffio==1.3.1
     # via anyio
-starlette==0.45.3
+starlette==0.39.1
     # via platformio
 tabulate==0.9.0
     # via platformio
-typing-extensions==4.12.2
-    # via anyio
-urllib3==2.5.0
+urllib3==2.2.3
     # via requests
-uvicorn==0.34.0
+uvicorn==0.30.6
     # via platformio
 wsproto==1.2.0
     # via platformio

tools/WLED_ESP32_32MB.csv

@@ -1,7 +0,0 @@
-# Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,  0x5000,
-otadata,  data, ota,     0xe000,  0x2000,
-app0,     app,  ota_0,   0x10000, 0x300000,
-app1,     app,  ota_1,   0x310000,0x300000,
-spiffs,   data, spiffs,  0x610000,0x19E0000,
-coredump, data, coredump,,64K

tools/cdata.js

@@ -17,7 +17,7 @@
 
 const fs = require("node:fs");
 const path = require("path");
-const inline = require("web-resource-inliner");
+const inliner = require("inliner");
 const zlib = require("node:zlib");
 const CleanCSS = require("clean-css");
 const minifyHtml = require("html-minifier-terser").minify;
@@ -26,7 +26,7 @@ const packageJson = require("../package.json");
 // Export functions for testing
 module.exports = { isFileNewerThan, isAnyFileInFolderNewerThan };
 
-const output = ["wled00/html_ui.h", "wled00/html_pixart.h", "wled00/html_cpal.h", "wled00/html_edit.h", "wled00/html_pxmagic.h", "wled00/html_pixelforge.h", "wled00/html_settings.h", "wled00/html_other.h", "wled00/js_iro.h", "wled00/js_omggif.h"]
+const output = ["wled00/html_ui.h", "wled00/html_pixart.h", "wled00/html_cpal.h", "wled00/html_pxmagic.h", "wled00/html_settings.h", "wled00/html_other.h"]
 
 // \x1b[34m is blue, \x1b[36m is cyan, \x1b[0m is reset
 const wledBanner = `
@@ -38,11 +38,6 @@ const wledBanner = `
 \t\t\x1b[36m build script for web UI
 \x1b[0m`;
 
-// Generate build timestamp as UNIX timestamp (seconds since epoch)
-function generateBuildTime() {
-  return Math.floor(Date.now() / 1000);
-}
-
 const singleHeader = `/*
  * Binary array for the Web UI.
  * gzip is used for smaller size and improved speeds.
@@ -50,9 +45,6 @@ const singleHeader = `/*
  * Please see https://kno.wled.ge/advanced/custom-features/#changing-web-ui
  * to find out how to easily modify the web UI source!
  */
-
-// Automatically generated build time for cache busting (UNIX timestamp)
-#define WEB_BUILD_TIME ${generateBuildTime()}
  
 `;
 
@@ -97,7 +89,7 @@ function adoptVersionAndRepo(html) {
     repoUrl = repoUrl.replace(/^git\+/, "");
     repoUrl = repoUrl.replace(/\.git$/, "");
     html = html.replaceAll("https://github.com/atuline/WLED", repoUrl);
-    html = html.replaceAll("https://github.com/wled-dev/WLED", repoUrl);
+    html = html.replaceAll("https://github.com/Aircoookie/WLED", repoUrl);
   }
   let version = packageJson.version;
   if (version) {
@@ -109,7 +101,6 @@ function adoptVersionAndRepo(html) {
 async function minify(str, type = "plain") {
   const options = {
     collapseWhitespace: true,
-    conservativeCollapse: true, // preserve spaces in text
     collapseBooleanAttributes: true,
     collapseInlineTagWhitespace: true,
     minifyCSS: true,
@@ -134,29 +125,23 @@ async function minify(str, type = "plain") {
   throw new Error("Unknown filter: " + type);
 }
 
-async function writeHtmlGzipped(sourceFile, resultFile, page, inlineCss = true) {
+async function writeHtmlGzipped(sourceFile, resultFile, page) {
   console.info("Reading " + sourceFile);
-  inline.html({
-    fileContent: fs.readFileSync(sourceFile, "utf8"),
-    relativeTo: path.dirname(sourceFile),
-    strict: inlineCss,     // when not inlining css, ignore errors (enables linking style.css from subfolder htm files)
-    stylesheets: inlineCss // when true (default), css is inlined
-  },
-    async function (error, html) {
-      if (error) throw error;
+  new inliner(sourceFile, async function (error, html) {
+    if (error) throw error;
 
-      html = adoptVersionAndRepo(html);
-      const originalLength = html.length;
-      html = await minify(html, "html-minify");
-      const result = zlib.gzipSync(html, { level: zlib.constants.Z_BEST_COMPRESSION });
-      console.info("Minified and compressed " + sourceFile + " from " + originalLength + " to " + result.length + " bytes");
-      const array = hexdump(result);
-      let src = singleHeader;
-      src += `const uint16_t PAGE_${page}_length = ${result.length};\n`;
-      src += `const uint8_t PAGE_${page}[] PROGMEM = {\n${array}\n};\n\n`;
-      console.info("Writing " + resultFile);
-      fs.writeFileSync(resultFile, src);
-    });
+    html = adoptVersionAndRepo(html);
+    const originalLength = html.length;
+    html = await minify(html, "html-minify");
+    const result = zlib.gzipSync(html, { level: zlib.constants.Z_BEST_COMPRESSION });
+    console.info("Minified and compressed " + sourceFile + " from " + originalLength + " to " + result.length + " bytes");
+    const array = hexdump(result);
+    let src = singleHeader;
+    src += `const uint16_t PAGE_${page}_L = ${result.length};\n`;
+    src += `const uint8_t PAGE_${page}[] PROGMEM = {\n${array}\n};\n\n`;
+    console.info("Writing " + resultFile);
+    fs.writeFileSync(resultFile, src);
+  });
 }
 
 async function specToChunk(srcDir, s) {
@@ -253,63 +238,8 @@ if (isAlreadyBuilt("wled00/data") && process.argv[2] !== '--force' && process.ar
 
 writeHtmlGzipped("wled00/data/index.htm", "wled00/html_ui.h", 'index');
 writeHtmlGzipped("wled00/data/pixart/pixart.htm", "wled00/html_pixart.h", 'pixart');
+writeHtmlGzipped("wled00/data/cpal/cpal.htm", "wled00/html_cpal.h", 'cpal');
 writeHtmlGzipped("wled00/data/pxmagic/pxmagic.htm", "wled00/html_pxmagic.h", 'pxmagic');
-writeHtmlGzipped("wled00/data/pixelforge/pixelforge.htm", "wled00/html_pixelforge.h", 'pixelforge', false); // do not inline css
-//writeHtmlGzipped("wled00/data/edit.htm", "wled00/html_edit.h", 'edit');
-
-writeChunks(
-  "wled00/data/",
-  [
-    {
-      file: "iro.js",
-      name: "JS_iro",
-      method: "gzip",
-      filter: "plain", // no minification, it is already minified
-      mangle: (s) => s.replace(/^\/\*![\s\S]*?\*\//, '') // remove license comment at the top
-    }
-  ],
-  "wled00/js_iro.h"
-);
-
-writeChunks(
-  "wled00/data/pixelforge",
-  [
-    {
-      file: "omggif.js",
-      name: "JS_omggif",
-      method: "gzip",
-      filter: "js-minify",
-      mangle: (s) => s.replace(/^\/\*![\s\S]*?\*\//, '') // remove license comment at the top
-    }
-  ],
-  "wled00/js_omggif.h"
-);
-
-writeChunks(
-  "wled00/data",
-  [
-    {
-      file: "edit.htm",
-      name: "PAGE_edit",
-      method: "gzip",
-      filter: "html-minify"
-    }
-  ],
-  "wled00/html_edit.h"
-);
-
-writeChunks(
-  "wled00/data/cpal",
-  [
-    {
-      file: "cpal.htm",
-      name: "PAGE_cpal",
-      method: "gzip",
-      filter: "html-minify"
-    }
-  ],
-  "wled00/html_cpal.h"
-);
 
 writeChunks(
   "wled00/data",
@@ -394,12 +324,6 @@ writeChunks(
       name: "PAGE_settings_pin",
       method: "gzip",
       filter: "html-minify"
-    },
-    {
-      file: "settings_pininfo.htm",
-      name: "PAGE_settings_pininfo",
-      method: "gzip",
-      filter: "html-minify"
     }
   ],
   "wled00/html_settings.h"
@@ -445,6 +369,12 @@ const char PAGE_dmxmap[] PROGMEM = R"=====()=====";
       name: "PAGE_update",
       method: "gzip",
       filter: "html-minify",
+      mangle: (str) =>
+        str
+          .replace(
+            /function GetV().*\<\/script\>/gms,
+            "</script><script src=\"/settings/s.js?p=9\"></script>"
+          )
     },
     {
       file: "welcome.htm",

tools/partitions-16MB_spiffs-tinyuf2.csv

@@ -1,10 +0,0 @@
-# ESP-IDF Partition Table
-# Name,   Type, SubType, Offset,  Size, Flags
-# bootloader.bin,,          0x1000, 32K
-# partition table,,         0x8000, 4K
-nvs,      data, nvs,      0x9000,  20K,
-otadata,  data, ota,      0xe000,  8K,
-ota_0,    app,  ota_0,   0x10000,  2048K,
-ota_1,    app,  ota_1,  0x210000,  2048K,
-uf2,      app,  factory,0x410000,  256K,
-spiffs,     data, spiffs,    0x450000,  11968K,

tools/partitions-4MB_spiffs-tinyuf2.csv

@@ -1,11 +0,0 @@
-# ESP-IDF Partition Table
-# Name,   Type, SubType, Offset,  Size, Flags
-# bootloader.bin,,          0x1000, 32K
-# partition table,          0x8000, 4K
-
-nvs,      data, nvs,      0x9000,  20K,
-otadata,  data, ota,      0xe000,  8K,
-ota_0,    0,    ota_0,   0x10000,  1408K,
-ota_1,    0,    ota_1,  0x170000,  1408K,
-uf2,      app,  factory,0x2d0000,  256K,
-spiffs,   data, spiffs, 0x310000,  960K,

tools/partitions-8MB_spiffs-tinyuf2.csv

@@ -1,10 +0,0 @@
-# ESP-IDF Partition Table
-# Name,   Type, SubType, Offset,  Size, Flags
-# bootloader.bin,,          0x1000, 32K
-# partition table,,         0x8000, 4K
-nvs,      data, nvs,      0x9000,  20K,
-otadata,  data, ota,      0xe000,  8K,
-ota_0,    app,    ota_0,   0x10000,  2048K,
-ota_1,    app,    ota_1,  0x210000,  2048K,
-uf2,      app,  factory,0x410000,  256K,
-spiffs,   data, spiffs,   0x450000,  3776K,

tools/stress_test.sh

@@ -27,7 +27,6 @@ read -a JSON_TINY_TARGETS <<< $(replicate "json/nodes")
 read -a JSON_SMALL_TARGETS <<< $(replicate "json/info")
 read -a JSON_LARGE_TARGETS <<< $(replicate "json/si")
 read -a JSON_LARGER_TARGETS <<< $(replicate "json/fxdata")
-read -a INDEX_TARGETS <<< $(replicate "")
 
 # Expand target URLS to full arguments for curl
 TARGETS=(${TARGET_STR[@]})

tools/wbf-to-header-bidirectional-fontconverter.html

@@ -1,696 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <title>WBF ↔ C Header Bi-Directional Converter</title>
-    <style>
-        * {
-            box-sizing: border-box;
-            margin: 0;
-        }
-        body {
-            font-family: system-ui, sans-serif;
-            background: #0a0a0a;
-            color: #e0e0e0;
-            padding: 20px;
-            min-height: 100vh;
-        }
-        .card {
-            max-width: 900px;
-            margin: auto;
-            background: #16213e;
-            padding: 30px;
-            border-radius: 12px;
-            box-shadow: 0 4px 20px rgba(0, 242, 255, .15);
-            border: 1px solid rgba(0, 242, 255, .1);
-        }
-        h1 {
-            color: #00f2ff;
-            text-align: center;
-            margin-bottom: 20px;
-            font-size: 2rem;
-            text-shadow: 0 0 25px #ffffff;
-        }
-        .mode-selector {
-            display: grid;
-            grid-template-columns: 1fr 1fr;
-            gap: 10px;
-            margin-bottom: 20px;
-        }
-        .mode-btn {
-            padding: 14px;
-            border-radius: 8px;
-            cursor: pointer;
-            font-weight: bold;
-            border: 2px solid rgba(0, 242, 255, .3);
-            background: rgba(0, 0, 0, .4);
-            color: #888;
-            transition: all .3s;
-        }
-        .mode-btn.active {
-            background: linear-gradient(135deg, #0095b3 0%, #00d4ff 100%);
-            border-color: #00f2ff;
-            color: #fff;
-            box-shadow: 0 0 14px rgba(0, 242, 255, .6);
-        }
-        .mode-btn:hover:not(.active) {
-            border-color: #00f2ff;
-            color: #00f2ff;
-        }
-        .controls {
-            background: rgba(255, 255, 255, .03);
-            padding: 20px;
-            border-radius: 15px;
-            margin-bottom: 20px;
-            border: 1px solid rgba(0, 242, 255, .1);
-            display: none;
-        }
-        .controls.active {
-            display: block;
-        }
-        label {
-            display: block;
-            font-size: .85rem;
-            font-weight: 600;
-            color: #00d4ff;
-            margin-bottom: 8px;
-            text-transform: uppercase;
-            letter-spacing: .5px;
-        }
-        input[type="file"] {
-            display: none;
-        }
-        .file-label {
-            display: block;
-            width: 100%;
-            padding: 12px;
-            border-radius: 8px;
-            border: 1px solid rgba(0, 242, 255, .2);
-            background: rgba(0, 0, 0, .4);
-            color: #888;
-            cursor: pointer;
-            text-align: center;
-            transition: all .3s;
-            margin-bottom: 15px;
-        }
-        .file-label:hover {
-            border-color: #00f2ff;
-            color: #00f2ff;
-        }
-        .file-label.has-file {
-            color: #00f2ff;
-        }
-        input[type="text"], textarea {
-            width: 100%;
-            padding: 10px;
-            border-radius: 8px;
-            border: 1px solid rgba(0, 242, 255, .2);
-            background: rgba(0, 0, 0, .4);
-            color: #fff;
-            margin-bottom: 15px;
-            transition: all .3s;
-            font-family: 'Courier New', monospace;
-        }
-        textarea {
-            min-height: 300px;
-            resize: vertical;
-            font-size: .85rem;
-        }
-        input[type="text"]:focus, textarea:focus {
-            outline: none;
-            border-color: #00f2ff;
-            box-shadow: 0 0 8px rgba(0, 242, 255, .3);
-        }
-        button {
-            width: 100%;
-            padding: 14px;
-            border-radius: 50px;
-            cursor: pointer;
-            font-weight: bold;
-            border: none;
-            background: linear-gradient(135deg, #0095b3 0%, #00d4ff 100%);
-            box-shadow: 0 0 14px rgba(0, 242, 255, .6);
-            color: #fff;
-            transition: all .3s;
-        }
-        button:hover:not(:disabled) {
-            transform: translateY(-2px);
-            box-shadow: 0 0 18px rgba(0, 242, 255, .9);
-        }
-        button:disabled {
-            opacity: .3;
-            cursor: not-allowed;
-        }
-        .info {
-            background: rgba(0, 242, 255, .05);
-            padding: 15px;
-            border-radius: 8px;
-            margin-bottom: 20px;
-            border: 1px solid rgba(0, 242, 255, .2);
-            font-size: .85rem;
-        }
-        .output {
-            background: rgba(0, 0, 0, .6);
-            padding: 20px;
-            border-radius: 10px;
-            border: 1px solid rgba(0, 242, 255, .2);
-            max-height: 500px;
-            overflow-y: auto;
-            display: none;
-        }
-        .output.active {
-            display: block;
-        }
-        pre {
-            color: #00f2ff;
-            font-family: 'Courier New', monospace;
-            font-size: .85rem;
-            white-space: pre-wrap;
-            word-wrap: break-word;
-        }
-        .copy-btn {
-            margin-top: 10px;
-        }
-    </style>
-</head>
-<body>
-<div class="card">
-    <h1>WBF ↔ C Header Converter</h1>
-    
-    <div class="mode-selector">
-        <button class="mode-btn active" onclick="switchMode('wbf-to-header')">WBF → C Header</button>
-        <button class="mode-btn" onclick="switchMode('header-to-wbf')">C Header → WBF</button>
-    </div>
-    
-    <!-- WBF to Header Mode -->
-    <div id="wbf-to-header" class="controls active">
-        <div class="info">
-            Load a WLED Bitmap Font (.wbf) file and convert it to a C/C++ header file.
-        </div>
-
-        <label>Select WBF Font File</label>
-        <label for="wbfFile" class="file-label" id="wbfFileLabel">Choose .wbf file</label>
-        <input type="file" id="wbfFile" accept=".wbf">
-        
-        <label>Array Name</label>
-        <input type="text" id="arrayName" placeholder="console_font_4x6" value="console_font_4x6">
-        
-        <button id="convertToHeaderBtn" disabled>Convert to Header</button>
-    </div>
-
-    <!-- Header to WBF Mode -->
-    <div id="header-to-wbf" class="controls">
-        <div class="info">
-            Paste a C/C++ header file containing a WLED font array and convert it to a .wbf file.
-        </div>
-
-        <label>Paste C Header Code</label>
-        <textarea id="headerInput" placeholder="Paste your C header code here (e.g., static const unsigned char font[] PROGMEM = {...};)"></textarea>
-        
-        <label>Output Filename (without .wbf extension)</label>
-        <input type="text" id="wbfFilename" placeholder="console_font_4x6" value="console_font_4x6">
-        
-        <button id="convertToWbfBtn" disabled>Convert to WBF</button>
-    </div>
-
-    <div id="output" class="output">
-        <pre id="outputCode"></pre>
-        <button class="copy-btn" onclick="copyToClipboard(event)">Copy to Clipboard</button>
-    </div>
-</div>
-
-<script>
-    // Elements for WBF to Header
-    const wbfFileInput = document.getElementById('wbfFile');
-    const wbfFileLabel = document.getElementById('wbfFileLabel');
-    const arrayNameInput = document.getElementById('arrayName');
-    const convertToHeaderBtn = document.getElementById('convertToHeaderBtn');
-    
-    // Elements for Header to WBF
-    const headerInput = document.getElementById('headerInput');
-    const wbfFilenameInput = document.getElementById('wbfFilename');
-    const convertToWbfBtn = document.getElementById('convertToWbfBtn');
-    
-    // Output elements
-    const output = document.getElementById('output');
-    const outputCode = document.getElementById('outputCode');
-    
-    let wbfData = null;
-    let fileName = '';
-
-    // Mode switching
-    function switchMode(mode) {
-        document.querySelectorAll('.mode-btn').forEach(btn => btn.classList.remove('active'));
-        document.querySelectorAll('.controls').forEach(ctrl => ctrl.classList.remove('active'));
-        
-        event.target.classList.add('active');
-        document.getElementById(mode).classList.add('active');
-        output.classList.remove('active');
-    }
-
-    // ==================== WBF to Header ====================
-    wbfFileInput.addEventListener('change', (e) => {
-        const file = e.target.files[0];
-        if (file) {
-            fileName = file.name.replace(/\.[^.]+$/, '');
-            wbfFileLabel.textContent = file.name;
-            wbfFileLabel.classList.add('has-file');
-            
-            const reader = new FileReader();
-            reader.onload = (ev) => {
-                wbfData = new Uint8Array(ev.target.result);
-                convertToHeaderBtn.disabled = false;
-            };
-            reader.readAsArrayBuffer(file);
-        }
-    });
-
-    convertToHeaderBtn.addEventListener('click', () => {
-        if (!wbfData) return;
-        
-        const header = parseWBF(wbfData);
-        if (header) {
-            generateHeader(header);
-        }
-    });
-
-    function parseWBF(data) {
-        if (data.length < 12) {
-            alert('Invalid WBF file: too short');
-            return null;
-        }
-        
-        // Parse header
-        if (data[0] !== 0x57) { // 'W'
-            alert('Invalid WBF file: missing magic byte');
-            return null;
-        }
-        
-        const height = data[1];
-        const maxWidth = data[2];
-        const spacing = data[3];
-        const flags = data[4];
-        const first = data[5];
-        const last = data[6];
-        const reserved = data[7];
-        
-        // Unicode offset is 32-bit little-endian
-        const unicodeOffset = data[8] | (data[9] << 8) | (data[10] << 16) | (data[11] << 24);
-        
-        const numChars = last - first + 1;
-        const isVariableWidth = (flags & 0x01) !== 0;
-        
-        let offset = 12; // Start after header
-        let widthTable = null;
-        
-        // If variable width, read width table
-        if (isVariableWidth) {
-            if (data.length < 12 + numChars) {
-                alert('Invalid WBF file: missing width table');
-                return null;
-            }
-            widthTable = Array.from(data.slice(12, 12 + numChars));
-            offset = 12 + numChars;
-        }
-        
-        // Calculate expected data size
-        let expectedDataSize = 0;
-        if (isVariableWidth) {
-            for (let w of widthTable) {
-                expectedDataSize += Math.ceil((w * height) / 8);
-            }
-        } else {
-            expectedDataSize = numChars * Math.ceil((maxWidth * height) / 8);
-        }
-        
-        if (data.length < offset + expectedDataSize) {
-            alert(`Invalid WBF file: expected ${offset + expectedDataSize} bytes, got ${data.length}`);
-            return null;
-        }
-        
-        return {
-            height,
-            maxWidth,
-            spacing,
-            flags,
-            first,
-            last,
-            reserved,
-            unicodeOffset,
-            data: data,
-            isVariableWidth,
-            widthTable,
-            dataOffset: offset
-        };
-    }
-
-    function generateHeader(header) {
-        const arrayName = arrayNameInput.value || 'console_font';
-        let code = '';
-        
-        // Header comment
-        code += `// Font: ${fileName}\n`;
-        code += `// Height: ${header.height}, Max Width: ${header.maxWidth}, Spacing: ${header.spacing}\n`;
-        code += `// Characters: ${header.first}-${header.last} (${header.last - header.first + 1} glyphs)\n`;
-        code += `// Unicode Offset: 0x${header.unicodeOffset.toString(16).padStart(8, '0').toUpperCase()}\n`;
-        code += `// Variable Width: ${header.isVariableWidth ? 'Yes' : 'No'}\n\n`;
-        
-        // Array declaration
-        code += `static const unsigned char ${arrayName}[] PROGMEM = {\n`;
-        
-        // Header bytes (12 bytes)
-        code += '    ';
-        code += `0x${header.data[0].toString(16).padStart(2, '0').toUpperCase()}, `; // Magic 'W'
-        code += `0x${header.height.toString(16).padStart(2, '0').toUpperCase()}, `; // Height
-        code += `0x${header.maxWidth.toString(16).padStart(2, '0').toUpperCase()}, `; // Max Width
-        code += `0x${header.spacing.toString(16).padStart(2, '0').toUpperCase()}, `; // Spacing
-        code += `0x${header.flags.toString(16).padStart(2, '0').toUpperCase()}, `; // Flags
-        code += `0x${header.first.toString(16).padStart(2, '0').toUpperCase()}, `; // First char
-        code += `0x${header.last.toString(16).padStart(2, '0').toUpperCase()}, `; // Last char
-        code += `0x${header.reserved.toString(16).padStart(2, '0').toUpperCase()}, `; // Reserved
-        
-        // Unicode offset (4 bytes, little-endian)
-        code += `0x${header.data[8].toString(16).padStart(2, '0').toUpperCase()}, `;
-        code += `0x${header.data[9].toString(16).padStart(2, '0').toUpperCase()}, `;
-        code += `0x${header.data[10].toString(16).padStart(2, '0').toUpperCase()}, `;
-        code += `0x${header.data[11].toString(16).padStart(2, '0').toUpperCase()}`;
-        
-        code += ',  // Header: \'W\', H, W, S, Flags, First, Last, Reserved, UnicodeOffset (32bit)\n\n';
-        
-        // Width table (if variable width)
-        if (header.isVariableWidth) {
-            code += '    // Width table\n';
-            const numChars = header.last - header.first + 1;
-            for (let i = 0; i < numChars; i++) {
-                if (i % 16 === 0) {
-                    if (i > 0) code += '\n';
-                    code += '    ';
-                }
-                code += `0x${header.widthTable[i].toString(16).padStart(2, '0').toUpperCase()}`;
-                if (i < numChars - 1) {
-                    code += ', ';
-                }
-            }
-            code += ',\n\n';
-        }
-
-        // Character data
-        const numChars = header.last - header.first + 1;
-        let offset = header.dataOffset;
-
-        // First pass: calculate max byte width for alignment
-        let maxByteWidth = 0;
-        let tempOffset = header.dataOffset;
-        for (let i = 0; i < numChars; i++) {
-            const charWidth = header.isVariableWidth ? header.widthTable[i] : header.maxWidth;
-            const bytesPerChar = Math.ceil((charWidth * header.height) / 8);
-            const byteStr = Array(bytesPerChar).fill('0x00').join(', ');
-            maxByteWidth = Math.max(maxByteWidth, byteStr.length);
-            tempOffset += bytesPerChar;
-        }
-
-        // Second pass: generate output with aligned comments
-        for (let i = 0; i < numChars; i++) {
-            const charCode = header.first + i;
-            const charStr = getAsciiString(charCode);
-
-            // Calculate bytes for this character
-            const charWidth = header.isVariableWidth ? header.widthTable[i] : header.maxWidth;
-            const bytesPerChar = Math.ceil((charWidth * header.height) / 8);
-
-            code += '    ';
-            let byteStr = '';
-            for (let b = 0; b < bytesPerChar; b++) {
-                const byte = header.data[offset++];
-                byteStr += `0x${byte.toString(16).padStart(2, '0').toUpperCase()}`;
-                if (b < bytesPerChar - 1) {
-                    byteStr += ', ';
-                }
-            }
-            code += byteStr;
-            code += ',';
-            
-            // Pad to align comments
-            const padding = ' '.repeat(maxByteWidth - byteStr.length + 5);
-            
-            const widthInfo = header.isVariableWidth ? `, w=${charWidth}` : '';
-            code += `${padding}/* code=${charCode}, hex=0x${charCode.toString(16).padStart(2, '0').toUpperCase()}, ascii="${charStr}"${widthInfo} */\n`;
-        }
-
-        code += '};\n';
-
-        // Display output
-        outputCode.textContent = code;
-        output.classList.add('active');
-    }
-
-    // ==================== Header to WBF ====================
-    headerInput.addEventListener('input', () => {
-        convertToWbfBtn.disabled = headerInput.value.trim().length === 0;
-    });
-
-    convertToWbfBtn.addEventListener('click', () => {
-        const headerText = headerInput.value.trim();
-        if (!headerText) return;
-        
-        const wbfData = parseHeaderToWBF(headerText);
-        if (wbfData) {
-            downloadWBF(wbfData);
-        }
-    });
-
-    function parseHeaderToWBF(headerText) {
-        try {
-            // Properly remove C-style comments
-            let cleanedText = removeComments(headerText);
-            
-            // Extract all hex values from the cleaned text
-            const hexPattern = /0x[0-9a-fA-F]{2}/g;
-            const hexValues = cleanedText.match(hexPattern);
-            
-            if (!hexValues || hexValues.length < 12) {
-                alert('Invalid header: Could not find enough hex values (need at least 12 for header)\nFound: ' + (hexValues ? hexValues.length : 0) + ' bytes');
-                return null;
-            }
-            
-            // Convert hex strings to bytes
-            const allBytes = hexValues.map(hex => parseInt(hex, 16));
-            
-            // Parse the header (first 12 bytes)
-            const height = allBytes[1];
-            const maxWidth = allBytes[2];
-            const spacing = allBytes[3];
-            const flags = allBytes[4];
-            const first = allBytes[5];
-            const last = allBytes[6];
-            const reserved = allBytes[7];
-            const unicodeOffset = allBytes[8] | (allBytes[9] << 8) | (allBytes[10] << 16) | (allBytes[11] << 24);
-            
-            // Validate magic byte
-            if (allBytes[0] !== 0x57) {
-                alert('Invalid header: First byte should be 0x57 (magic \'W\'), found 0x' + allBytes[0].toString(16).padStart(2, '0').toUpperCase());
-                return null;
-            }
-            
-            const numChars = last - first + 1;
-            const isVariableWidth = (flags & 0x01) !== 0;
-            
-            // Now we need to separate header, width table (if present), and bitmap data
-            let dataStartIndex = 12; // After the 12-byte header
-            let widthTable = null;
-            
-            if (isVariableWidth) {
-                // Extract width table
-                widthTable = allBytes.slice(dataStartIndex, dataStartIndex + numChars);
-                dataStartIndex += numChars;
-            }
-            
-            // Calculate expected bitmap data size
-            let expectedBitmapSize = 0;
-            if (isVariableWidth) {
-                for (let w of widthTable) {
-                    expectedBitmapSize += Math.ceil((w * height) / 8);
-                }
-            } else {
-                expectedBitmapSize = numChars * Math.ceil((maxWidth * height) / 8);
-            }
-            
-            // Extract bitmap data
-            const bitmapData = allBytes.slice(dataStartIndex, dataStartIndex + expectedBitmapSize);
-            
-            // Validate we have all the data
-            const totalExpected = dataStartIndex + expectedBitmapSize;
-            if (allBytes.length < totalExpected) {
-                alert(`Invalid header: Expected at least ${totalExpected} bytes, found ${allBytes.length}\n\n` +
-                      `Header shows: ${numChars} characters from ${first} to ${last}\n` +
-                      `${isVariableWidth ? 'Variable width font' : 'Fixed width font'}\n` +
-                      `Height: ${height}, Max Width: ${maxWidth}\n` +
-                      `Expected bitmap size: ${expectedBitmapSize} bytes`);
-                return null;
-            }
-            
-            // Reconstruct the WBF file
-            let wbfSize = 12; // Header
-            if (isVariableWidth) {
-                wbfSize += numChars; // Width table
-            }
-            wbfSize += expectedBitmapSize; // Bitmap data
-            
-            const wbfData = new Uint8Array(wbfSize);
-            let offset = 0;
-            
-            // Write header
-            wbfData[offset++] = 0x57; // Magic 'W'
-            wbfData[offset++] = height;
-            wbfData[offset++] = maxWidth;
-            wbfData[offset++] = spacing;
-            wbfData[offset++] = flags;
-            wbfData[offset++] = first;
-            wbfData[offset++] = last;
-            wbfData[offset++] = reserved;
-            wbfData[offset++] = unicodeOffset & 0xFF;
-            wbfData[offset++] = (unicodeOffset >> 8) & 0xFF;
-            wbfData[offset++] = (unicodeOffset >> 16) & 0xFF;
-            wbfData[offset++] = (unicodeOffset >> 24) & 0xFF;
-            
-            // Write width table if variable width
-            if (isVariableWidth) {
-                for (let w of widthTable) {
-                    wbfData[offset++] = w;
-                }
-            }
-            
-            // Write bitmap data
-            for (let byte of bitmapData) {
-                wbfData[offset++] = byte;
-            }
-            
-            // Show success message
-            outputCode.textContent = `Successfully parsed header!\n\n` +
-                `Height: ${height}\n` +
-                `Max Width: ${maxWidth}\n` +
-                `Spacing: ${spacing}\n` +
-                `Flags: 0x${flags.toString(16).padStart(2, '0').toUpperCase()} (${isVariableWidth ? 'Variable Width' : 'Fixed Width'})\n` +
-                `Characters: ${first}-${last} (${numChars} glyphs)\n` +
-                `Unicode Offset: 0x${unicodeOffset.toString(16).padStart(8, '0').toUpperCase()}\n` +
-                `Total Size: ${wbfData.length} bytes\n` +
-                `  Header: 12 bytes\n` +
-                (isVariableWidth ? `  Width table: ${numChars} bytes\n` : '') +
-                `  Bitmap data: ${expectedBitmapSize} bytes\n` +
-                `Parsed ${allBytes.length} total hex values\n\n` +
-                `Your .wbf file is ready to download!`;
-            output.classList.add('active');
-            
-            return wbfData;
-        } catch (error) {
-            alert('Error parsing header: ' + error.message);
-            console.error('Parse error:', error);
-            return null;
-        }
-    }
-
-    // Proper C-style comment removal
-    function removeComments(code) {
-        let result = '';
-        let i = 0;
-        
-        while (i < code.length) {
-            // Check for // comment (single-line)
-            if (code[i] === '/' && code[i + 1] === '/') {
-                // Skip until end of line
-                i += 2;
-                while (i < code.length && code[i] !== '\n') {
-                    i++;
-                }
-                // Keep the newline
-                if (i < code.length) {
-                    result += '\n';
-                    i++;
-                }
-            }
-            // Check for /* comment (multi-line)
-            else if (code[i] === '/' && code[i + 1] === '*') {
-                // Skip until we find */
-                i += 2;
-                while (i < code.length - 1) {
-                    if (code[i] === '*' && code[i + 1] === '/') {
-                        i += 2;
-                        break;
-                    }
-                    // Preserve newlines in multi-line comments (for line counting if needed)
-                    if (code[i] === '\n') {
-                        result += '\n';
-                    }
-                    i++;
-                }
-            }
-            // Regular character
-            else {
-                result += code[i];
-                i++;
-            }
-        }
-        
-        return result;
-    }
-
-    function downloadWBF(data) {
-        const filename = wbfFilenameInput.value.trim() || 'font';
-        const blob = new Blob([data], { type: 'application/octet-stream' });
-        const a = document.createElement('a');
-        a.href = URL.createObjectURL(blob);
-        a.download = `${filename}.wbf`;
-        a.click();
-    }
-
-    // ==================== Utility Functions ====================
-    function getAsciiString(code) {
-        if (code < 32) {
-            // Control characters
-            return '^' + String.fromCharCode(64 + code);
-        } else if (code === 127) {
-            return '^?';
-        } else if (code >= 32 && code <= 126) {
-            // Printable ASCII
-            return String.fromCharCode(code);
-        } else {
-            // Extended ASCII
-            return '\\x' + code.toString(16).padStart(2, '0');
-        }
-    }
-
-    function copyToClipboard(event) {
-        const text = outputCode.textContent;
-        navigator.clipboard.writeText(text).then(() => {
-            const btn = event.target;
-            const originalText = btn.textContent;
-            btn.textContent = 'Copied!';
-            setTimeout(() => {
-                btn.textContent = originalText;
-            }, 2000);
-        }).catch(err => {
-            console.error('Clipboard error:', err);
-            // Fallback method for older browsers
-            const textarea = document.createElement('textarea');
-            textarea.value = text;
-            textarea.style.position = 'fixed';
-            textarea.style.opacity = '0';
-            document.body.appendChild(textarea);
-            textarea.select();
-            try {
-                document.execCommand('copy');
-                const btn = event.target;
-                const originalText = btn.textContent;
-                btn.textContent = 'Copied!';
-                setTimeout(() => {
-                    btn.textContent = originalText;
-                }, 2000);
-            } catch (e) {
-                alert('Failed to copy to clipboard: ' + e.message);
-            }
-            document.body.removeChild(textarea);
-        });
-    }
-</script>
-</body>
-</html>

tools/wled-tools

@@ -1,329 +0,0 @@
-#!/bin/bash
-
-# WLED Tools
-# A utility for managing WLED devices in a local network
-# https://github.com/wled/WLED
-
-# Color Definitions
-GREEN="\e[32m"
-RED="\e[31m"
-BLUE="\e[34m"
-YELLOW="\e[33m"
-RESET="\e[0m"
-
-# Logging function
-log() {
-    local category="$1"
-    local color="$2"
-    local text="$3"
-
-    if [ "$quiet" = true ]; then
-        return
-    fi
-
-    if [ -t 1 ]; then  # Check if output is a terminal
-        echo -e "${color}[${category}]${RESET} ${text}"
-    else
-        echo "[${category}] ${text}"
-    fi
-}
-
-# Fetch a URL to a destination file, validating status codes.
-# Usage: fetch "<url>" "<dest or empty>" "200 404"
-fetch() {
-    local url="$1"
-    local dest="$2"
-    local accepted="${3:-200}"
-
-    # If no dest given, just discard body
-    local out
-    if [ -n "$dest" ]; then
-        # Write to ".tmp" files first, then move when success, to ensure we don't write partial files
-        out="${dest}.tmp"
-    else
-        out="/dev/null"
-    fi
-
-    response=$(curl --connect-timeout 5 --max-time 30 -s -w "%{http_code}" -o "$out" "$url")
-    local curl_exit_code=$?
-
-    if [ $curl_exit_code -ne 0 ]; then
-        [ -n "$dest" ] && rm -f "$out"
-        log "ERROR" "$RED" "Connection error during request to $url (curl exit code: $curl_exit_code)."
-        return 1
-    fi
-
-    for code in $accepted; do
-        if [ "$response" = "$code" ]; then
-            # Accepted; only persist body for 2xx responses
-            if [ -n "$dest" ]; then
-                if [[ "$response" =~ ^2 ]]; then
-                    mv "$out" "$dest"
-                else
-                    rm -f "$out"
-                fi
-            fi
-            return 0
-        fi
-    done
-
-    # not accepted
-    [ -n "$dest" ] && rm -f "$out"
-    log "ERROR" "$RED" "Unexpected response from $url (HTTP $response)."
-    return 2
-}
-
-
-# POST a file to a URL, validating status codes.
-# Usage: post_file "<url>" "<file>" "200"
-post_file() {
-    local url="$1"
-    local file="$2"
-    local accepted="${3:-200}"
-
-    response=$(curl --connect-timeout 5 --max-time 300 -s -w "%{http_code}" -o /dev/null -X POST -F "file=@$file" "$url")
-    local curl_exit_code=$?
-
-    if [ $curl_exit_code -ne 0 ]; then
-        log "ERROR" "$RED" "Connection error during POST to $url (curl exit code: $curl_exit_code)."
-        return 1
-    fi
-
-    for code in $accepted; do
-        if [ "$response" -eq "$code" ]; then
-            return 0
-        fi
-    done
-
-    log "ERROR" "$RED" "Unexpected response from $url (HTTP $response)."
-    return 2
-}
-
-
-# Print help message
-show_help() {
-    cat << EOF
-Usage: wled-tools.sh [OPTIONS] COMMAND [ARGS...]
-
-Options:
-  -h, --help              Show this help message and exit.
-  -t, --target <IP/Host>  Specify a single WLED device by IP address or hostname.
-  -D, --discover          Discover multiple WLED devices using mDNS.
-  -d, --directory <Path>  Specify a directory for saving backups (default: working directory).
-  -f, --firmware <File>   Specify the firmware file for updating devices.
-  -q, --quiet             Suppress logging output (also makes discover output hostnames only).
-
-Commands:
-  backup      Backup the current state of a WLED device or multiple discovered devices.
-  update      Update the firmware of a WLED device or multiple discovered devices.
-  discover    Discover WLED devices using mDNS and list their IP addresses and names.
-
-Examples:
-  # Discover all WLED devices on the network
-  ./wled-tools discover
-
-  # Backup a specific WLED device
-  ./wled-tools -t 192.168.1.100 backup
-
-  # Backup all discovered WLED devices to a specific directory
-  ./wled-tools -D -d /path/to/backups backup
-
-  # Update firmware on all discovered WLED devices
-  ./wled-tools -D -f /path/to/firmware.bin update
-
-EOF
-}
-
-# Discover devices using mDNS
-discover_devices() {  
-    if ! command -v avahi-browse &> /dev/null; then  
-        log "ERROR" "$RED" "'avahi-browse' is required but not installed, please install avahi-utils using your preferred package manager."
-        exit 1  
-    fi  
-
-    # 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  
-        IFS=$'\x1F' read -r hostname address port <<< "$device"  
-        devices_array+=("$hostname" "$address" "$port")  
-    done  
-
-    echo "${devices_array[@]}"  
-}  
-
-# Backup one device
-backup_one() {
-    local hostname="$1"
-    local address="$2"
-    local port="$3"
-
-    log "INFO" "$YELLOW" "Backing up device config/presets/ir: $hostname ($address:$port)"
-
-    mkdir -p "$backup_dir"
-
-    local file_prefix="${backup_dir}/${hostname}"
-
-    if ! fetch "http://$address:$port/cfg.json" "${file_prefix}.cfg.json"; then  
-        log "ERROR" "$RED" "Failed to backup configuration for $hostname"  
-        return 1  
-    fi  
-    
-    if ! fetch "http://$address:$port/presets.json" "${file_prefix}.presets.json"; then  
-        log "ERROR" "$RED" "Failed to backup presets for $hostname"  
-        return 1  
-    fi
-
-    # ir.json is optional
-    if ! fetch "http://$address:$port/ir.json" "${file_prefix}.ir.json" "200 404"; then
-        log "ERROR" "$RED" "Failed to backup ir configs for $hostname" 
-    fi
-
-    log "INFO" "$GREEN" "Successfully backed up config and presets for $hostname"
-    return 0
-}
-
-# Update one device
-update_one() {
-    local hostname="$1"
-    local address="$2"
-    local port="$3"
-    local firmware="$4"
-
-    log "INFO" "$YELLOW" "Starting firmware update for device: $hostname ($address:$port)"
-
-    local url="http://$address:$port/update"
-
-    if ! post_file "$url" "$firmware" "200"; then
-        log "ERROR" "$RED" "Failed to update firmware for $hostname"
-        return 1
-    fi
-    
-    log "INFO" "$GREEN" "Successfully initiated firmware update for $hostname"
-    return 0
-}
-
-# Command-line arguments processing
-command=""
-target=""
-discover=false
-quiet=false
-backup_dir="./"
-firmware_file=""
-
-if [ $# -eq 0 ]; then
-    show_help
-    exit 0
-fi
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        -h|--help)
-            show_help
-            exit 0
-            ;;
-        -t|--target)
-            if [ -z "$2" ] || [[ "$2" == -* ]]; then
-                log "ERROR" "$RED" "The --target option requires an argument."
-                exit 1
-            fi
-            target="$2"
-            shift 2
-            ;;
-        -D|--discover)
-            discover=true
-            shift
-            ;;
-        -d|--directory)
-            if [ -z "$2" ] || [[ "$2" == -* ]]; then
-                log "ERROR" "$RED" "The --directory option requires an argument."
-                exit 1
-            fi
-            backup_dir="$2"
-            shift 2
-            ;;
-        -f|--firmware)
-            if [ -z "$2" ] || [[ "$2" == -* ]]; then
-                log "ERROR" "$RED" "The --firmware option requires an argument."
-                exit 1
-            fi
-            firmware_file="$2"
-            shift 2
-            ;;
-        -q|--quiet)
-            quiet=true
-            shift
-            ;;
-        backup|update|discover)
-            command="$1"
-            shift
-            ;;
-        *)
-            log "ERROR" "$RED" "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Execute the appropriate command
-case "$command" in
-    discover)
-        read -ra devices <<< "$(discover_devices)"
-        for ((i=0; i<${#devices[@]}; i+=3)); do
-            hostname="${devices[$i]}"
-            address="${devices[$i+1]}"
-            port="${devices[$i+2]}"
-
-            if [ "$quiet" = true ]; then
-                echo "$hostname"
-            else
-                log "INFO" "$BLUE" "Discovered device: Hostname=$hostname, Address=$address, Port=$port"
-            fi
-        done
-        ;;
-    backup)
-        if [ -n "$target" ]; then
-            # Assume target is both the hostname and address, with port 80
-            backup_one "$target" "$target" "80"
-        elif [ "$discover" = true ]; then
-            read -ra devices <<< "$(discover_devices)"
-            for ((i=0; i<${#devices[@]}; i+=3)); do
-                hostname="${devices[$i]}"
-                address="${devices[$i+1]}"
-                port="${devices[$i+2]}"
-                backup_one "$hostname" "$address" "$port"
-            done
-        else
-            log "ERROR" "$RED" "No target specified. Use --target or --discover."
-            exit 1
-        fi
-        ;;
-    update)
-        # Validate firmware before proceeding
-        if [ -z "$firmware_file" ] || [ ! -f "$firmware_file" ]; then
-            log "ERROR" "$RED" "Please provide a file in --firmware that exists"
-            exit 1
-        fi
-        
-        if [ -n "$target" ]; then
-            # Assume target is both the hostname and address, with port 80
-            update_one "$target" "$target" "80" "$firmware_file"
-        elif [ "$discover" = true ]; then
-            read -ra devices <<< "$(discover_devices)"
-            for ((i=0; i<${#devices[@]}; i+=3)); do
-                hostname="${devices[$i]}"
-                address="${devices[$i+1]}"
-                port="${devices[$i+2]}"
-                update_one "$hostname" "$address" "$port" "$firmware_file"
-            done
-        else
-            log "ERROR" "$RED" "No target specified. Use --target or --discover."
-            exit 1
-        fi
-        ;;
-    *)
-        show_help
-        exit 1
-        ;;
-esac

usermods/ADS1115_v2/library.json

@@ -1,8 +0,0 @@
-{
-  "name": "ADS1115_v2",
-  "build": { "libArchive": false },
-  "dependencies": {
-    "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

@@ -6,5 +6,5 @@ Configuration is performed via the Usermod menu. There are no parameters to set
 
 ## Installation 
 
-Add 'ADS1115' to `custom_usermods` in your platformio environment.
-
+Add the build flag `-D USERMOD_ADS1115` to your platformio environment.
+Uncomment libraries with comment `#For ADS1115 sensor uncomment following`

usermods/ADS1115_v2/usermod_ads1115.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "wled.h"
 #include <Adafruit_ADS1X15.h>
 #include <math.h>
@@ -250,7 +252,4 @@ class ADS1115Usermod : public Usermod {
         int16_t results = ads.getLastConversionResults();
         readings[activeChannel] = ads.computeVolts(results);
     }
-};
-
-static ADS1115Usermod ads1115_v2;
-REGISTER_USERMOD(ads1115_v2);
+};

usermods/AHT10_v2/README.md

@@ -22,9 +22,15 @@ Dependencies, These must be added under `lib_deps` in your `platform.ini` (or `p
 
 # Compiling
 
-To enable, add 'AHT10' to `custom_usermods` in your platformio encrionment  (e.g. in `platformio_override.ini`)
+To enable, compile with `USERMOD_AHT10` defined  (e.g. in `platformio_override.ini`)
 ```ini
 [env:aht10_example]
 extends = env:esp32dev
-custom_usermods = ${env:esp32dev.custom_usermods} AHT10
+build_flags =
+  ${common.build_flags} ${esp32.build_flags}
+  -D USERMOD_AHT10
+  ; -D USERMOD_AHT10_DEBUG ; -- add a debug status to the info modal
+lib_deps = 
+  ${esp32.lib_deps}
+  enjoyneering/AHT10@~1.1.0
 ```

usermods/AHT10_v2/library.json

@@ -1,7 +0,0 @@
-{
-  "name": "AHT10_v2",
-  "build": { "libArchive": false },  
-  "dependencies": {
-    "enjoyneering/AHT10":"~1.1.0"
-  }
-}

usermods/AHT10_v2/platformio_override.ini

@@ -2,4 +2,8 @@
 extends = env:esp32dev
 build_flags =
   ${common.build_flags} ${esp32.build_flags}
+  -D USERMOD_AHT10
   ; -D USERMOD_AHT10_DEBUG ; -- add a debug status to the info modal
+lib_deps = 
+  ${esp32.lib_deps}
+  enjoyneering/AHT10@~1.1.0

usermods/AHT10_v2/usermod_aht10.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "wled.h"
 #include <AHT10.h>
 
@@ -52,6 +54,12 @@ private:
     _lastTemperature = 0;
   }
 
+  ~UsermodAHT10()
+  {
+    delete _aht;
+    _aht = nullptr;
+  }
+
 #ifndef WLED_DISABLE_MQTT
   void mqttInitialize()
   {
@@ -314,15 +322,6 @@ public:
     _initDone = true;
     return configComplete;
   }
-
-  ~UsermodAHT10()
-  {
-    delete _aht;
-    _aht = nullptr;
-  }
 };
 
-const char UsermodAHT10::_name[] PROGMEM = "AHTxx";
-
-static UsermodAHT10 aht10_v2;
-REGISTER_USERMOD(aht10_v2);
+const char UsermodAHT10::_name[] PROGMEM = "AHTxx";

usermods/Analog_Clock/Analog_Clock.h

@@ -1,8 +1,10 @@
+#pragma once
 #include "wled.h"
 
 /*
  * Usermod for analog clock
  */
+extern Timezone* tz;
 
 class AnalogClockUsermod : public Usermod {
 private:
@@ -100,10 +102,10 @@ private:
 
     void secondsEffectSineFade(int16_t secondLed, Toki::Time const& time) {
         uint32_t ms = time.ms % 1000;
-        uint8_t b0 = (cos8_t(ms * 64 / 1000) - 128) * 2;
-        setPixelColor(secondLed, scale32(secondColor, b0));
-        uint8_t b1 = (sin8_t(ms * 64 / 1000) - 128) * 2;
-        setPixelColor(inc(secondLed, 1, secondsSegment), scale32(secondColor, b1));
+        uint8_t b0 = (cos8(ms * 64 / 1000) - 128) * 2;
+        setPixelColor(secondLed, gamma32(scale32(secondColor, b0)));
+        uint8_t b1 = (sin8(ms * 64 / 1000) - 128) * 2;
+        setPixelColor(inc(secondLed, 1, secondsSegment), gamma32(scale32(secondColor, b1)));
     }
 
     static inline uint32_t qadd32(uint32_t c1, uint32_t c2) {
@@ -115,7 +117,7 @@ private:
         );
     }
 
-    static inline uint32_t scale32(uint32_t c, uint8_t scale) {
+    static inline uint32_t scale32(uint32_t c, fract8 scale) {
         return RGBW32(
             scale8(R(c), scale),
             scale8(G(c), scale),
@@ -190,7 +192,7 @@ public:
             // for (uint16_t i = 1; i < secondsTrail + 1; ++i) {
             //     uint16_t trailLed = dec(secondLed, i, secondsSegment);
             //     uint8_t trailBright = 255 / (secondsTrail + 1) * (secondsTrail - i + 1);
-            //     setPixelColor(trailLed, scale32(secondColor, trailBright));
+            //     setPixelColor(trailLed, gamma32(scale32(secondColor, trailBright)));
             // }
         }
 
@@ -252,7 +254,3 @@ public:
         return USERMOD_ID_ANALOG_CLOCK;
     }
 };
-
-
-static AnalogClockUsermod analog_clock;
-REGISTER_USERMOD(analog_clock);

usermods/Analog_Clock/library.json

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

usermods/Animated_Staircase/Animated_Staircase.h

@@ -7,6 +7,7 @@
  * 
  * See the accompanying README.md file for more info.
  */
+#pragma once
 #include "wled.h"
 
 class Animated_Staircase : public Usermod {
@@ -561,7 +562,3 @@ const char Animated_Staircase::_bottomEcho_pin[]            PROGMEM = "bottomEch
 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/Animated_Staircase/README.md

@@ -1,5 +1,4 @@
 # Usermod Animated Staircase
-
 This usermod makes your staircase look cool by illuminating it with an animation. It uses
 PIR or ultrasonic sensors at the top and bottom of your stairs to:
 
@@ -12,15 +11,14 @@ The Animated Staircase can be controlled by the WLED API. Change settings such a
 speed, on/off time and distance by sending an HTTP request, see below.
 
 ## WLED integration
-
 To include this usermod in your WLED setup, you have to be able to [compile WLED from source](https://kno.wled.ge/advanced/compiling-wled/).
 
 Before compiling, you have to make the following modifications:
 
-Edit your environment in `platformio_override.ini`
-
-1. Open `platformio_override.ini`
-2. add `Animated_Staircase` to the `custom_usermods` line for your environment
+Edit `usermods_list.cpp`:
+1. Open `wled00/usermods_list.cpp`
+2. add `#include "../usermods/Animated_Staircase/Animated_Staircase.h"` to the top of the file
+3. add `UsermodManager::add(new Animated_Staircase());` to the end of the `void registerUsermods()` function.
 
 You can configure usermod using the Usermods settings page.
 Please enter GPIO pins for PIR or ultrasonic sensors (trigger and echo).
@@ -28,10 +26,10 @@ If you use PIR sensor enter -1 for echo pin.
 Maximum distance for ultrasonic sensor can be configured as the time needed for an echo (see below).
 
 ## Hardware installation
-
 1. Attach the LED strip to each step of the stairs.
 2. Connect the ESP8266 pin D4 or ESP32 pin D2 to the first LED data pin at the bottom step.
-3. Connect the data-out pin at the end of each strip per step to the data-in pin on the next step, creating one large virtual LED strip.
+3. Connect the data-out pin at the end of each strip per step to the data-in pin on the 
+   next step, creating one large virtual LED strip.
 4. Mount sensors of choice at the bottom and top of the stairs and connect them to the ESP.
 5. To make sure all LEDs get enough power and have your staircase lighted evenly, power each
    step from one side, using at least AWG14 or 2.5mm^2 cable. Don't connect them serial as you
@@ -40,23 +38,24 @@ Maximum distance for ultrasonic sensor can be configured as the time needed for
 You _may_ need to use 10k pull-down resistors on the selected PIR pins, depending on the sensor.
 
 ## WLED configuration
-
-1. In the WLED UI, configure a segment for each step. The lowest step of the stairs is the lowest segment id.
-2. Save your segments into a preset.
-3. Ideally, add the preset in the config > LED setup menu to the "apply preset **n** at boot" setting.
+1. In the WLED UI, configure a segment for each step. The lowest step of the stairs is the 
+   lowest segment id. 
+2. Save your segments into a preset. 
+3. Ideally, add the preset in the config > LED setup menu to the "apply 
+   preset **n** at boot" setting.
 
 ## Changing behavior through API
-
 The Staircase settings can be changed through the WLED JSON api.
 
 **NOTE:** We are using [curl](https://curl.se/) to send HTTP POSTs to the WLED API.
 If you're using Windows and want to use the curl commands, replace the `\` with a `^`
 or remove them and put everything on one line.
 
+
 | Setting          | Description                                                   | Default |
 |------------------|---------------------------------------------------------------|---------|
 | enabled          | Enable or disable the usermod                                 | true    |
-| bottom-sensor    | Manually trigger a down to up animation via API               | false   |
+| bottom-sensor    | Manually trigger a down to up animation via API               | false   | 
 | top-sensor       | Manually trigger an up to down animation via API              | false   |
 
 
@@ -76,7 +75,6 @@ The staircase settings and sensor states are inside the WLED "state" element:
 ```
 
 ### Enable/disable the usermod
-
 By disabling the usermod you will be able to keep the LED's on, independent from the sensor
 activity. This enables you to play with the lights without the usermod switching them on or off.
 
@@ -93,7 +91,6 @@ To enable the usermod again, use `"enabled":true`.
 Alternatively you can use _Usermod_ Settings page where you can change other parameters as well.
 
 ### Changing animation parameters and detection range of the ultrasonic HC-SR04 sensor
-
 Using _Usermod_ Settings page you can define different usermod parameters, including sensor pins, delay between segment activation etc.
 
 When an ultrasonic sensor is enabled you can enter maximum detection distance in centimeters separately for top and bottom sensors.
@@ -103,7 +100,6 @@ distances creates delays in the WLED software, _might_ introduce timing hiccups
 a less responsive web interface. It is therefore advised to keep the detection distance as short as possible.
 
 ### Animation triggering through the API
-
 In addition to activation by one of the stair sensors, you can also trigger the animation manually
 via the API. To simulate triggering the bottom sensor, use:
 
@@ -120,19 +116,15 @@ curl -X POST -H "Content-Type: application/json" \
      -d '{"staircase":{"top-sensor":true}}' \
      xxx.xxx.xxx.xxx/json/state
 ```
-
 **MQTT**
 You can publish a message with either `up` or `down` on topic `/swipe` to trigger animation.
 You can also use `on` or `off` for enabling or disabling the usermod.
 
-Have fun with this usermod
-
-`www.rolfje.com`
+Have fun with this usermod.<br/>
+www.rolfje.com
 
 Modifications @blazoncek
 
 ## Change log
-
 2021-04
-
-- Adaptation for runtime configuration.
+* Adaptation for runtime configuration.

usermods/Animated_Staircase/library.json

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

usermods/BH1750_v2/BH1750_v2.cpp

@@ -1,186 +0,0 @@
-// force the compiler to show a warning to confirm that this file is included
-#warning **** Included USERMOD_BH1750 ****
-
-#include "wled.h"
-#include "BH1750_v2.h"
-
-#ifdef WLED_DISABLE_MQTT
-#error "This user mod requires MQTT to be enabled."
-#endif
-
-static bool checkBoundSensor(float newValue, float prevValue, float maxDiff)
-{
-  return isnan(prevValue) || newValue <= prevValue - maxDiff || newValue >= prevValue + maxDiff || (newValue == 0.0 && prevValue > 0.0);
-}
-
-void Usermod_BH1750::_mqttInitialize()
-{
-  mqttLuminanceTopic = String(mqttDeviceTopic) + F("/brightness");
-
-  if (HomeAssistantDiscovery) _createMqttSensor(F("Brightness"), mqttLuminanceTopic, F("Illuminance"), F(" lx"));
-}
-
-// Create an MQTT Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
-void Usermod_BH1750::_createMqttSensor(const String &name, const String &topic, const String &deviceClass, const String &unitOfMeasurement)
-{
-  String t = String(F("homeassistant/sensor/")) + mqttClientID + F("/") + name + F("/config");
-  
-  StaticJsonDocument<600> doc;
-  
-  doc[F("name")] = String(serverDescription) + " " + name;
-  doc[F("state_topic")] = topic;
-  doc[F("unique_id")] = String(mqttClientID) + name;
-  if (unitOfMeasurement != "")
-    doc[F("unit_of_measurement")] = unitOfMeasurement;
-  if (deviceClass != "")
-    doc[F("device_class")] = deviceClass;
-  doc[F("expire_after")] = 1800;
-
-  JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device
-  device[F("name")] = serverDescription;
-  device[F("identifiers")] = "wled-sensor-" + String(mqttClientID);
-  device[F("manufacturer")] = F(WLED_BRAND);
-  device[F("model")] = F(WLED_PRODUCT_NAME);
-  device[F("sw_version")] = versionString;
-
-  String temp;
-  serializeJson(doc, temp);
-  DEBUG_PRINTLN(t);
-  DEBUG_PRINTLN(temp);
-
-  mqtt->publish(t.c_str(), 0, true, temp.c_str());
-}
-
-void Usermod_BH1750::setup()
-{
-  if (i2c_scl<0 || i2c_sda<0) { enabled = false; return; }
-  sensorFound = lightMeter.begin();
-  initDone = true;
-}
-
-void Usermod_BH1750::loop()
-{
-  if ((!enabled) || strip.isUpdating())
-    return;
-
-  unsigned long now = millis();
-
-  // check to see if we are due for taking a measurement
-  // lastMeasurement will not be updated until the conversion
-  // is complete the the reading is finished
-  if (now - lastMeasurement < minReadingInterval)
-  {
-    return;
-  }
-
-  bool shouldUpdate = now - lastSend > maxReadingInterval;
-
-  float lux = lightMeter.readLightLevel();
-  lastMeasurement = millis();
-  getLuminanceComplete = true;
-
-  if (shouldUpdate || checkBoundSensor(lux, lastLux, offset))
-  {
-    lastLux = lux;
-    lastSend = millis();
-
-    if (WLED_MQTT_CONNECTED)
-    {
-      if (!mqttInitialized)
-        {
-          _mqttInitialize();
-          mqttInitialized = true;
-        }
-      mqtt->publish(mqttLuminanceTopic.c_str(), 0, true, String(lux).c_str());
-      DEBUG_PRINTLN(F("Brightness: ") + String(lux) + F("lx"));
-    }
-    else
-    {
-      DEBUG_PRINTLN(F("Missing MQTT connection. Not publishing data"));
-    }
-  }
-}
-
-
-void Usermod_BH1750::addToJsonInfo(JsonObject &root)
-{
-  JsonObject user = root[F("u")];
-  if (user.isNull())
-    user = root.createNestedObject(F("u"));
-
-  JsonArray lux_json = user.createNestedArray(F("Luminance"));
-  if (!enabled) {
-    lux_json.add(F("disabled"));
-  } else if (!sensorFound) {
-      // if no sensor 
-      lux_json.add(F("BH1750 "));
-      lux_json.add(F("Not Found"));
-  } else if (!getLuminanceComplete) {
-    // if we haven't read the sensor yet, let the user know
-      // that we are still waiting for the first measurement
-      lux_json.add((USERMOD_BH1750_FIRST_MEASUREMENT_AT - millis()) / 1000);
-      lux_json.add(F(" sec until read"));
-      return;
-  } else {
-    lux_json.add(lastLux);
-    lux_json.add(F(" lx"));
-  }
-}
-
-// (called from set.cpp) stores persistent properties to cfg.json
-void Usermod_BH1750::addToConfig(JsonObject &root)
-{
-  // we add JSON object.
-  JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
-  top[FPSTR(_enabled)] = enabled;
-  top[FPSTR(_maxReadInterval)] = maxReadingInterval;
-  top[FPSTR(_minReadInterval)] = minReadingInterval;
-  top[FPSTR(_HomeAssistantDiscovery)] = HomeAssistantDiscovery;
-  top[FPSTR(_offset)] = offset;
-
-  DEBUG_PRINTLN(F("BH1750 config saved."));
-}
-
-// called before setup() to populate properties from values stored in cfg.json
-bool Usermod_BH1750::readFromConfig(JsonObject &root)
-{
-  // we look for JSON object.
-  JsonObject top = root[FPSTR(_name)];
-  if (top.isNull())
-  {
-    DEBUG_PRINT(FPSTR(_name));
-    DEBUG_PRINT(F("BH1750"));
-    DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
-    return false;
-  }
-  bool configComplete = !top.isNull();
-
-  configComplete &= getJsonValue(top[FPSTR(_enabled)], enabled, false);
-  configComplete &= getJsonValue(top[FPSTR(_maxReadInterval)], maxReadingInterval, 10000); //ms
-  configComplete &= getJsonValue(top[FPSTR(_minReadInterval)], minReadingInterval, 500); //ms
-  configComplete &= getJsonValue(top[FPSTR(_HomeAssistantDiscovery)], HomeAssistantDiscovery, false);
-  configComplete &= getJsonValue(top[FPSTR(_offset)], offset, 1);
-
-  DEBUG_PRINT(FPSTR(_name));
-  if (!initDone) {
-    DEBUG_PRINTLN(F(" config loaded."));
-  } else {
-    DEBUG_PRINTLN(F(" config (re)loaded."));
-  }
-
-  return configComplete;
-  
-}
-
-
-// strings to reduce flash memory usage (used more than twice)
-const char Usermod_BH1750::_name[] PROGMEM = "BH1750";
-const char Usermod_BH1750::_enabled[] PROGMEM = "enabled";
-const char Usermod_BH1750::_maxReadInterval[] PROGMEM = "max-read-interval-ms";
-const char Usermod_BH1750::_minReadInterval[] PROGMEM = "min-read-interval-ms";
-const char Usermod_BH1750::_HomeAssistantDiscovery[] PROGMEM = "HomeAssistantDiscoveryLux";
-const char Usermod_BH1750::_offset[] PROGMEM = "offset-lx";
-
-
-static Usermod_BH1750 bh1750_v2;
-REGISTER_USERMOD(bh1750_v2);

usermods/BH1750_v2/BH1750_v2.h

@@ -1,92 +0,0 @@
-
-#pragma once
-#include "wled.h"
-#include <BH1750.h>
-
-#ifdef WLED_DISABLE_MQTT
-#error "This user mod requires MQTT to be enabled."
-#endif
-
-// the max frequency to check photoresistor, 10 seconds
-#ifndef USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL
-#define USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL 10000
-#endif
-
-// the min frequency to check photoresistor, 500 ms
-#ifndef USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL
-#define USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL 500
-#endif
-
-// how many seconds after boot to take first measurement, 10 seconds
-#ifndef USERMOD_BH1750_FIRST_MEASUREMENT_AT
-#define USERMOD_BH1750_FIRST_MEASUREMENT_AT 10000
-#endif
-
-// only report if difference grater than offset value
-#ifndef USERMOD_BH1750_OFFSET_VALUE
-#define USERMOD_BH1750_OFFSET_VALUE 1
-#endif
-
-class Usermod_BH1750 : public Usermod
-{
-private:
-  int8_t offset = USERMOD_BH1750_OFFSET_VALUE;
-
-  unsigned long maxReadingInterval = USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL;
-  unsigned long minReadingInterval = USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL;
-  unsigned long lastMeasurement = UINT32_MAX - (USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL - USERMOD_BH1750_FIRST_MEASUREMENT_AT);
-  unsigned long lastSend = UINT32_MAX - (USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL - USERMOD_BH1750_FIRST_MEASUREMENT_AT);
-  // flag to indicate we have finished the first readLightLevel call
-  // allows this library to report to the user how long until the first
-  // measurement
-  bool getLuminanceComplete = false;
-
-  // flag set at startup
-  bool enabled = true;
-
-  // strings to reduce flash memory usage (used more than twice)
-  static const char _name[];
-  static const char _enabled[];
-  static const char _maxReadInterval[];
-  static const char _minReadInterval[];
-  static const char _offset[];
-  static const char _HomeAssistantDiscovery[];
-
-  bool initDone = false;
-  bool sensorFound = false;
-
-  // Home Assistant and MQTT  
-  String mqttLuminanceTopic;
-  bool mqttInitialized = false;
-  bool HomeAssistantDiscovery = true; // Publish Home Assistant Discovery messages
-
-  BH1750 lightMeter;
-  float lastLux = -1000;
-
-  // set up Home Assistant discovery entries
-  void _mqttInitialize();
-
-  // Create an MQTT Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
-  void _createMqttSensor(const String &name, const String &topic, const String &deviceClass, const String &unitOfMeasurement);
-
-public:
-  void setup();
-  void loop();
-  inline float getIlluminance()  {
-    return (float)lastLux;
-  }
-
-  void addToJsonInfo(JsonObject &root);
-
-  // (called from set.cpp) stores persistent properties to cfg.json
-  void addToConfig(JsonObject &root);
-
-  // called before setup() to populate properties from values stored in cfg.json
-  bool readFromConfig(JsonObject &root);
-
-  inline uint16_t getId()
-  {
-    return USERMOD_ID_BH1750;
-  }
-
-};

usermods/BH1750_v2/library.json

@@ -1,7 +0,0 @@
-{
-  "name": "BH1750_v2",
-  "build": { "libArchive": false },
-  "dependencies": {
-    "claws/BH1750":"^1.2.0"
-  }
-}

usermods/BH1750_v2/readme.md

@@ -4,40 +4,43 @@ This usermod will read from an ambient light sensor like the BH1750.
 The luminance is displayed in both the Info section of the web UI, as well as published to the `/luminance` MQTT topic if enabled.
 
 ## Dependencies
-
 - Libraries
   - `claws/BH1750 @^1.2.0`
+  - This must be added under `lib_deps` in your `platformio.ini` (or `platformio_override.ini`).
 - Data is published over MQTT - make sure you've enabled the MQTT sync interface.
 
 ## Compilation
 
-To enable, compile with `BH1750` in `custom_usermods` (e.g. in `platformio_override.ini`)
+To enable, compile with `USERMOD_BH1750` defined  (e.g. in `platformio_override.ini`)
+```ini
+[env:usermod_BH1750_d1_mini]
+extends = env:d1_mini
+build_flags =
+    ${common.build_flags_esp8266}
+    -D USERMOD_BH1750
+lib_deps = 
+    ${esp8266.lib_deps}
+    claws/BH1750 @ ^1.2.0
+```
 
 ### Configuration Options
-
 The following settings can be set at compile-time but are configurable on the usermod menu (except First Measurement time):
-
-- `USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL` - the max number of milliseconds between measurements, defaults to 10000ms
-- `USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL` - the min number of milliseconds between measurements, defaults to 500ms
-- `USERMOD_BH1750_OFFSET_VALUE` - the offset value to report on, defaults to 1
-- `USERMOD_BH1750_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 10000 ms
+*   `USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL` - the max number of milliseconds between measurements, defaults to 10000ms
+*   `USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL` - the min number of milliseconds between measurements, defaults to 500ms
+*   `USERMOD_BH1750_OFFSET_VALUE` - the offset value to report on, defaults to 1
+*   `USERMOD_BH1750_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 10000 ms
 
 In addition, the Usermod screen allows you to:
-
 - enable/disable the usermod
 - Enable Home Assistant Discovery of usermod
 - Configure the SCL/SDA pins
 
 ## API
-
 The following method is available to interact with the usermod from other code modules:
-
 - `getIlluminance` read the brightness from the sensor
 
 ## Change Log
-
 Jul 2022
-
 - Added Home Assistant Discovery
 - Implemented PinManager to register pins
 - Made pins configurable in usermod menu

usermods/BH1750_v2/usermod_bh1750.h

@@ -0,0 +1,252 @@
+// force the compiler to show a warning to confirm that this file is included
+#warning **** Included USERMOD_BH1750 ****
+
+#ifndef WLED_ENABLE_MQTT
+#error "This user mod requires MQTT to be enabled."
+#endif
+
+#pragma once
+
+#include "wled.h"
+#include <BH1750.h>
+
+// the max frequency to check photoresistor, 10 seconds
+#ifndef USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL
+#define USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL 10000
+#endif
+
+// the min frequency to check photoresistor, 500 ms
+#ifndef USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL
+#define USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL 500
+#endif
+
+// how many seconds after boot to take first measurement, 10 seconds
+#ifndef USERMOD_BH1750_FIRST_MEASUREMENT_AT
+#define USERMOD_BH1750_FIRST_MEASUREMENT_AT 10000
+#endif
+
+// only report if difference grater than offset value
+#ifndef USERMOD_BH1750_OFFSET_VALUE
+#define USERMOD_BH1750_OFFSET_VALUE 1
+#endif
+
+class Usermod_BH1750 : public Usermod
+{
+private:
+  int8_t offset = USERMOD_BH1750_OFFSET_VALUE;
+
+  unsigned long maxReadingInterval = USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL;
+  unsigned long minReadingInterval = USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL;
+  unsigned long lastMeasurement = UINT32_MAX - (USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL - USERMOD_BH1750_FIRST_MEASUREMENT_AT);
+  unsigned long lastSend = UINT32_MAX - (USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL - USERMOD_BH1750_FIRST_MEASUREMENT_AT);
+  // flag to indicate we have finished the first readLightLevel call
+  // allows this library to report to the user how long until the first
+  // measurement
+  bool getLuminanceComplete = false;
+
+  // flag set at startup
+  bool enabled = true;
+
+  // strings to reduce flash memory usage (used more than twice)
+  static const char _name[];
+  static const char _enabled[];
+  static const char _maxReadInterval[];
+  static const char _minReadInterval[];
+  static const char _offset[];
+  static const char _HomeAssistantDiscovery[];
+
+  bool initDone = false;
+  bool sensorFound = false;
+
+  // Home Assistant and MQTT  
+  String mqttLuminanceTopic;
+  bool mqttInitialized = false;
+  bool HomeAssistantDiscovery = true; // Publish Home Assistant Discovery messages
+
+  BH1750 lightMeter;
+  float lastLux = -1000;
+
+  bool checkBoundSensor(float newValue, float prevValue, float maxDiff)
+  {
+    return isnan(prevValue) || newValue <= prevValue - maxDiff || newValue >= prevValue + maxDiff || (newValue == 0.0 && prevValue > 0.0);
+  }
+  
+  // set up Home Assistant discovery entries
+  void _mqttInitialize()
+  {
+    mqttLuminanceTopic = String(mqttDeviceTopic) + F("/brightness");
+
+    if (HomeAssistantDiscovery) _createMqttSensor(F("Brightness"), mqttLuminanceTopic, F("Illuminance"), F(" lx"));
+  }
+
+  // Create an MQTT Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
+  void _createMqttSensor(const String &name, const String &topic, const String &deviceClass, const String &unitOfMeasurement)
+  {
+    String t = String(F("homeassistant/sensor/")) + mqttClientID + F("/") + name + F("/config");
+    
+    StaticJsonDocument<600> doc;
+    
+    doc[F("name")] = String(serverDescription) + " " + name;
+    doc[F("state_topic")] = topic;
+    doc[F("unique_id")] = String(mqttClientID) + name;
+    if (unitOfMeasurement != "")
+      doc[F("unit_of_measurement")] = unitOfMeasurement;
+    if (deviceClass != "")
+      doc[F("device_class")] = deviceClass;
+    doc[F("expire_after")] = 1800;
+
+    JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device
+    device[F("name")] = serverDescription;
+    device[F("identifiers")] = "wled-sensor-" + String(mqttClientID);
+    device[F("manufacturer")] = F(WLED_BRAND);
+    device[F("model")] = F(WLED_PRODUCT_NAME);
+    device[F("sw_version")] = versionString;
+
+    String temp;
+    serializeJson(doc, temp);
+    DEBUG_PRINTLN(t);
+    DEBUG_PRINTLN(temp);
+
+    mqtt->publish(t.c_str(), 0, true, temp.c_str());
+  }
+
+public:
+  void setup()
+  {
+    if (i2c_scl<0 || i2c_sda<0) { enabled = false; return; }
+    sensorFound = lightMeter.begin();
+    initDone = true;
+  }
+
+  void loop()
+  {
+    if ((!enabled) || strip.isUpdating())
+      return;
+
+    unsigned long now = millis();
+
+    // check to see if we are due for taking a measurement
+    // lastMeasurement will not be updated until the conversion
+    // is complete the the reading is finished
+    if (now - lastMeasurement < minReadingInterval)
+    {
+      return;
+    }
+
+    bool shouldUpdate = now - lastSend > maxReadingInterval;
+
+    float lux = lightMeter.readLightLevel();
+    lastMeasurement = millis();
+    getLuminanceComplete = true;
+
+    if (shouldUpdate || checkBoundSensor(lux, lastLux, offset))
+    {
+      lastLux = lux;
+      lastSend = millis();
+#ifndef WLED_DISABLE_MQTT
+      if (WLED_MQTT_CONNECTED)
+      {
+        if (!mqttInitialized)
+          {
+            _mqttInitialize();
+            mqttInitialized = true;
+          }
+        mqtt->publish(mqttLuminanceTopic.c_str(), 0, true, String(lux).c_str());
+        DEBUG_PRINTLN(F("Brightness: ") + String(lux) + F("lx"));
+      }
+      else
+      {
+        DEBUG_PRINTLN(F("Missing MQTT connection. Not publishing data"));
+      }
+#endif
+    }
+  }
+
+  inline float getIlluminance() {
+    return (float)lastLux;
+  }
+
+  void addToJsonInfo(JsonObject &root)
+  {
+    JsonObject user = root[F("u")];
+    if (user.isNull())
+      user = root.createNestedObject(F("u"));
+
+    JsonArray lux_json = user.createNestedArray(F("Luminance"));
+    if (!enabled) {
+      lux_json.add(F("disabled"));
+    } else if (!sensorFound) {
+        // if no sensor 
+        lux_json.add(F("BH1750 "));
+        lux_json.add(F("Not Found"));
+    } else if (!getLuminanceComplete) {
+      // if we haven't read the sensor yet, let the user know
+        // that we are still waiting for the first measurement
+        lux_json.add((USERMOD_BH1750_FIRST_MEASUREMENT_AT - millis()) / 1000);
+        lux_json.add(F(" sec until read"));
+        return;
+    } else {
+      lux_json.add(lastLux);
+      lux_json.add(F(" lx"));
+    }
+  }
+
+  // (called from set.cpp) stores persistent properties to cfg.json
+  void addToConfig(JsonObject &root)
+  {
+    // we add JSON object.
+    JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
+    top[FPSTR(_enabled)] = enabled;
+    top[FPSTR(_maxReadInterval)] = maxReadingInterval;
+    top[FPSTR(_minReadInterval)] = minReadingInterval;
+    top[FPSTR(_HomeAssistantDiscovery)] = HomeAssistantDiscovery;
+    top[FPSTR(_offset)] = offset;
+
+    DEBUG_PRINTLN(F("BH1750 config saved."));
+  }
+
+  // called before setup() to populate properties from values stored in cfg.json
+  bool readFromConfig(JsonObject &root)
+  {
+    // we look for JSON object.
+    JsonObject top = root[FPSTR(_name)];
+    if (top.isNull())
+    {
+      DEBUG_PRINT(FPSTR(_name));
+      DEBUG_PRINT(F("BH1750"));
+      DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
+      return false;
+    }
+    bool configComplete = !top.isNull();
+
+    configComplete &= getJsonValue(top[FPSTR(_enabled)], enabled, false);
+    configComplete &= getJsonValue(top[FPSTR(_maxReadInterval)], maxReadingInterval, 10000); //ms
+    configComplete &= getJsonValue(top[FPSTR(_minReadInterval)], minReadingInterval, 500); //ms
+    configComplete &= getJsonValue(top[FPSTR(_HomeAssistantDiscovery)], HomeAssistantDiscovery, false);
+    configComplete &= getJsonValue(top[FPSTR(_offset)], offset, 1);
+
+    DEBUG_PRINT(FPSTR(_name));
+    if (!initDone) {
+      DEBUG_PRINTLN(F(" config loaded."));
+    } else {
+      DEBUG_PRINTLN(F(" config (re)loaded."));
+    }
+
+    return configComplete;
+    
+  }
+
+  uint16_t getId()
+  {
+    return USERMOD_ID_BH1750;
+  }
+
+};
+
+// strings to reduce flash memory usage (used more than twice)
+const char Usermod_BH1750::_name[] PROGMEM = "BH1750";
+const char Usermod_BH1750::_enabled[] PROGMEM = "enabled";
+const char Usermod_BH1750::_maxReadInterval[] PROGMEM = "max-read-interval-ms";
+const char Usermod_BH1750::_minReadInterval[] PROGMEM = "min-read-interval-ms";
+const char Usermod_BH1750::_HomeAssistantDiscovery[] PROGMEM = "HomeAssistantDiscoveryLux";
+const char Usermod_BH1750::_offset[] PROGMEM = "offset-lx";

usermods/BME280_v2/README.md

@@ -22,6 +22,7 @@ Dependencies
 - Libraries
   - `BME280@~3.0.0` (by [finitespace](https://github.com/finitespace/BME280))
   - `Wire`
+  - These must be added under `lib_deps` in your `platform.ini` (or `platform_override.ini`).
 - Data is published over MQTT - make sure you've enabled the MQTT sync interface.
 - This usermod also writes to serial (GPIO1 on ESP8266). Please make sure nothing else is listening to the serial TX pin or your board will get confused by log messages!
 
@@ -39,11 +40,17 @@ Methods also exist to read the read/calculated values from other WLED modules th
 
 # Compiling
 
-To enable, add `BME280_v2` to your `custom_usermods`  (e.g. in `platformio_override.ini`)
+To enable, compile with `USERMOD_BME280` defined  (e.g. in `platformio_override.ini`)
 ```ini
 [env:usermod_bme280_d1_mini]
 extends = env:d1_mini
-custom_usermods = ${env:d1_mini.custom_usermods} BME280_v2
+build_flags =
+  ${common.build_flags_esp8266}
+  -D USERMOD_BME280
+lib_deps = 
+  ${esp8266.lib_deps}
+  BME280@~3.0.0
+  Wire
 ```
 
 

usermods/BME280_v2/library.json

@@ -1,7 +0,0 @@
-{
-  "name": "BME280_v2",
-  "build": { "libArchive": false },
-  "dependencies": {
-    "finitespace/BME280":"~3.0.0"
-  }
-}

usermods/BME280_v2/usermod_bme280.h

@@ -1,15 +1,17 @@
 // force the compiler to show a warning to confirm that this file is included
 #warning **** Included USERMOD_BME280 version 2.0 ****
 
+#ifndef WLED_ENABLE_MQTT
+#error "This user mod requires MQTT to be enabled."
+#endif
+
+#pragma once
+
 #include "wled.h"
 #include <Arduino.h>
 #include <BME280I2C.h>               // BME280 sensor
 #include <EnvironmentCalculations.h> // BME280 extended measurements
 
-#ifdef WLED_DISABLE_MQTT
-#error "This user mod requires MQTT to be enabled."
-#endif
-
 class UsermodBME280 : public Usermod
 {
 private:
@@ -239,7 +241,7 @@ public:
         // from the UI and values read from sensor, then publish to broker
         if (temperature != lastTemperature || PublishAlways)
         {
-          publishMqtt("temperature", String(temperature, (unsigned) TemperatureDecimals).c_str());
+          publishMqtt("temperature", String(temperature, TemperatureDecimals).c_str());
         }
 
         lastTemperature = temperature; // Update last sensor temperature for next loop
@@ -252,17 +254,17 @@ public:
 
           if (humidity != lastHumidity || PublishAlways)
           {
-            publishMqtt("humidity", String(humidity, (unsigned) HumidityDecimals).c_str());
+            publishMqtt("humidity", String(humidity, HumidityDecimals).c_str());
           }
 
           if (heatIndex != lastHeatIndex || PublishAlways)
           {
-            publishMqtt("heat_index", String(heatIndex, (unsigned) TemperatureDecimals).c_str());
+            publishMqtt("heat_index", String(heatIndex, TemperatureDecimals).c_str());
           }
 
           if (dewPoint != lastDewPoint || PublishAlways)
           {
-            publishMqtt("dew_point", String(dewPoint, (unsigned) TemperatureDecimals).c_str());
+            publishMqtt("dew_point", String(dewPoint, TemperatureDecimals).c_str());
           }
 
           lastHumidity = humidity;
@@ -279,7 +281,7 @@ public:
 
         if (pressure != lastPressure || PublishAlways)
         {
-          publishMqtt("pressure", String(pressure, (unsigned) PressureDecimals).c_str());
+          publishMqtt("pressure", String(pressure, PressureDecimals).c_str());
         }
 
         lastPressure = pressure;
@@ -477,7 +479,3 @@ public:
 
 const char UsermodBME280::_name[]                      PROGMEM = "BME280/BMP280";
 const char UsermodBME280::_enabled[]                   PROGMEM = "enabled";
-
-
-static UsermodBME280 bme280_v2;
-REGISTER_USERMOD(bme280_v2);

usermods/BME68X_v2/README.md

@@ -1,70 +1,65 @@
 # Usermod BME68X
-
-This usermod was developed for a BME680/BME68X sensor. The BME68X is not compatible with the BME280/BMP280 chip. It has its own library. The original 'BSEC Software Library' from Bosch was used to develop the code. The measured values are displayed on the WLED info page.
+This usermod was developed for a BME680/BME68X sensor. The BME68X is not compatible with the BME280/BMP280 chip. It has its own library. The original 'BSEC Software Library' from Bosch was used to develop the code. The measured values are displayed on the WLED info page. 
 
 <p align="center"><img src="pics/pic1.png" style="width:60%;"></p>
 
 In addition, the values are published on MQTT if this is active. The topic used for this is: 'wled/[MQTT Client ID]'. The Client ID is set in the WLED MQTT settings.
-
 <p align="center"><img src="pics/pic2.png"></p>
 
 If you use HomeAssistance discovery, the device tree for HomeAssistance is created.  This is published under the topic 'homeassistant/sensor/[MQTT Client ID]' via MQTT.
-
 <p align="center"><img src="pics/pic3.png"></p>
 
 A device with the following sensors appears in HomeAssistant. Please note that MQTT must be activated in HomeAssistant.
-
 <p align="center"><img src="pics/pic4.png" style="width:60%;"></p>
 
-## Features
 
+## Features
 Raw sensor types
 
-Sensor		Accuracy	Scale		Range
------------------------------
+	Sensor		Accuracy	Scale		Range
+ 	--------------------------------------------------------------------------------------------------
+	Temperature	+/- 1.0		°C/°F		-40 to 85 °C
+	Humidity	+/- 3 		%		0 to 100 %
+	Pressure	+/- 1 		hPa		300 to 1100 hPa
+	Gas Resistance			Ohm
 
-Temperature	+/- 1.0		°C/°F		-40 to 85 °C
-Humidity	+/- 3 		%		0 to 100 %
-Pressure	+/- 1 		hPa		300 to 1100 hPa
-Gas Resistance			Ohm
 The BSEC Library calculates the following values via the gas resistance
 
-Sensor		Accuracy	Scale		Range
------------------------------
+	Sensor		Accuracy	Scale		Range
+ 	--------------------------------------------------------------------------------------------------
+	IAQ 						value between 0 and 500
+	Static IAQ 					same as IAQ but for permanently installed devices
+	CO2 				PPM
+	VOC 				PPM
+	Gas-Percentage 			%
+
 
-IAQ 						value between 0 and 500
-Static IAQ 					same as IAQ but for permanently installed devices
-CO2 				PPM
-VOC 				PPM
-Gas-Percentage 			%
 In addition the usermod calculates
 
-Sensor		Accuracy	Scale		Range
------------------------------
-
-Absolute humidity	 	g/m³
-Dew point 			°C/°F
+	Sensor		Accuracy	Scale		Range
+ 	--------------------------------------------------------------------------------------------------
+	Absolute humidity	 	g/m³
+	Dew point 			°C/°F
 
 ### IAQ (Indoor Air Quality)
-
-The IAQ is divided into the following value groups.
-
+The IAQ is divided into the following value groups. 
 <p align="center"><img src="pics/pic5.png"></p>
 
 For more detailed information, please consult the enclosed Bosch product description (BME680.pdf).
 
+
 ## Calibration of the device
 
-The gas sensor of the BME68X must be calibrated. This differs from the BME280, which does not require any calibration.
+The gas sensor of the BME68X must be calibrated. This differs from the BME280, which does not require any calibration. 
 There is a range of additional information for this, which the driver also provides. These values can be found in HomeAssistant under Diagnostics.
 
 - **STABILIZATION_STATUS**: Gas sensor stabilization status [boolean] Indicates initial stabilization status of the gas sensor element: stabilization is ongoing (0) or stabilization is finished (1).
 - **RUN_IN_STATUS**: 	Gas sensor run-in status [boolean] Indicates power-on stabilization status of the gas sensor element: stabilization is ongoing (0) or stabilization is finished (1)
 
-Furthermore, all GAS based values have their own accuracy value. These have the following meaning:
+Furthermore, all GAS based values have their own accuracy value. These have the following meaning: 
 
-- **Accuracy = 0** 	means the sensor is being stabilized (this can take a while on the first run)
-- **Accuracy = 1**	means that the previous measured values show too few differences and cannot be used for calibration. If the sensor is at accuracy 1 for too long, you must ensure that the ambient air is chaning. Opening the windows is fine. Or sometimes it is sufficient to breathe on the sensor for approx. 5 minutes.
+- **Accuracy = 0** 	means the sensor is being stabilized (this can take a while on the first run) 
+- **Accuracy = 1**	means that the previous measured values show too few differences and cannot be used for calibration. If the sensor is at accuracy 1 for too long, you must ensure that the ambient air is chaning. Opening the windows is fine. Or sometimes it is sufficient to breathe on the sensor for approx. 5 minutes. 
 - **Accuracy = 2**	means the sensor is currently calibrating.
 - **Accuracy = 3**	means that the sensor has been successfully calibrated. Once accuracy 3 is reached, the calibration data is automatically written to the file system. This calibration data will be used again at the next start and will speed up the calibration.
 
@@ -72,29 +67,28 @@ The IAQ index is therefore only meaningful if IAQ Accuracy = 3. In addition to t
 
 Reasonably reliable values are therefore only achieved when accuracy displays the value 3.
 
+
+
 ## Settings
-
-The settings of the usermods are set in the usermod section of wled.
-
+The settings of the usermods are set in the usermod section of wled. 
 <p align="center"><img src="pics/pic6.png"></p>
 
 The possible settings are
 
 - **Enable:**			Enables / disables the usermod
 - **I2C address:**		I2C address of the sensor. You can choose between 0X77 & 0X76. The default is 0x77.
-- **Interval:**			Specifies the interval of seconds at which the usermod should be executed. The default is every second.
-- **Pub Chages Only:**		If this item is active, the values are only published if they have changed since the last publication.
-- **Pub Accuracy:**		The Accuracy values associated with the gas values are also published.
-- **Pub Calib State:**		If this item is active, STABILIZATION_STATUS& RUN_IN_STATUS are also published.
+- **Interval:**			Specifies the interval of seconds at which the usermod should be executed. The default is every second. 
+- **Pub Chages Only:**		If this item is active, the values are only published if they have changed since the last publication. 
+- **Pub Accuracy:**		The Accuracy values associated with the gas values are also published. 
+- **Pub Calib State:**		If this item is active, STABILIZATION_STATUS& RUN_IN_STATUS are also published. 
 - **Temp Scale:**		Here you can choose between °C and °F.
-- **Temp Offset:**		The temperature offset is always set in °C. It must be converted for Fahrenheit.
-- **HA Discovery:**		If this item is active, the HomeAssistant sensor tree is created.
+- **Temp Offset:**		The temperature offset is always set in °C. It must be converted for Fahrenheit. 
+- **HA Discovery:**		If this item is active, the HomeAssistant sensor tree is created. 
 - **Pause While WLED Active:**	If WLED has many LEDs to calculate, the computing power may no longer be sufficient to calculate the LEDs and read the sensor data. The LEDs then hang for a few microseconds, which can be seen. If this point is active, no sensor data is fetched as long as WLED is running.
-- **Del Calibration Hist:**	If a check mark is set here, the calibration file saved in the file system is deleted when the settings are saved.
+- **Del Calibration Hist:**	If a check mark is set here, the calibration file saved in the file system is deleted when the settings are saved. 
 
 ### Sensors
-
-Applies to all sensors. The number of decimal places is set here. If the sensor is set to -1, it will no longer be published. In addition, the IAQ values can be activated here in verbal form.
+Applies to all sensors. The number of decimal places is set here. If the sensor is set to -1, it will no longer be published. In addition, the IAQ values can be activated here in verbal form. 
 
 It is recommended to use the Static IAQ for the IAQ values. This is recommended by Bosch for statically placed devices.
 
@@ -105,9 +99,8 @@ Data is published over MQTT - make sure you've enabled the MQTT sync interface.
 In addition to outputting via MQTT, you can read the values from the Info Screen on the dashboard page of the device's web interface.
 
 Methods also exist to read the read/calculated values from other WLED modules through code.
-
 - getTemperature();	The scale °C/°F is depended to the settings
-- getHumidity();
+- getHumidity();	
 - getPressure();
 - getGasResistance();
 - getAbsoluteHumidity();
@@ -125,36 +118,32 @@ Methods also exist to read the read/calculated values from other WLED modules th
 - getStabStatus();
 - getRunInStatus();
 
-## Compilation
 
-To enable, compile with `BME68X` in `custom_usermods` (e.g. in `platformio_override.ini`)
+## Compiling
 
-Example:
+To enable, compile with `USERMOD_BME68X` defined (e.g. in `platformio_override.ini`) and add the `BSEC Software Library` to the lib_deps.
 
-```[env:esp32_mySpecial]
-extends = env:esp32dev
-custom_usermods = ${env:esp32dev.custom_usermods} BME68X
+```
+[env:esp32-BME680]
+board = 		esp32dev
+platform = 		${esp32.platform}
+platform_packages = 	${esp32.platform_packages}
+lib_deps = 		${esp32.lib_deps}
+           		boschsensortec/BSEC Software Library @ ^1.8.1492      	; USERMOD: BME680                                          
+build_unflags = 	${common.build_unflags}
+build_flags = 		${common.build_flags_esp32} 
+              		-D USERMOD_BME68X                      			; USERMOD: BME680
 ```
 
 ## Revision History
-
 ### Version 1.0.0
-
 - First version of the BME68X_v user module
-
 ### Version 1.0.1
-
 - Rebased to WELD Version 0.15
 - Reworked some default settings
 - A problem with the default settings has been fixed
 
-### Version 1.0.2
-
-* Rebased to WELD Version 0.16
-* Fixed: Solved compilation problems related to some macro naming interferences.
-
 ## Known problems
-
 - MQTT goes online at device start. Shortly afterwards it goes offline and takes quite a while until it goes online again. The problem does not come from this user module, but from the WLED core.
 - If you save the settings often, WLED can get stuck.
 - If many LEDS are connected to WLED, reading the sensor can cause a small but noticeable hang. The "Pause While WLED Active" option was introduced as a workaround.

usermods/BME68X_v2/library.json

@@ -1,7 +0,0 @@
-{
-  "name": "BME68X",
-  "build": { "libArchive": false },
-  "dependencies": {
-    "boschsensortec/BSEC Software Library":"^1.8.1492"
-  }
-}

usermods/Battery/library.json

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

usermods/Battery/readme.md

@@ -23,7 +23,9 @@ Enables battery level monitoring of your project.
 
 ## 🎈 Installation
 
-In `platformio_override.ini` (or `platformio.ini`)<br>Under: `custom_usermods =`, add the line: `Battery`<br><br>[Example: platformio_override.ini](assets/installation_platformio_override_ini.png) |
+| **Option 1** | **Option 2** |
+|--------------|--------------|
+| In `wled00/my_config.h`<br>Add the line: `#define USERMOD_BATTERY`<br><br>[Example: my_config.h](assets/installation_my_config_h.png) | In `platformio_override.ini` (or `platformio.ini`)<br>Under: `build_flags =`, add the line: `-D USERMOD_BATTERY`<br><br>[Example: platformio_override.ini](assets/installation_platformio_override_ini.png) |
 
 <br><br>
 

usermods/Battery/usermod_v2_Battery.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "wled.h"
 #include "battery_defaults.h"
 #include "UMBattery.h"
@@ -855,7 +857,3 @@ const char UsermodBattery::_preset[]        PROGMEM = "preset";
 const char UsermodBattery::_duration[]      PROGMEM = "duration";
 const char UsermodBattery::_init[]          PROGMEM = "init";
 const char UsermodBattery::_haDiscovery[]   PROGMEM = "HA-discovery";
-
-
-static UsermodBattery battery;
-REGISTER_USERMOD(battery);

usermods/Cronixie/library.json

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

usermods/Cronixie/readme.md

@@ -4,5 +4,5 @@ This usermod supports driving the Cronixie M and L clock kits by Diamex.
 
 ## Installation 
 
-Compile and upload after adding `Cronixie` to `custom_usermods` of your PlatformIO environment.  
+Compile and upload after adding `-D USERMOD_CRONIXIE` to `build_flags` of your PlatformIO environment.  
 Make sure the Auto Brightness Limiter is enabled at 420mA (!) and configure 60 WS281x LEDs.

usermods/Cronixie/usermod_cronixie.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "wled.h"
 
 class UsermodCronixie : public Usermod {
@@ -247,7 +249,7 @@ class UsermodCronixie : public Usermod {
         
         if (backlight && _digitOut[i] <11)
         {
-          uint32_t col = strip.getSegment(0).colors[1];
+          uint32_t col = gamma32(strip.getSegment(0).colors[1]);
           for (uint16_t j=o; j< o+10; j++) {
             if (j != excl) strip.setPixelColor(j, col);
           }
@@ -297,7 +299,4 @@ class UsermodCronixie : public Usermod {
     {
       return USERMOD_ID_CRONIXIE;
     }
-};
-
-static UsermodCronixie cronixie;
-REGISTER_USERMOD(cronixie);
+};

usermods/DHT/library.json

@@ -1,7 +0,0 @@
-{
-  "name": "DHT",
-  "build": { "libArchive": false},
-  "dependencies": {
-    "DHT_nonblocking":"https://github.com/alwynallan/DHT_nonblocking"
-  }
-}

usermods/DHT/platformio_override.ini

@@ -1,5 +1,6 @@
 ; Options
 ; -------
+; USERMOD_DHT                      - define this to have this user mod included wled00\usermods_list.cpp
 ; USERMOD_DHT_DHTTYPE              - DHT model: 11, 21, 22 for DHT11, DHT21, or DHT22, defaults to 22/DHT22
 ; USERMOD_DHT_PIN                  - pin to which DTH is connected, defaults to Q2 pin on QuinLed Dig-Uno's board
 ; USERMOD_DHT_CELSIUS              - define this to report temperatures in degrees celsious, otherwise fahrenheit will be reported
@@ -10,11 +11,13 @@
 
 [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
+build_flags = ${env:d1_mini.build_flags} -D USERMOD_DHT -D USERMOD_DHT_CELSIUS
+lib_deps = ${env:d1_mini.lib_deps}
+    https://github.com/alwynallan/DHT_nonblocking
 
 [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
+build_flags = ${env:custom32_LEDPIN_16.build_flags} -D USERMOD_DHT -D USERMOD_DHT_CELSIUS -D USERMOD_DHT_STATS
+lib_deps = ${env.lib_deps}
+    https://github.com/alwynallan/DHT_nonblocking
 

usermods/DHT/readme.md

@@ -15,6 +15,7 @@ Copy the example `platformio_override.ini` to the root directory.  This file sho
 
 ### Define Your Options
 
+* `USERMOD_DHT`                      - define this to include this user mod wled00\usermods_list.cpp
 * `USERMOD_DHT_DHTTYPE`              - DHT model: 11, 21, 22 for DHT11, DHT21, or DHT22, defaults to 22/DHT22
 * `USERMOD_DHT_PIN`                  - pin to which DTH is connected, defaults to Q2 pin on QuinLed Dig-Uno's board
 * `USERMOD_DHT_CELSIUS`              - define this to report temperatures in degrees Celsius, otherwise Fahrenheit will be reported

usermods/DHT/usermod_dht.h

@@ -1,5 +1,7 @@
+#pragma once
+
 #include "wled.h"
-#ifdef WLED_DISABLE_MQTT
+#ifndef WLED_ENABLE_MQTT
 #error "This user mod requires MQTT to be enabled."
 #endif
 
@@ -243,7 +245,3 @@ class UsermodDHT : public Usermod {
     }
 
 };
-
-
-static UsermodDHT dht;
-REGISTER_USERMOD(dht);

usermods/EXAMPLE/library.json

@@ -1,5 +0,0 @@
-{
-  "name": "EXAMPLE",
-  "build": { "libArchive": false },
-  "dependencies": {}
-}

usermods/EXAMPLE_v2/readme.md

@@ -4,6 +4,7 @@ In this usermod file you can find the documentation on how to take advantage of
 
 ## Installation 
 
-Add `EXAMPLE` to `custom_usermods` in your PlatformIO environment and compile!
+Copy `usermod_v2_example.h` to the wled00 directory.  
+Uncomment the corresponding lines in `usermods_list.cpp` and compile!  
 _(You shouldn't need to actually install this, it does nothing useful)_
 

usermods/EXAMPLE_v2/usermod_v2_example.h

@@ -1,8 +1,10 @@
+#pragma once
+
 #include "wled.h"
 
 /*
  * Usermods allow you to add own functionality to WLED more easily
- * See: https://github.com/wled-dev/WLED/wiki/Add-own-functionality
+ * See: https://github.com/Aircoookie/WLED/wiki/Add-own-functionality
  * 
  * This is an example for a v2 usermod.
  * v2 usermods are class inheritance based and can (but don't have to) implement more functions, each of them is shown in this example.
@@ -313,11 +315,11 @@ class MyExampleUsermod : public Usermod {
       yield();
       // ignore certain button types as they may have other consequences
       if (!enabled
-       || buttons[b].type == BTN_TYPE_NONE
-       || buttons[b].type == BTN_TYPE_RESERVED
-       || buttons[b].type == BTN_TYPE_PIR_SENSOR
-       || buttons[b].type == BTN_TYPE_ANALOG
-       || buttons[b].type == BTN_TYPE_ANALOG_INVERTED) {
+       || buttonType[b] == BTN_TYPE_NONE
+       || buttonType[b] == BTN_TYPE_RESERVED
+       || buttonType[b] == BTN_TYPE_PIR_SENSOR
+       || buttonType[b] == BTN_TYPE_ANALOG
+       || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) {
         return false;
       }
 
@@ -402,6 +404,3 @@ void MyExampleUsermod::publishMqtt(const char* state, bool retain)
   }
 #endif
 }
-
-static MyExampleUsermod example_usermod;
-REGISTER_USERMOD(example_usermod);

usermods/EleksTube_IPS/library.json.disabled

@@ -1,8 +0,0 @@
-{
-  "name:": "EleksTube_IPS",
-  "build": { "libArchive": false },
-  "dependencies": {
-    "TFT_eSPI" : "2.5.33"
-  } 
-}
-# Seems to add 300kb to the RAM requirement???

usermods/EleksTube_IPS/usermod_elekstube_ips.h

@@ -1,3 +1,4 @@
+#pragma once
 #include "TFTs.h"
 #include "wled.h"
 
@@ -155,7 +156,3 @@ class ElekstubeIPSUsermod : public Usermod {
 const char ElekstubeIPSUsermod::_name[]         PROGMEM = "EleksTubeIPS";
 const char ElekstubeIPSUsermod::_tubeSeg[]      PROGMEM = "tubeSegment";
 const char ElekstubeIPSUsermod::_digitOffset[]  PROGMEM = "digitOffset";
-
-
-static ElekstubeIPSUsermod elekstube_ips;
-REGISTER_USERMOD(elekstube_ips);

usermods/Enclosure_with_OLED_temp_ESP07/usermod.cpp

@@ -1,12 +1,11 @@
+#ifndef WLED_ENABLE_MQTT
+#error "This user mod requires MQTT to be enabled."
+#endif
+
 #include "wled.h"
 #include <Arduino.h>
 #include <U8x8lib.h> // from https://github.com/olikraus/u8g2/
 #include <DallasTemperature.h> //Dallastemperature sensor
-
-#ifdef WLED_DISABLE_MQTT
-#error "This user mod requires MQTT to be enabled."
-#endif
-
 //The SCL and SDA pins are defined here. 
 //Lolin32 boards use SCL=5 SDA=4 
 #define U8X8_PIN_SCL 5

usermods/Enclosure_with_OLED_temp_ESP07/usermod_bme280.cpp

@@ -1,13 +1,13 @@
+#ifndef WLED_ENABLE_MQTT
+#error "This user mod requires MQTT to be enabled."
+#endif
+
 #include "wled.h"
 #include <Arduino.h>
 #include <U8x8lib.h> // from https://github.com/olikraus/u8g2/
 #include <Wire.h>
 #include <BME280I2C.h> //BME280 sensor
 
-#ifdef WLED_DISABLE_MQTT
-#error "This user mod requires MQTT to be enabled."
-#endif
-
 void UpdateBME280Data();
 
 #define Celsius // Show temperature measurement in Celsius otherwise is in Fahrenheit 

usermods/Fix_unreachable_netservices_v2/library.json

@@ -1,4 +0,0 @@
-{
-  "name": "Fix_unreachable_netservices_v2",
-  "platforms": ["espressif8266"]
-}

usermods/Fix_unreachable_netservices_v2/readme.md

@@ -30,6 +30,41 @@ The usermod supports the following state changes:
 
 ## Installation
 
-1. Add `Fix_unreachable_netservices` to `custom_usermods` in your PlatformIO environment.
+1. Copy the file `usermod_Fix_unreachable_netservices.h` to the `wled00` directory.
+2. Register the usermod by adding `#include "usermod_Fix_unreachable_netservices.h"` in the top and `registerUsermod(new FixUnreachableNetServices());` in the bottom of `usermods_list.cpp`.
+
+Example **usermods_list.cpp**:
+
+```cpp
+#include "wled.h"
+/*
+ * Register your v2 usermods here!
+ *   (for v1 usermods using just usermod.cpp, you can ignore this file)
+ */
+
+/*
+ * Add/uncomment your usermod filename here (and once more below)
+ * || || ||
+ * \/ \/ \/
+ */
+//#include "usermod_v2_example.h"
+//#include "usermod_temperature.h"
+//#include "usermod_v2_empty.h"
+#include  "usermod_Fix_unreachable_netservices.h"
+
+void registerUsermods()
+{
+  /*
+   * Add your usermod class name here
+   * || || ||
+   * \/ \/ \/
+   */
+  //UsermodManager::add(new MyExampleUsermod());
+  //UsermodManager::add(new UsermodTemperature());
+  //UsermodManager::add(new UsermodRenameMe());
+  UsermodManager::add(new FixUnreachableNetServices());
+
+}
+```
 
 Hopefully I can help someone with that - @gegu

usermods/Fix_unreachable_netservices_v2/usermod_Fix_unreachable_netservices.h

@@ -1,4 +1,12 @@
+#pragma once
+
 #include "wled.h"
+#if defined(ESP32)
+#warning "Usermod FixUnreachableNetServices works only with ESP8266 builds"
+class FixUnreachableNetServices : public Usermod
+{
+};
+#endif
 
 #if defined(ESP8266)
 #include <ping.h>
@@ -8,7 +16,7 @@
  * By this procedure the net services of WLED remains accessible in some problematic WLAN environments.
  * 
  * Usermods allow you to add own functionality to WLED more easily
- * See: https://github.com/wled-dev/WLED/wiki/Add-own-functionality
+ * See: https://github.com/Aircoookie/WLED/wiki/Add-own-functionality
  * 
  * v2 usermods are class inheritance based and can (but don't have to) implement more functions, each of them is shown in this example.
  * Multiple v2 usermods can be added to one compilation easily.
@@ -160,11 +168,4 @@ Delay <input type=\"number\" min=\"5\" max=\"300\" value=\"";
     return USERMOD_ID_FIXNETSERVICES;
   }
 };
-
-static FixUnreachableNetServices fix_unreachable_net_services;
-REGISTER_USERMOD(fix_unreachable_net_services);
-
-#else /* !ESP8266 */
-#warning "Usermod FixUnreachableNetServices works only with ESP8266 builds"
 #endif
-

usermods/INA226_v2/README.md

@@ -22,6 +22,13 @@ The following settings can be configured in the Usermod Menu:
 - **MqttPublishAlways**: Publish always, regardless if there is a change.
 - **MqttHomeAssistantDiscovery**: Enable Home Assistant discovery.
 
+## Dependencies
+
+These must be added under `lib_deps` in your `platform.ini` (or `platform_override.ini`).
+
+- Libraries
+  - `wollewald/INA226_WE@~1.2.9` (by [wollewald](https://registry.platformio.org/libraries/wollewald/INA226_WE))
+  - `Wire`
 
 ## Understanding Samples and Conversion Times
 
@@ -55,12 +62,16 @@ For detailed programming information and register configurations, refer to the [
 
 ## Compiling
 
-To enable, compile with `INA226` in `custom_usermods` (e.g. in `platformio_override.ini`).
+To enable, compile with `USERMOD_INA226` defined (e.g. in `platformio_override.ini`).
 
 ```ini
 [env:ina226_example]
 extends = env:esp32dev
-custom_usermods = ${env:esp32dev.custom_usermods} INA226
-build_flags = ${env:esp32dev.build_flags}
+build_flags =
+  ${common.build_flags} ${esp32.build_flags}
+  -D USERMOD_INA226
   ; -D USERMOD_INA226_DEBUG ; -- add a debug status to the info modal
+lib_deps = 
+  ${esp32.lib_deps}
+  wollewald/INA226_WE@~1.2.9
 ```