Firmware upgrade requires tasmota

Add ESP32 bootloader upgrade capability to OTA update page with JSON API support and ESP-IDF validation

.github/workflows/build.yml

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

.github/workflows/release.yml

@@ -0,0 +1,36 @@
+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.3
+      with:
+          token: ${{ secrets.GITHUB_TOKEN }} 
+          sinceTag: v0.15.0
+          releaseBranch: 0_15_x 
+    - name: Create draft release
+      uses: softprops/action-gh-release@v1
+      with:
+        body: ${{ steps.changelog.outputs.changelog }}
+        draft: True
+        files: |
+          *.bin
+          *.bin.gz
+

.github/workflows/wled-ci.yml

@@ -1,94 +1,11 @@
 name: WLED CI
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - '*'
+  pull_request:
 
 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 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
+  wled_build:
+    uses: ./.github/workflows/build.yml

.gitignore

@@ -15,6 +15,7 @@ wled-update.sh
 
 /build_output/
 /node_modules/
+/logs/
 
 /wled00/extLibs
 /wled00/LittleFS

CHANGELOG.md

@@ -1,5 +1,54 @@
 ## WLED changelog
 
+#### Build 2412100
+-   WLED 0.15.0 release
+-   Usermod BME280: Fix "Unit of Measurement" for temperature
+-   WiFi reconnect bugfix (@blazoncek)
+
+#### Build 2411250
+-   WLED 0.15.0-rc1 release
+-   Add support for esp32S3_wroom2 (#4243 by @softhack007)
+-   Fix mixed LED SK6812 and ws2812b booloop (#4301 by @willmmiles)
+-   Improved FPS calculation (by DedeHai)
+-   Fix crashes when using HTTP API within MQTT (#4269 by @willmmiles)
+-   Fix array overflow in exploding_fireworks (#4120 by @willmmiles)
+-   Fix MQTT topic buffer length (#4293 by @WouterGritter)
+-   Fix SparkFunDMX fix for possible array bounds violation in DMX.write (by @softhack007)
+-   Allow TV Simulator on single LED segments (by @softhack007)
+-   Fix WLED_RELEASE_NAME (by @netmindz)
+
+
+#### Build 2410270
+-   WLED 0.15.0-b7 release
+-   Re-license the WLED project from MIT to EUPL (#4194 by @Aircoookie)
+-   Fix alexa devices invisible/uncontrollable (#4214 by @Svennte)
+-   Add visual expand button on hover (#4172)
+-   Usermod: Audioreactive tuning and performance enhancements (by @softhack007)
+-   `/json/live` (JSON live data/peek) only enabled when WebSockets are disabled
+-   Various bugfixes and optimisations: #4179, #4215, #4219, #4222, #4223, #4224, #4228, #4230
+
+#### Build 2410140
+-   WLED 0.15.0-b6 release
+-   Added BRT timezone (#4188 by @LuisFadini)
+-   Fixed the positioning of the "Download the latest binary" button (#4184 by @maxi4329)
+-   Add WLED_AUTOSEGMENTS compile flag (#4183 by @PaoloTK)
+-   New 512kB FS parition map for 4MB devices
+-   Internal API change: Static PinManager & UsermodManager
+-   Change in Improv chip ID and version generation
+-   Various optimisations, bugfixes and enhancements (#4005, #4174 & #4175 by @Xevel, #4180, #4168, #4154, #4189 by @dosipod)
+
+#### Build 2409170
+-   UI: Introduce common.js in settings pages (size optimisation)
+-   Add the ability to toggle the reception of palette synchronizations (#4137 by @felddy)
+-   Usermod/FX: Temperature usermod added Temperature effect (example usermod effect by @blazoncek)
+-   Fix AsyncWebServer version pin
+
+#### Build 2409140
+-   Configure different kinds of busses at compile (#4107 by @PaoloTK)
+    - BREAKING: removes LEDPIN and DEFAULT_LED_TYPE compile overrides
+-   Fetch LED types from Bus classes (dynamic UI) (#4129 by @netmindz, @blazoncek, @dedehai)
+-   Temperature usermod: update OneWire to 2.3.8 (#4131 by @iammattcoleman)
+
 #### Build 2409100
 -   WLED 0.15.0-b5 release
 -   Audioreactive usermod included by default in all compatible builds (including ESP8266)

CONTRIBUTING.md

@@ -16,6 +16,20 @@ A good description helps us to review and understand your proposed changes. For
 
 Please make all PRs against the `0_15` branch.
 
+### Updating your code
+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.
+
+> [!CAUTION]
+> Do not use "force-push" while your PR is open!
+> 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.
+
+
+You can find a collection of very useful tips and tricks here: https://github.com/Aircoookie/WLED/wiki/How-to-properly-submit-a-PR
+
+
 ### Code style
 
 When in doubt, it is easiest to replicate the code style you find in the files you want to edit :)
@@ -37,6 +51,11 @@ if (a == b) {
 }
 ```
 
+```cpp
+if (a == b) doStuff(a);
+```
+
+Acceptable - however the first variant is usually easier to read:
 ```cpp
 if (a == b)
 {
@@ -44,9 +63,6 @@ if (a == b)
 }
 ```
 
-```cpp
-if (a == b) doStuff(a);
-```
 
 There should always be a space between a keyword and its condition and between the condition and brace.  
 Within the condition, no space should be between the parenthesis and variables.  

LICENSE

@@ -1,21 +1,294 @@
-MIT License
+Copyright (c) 2016-present Christian Schwinne and individual WLED contributors
+Licensed under the EUPL v. 1.2 or later
 
-Copyright (c) 2016 Christian Schwinne
+                      EUROPEAN UNION PUBLIC LICENCE v. 1.2
+                      EUPL © the European Union 2007, 2016
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+This European Union Public Licence (the ‘EUPL’) applies to the Work (as
+defined below) which is provided under the terms of this Licence. Any use of
+the Work, other than as authorised under this Licence is prohibited (to the
+extent such use is covered by a right of the copyright holder of the Work).
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The Work is provided under the terms of this Licence when the Licensor (as
+defined below) has placed the following notice immediately following the
+copyright notice for the Work:
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+        Licensed under the EUPL
+
+or has expressed by any other means his willingness to license under the EUPL.
+
+1. Definitions
+
+In this Licence, the following terms have the following meaning:
+
+- ‘The Licence’: this Licence.
+
+- ‘The Original Work’: the work or software distributed or communicated by the
+  Licensor under this Licence, available as Source Code and also as Executable
+  Code as the case may be.
+
+- ‘Derivative Works’: the works or software that could be created by the
+  Licensee, based upon the Original Work or modifications thereof. This
+  Licence does not define the extent of modification or dependence on the
+  Original Work required in order to classify a work as a Derivative Work;
+  this extent is determined by copyright law applicable in the country
+  mentioned in Article 15.
+
+- ‘The Work’: the Original Work or its Derivative Works.
+
+- ‘The Source Code’: the human-readable form of the Work which is the most
+  convenient for people to study and modify.
+
+- ‘The Executable Code’: any code which has generally been compiled and which
+  is meant to be interpreted by a computer as a program.
+
+- ‘The Licensor’: the natural or legal person that distributes or communicates
+  the Work under the Licence.
+
+- ‘Contributor(s)’: any natural or legal person who modifies the Work under
+  the Licence, or otherwise contributes to the creation of a Derivative Work.
+
+- ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of
+  the Work under the terms of the Licence.
+
+- ‘Distribution’ or ‘Communication’: any act of selling, giving, lending,
+  renting, distributing, communicating, transmitting, or otherwise making
+  available, online or offline, copies of the Work or providing access to its
+  essential functionalities at the disposal of any other natural or legal
+  person.
+
+2. Scope of the rights granted by the Licence
+
+The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
+sublicensable licence to do the following, for the duration of copyright
+vested in the Original Work:
+
+- use the Work in any circumstance and for all usage,
+- reproduce the Work,
+- modify the Work, and make Derivative Works based upon the Work,
+- communicate to the public, including the right to make available or display
+  the Work or copies thereof to the public and perform publicly, as the case
+  may be, the Work,
+- distribute the Work or copies thereof,
+- lend and rent the Work or copies thereof,
+- sublicense rights in the Work or copies thereof.
+
+Those rights can be exercised on any media, supports and formats, whether now
+known or later invented, as far as the applicable law permits so.
+
+In the countries where moral rights apply, the Licensor waives his right to
+exercise his moral right to the extent allowed by law in order to make
+effective the licence of the economic rights here above listed.
+
+The Licensor grants to the Licensee royalty-free, non-exclusive usage rights
+to any patents held by the Licensor, to the extent necessary to make use of
+the rights granted on the Work under this Licence.
+
+3. Communication of the Source Code
+
+The Licensor may provide the Work either in its Source Code form, or as
+Executable Code. If the Work is provided as Executable Code, the Licensor
+provides in addition a machine-readable copy of the Source Code of the Work
+along with each copy of the Work that the Licensor distributes or indicates,
+in a notice following the copyright notice attached to the Work, a repository
+where the Source Code is easily and freely accessible for as long as the
+Licensor continues to distribute or communicate the Work.
+
+4. Limitations on copyright
+
+Nothing in this Licence is intended to deprive the Licensee of the benefits
+from any exception or limitation to the exclusive rights of the rights owners
+in the Work, of the exhaustion of those rights or of other applicable
+limitations thereto.
+
+5. Obligations of the Licensee
+
+The grant of the rights mentioned above is subject to some restrictions and
+obligations imposed on the Licensee. Those obligations are the following:
+
+Attribution right: The Licensee shall keep intact all copyright, patent or
+trademarks notices and all notices that refer to the Licence and to the
+disclaimer of warranties. The Licensee must include a copy of such notices and
+a copy of the Licence with every copy of the Work he/she distributes or
+communicates. The Licensee must cause any Derivative Work to carry prominent
+notices stating that the Work has been modified and the date of modification.
+
+Copyleft clause: If the Licensee distributes or communicates copies of the
+Original Works or Derivative Works, this Distribution or Communication will be
+done under the terms of this Licence or of a later version of this Licence
+unless the Original Work is expressly distributed only under this version of
+the Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee
+(becoming Licensor) cannot offer or impose any additional terms or conditions
+on the Work or Derivative Work that alter or restrict the terms of the
+Licence.
+
+Compatibility clause: If the Licensee Distributes or Communicates Derivative
+Works or copies thereof based upon both the Work and another work licensed
+under a Compatible Licence, this Distribution or Communication can be done
+under the terms of this Compatible Licence. For the sake of this clause,
+‘Compatible Licence’ refers to the licences listed in the appendix attached to
+this Licence. Should the Licensee's obligations under the Compatible Licence
+conflict with his/her obligations under this Licence, the obligations of the
+Compatible Licence shall prevail.
+
+Provision of Source Code: When distributing or communicating copies of the
+Work, the Licensee will provide a machine-readable copy of the Source Code or
+indicate a repository where this Source will be easily and freely available
+for as long as the Licensee continues to distribute or communicate the Work.
+
+Legal Protection: This Licence does not grant permission to use the trade
+names, trademarks, service marks, or names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the copyright notice.
+
+6. Chain of Authorship
+
+The original Licensor warrants that the copyright in the Original Work granted
+hereunder is owned by him/her or licensed to him/her and that he/she has the
+power and authority to grant the Licence.
+
+Each Contributor warrants that the copyright in the modifications he/she
+brings to the Work are owned by him/her or licensed to him/her and that he/she
+has the power and authority to grant the Licence.
+
+Each time You accept the Licence, the original Licensor and subsequent
+Contributors grant You a licence to their contributions to the Work, under the
+terms of this Licence.
+
+7. Disclaimer of Warranty
+
+The Work is a work in progress, which is continuously improved by numerous
+Contributors. It is not a finished work and may therefore contain defects or
+‘bugs’ inherent to this type of development.
+
+For the above reason, the Work is provided under the Licence on an ‘as is’
+basis and without warranties of any kind concerning the Work, including
+without limitation merchantability, fitness for a particular purpose, absence
+of defects or errors, accuracy, non-infringement of intellectual property
+rights other than copyright as stated in Article 6 of this Licence.
+
+This disclaimer of warranty is an essential part of the Licence and a
+condition for the grant of any rights to the Work.
+
+8. Disclaimer of Liability
+
+Except in the cases of wilful misconduct or damages directly caused to natural
+persons, the Licensor will in no event be liable for any direct or indirect,
+material or moral, damages of any kind, arising out of the Licence or of the
+use of the Work, including without limitation, damages for loss of goodwill,
+work stoppage, computer failure or malfunction, loss of data or any commercial
+damage, even if the Licensor has been advised of the possibility of such
+damage. However, the Licensor will be liable under statutory product liability
+laws as far such laws apply to the Work.
+
+9. Additional agreements
+
+While distributing the Work, You may choose to conclude an additional
+agreement, defining obligations or services consistent with this Licence.
+However, if accepting obligations, You may act only on your own behalf and on
+your sole responsibility, not on behalf of the original Licensor or any other
+Contributor, and only if You agree to indemnify, defend, and hold each
+Contributor harmless for any liability incurred by, or claims asserted against
+such Contributor by the fact You have accepted any warranty or additional
+liability.
+
+10. Acceptance of the Licence
+
+The provisions of this Licence can be accepted by clicking on an icon ‘I
+agree’ placed under the bottom of a window displaying the text of this Licence
+or by affirming consent in any other similar way, in accordance with the rules
+of applicable law. Clicking on that icon indicates your clear and irrevocable
+acceptance of this Licence and all of its terms and conditions.
+
+Similarly, you irrevocably accept this Licence and all of its terms and
+conditions by exercising any rights granted to You by Article 2 of this
+Licence, such as the use of the Work, the creation by You of a Derivative Work
+or the Distribution or Communication by You of the Work or copies thereof.
+
+11. Information to the public
+
+In case of any Distribution or Communication of the Work by means of
+electronic communication by You (for example, by offering to download the Work
+from a remote location) the distribution channel or media (for example, a
+website) must at least provide to the public the information requested by the
+applicable law regarding the Licensor, the Licence and the way it may be
+accessible, concluded, stored and reproduced by the Licensee.
+
+12. Termination of the Licence
+
+The Licence and the rights granted hereunder will terminate automatically upon
+any breach by the Licensee of the terms of the Licence.
+
+Such a termination will not terminate the licences of any person who has
+received the Work from the Licensee under the Licence, provided such persons
+remain in full compliance with the Licence.
+
+13. Miscellaneous
+
+Without prejudice of Article 9 above, the Licence represents the complete
+agreement between the Parties as to the Work.
+
+If any provision of the Licence is invalid or unenforceable under applicable
+law, this will not affect the validity or enforceability of the Licence as a
+whole. Such provision will be construed or reformed so as necessary to make it
+valid and enforceable.
+
+The European Commission may publish other linguistic versions or new versions
+of this Licence or updated versions of the Appendix, so far this is required
+and reasonable, without reducing the scope of the rights granted by the
+Licence. New versions of the Licence will be published with a unique version
+number.
+
+All linguistic versions of this Licence, approved by the European Commission,
+have identical value. Parties can take advantage of the linguistic version of
+their choice.
+
+14. Jurisdiction
+
+Without prejudice to specific agreement between parties,
+
+- any litigation resulting from the interpretation of this License, arising
+  between the European Union institutions, bodies, offices or agencies, as a
+  Licensor, and any Licensee, will be subject to the jurisdiction of the Court
+  of Justice of the European Union, as laid down in article 272 of the Treaty
+  on the Functioning of the European Union,
+
+- any litigation arising between other parties and resulting from the
+  interpretation of this License, will be subject to the exclusive
+  jurisdiction of the competent court where the Licensor resides or conducts
+  its primary business.
+
+15. Applicable Law
+
+Without prejudice to specific agreement between parties,
+
+- this Licence shall be governed by the law of the European Union Member State
+  where the Licensor has his seat, resides or has his registered office,
+
+- this licence shall be governed by Belgian law if the Licensor has no seat,
+  residence or registered office inside a European Union Member State.
+
+Appendix
+
+‘Compatible Licences’ according to Article 5 EUPL are:
+
+- GNU General Public License (GPL) v. 2, v. 3
+- GNU Affero General Public License (AGPL) v. 3
+- Open Software License (OSL) v. 2.1, v. 3.0
+- Eclipse Public License (EPL) v. 1.0
+- CeCILL v. 2.0, v. 2.1
+- Mozilla Public Licence (MPL) v. 2
+- GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
+- Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
+  works other than software
+- European Union Public Licence (EUPL) v. 1.1, v. 1.2
+- Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong
+  Reciprocity (LiLiQ-R+).
+
+The European Commission may update this Appendix to later versions of the
+above licences without producing a new version of the EUPL, as long as they
+provide the rights granted in Article 2 of this Licence and protect the
+covered Source Code from exclusive appropriation.
+
+All other changes or additions to this Appendix require the production of a
+new EUPL version.

lib/NeoESP32RmtHI/include/NeoEsp32RmtHIMethod.h

@@ -0,0 +1,469 @@
+/*-------------------------------------------------------------------------
+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

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

lib/NeoESP32RmtHI/src/NeoEsp32RmtHI.S

@@ -0,0 +1,263 @@
+/* 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

@@ -0,0 +1,507 @@
+/*-------------------------------------------------------------------------
+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-lock.json

@@ -1,18 +1,21 @@
 {
   "name": "wled",
-  "version": "0.15.0-b5",
+  "version": "0.15.2-beta2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "wled",
-      "version": "0.15.0-b5",
+      "version": "0.15.2-beta2",
       "license": "ISC",
       "dependencies": {
         "clean-css": "^5.3.3",
         "html-minifier-terser": "^7.2.0",
         "inliner": "^1.13.1",
-        "nodemon": "^3.0.2"
+        "nodemon": "^3.1.7"
+      },
+      "engines": {
+        "node": ">=20.0.0"
       }
     },
     "node_modules/@jridgewell/gen-mapping": {
@@ -54,9 +57,9 @@
       }
     },
     "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.15",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
-      "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg=="
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ=="
     },
     "node_modules/@jridgewell/trace-mapping": {
       "version": "0.3.25",
@@ -67,15 +70,10 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
-    "node_modules/abbrev": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
-      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q=="
-    },
     "node_modules/acorn": {
-      "version": "8.11.3",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz",
-      "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==",
+      "version": "8.12.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
+      "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -190,9 +188,9 @@
       }
     },
     "node_modules/aws4": {
-      "version": "1.12.0",
-      "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz",
-      "integrity": "sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg=="
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.13.2.tgz",
+      "integrity": "sha512-lHe62zvbTB5eEABUVi/AwVh0ZKY9rMMDhmm+eeyuuUQbQ3+J+fONVQOZyj+DdrvD4BY33uYniyRJ4UJIaSKAfw=="
     },
     "node_modules/balanced-match": {
       "version": "1.0.2",
@@ -233,11 +231,11 @@
       }
     },
     "node_modules/braces": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
-      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
       "dependencies": {
-        "fill-range": "^7.0.1"
+        "fill-range": "^7.1.1"
       },
       "engines": {
         "node": ">=8"
@@ -701,9 +699,9 @@
       "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="
     },
     "node_modules/fill-range": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
-      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
       "dependencies": {
         "to-regex-range": "^5.0.1"
       },
@@ -1281,17 +1279,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/lru-cache": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
-      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
-      "dependencies": {
-        "yallist": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/mime": {
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
@@ -1375,9 +1362,9 @@
       }
     },
     "node_modules/nodemon": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.0.tgz",
-      "integrity": "sha512-xqlktYlDMCepBJd43ZQhjWwMw2obW/JRvkrLxq5RCNcuDDX1DbcPT+qT1IlIIdf+DhnWs90JpTMe+Y5KxOchvA==",
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.7.tgz",
+      "integrity": "sha512-hLj7fuMow6f0lbB0cD14Lz2xNjwsyruH251Pk4t/yIitCFJbmY1myuLlHm/q06aST4jg6EgAh74PIBBrRqpVAQ==",
       "dependencies": {
         "chokidar": "^3.5.2",
         "debug": "^4",
@@ -1402,11 +1389,11 @@
       }
     },
     "node_modules/nodemon/node_modules/debug": {
-      "version": "4.3.4",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
-      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
       "dependencies": {
-        "ms": "2.1.2"
+        "ms": "^2.1.3"
       },
       "engines": {
         "node": ">=6.0"
@@ -1418,9 +1405,9 @@
       }
     },
     "node_modules/nodemon/node_modules/ms": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
     },
     "node_modules/nodemon/node_modules/supports-color": {
       "version": "5.5.0",
@@ -1433,20 +1420,6 @@
         "node": ">=4"
       }
     },
-    "node_modules/nopt": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz",
-      "integrity": "sha512-NWmpvLSqUrgrAC9HCuxEvb+PSloHpqVu+FqcO4eeF2h5qYRhA7ev6KvelyQAKtegUbC6RypJnlEOhd8vloNKYg==",
-      "dependencies": {
-        "abbrev": "1"
-      },
-      "bin": {
-        "nopt": "bin/nopt.js"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
     "node_modules/normalize-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
@@ -1507,6 +1480,7 @@
       "version": "0.1.5",
       "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz",
       "integrity": "sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==",
+      "deprecated": "This package is no longer supported.",
       "dependencies": {
         "os-homedir": "^1.0.0",
         "os-tmpdir": "^1.0.0"
@@ -1620,6 +1594,7 @@
       "version": "1.5.1",
       "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz",
       "integrity": "sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw==",
+      "deprecated": "You or someone you depend on is using Q, the JavaScript Promise library that gave JavaScript developers strong feelings about promises. They can almost certainly migrate to the native JavaScript promise now. Thank you literally everyone for joining me in this bet against the odds. Be excellent to each other.\n\n(For a CapTP with native promises, see @endo/eventual-send and @endo/captp)",
       "engines": {
         "node": ">=0.6.0",
         "teleport": ">=0.2.0"
@@ -1826,12 +1801,9 @@
       "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw=="
     },
     "node_modules/semver": {
-      "version": "7.6.0",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.0.tgz",
-      "integrity": "sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==",
-      "dependencies": {
-        "lru-cache": "^6.0.0"
-      },
+      "version": "7.6.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
+      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
       "bin": {
         "semver": "bin/semver.js"
       },
@@ -1993,9 +1965,9 @@
       }
     },
     "node_modules/terser": {
-      "version": "5.29.2",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.29.2.tgz",
-      "integrity": "sha512-ZiGkhUBIM+7LwkNjXYJq8svgkd+QK3UUr0wJqY4MieaezBSAIPgbSPZyIx0idM6XWK5CMzSWa8MJIzmRcB8Caw==",
+      "version": "5.34.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.34.0.tgz",
+      "integrity": "sha512-y5NUX+U9HhVsK/zihZwoq4r9dICLyV2jXGOriDAVOeKhq3LKVjgJbGO90FisozXLlJfvjHqgckGmJFBb9KYoWQ==",
       "dependencies": {
         "@jridgewell/source-map": "^0.3.3",
         "acorn": "^8.8.2",
@@ -2042,12 +2014,9 @@
       }
     },
     "node_modules/touch": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.0.tgz",
-      "integrity": "sha512-WBx8Uy5TLtOSRtIq+M03/sKDrXCLHxwDcquSP2c43Le03/9serjQBIztjRz6FkJez9D/hleyAXTBGLwwZUw9lA==",
-      "dependencies": {
-        "nopt": "~1.0.10"
-      },
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
       "bin": {
         "nodetouch": "bin/nodetouch.js"
       }
@@ -2065,9 +2034,9 @@
       }
     },
     "node_modules/tslib": {
-      "version": "2.6.2",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
-      "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
+      "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA=="
     },
     "node_modules/tunnel-agent": {
       "version": "0.6.0",
@@ -2229,11 +2198,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/yallist": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
-    },
     "node_modules/yargs": {
       "version": "3.10.0",
       "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "wled",
-  "version": "0.15.0-b5",
+  "version": "0.15.2-beta2",
   "description": "Tools for WLED project",
   "main": "tools/cdata.js",
   "directories": {
@@ -26,6 +26,9 @@
     "clean-css": "^5.3.3",
     "html-minifier-terser": "^7.2.0",
     "inliner": "^1.13.1",
-    "nodemon": "^3.0.2"
+    "nodemon": "^3.1.7"
+  },
+  "engines": {
+    "node": ">=20.0.0"
   }
 }

pio-scripts/build_ui.py

@@ -1,3 +1,21 @@
-Import('env')
+Import("env")
+import shutil
 
-env.Execute("npm run build")
+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 install")
+
+    # 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)

pio-scripts/output_bins.py

@@ -2,6 +2,7 @@ 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")
@@ -19,9 +20,11 @@ def _create_dirs(dirs=["map", "release", "firmware"]):
         os.makedirs(os.path.join(OUTPUT_DIR, d), exist_ok=True)
 
 def create_release(source):
-    release_name = _get_cpp_define_value(env, "WLED_RELEASE_NAME")
-    if release_name:
-        version = _get_cpp_define_value(env, "WLED_VERSION")
+    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_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

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

@@ -1,8 +0,0 @@
-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}"])

platformio.ini

@@ -10,7 +10,7 @@
 # ------------------------------------------------------------------------------
 
 # CI/release binaries
-default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, nodemcuv2_160, esp8266_2m_160, esp01_1m_full_160, nodemcuv2_compat, esp8266_2m_compat, esp01_1m_full_compat, esp32dev, esp32_eth, lolin_s2_mini, esp32c3dev, esp32s3dev_16MB_opi, esp32s3dev_8MB_opi, esp32s3_4M_qspi, esp32_wrover
+default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, nodemcuv2_160, esp8266_2m_160, esp01_1m_full_160, nodemcuv2_compat, esp8266_2m_compat, esp01_1m_full_compat, esp32dev, esp32dev_V4, esp32_eth, lolin_s2_mini, esp32c3dev, esp32s3dev_16MB_opi, esp32s3dev_8MB_opi, esp32s3_4M_qspi, esp32_wrover
 
 src_dir  = ./wled00
 data_dir = ./wled00/data
@@ -110,7 +110,7 @@ ldscript_4m1m = eagle.flash.4m1m.ld
 
 [scripts_defaults]
 extra_scripts =
-  pre:pio-scripts/set_version.py
+  pre:pio-scripts/set_metadata.py
   post:pio-scripts/output_bins.py
   post:pio-scripts/strip-floats.py
   pre:pio-scripts/user_config_copy.py
@@ -138,9 +138,8 @@ lib_compat_mode = strict
 lib_deps =
     fastled/FastLED @ 3.6.0
     IRremoteESP8266 @ 2.8.2
-    makuna/NeoPixelBus @ 2.8.0
-    #https://github.com/makuna/NeoPixelBus.git#CoreShaderBeta
-    https://github.com/Aircoookie/ESPAsyncWebServer.git @ 2.2.1
+    makuna/NeoPixelBus @ 2.8.3
+    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.4.2
   # for I2C interface
     ;Wire
   # ESP-NOW library
@@ -176,6 +175,7 @@ lib_deps =
 extra_scripts = ${scripts_defaults.extra_scripts}
 
 [esp8266]
+build_unflags = ${common.build_unflags}
 build_flags =
   -DESP8266
   -DFP_IN_IROM
@@ -197,6 +197,7 @@ build_flags =
   ; decrease code cache size and increase IRAM to fit all pixel functions
   -D PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48 ;; in case of linker errors like "section `.text1' will not fit in region `iram1_0_seg'"
   ; -D PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48_SECHEAP_SHARED ;; (experimental) adds some extra heap, but may cause slowdown
+  -D NON32XFER_HANDLER ;; ask forgiveness for PROGMEM misuse
 
 lib_deps =
   #https://github.com/lorol/LITTLEFS.git
@@ -234,17 +235,19 @@ lib_deps_compat =
   IRremoteESP8266 @ 2.8.2
   makuna/NeoPixelBus @ 2.7.9
   https://github.com/blazoncek/QuickESPNow.git#optional-debug
-  https://github.com/Aircoookie/ESPAsyncWebServer.git @ 2.2.1
+  https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.2.1
 
 
 [esp32]
 #platform = https://github.com/tasmota/platform-espressif32/releases/download/v2.0.2.3/platform-espressif32-2.0.2.3.zip
 platform = espressif32@3.5.0
 platform_packages = framework-arduinoespressif32 @ https://github.com/Aircoookie/arduino-esp32.git#1.0.6.4
+build_unflags = ${common.build_unflags}
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   #-DCONFIG_LITTLEFS_FOR_IDF_3_2
   -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
   #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
@@ -256,11 +259,13 @@ large_partitions = tools/WLED_ESP32_8MB.csv
 extreme_partitions = tools/WLED_ESP32_16MB_9MB_FS.csv
 lib_deps =
   https://github.com/lorol/LITTLEFS.git
-  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  esp32async/AsyncTCP @ 3.4.7
   ${env.lib_deps}
 # additional build flags for audioreactive
-AR_build_flags = -D USERMOD_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
+board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
 
 [esp32_idf_V4]
 ;; experimental build environment for ESP32 using ESP-IDF 4.4.x / arduino-esp32 v2.0.5
@@ -268,69 +273,83 @@ AR_lib_deps = kosme/arduinoFFT @ 2.0.1
 ;;
 ;; 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 = 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)
+platform = https://github.com/tasmota/platform-espressif32/releases/download/2023.06.02/platform-espressif32.zip ;; Tasmota Arduino Core 2.0.9 with IPv6 support, based on IDF 4.4.4
+platform_packages =
+build_unflags = ${common.build_unflags}
 build_flags = -g
   -Wshadow=compatible-local ;; emit warning in case a local variable "shadows" another local one
   -DARDUINO_ARCH_ESP32 -DESP32
   -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
   -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
+  -D WLED_ENABLE_DMX_INPUT
 lib_deps =
-  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  esp32async/AsyncTCP @ 3.4.7
+  https://github.com/someweisguy/esp_dmx.git#47db25d
   ${env.lib_deps}
+board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
 
 [esp32s2]
 ;; generic definitions for all ESP32-S2 boards
 platform = 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_unflags = ${common.build_unflags}
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32S2
   -DCONFIG_IDF_TARGET_ESP32S2=1
   -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
   -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
 lib_deps =
-  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  esp32async/AsyncTCP @ 3.4.7
   ${env.lib_deps}
+board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
 
 [esp32c3]
 ;; generic definitions for all ESP32-C3 boards
 platform = 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_unflags = ${common.build_unflags}
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32C3
   -DCONFIG_IDF_TARGET_ESP32C3=1
   -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
   -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
 lib_deps =
-  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  esp32async/AsyncTCP @ 3.4.7
   ${env.lib_deps}
+board_build.partitions = ${esp32.default_partitions}   ;; default partioning for 4MB Flash - can be overridden in build envs
 
 [esp32s3]
 ;; generic definitions for all ESP32-S3 boards
 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_unflags = ${common.build_unflags}
 build_flags = -g
   -DESP32
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32S3
   -DCONFIG_IDF_TARGET_ESP32S3=1
   -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
   -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
 lib_deps =
-  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  esp32async/AsyncTCP @ 3.4.7
   ${env.lib_deps}
+board_build.partitions = ${esp32.large_partitions}   ;; default partioning for 8MB flash - can be overridden in build envs
 
 
 # ------------------------------------------------------------------------------
@@ -343,7 +362,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
+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
 
@@ -352,13 +371,13 @@ 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
+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
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP8266_160\" #-DWLED_DISABLE_2D
   -D USERMOD_AUDIOREACTIVE
 
 [env:esp8266_2m]
@@ -367,7 +386,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
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP02\"
 lib_deps = ${esp8266.lib_deps}
 
 [env:esp8266_2m_compat]
@@ -375,12 +394,12 @@ 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
+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
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D WLED_RELEASE_NAME=\"ESP02_160\"
   -D USERMOD_AUDIOREACTIVE
 
 [env:esp01_1m_full]
@@ -389,7 +408,7 @@ 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
 lib_deps = ${esp8266.lib_deps}
 
@@ -398,12 +417,12 @@ 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
+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
 
@@ -412,32 +431,65 @@ 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 #-D WLED_DISABLE_BROWNOUT_DET
+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}
 
+[env:esp32dev_V4]
+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_V4\" #-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.default_partitions}
+board_build.flash_mode = dio
+upload_speed = 921600
+
 [env:esp32dev_8M]
 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_8M #-D WLED_DISABLE_BROWNOUT_DET
+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 = qio
+
+[env:esp32dev_16M]
+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_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
+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
+;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}
@@ -452,7 +504,7 @@ platform = ${esp32.platform}
 platform_packages = ${esp32.platform_packages}
 upload_speed = 921600
 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
+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}
@@ -468,9 +520,9 @@ board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 board_build.partitions = ${esp32.extended_partitions}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=ESP32_WROVER
+build_flags = ${common.build_flags} ${esp32_idf_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 LEDPIN=25
+  -D DATA_PINS=25
   ${esp32.AR_build_flags}
 lib_deps = ${esp32_idf_V4.lib_deps}
   ${esp32.AR_lib_deps}
@@ -482,7 +534,7 @@ platform_packages = ${esp32c3.platform_packages}
 framework = arduino
 board = esp32-c3-devkitm-1
 board_build.partitions = ${esp32.default_partitions}
-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
@@ -499,7 +551,7 @@ platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_16MB_opi
+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")
@@ -508,6 +560,8 @@ build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=
 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
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 monitor_filters = esp32_exception_decoder
@@ -520,7 +574,7 @@ platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_8MB_opi
+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")
@@ -533,6 +587,33 @@ board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 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)
+platform = ${esp32s3.platform}
+platform_packages = ${esp32s3.platform_packages}
+board = esp32s3camlcd ;; this is the only standard board with "opi_opi"
+board_build.arduino.memory_type = opi_opi
+upload_speed = 921600
+build_unflags = ${common.build_unflags}
+build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=\"ESP32-S3_WROOM-2\"
+  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
+  -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
+  ${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_4M_qspi]
 ;; ESP32-S3, with 4MB FLASH and <= 4MB PSRAM (memory_type: qio_qspi)
 board = lolin_s3_mini ;; -S3 mini, 4MB flash 2MB PSRAM 
@@ -540,7 +621,7 @@ platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_4M_qspi
+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
@@ -561,7 +642,7 @@ board_build.partitions = ${esp32.default_partitions}
 board_build.flash_mode = qio
 board_build.f_flash = 80000000L
 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
@@ -569,7 +650,8 @@ build_flags = ${common.build_flags} ${esp32s2.build_flags} -D WLED_RELEASE_NAME=
   -DLOLIN_WIFI_FIX ; seems to work much better with this
   -D WLED_WATCHDOG_TIMEOUT=0
   -D CONFIG_ASYNC_TCP_USE_WDT=0
-  -D LEDPIN=16
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=8192
+  -D DATA_PINS=16
   -D HW_PIN_SCL=35
   -D HW_PIN_SDA=33
   -D HW_PIN_CLOCKSPI=7

platformio_override.sample.ini

@@ -5,7 +5,7 @@
 # Please visit documentation: https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = WLED_tasmota_1M  # define as many as you need
+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
 
 #----------
 # SAMPLE
@@ -28,8 +28,8 @@ 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
+;  ${esp32.AR_lib_deps} ;; needed for USERMOD_AUDIOREACTIVE
 
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp8266.build_flags}
@@ -37,7 +37,7 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ; *** 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
@@ -59,7 +59,7 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;   -D WLED_ENABLE_DMX
 ;
 ; PIN defines - uncomment and change, if needed:
-;   -D LEDPIN=2
+;   -D DATA_PINS=2
 ; or use this for multiple outputs
 ;   -D DATA_PINS=1,3
 ;   -D BTNPIN=0
@@ -111,7 +111,6 @@ 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
@@ -142,7 +141,8 @@ 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
+;   ${esp32.AR_build_flags} ;; default flags required to properly configure ArduinoFFT
+;   ;; don't forget to add ArduinoFFT to your libs_deps: ${esp32.AR_lib_deps}
 ;   -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
@@ -158,17 +158,22 @@ 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 DEFAULT_LED_COUNT=30
+;   -D PIXEL_COUNTS=30
 ; or this for multiple outputs
 ;   -D PIXEL_COUNTS=30,30
 ;
 ; set the default LED type
-;   -D DEFAULT_LED_TYPE=22    # see const.h (TYPE_xxxx)
+;   -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
 ;
 ; set milliampere limit when using ESP power pin (or inadequate PSU) to power LEDs
 ;   -D ABL_MILLIAMPS_DEFAULT=850
@@ -177,9 +182,6 @@ 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
 ;
@@ -233,18 +235,17 @@ 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 LEDPIN=1 -D WLED_DISABLE_INFRARED
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
 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
+  ${esp32.AR_build_flags} ;; optional - includes USERMOD_AUDIOREACTIVE
 lib_deps = ${esp32.lib_deps}
+  ${esp32.AR_lib_deps} ;; needed for USERMOD_AUDIOREACTIVE
 monitor_filters = esp32_exception_decoder
-board_build.partitions = ${esp32.default_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 
@@ -252,26 +253,25 @@ 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
+  ${esp32.AR_build_flags} ;; includes USERMOD_AUDIOREACTIVE
 lib_deps = ${esp32_idf_V4.lib_deps}
+  ${esp32.AR_lib_deps} ;; needed for USERMOD_AUDIOREACTIVE
 monitor_filters = esp32_exception_decoder
-board_build.partitions = ${esp32_idf_V4.default_partitions}
+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.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
@@ -308,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
+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.
 lib_deps = ${esp8266.lib_deps}
 
 [env:d1_mini_debug]
@@ -339,7 +339,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 LEDPIN=12 -D IRPIN=-1 -D RLYPIN=2
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=12 -D IRPIN=-1 -D RLYPIN=2
 lib_deps = ${esp8266.lib_deps}
 
 [env:esp32c3dev_2MB]
@@ -359,51 +359,65 @@ upload_speed = 115200
 lib_deps = ${esp32c3.lib_deps}
 board_build.partitions = tools/WLED_ESP32_2MB_noOTA.csv
 board_build.flash_mode = dio
+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 LEDPIN=16
+  -D WLED_RELEASE_NAME=\"ESP32_wemos_shield\"
+  -D DATA_PINS=16
   -D RLYPIN=19
   -D BTNPIN=17
   -D IRPIN=18
-  -D UWLED_USE_MY_CONFIG
+  -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
+  ${esp32.AR_build_flags} ;; includes USERMOD_AUDIOREACTIVE
 lib_deps = ${esp32.lib_deps}
-  OneWire@~2.3.5
-  olikraus/U8g2 @ ^2.28.8
-  https://github.com/blazoncek/arduinoFFT.git
+  OneWire@~2.3.5          ;; needed for USERMOD_DALLASTEMPERATURE
+  olikraus/U8g2 @ ^2.28.8 ;; needed for USERMOD_FOUR_LINE_DISPLAY
+  ${esp32.AR_lib_deps}    ;; needed for USERMOD_AUDIOREACTIVE
 board_build.partitions = ${esp32.default_partitions}
 
-[env:m5atom]
-board = esp32dev
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32.build_flags} -D LEDPIN=27 -D BTNPIN=39
+[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
+  ${esp32.AR_build_flags}    ;; include USERMOD_AUDIOREACTIVE
+  -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}
-platform = ${esp32.platform}
-platform_packages = ${esp32.platform_packages}
+  ${esp32.AR_lib_deps}       ;; needed for USERMOD_AUDIOREACTIVE
 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)
+build_flags = ${common.build_flags} ${esp32.build_flags} -D DATA_PINS=27 -D BTNPIN=39
 
 [env:sp501e]
 board = esp_wroom_02
 platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_2m512k}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D LEDPIN=3 -D BTNPIN=1
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=3 -D BTNPIN=1
 lib_deps = ${esp8266.lib_deps}
 
 [env:sp511e]
 board = esp_wroom_02
 platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_2m512k}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D LEDPIN=3 -D BTNPIN=2 -D IRPIN=5 -D WLED_MAX_BUTTONS=3
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=3 -D BTNPIN=2 -D IRPIN=5 -D WLED_MAX_BUTTONS=3
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_RGBCW]        ;7w and 5w(GU10) bulbs
@@ -413,7 +427,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 DEFAULT_LED_TYPE=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0
+                                            -D LED_TYPES=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_15w_RGBCW]        ;15w bulb
@@ -423,7 +437,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 DEFAULT_LED_TYPE=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0 -D WLED_USE_IC_CCT
+                                            -D LED_TYPES=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
@@ -432,7 +446,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 BTNPIN=0 -D RLYPIN=-1 -D LEDPIN=1 -D WLED_DISABLE_INFRARED
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=-1 -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_4Pin_Controller]       ; With clock and data interface
@@ -441,7 +455,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 BTNPIN=0 -D RLYPIN=12 -D LEDPIN=1 -D WLED_DISABLE_INFRARED
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=12 -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_5Pin_Controller]      ;Analog light strip controller
@@ -489,17 +503,16 @@ 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
 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 LEDPIN=12
+  -D DATA_PINS=12
   -D RLYPIN=27
   -D BTNPIN=34
-  -D DEFAULT_LED_COUNT=6
+  -D PIXEL_COUNTS=6
   # Display config
   -D ST7789_DRIVER
   -D TFT_WIDTH=135
@@ -515,5 +528,4 @@ build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_DISABLE_BROWNOU
 monitor_filters = esp32_exception_decoder
 lib_deps =
   ${esp32.lib_deps}
-  TFT_eSPI @ ^2.3.70
-board_build.partitions = ${esp32.default_partitions}
+  TFT_eSPI @ 2.5.33  ;; this is the last version that compiles with the WLED default framework - newer versions require platform = espressif32 @ ^6.3.2

readme.md

@@ -61,7 +61,7 @@ See [here](https://kno.wled.ge/basics/compatible-hardware)!
 
 ## ✌️ Other
 
-Licensed under the MIT license  
+Licensed under the EUPL v1.2 license  
 Credits [here](https://kno.wled.ge/about/contributors/)!
 
 Join the Discord server to discuss everything about WLED!
@@ -80,5 +80,5 @@ If WLED really brightens up your day, you can [![](https://img.shields.io/badge/
 If you are prone to photosensitive epilepsy, we recommended you do **not** use this software.  
 If you still want to try, don't use strobe, lighting or noise modes or high effect speed settings.
 
-As per the MIT license, I assume no liability for any damage to you or any other person or equipment.  
+As per the EUPL license, I assume no liability for any damage to you or any other person or equipment.  
 

requirements.txt

@@ -4,19 +4,17 @@
 #
 #    pip-compile
 #
-aiofiles==22.1.0
-    # via platformio
 ajsonrpc==1.2.0
     # via platformio
-anyio==3.6.2
+anyio==4.6.0
     # via starlette
-bottle==0.12.25
+bottle==0.13.1
     # via platformio
-certifi==2023.7.22
+certifi==2024.8.30
     # via requests
-charset-normalizer==3.1.0
+charset-normalizer==3.3.2
     # via requests
-click==8.1.3
+click==8.1.7
     # via
     #   platformio
     #   uvicorn
@@ -28,35 +26,33 @@ h11==0.14.0
     # via
     #   uvicorn
     #   wsproto
-idna==3.7
+idna==3.10
     # via
     #   anyio
     #   requests
-marshmallow==3.19.0
+marshmallow==3.22.0
     # via platformio
-packaging==23.1
+packaging==24.1
     # via marshmallow
-platformio==6.1.14
+platformio==6.1.16
     # via -r requirements.in
-pyelftools==0.29
+pyelftools==0.31
     # via platformio
 pyserial==3.5
     # via platformio
-requests==2.32.0
+requests==2.32.3
     # via platformio
 semantic-version==2.10.0
     # via platformio
-sniffio==1.3.0
+sniffio==1.3.1
     # via anyio
-starlette==0.23.1
+starlette==0.39.1
     # via platformio
 tabulate==0.9.0
     # via platformio
-typing-extensions==4.11.0
-    # via starlette
-urllib3==1.26.19
+urllib3==2.2.3
     # via requests
-uvicorn==0.20.0
+uvicorn==0.30.6
     # via platformio
 wsproto==1.2.0
     # via platformio

tools/WLED_ESP32_4MB_512KB_FS.csv

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

tools/all_xml.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Pull all settings pages for comparison
+HOST=$1
+TGT_PATH=$2
+CURL_ARGS="--compressed"
+
+# Replicate one target many times
+function replicate() {
+  for i in {0..10}
+  do  
+    echo -n " http://${HOST}/settings.js?p=$i -o ${TGT_PATH}/$i.xml"
+  done
+}
+read -a TARGETS <<< $(replicate)
+
+mkdir -p ${TGT_PATH}
+curl ${CURL_ARGS} ${TARGETS[@]}

tools/cdata.js

@@ -101,6 +101,7 @@ 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,
@@ -116,7 +117,8 @@ async function minify(str, type = "plain") {
   } else if (type == "css-minify") {
     return new CleanCSS({}).minify(str).styles;
   } else if (type == "js-minify") {
-    return await minifyHtml('<script>' + str + '</script>', options).replace(/<[\/]*script>/g, '');
+    let js = await minifyHtml('<script>' + str + '</script>', options);
+    return js.replace(/<[\/]*script>/g, '');
   } else if (type == "html-minify") {
     return await minifyHtml(str, options);
   }
@@ -252,6 +254,12 @@ writeChunks(
         str
           .replace("%%", "%")
     },
+    {
+      file: "common.js",
+      name: "JS_common",
+      method: "gzip",
+      filter: "js-minify",
+    },
     {
       file: "settings.htm",
       name: "PAGE_settings",
@@ -362,12 +370,6 @@ 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",

usermods/Analog_Clock/Analog_Clock.h

@@ -102,9 +102,9 @@ private:
 
     void secondsEffectSineFade(int16_t secondLed, Toki::Time const& time) {
         uint32_t ms = time.ms % 1000;
-        uint8_t b0 = (cos8(ms * 64 / 1000) - 128) * 2;
+        uint8_t b0 = (cos8_t(ms * 64 / 1000) - 128) * 2;
         setPixelColor(secondLed, gamma32(scale32(secondColor, b0)));
-        uint8_t b1 = (sin8(ms * 64 / 1000) - 128) * 2;
+        uint8_t b1 = (sin8_t(ms * 64 / 1000) - 128) * 2;
         setPixelColor(inc(secondLed, 1, secondsSegment), gamma32(scale32(secondColor, b1)));
     }
 

usermods/Animated_Staircase/Animated_Staircase.h

@@ -332,7 +332,7 @@ class Animated_Staircase : public Usermod {
       };
       // NOTE: this *WILL* return TRUE if all the pins are set to -1.
       //       this is *BY DESIGN*.
-      if (!pinManager.allocateMultiplePins(pins, 4, PinOwner::UM_AnimatedStaircase)) {
+      if (!PinManager::allocateMultiplePins(pins, 4, PinOwner::UM_AnimatedStaircase)) {
         topPIRorTriggerPin = -1;
         topEchoPin = -1;
         bottomPIRorTriggerPin = -1;
@@ -425,10 +425,10 @@ class Animated_Staircase : public Usermod {
     }
 
     void appendConfigData() {
-      //oappend(SET_F("dd=addDropdown('staircase','selectfield');"));
-      //oappend(SET_F("addOption(dd,'1st value',0);"));
-      //oappend(SET_F("addOption(dd,'2nd value',1);"));
-      //oappend(SET_F("addInfo('staircase:selectfield',1,'additional info');"));  // 0 is field type, 1 is actual field
+      //oappend(F("dd=addDropdown('staircase','selectfield');"));
+      //oappend(F("addOption(dd,'1st value',0);"));
+      //oappend(F("addOption(dd,'2nd value',1);"));
+      //oappend(F("addInfo('staircase:selectfield',1,'additional info');"));  // 0 is field type, 1 is actual field
     }
 
 
@@ -513,10 +513,10 @@ class Animated_Staircase : public Usermod {
             (oldBottomAPin != bottomPIRorTriggerPin) ||
             (oldBottomBPin != bottomEchoPin)) {
           changed = true;
-          pinManager.deallocatePin(oldTopAPin, PinOwner::UM_AnimatedStaircase);
-          pinManager.deallocatePin(oldTopBPin, PinOwner::UM_AnimatedStaircase);
-          pinManager.deallocatePin(oldBottomAPin, PinOwner::UM_AnimatedStaircase);
-          pinManager.deallocatePin(oldBottomBPin, PinOwner::UM_AnimatedStaircase);
+          PinManager::deallocatePin(oldTopAPin, PinOwner::UM_AnimatedStaircase);
+          PinManager::deallocatePin(oldTopBPin, PinOwner::UM_AnimatedStaircase);
+          PinManager::deallocatePin(oldBottomAPin, PinOwner::UM_AnimatedStaircase);
+          PinManager::deallocatePin(oldBottomBPin, PinOwner::UM_AnimatedStaircase);
         }
         if (changed) setup();
       }

usermods/Animated_Staircase/README.md

@@ -18,7 +18,7 @@ Before compiling, you have to make the following modifications:
 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 `usermods.add(new Animated_Staircase());` to the end of the `void registerUsermods()` function.
+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).

usermods/BME280_v2/usermod_bme280.h

@@ -444,6 +444,7 @@ public:
     configComplete &= getJsonValue(top[F("PublishAlways")], PublishAlways, false);
     configComplete &= getJsonValue(top[F("UseCelsius")], UseCelsius, true);
     configComplete &= getJsonValue(top[F("HomeAssistantDiscovery")], HomeAssistantDiscovery, false);
+    tempScale = UseCelsius ? "°C" : "°F";
 
     DEBUG_PRINT(FPSTR(_name));
     if (!initDone) {

usermods/BME68X_v2/usermod_bme68x.h

@@ -767,22 +767,22 @@ void UsermodBME68X::appendConfigData() {
 	// snprintf_P(charbuffer, 127, PSTR("addInfo('%s:%s',1,'*) Set to minus to deactivate (all sensors)');"), UMOD_NAME, _nameTemp); oappend(charbuffer);
 
 	/* Dropdown for Celsius/Fahrenheit*/
-	oappend(SET_F("dd=addDropdown('"));
+	oappend(F("dd=addDropdown('"));
 	oappend(UMOD_NAME);
-	oappend(SET_F("','"));
+	oappend(F("','"));
 	oappend(_nameTempScale);
-	oappend(SET_F("');"));
-	oappend(SET_F("addOption(dd,'Celsius',0);"));
-	oappend(SET_F("addOption(dd,'Fahrenheit',1);"));
+	oappend(F("');"));
+	oappend(F("addOption(dd,'Celsius',0);"));
+	oappend(F("addOption(dd,'Fahrenheit',1);"));
 
 	/* i²C Address*/
-	oappend(SET_F("dd=addDropdown('"));
+	oappend(F("dd=addDropdown('"));
 	oappend(UMOD_NAME);
-	oappend(SET_F("','"));
+	oappend(F("','"));
 	oappend(_nameI2CAdr);
-	oappend(SET_F("');"));
-	oappend(SET_F("addOption(dd,'0x76',0x76);"));
-	oappend(SET_F("addOption(dd,'0x77',0x77);"));
+	oappend(F("');"));
+	oappend(F("addOption(dd,'0x76',0x76);"));
+	oappend(F("addOption(dd,'0x77',0x77);"));
 }
 
 /**

usermods/Battery/usermod_v2_Battery.h

@@ -200,7 +200,7 @@ class UsermodBattery : public Usermod
         bool success = false;
         DEBUG_PRINTLN(F("Allocating battery pin..."));
         if (batteryPin >= 0 && digitalPinToAnalogChannel(batteryPin) >= 0) 
-          if (pinManager.allocatePin(batteryPin, false, PinOwner::UM_Battery)) {
+          if (PinManager::allocatePin(batteryPin, false, PinOwner::UM_Battery)) {
             DEBUG_PRINTLN(F("Battery pin allocation succeeded."));
             success = true;
           }
@@ -478,29 +478,29 @@ class UsermodBattery : public Usermod
     void appendConfigData()
     {
       // Total: 462 Bytes
-      oappend(SET_F("td=addDropdown('Battery','type');"));              // 34 Bytes
-      oappend(SET_F("addOption(td,'Unkown','0');"));                    // 28 Bytes
-      oappend(SET_F("addOption(td,'LiPo','1');"));                      // 26 Bytes
-      oappend(SET_F("addOption(td,'LiOn','2');"));                      // 26 Bytes
-      oappend(SET_F("addInfo('Battery:type',1,'<small style=\"color:orange\">requires reboot</small>');")); // 81 Bytes
-      oappend(SET_F("addInfo('Battery:min-voltage',1,'v');"));          // 38 Bytes
-      oappend(SET_F("addInfo('Battery:max-voltage',1,'v');"));          // 38 Bytes
-      oappend(SET_F("addInfo('Battery:interval',1,'ms');"));            // 36 Bytes
-      oappend(SET_F("addInfo('Battery:HA-discovery',1,'');"));          // 38 Bytes
-      oappend(SET_F("addInfo('Battery:auto-off:threshold',1,'%');"));   // 45 Bytes
-      oappend(SET_F("addInfo('Battery:indicator:threshold',1,'%');"));  // 46 Bytes
-      oappend(SET_F("addInfo('Battery:indicator:duration',1,'s');"));   // 45 Bytes
+      oappend(F("td=addDropdown('Battery','type');"));              // 34 Bytes
+      oappend(F("addOption(td,'Unkown','0');"));                    // 28 Bytes
+      oappend(F("addOption(td,'LiPo','1');"));                      // 26 Bytes
+      oappend(F("addOption(td,'LiOn','2');"));                      // 26 Bytes
+      oappend(F("addInfo('Battery:type',1,'<small style=\"color:orange\">requires reboot</small>');")); // 81 Bytes
+      oappend(F("addInfo('Battery:min-voltage',1,'v');"));          // 38 Bytes
+      oappend(F("addInfo('Battery:max-voltage',1,'v');"));          // 38 Bytes
+      oappend(F("addInfo('Battery:interval',1,'ms');"));            // 36 Bytes
+      oappend(F("addInfo('Battery:HA-discovery',1,'');"));          // 38 Bytes
+      oappend(F("addInfo('Battery:auto-off:threshold',1,'%');"));   // 45 Bytes
+      oappend(F("addInfo('Battery:indicator:threshold',1,'%');"));  // 46 Bytes
+      oappend(F("addInfo('Battery:indicator:duration',1,'s');"));   // 45 Bytes
       
       // this option list would exeed the oappend() buffer
       // a list of all presets to select one from
-      // oappend(SET_F("bd=addDropdown('Battery:low-power-indicator', 'preset');"));
-      // the loop generates: oappend(SET_F("addOption(bd, 'preset name', preset id);"));
+      // oappend(F("bd=addDropdown('Battery:low-power-indicator', 'preset');"));
+      // the loop generates: oappend(F("addOption(bd, 'preset name', preset id);"));
       // for(int8_t i=1; i < 42; i++) {
-      //   oappend(SET_F("addOption(bd, 'Preset#"));
+      //   oappend(F("addOption(bd, 'Preset#"));
       //   oappendi(i);
-      //   oappend(SET_F("',"));
+      //   oappend(F("',"));
       //   oappendi(i);
-      //   oappend(SET_F(");"));
+      //   oappend(F(");"));
       // }
     }
 
@@ -561,7 +561,7 @@ class UsermodBattery : public Usermod
           if (newBatteryPin != batteryPin) 
           {
             // deallocate pin
-            pinManager.deallocatePin(batteryPin, PinOwner::UM_Battery);
+            PinManager::deallocatePin(batteryPin, PinOwner::UM_Battery);
             batteryPin = newBatteryPin;
             // initialise
             setup();

usermods/EXAMPLE_v2/usermod_v2_example.h

@@ -71,7 +71,7 @@ class MyExampleUsermod : public Usermod {
     //   #endif
     //  in setup()
     //   #ifdef USERMOD_EXAMPLE
-    //   UM = (MyExampleUsermod*) usermods.lookup(USERMOD_ID_EXAMPLE);
+    //   UM = (MyExampleUsermod*) UsermodManager::lookup(USERMOD_ID_EXAMPLE);
     //   #endif
     //  somewhere in loop() or other member method
     //   #ifdef USERMOD_EXAMPLE
@@ -287,11 +287,11 @@ class MyExampleUsermod : public Usermod {
      */
     void appendConfigData() override
     {
-      oappend(SET_F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(SET_F(":great")); oappend(SET_F("',1,'<i>(this is a great config value)</i>');"));
-      oappend(SET_F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(SET_F(":testString")); oappend(SET_F("',1,'enter any string you want');"));
-      oappend(SET_F("dd=addDropdown('")); oappend(String(FPSTR(_name)).c_str()); oappend(SET_F("','testInt');"));
-      oappend(SET_F("addOption(dd,'Nothing',0);"));
-      oappend(SET_F("addOption(dd,'Everything',42);"));
+      oappend(F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(F(":great")); oappend(F("',1,'<i>(this is a great config value)</i>');"));
+      oappend(F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(F(":testString")); oappend(F("',1,'enter any string you want');"));
+      oappend(F("dd=addDropdown('")); oappend(String(FPSTR(_name)).c_str()); oappend(F("','testInt');"));
+      oappend(F("addOption(dd,'Nothing',0);"));
+      oappend(F("addOption(dd,'Everything',42);"));
     }
 
 

usermods/Fix_unreachable_netservices_v2/readme.md

@@ -59,10 +59,10 @@ void registerUsermods()
    * || || ||
    * \/ \/ \/
    */
-  //usermods.add(new MyExampleUsermod());
-  //usermods.add(new UsermodTemperature());
-  //usermods.add(new UsermodRenameMe());
-  usermods.add(new FixUnreachableNetServices());
+  //UsermodManager::add(new MyExampleUsermod());
+  //UsermodManager::add(new UsermodTemperature());
+  //UsermodManager::add(new UsermodRenameMe());
+  UsermodManager::add(new FixUnreachableNetServices());
 
 }
 ```

usermods/Internal_Temperature_v2/usermod_internal_temperature.h

@@ -149,11 +149,11 @@ public:
     void appendConfigData()
     {
     // Display 'ms' next to the 'Loop Interval' setting
-    oappend(SET_F("addInfo('Internal Temperature:Loop Interval', 1, 'ms');"));
+    oappend(F("addInfo('Internal Temperature:Loop Interval', 1, 'ms');"));
     // Display '°C' next to the 'Activation Threshold' setting
-    oappend(SET_F("addInfo('Internal Temperature:Activation Threshold', 1, '°C');"));
+    oappend(F("addInfo('Internal Temperature:Activation Threshold', 1, '°C');"));
     // Display '0 = Disabled' next to the 'Preset To Activate' setting
-    oappend(SET_F("addInfo('Internal Temperature:Preset To Activate', 1, '0 = unused');"));
+    oappend(F("addInfo('Internal Temperature:Preset To Activate', 1, '0 = unused');"));
     }
 
   bool readFromConfig(JsonObject &root)

usermods/LDR_Dusk_Dawn_v2/usermod_LDR_Dusk_Dawn_v2.h

@@ -30,7 +30,7 @@ class LDR_Dusk_Dawn_v2 : public Usermod {
     void setup() {
       // register ldrPin
       if ((ldrPin >= 0) && (digitalPinToAnalogChannel(ldrPin) >= 0)) {
-        if(!pinManager.allocatePin(ldrPin, false, PinOwner::UM_LDR_DUSK_DAWN)) ldrEnabled = false; // pin already in use -> disable usermod
+        if(!PinManager::allocatePin(ldrPin, false, PinOwner::UM_LDR_DUSK_DAWN)) ldrEnabled = false; // pin already in use -> disable usermod
         else pinMode(ldrPin, INPUT);                                                               // alloc success -> configure pin for input
       } else ldrEnabled = false;                                                                   // invalid pin -> disable usermod
       initDone = true;
@@ -110,7 +110,7 @@ class LDR_Dusk_Dawn_v2 : public Usermod {
 
       if (initDone && (ldrPin != oldLdrPin)) {
          // pin changed - un-register previous pin, register new pin
-        if (oldLdrPin >= 0) pinManager.deallocatePin(oldLdrPin, PinOwner::UM_LDR_DUSK_DAWN);
+        if (oldLdrPin >= 0) PinManager::deallocatePin(oldLdrPin, PinOwner::UM_LDR_DUSK_DAWN);
         setup();             // setup new pin
       }
       return configComplete;
@@ -139,7 +139,7 @@ class LDR_Dusk_Dawn_v2 : public Usermod {
       //LDR_Off_Count.add(ldrOffCount);
 
       //bool pinValid = ((ldrPin >= 0) && (digitalPinToAnalogChannel(ldrPin) >= 0));
-      //if (pinManager.getPinOwner(ldrPin) != PinOwner::UM_LDR_DUSK_DAWN) pinValid = false;
+      //if (PinManager::getPinOwner(ldrPin) != PinOwner::UM_LDR_DUSK_DAWN) pinValid = false;
       //JsonArray LDR_valid = user.createNestedArray(F("LDR pin"));
       //LDR_valid.add(ldrPin);
       //LDR_valid.add(pinValid ? F(" OK"): F(" invalid"));

usermods/PIR_sensor_switch/readme.md

@@ -52,7 +52,7 @@ class MyUsermod : public Usermod {
 
   void togglePIRSensor() {
     #ifdef USERMOD_PIR_SENSOR_SWITCH
-    PIRsensorSwitch *PIRsensor = (PIRsensorSwitch::*) usermods.lookup(USERMOD_ID_PIRSWITCH);
+    PIRsensorSwitch *PIRsensor = (PIRsensorSwitch::*) UsermodManager::lookup(USERMOD_ID_PIRSWITCH);
     if (PIRsensor != nullptr) {
       PIRsensor->EnablePIRsensor(!PIRsensor->PIRsensorEnabled());
     }

usermods/PIR_sensor_switch/usermod_PIR_sensor_switch.h

@@ -375,7 +375,7 @@ void PIRsensorSwitch::setup()
     sensorPinState[i] = LOW;
     if (PIRsensorPin[i] < 0) continue;
     // pin retrieved from cfg.json (readFromConfig()) prior to running setup()
-    if (pinManager.allocatePin(PIRsensorPin[i], false, PinOwner::UM_PIR)) {
+    if (PinManager::allocatePin(PIRsensorPin[i], false, PinOwner::UM_PIR)) {
       // PIR Sensor mode INPUT_PULLDOWN
       #ifdef ESP8266
       pinMode(PIRsensorPin[i], PIRsensorPin[i]==16 ? INPUT_PULLDOWN_16 : INPUT_PULLUP); // ESP8266 has INPUT_PULLDOWN on GPIO16 only
@@ -511,8 +511,8 @@ void PIRsensorSwitch::addToConfig(JsonObject &root)
 
 void PIRsensorSwitch::appendConfigData()
 {
-  oappend(SET_F("addInfo('PIRsensorSwitch:HA-discovery',1,'HA=Home Assistant');"));     // 0 is field type, 1 is actual field
-  oappend(SET_F("addInfo('PIRsensorSwitch:override',1,'Cancel timer on change');"));    // 0 is field type, 1 is actual field
+  oappend(F("addInfo('PIRsensorSwitch:HA-discovery',1,'HA=Home Assistant');"));     // 0 is field type, 1 is actual field
+  oappend(F("addInfo('PIRsensorSwitch:override',1,'Cancel timer on change');"));    // 0 is field type, 1 is actual field
   for (int i = 0; i < PIR_SENSOR_MAX_SENSORS; i++) {
     char str[128];
     sprintf_P(str, PSTR("addInfo('PIRsensorSwitch:pin[]',%d,'','#%d');"), i, i);
@@ -564,7 +564,7 @@ bool PIRsensorSwitch::readFromConfig(JsonObject &root)
     DEBUG_PRINTLN(F(" config loaded."));
   } else {
     for (int i = 0; i < PIR_SENSOR_MAX_SENSORS; i++)
-      if (oldPin[i] >= 0) pinManager.deallocatePin(oldPin[i], PinOwner::UM_PIR);
+      if (oldPin[i] >= 0) PinManager::deallocatePin(oldPin[i], PinOwner::UM_PIR);
     setup();
     DEBUG_PRINTLN(F(" config (re)loaded."));
   }

usermods/PWM_fan/usermod_PWM_fan.h

@@ -75,7 +75,7 @@ class PWMFanUsermod : public Usermod {
     static const char _lock[];
 
     void initTacho(void) {
-      if (tachoPin < 0 || !pinManager.allocatePin(tachoPin, false, PinOwner::UM_Unspecified)){
+      if (tachoPin < 0 || !PinManager::allocatePin(tachoPin, false, PinOwner::UM_Unspecified)){
         tachoPin = -1;
         return;
       }
@@ -88,7 +88,7 @@ class PWMFanUsermod : public Usermod {
     void deinitTacho(void) {
       if (tachoPin < 0) return;
       detachInterrupt(digitalPinToInterrupt(tachoPin));
-      pinManager.deallocatePin(tachoPin, PinOwner::UM_Unspecified);
+      PinManager::deallocatePin(tachoPin, PinOwner::UM_Unspecified);
       tachoPin = -1;
     }
 
@@ -111,7 +111,7 @@ class PWMFanUsermod : public Usermod {
 
     // https://randomnerdtutorials.com/esp32-pwm-arduino-ide/
     void initPWMfan(void) {
-      if (pwmPin < 0 || !pinManager.allocatePin(pwmPin, true, PinOwner::UM_Unspecified)) {
+      if (pwmPin < 0 || !PinManager::allocatePin(pwmPin, true, PinOwner::UM_Unspecified)) {
         enabled = false;
         pwmPin = -1;
         return;
@@ -121,7 +121,7 @@ class PWMFanUsermod : public Usermod {
       analogWriteRange(255);
       analogWriteFreq(WLED_PWM_FREQ);
       #else
-      pwmChannel = pinManager.allocateLedc(1);
+      pwmChannel = PinManager::allocateLedc(1);
       if (pwmChannel == 255) { //no more free LEDC channels
         deinitPWMfan(); return;
       }
@@ -136,9 +136,9 @@ class PWMFanUsermod : public Usermod {
     void deinitPWMfan(void) {
       if (pwmPin < 0) return;
 
-      pinManager.deallocatePin(pwmPin, PinOwner::UM_Unspecified);
+      PinManager::deallocatePin(pwmPin, PinOwner::UM_Unspecified);
       #ifdef ARDUINO_ARCH_ESP32
-      pinManager.deallocateLedc(pwmChannel, 1);
+      PinManager::deallocateLedc(pwmChannel, 1);
       #endif
       pwmPin = -1;
     }
@@ -191,9 +191,9 @@ class PWMFanUsermod : public Usermod {
     void setup() override {
       #ifdef USERMOD_DALLASTEMPERATURE   
       // This Usermod requires Temperature usermod
-      tempUM = (UsermodTemperature*) usermods.lookup(USERMOD_ID_TEMPERATURE);
+      tempUM = (UsermodTemperature*) UsermodManager::lookup(USERMOD_ID_TEMPERATURE);
       #elif defined(USERMOD_SHT)
-      tempUM = (ShtUsermod*) usermods.lookup(USERMOD_ID_SHT);
+      tempUM = (ShtUsermod*) UsermodManager::lookup(USERMOD_ID_SHT);
       #endif
       initTacho();
       initPWMfan();

usermods/SN_Photoresistor/usermods_list.cpp

@@ -9,6 +9,6 @@
 void registerUsermods()
 {
 #ifdef USERMOD_SN_PHOTORESISTOR
-  usermods.add(new Usermod_SN_Photoresistor());
+  UsermodManager::add(new Usermod_SN_Photoresistor());
 #endif
 }

usermods/ST7789_display/ST7789_display.h

@@ -138,10 +138,10 @@ class St7789DisplayUsermod : public Usermod {
     void setup() override
     {
         PinManagerPinType spiPins[] = { { spi_mosi, true }, { spi_miso, false}, { spi_sclk, true } };
-        if (!pinManager.allocateMultiplePins(spiPins, 3, PinOwner::HW_SPI)) { enabled = false; return; }
+        if (!PinManager::allocateMultiplePins(spiPins, 3, PinOwner::HW_SPI)) { enabled = false; return; }
         PinManagerPinType displayPins[] = { { TFT_CS, true}, { TFT_DC, true}, { TFT_RST, true }, { TFT_BL, true } };
-        if (!pinManager.allocateMultiplePins(displayPins, sizeof(displayPins)/sizeof(PinManagerPinType), PinOwner::UM_FourLineDisplay)) {
-            pinManager.deallocateMultiplePins(spiPins, 3, PinOwner::HW_SPI);
+        if (!PinManager::allocateMultiplePins(displayPins, sizeof(displayPins)/sizeof(PinManagerPinType), PinOwner::UM_FourLineDisplay)) {
+            PinManager::deallocateMultiplePins(spiPins, 3, PinOwner::HW_SPI);
             enabled = false;
             return;
         }
@@ -377,10 +377,10 @@ class St7789DisplayUsermod : public Usermod {
 
 
     void appendConfigData() override {
-      oappend(SET_F("addInfo('ST7789:pin[]',0,'','SPI CS');"));
-      oappend(SET_F("addInfo('ST7789:pin[]',1,'','SPI DC');"));
-      oappend(SET_F("addInfo('ST7789:pin[]',2,'','SPI RST');"));
-      oappend(SET_F("addInfo('ST7789:pin[]',3,'','SPI BL');"));
+      oappend(F("addInfo('ST7789:pin[]',0,'','SPI CS');"));
+      oappend(F("addInfo('ST7789:pin[]',1,'','SPI DC');"));
+      oappend(F("addInfo('ST7789:pin[]',2,'','SPI RST');"));
+      oappend(F("addInfo('ST7789:pin[]',3,'','SPI BL');"));
     }
 
     /*

usermods/Temperature/platformio_override.ini

@@ -7,6 +7,4 @@
 extends = env:d1_mini
 build_flags = ${common.build_flags_esp8266} -D USERMOD_DALLASTEMPERATURE
 lib_deps = ${env.lib_deps}
-  paulstoffregen/OneWire@~2.3.7
-# you may want to use following with ESP32
-;  https://github.com/blazoncek/OneWire.git # fixes Sensor error on ESP32
+  paulstoffregen/OneWire@~2.3.8

usermods/Temperature/readme.md

@@ -43,10 +43,8 @@ default_envs = d1_mini
 ...
 lib_deps =
   ...
-  #For Dallas sensor uncomment following line
-  OneWire@~2.3.7
-  # ... or you may want to use following with ESP32
-;  https://github.com/blazoncek/OneWire.git # fixes Sensor error on ESP32...
+  #For Dallas sensor uncomment following
+    paulstoffregen/OneWire @ ~2.3.8
 ```
 
 ## Change Log
@@ -56,8 +54,14 @@ lib_deps =
 * Do not report erroneous low temperatures to MQTT
 * Disable plugin if temperature sensor not detected
 * Report the number of seconds until the first read in the info screen instead of sensor error
+
 2021-04
 * Adaptation for runtime configuration.
+
 2023-05
 * Rewrite to conform to newer recommendations.
-* Recommended @blazoncek fork of OneWire for ESP32 to avoid Sensor error
+* Recommended @blazoncek fork of OneWire for ESP32 to avoid Sensor error
+
+2024-09
+* Update OneWire to version 2.3.8, which includes stickbreaker's and garyd9's ESP32 fixes:
+  blazoncek's fork is no longer needed

usermods/Temperature/usermod_temperature.h

@@ -17,6 +17,8 @@
 #define USERMOD_DALLASTEMPERATURE_MEASUREMENT_INTERVAL 60000
 #endif
 
+static uint16_t mode_temperature();
+
 class UsermodTemperature : public Usermod {
 
   private:
@@ -60,6 +62,7 @@ class UsermodTemperature : public Usermod {
     static const char _sensor[];
     static const char _temperature[];
     static const char _Temperature[];
+    static const char _data_fx[];
     
     //Dallas sensor quick (& dirty) reading. Credit to - Author: Peter Scargill, August 17th, 2013
     float readDallas();
@@ -70,8 +73,13 @@ class UsermodTemperature : public Usermod {
     void publishHomeAssistantAutodiscovery();
 #endif
 
+    static UsermodTemperature* _instance; // to overcome nonstatic getTemperatureC() method and avoid UsermodManager::lookup(USERMOD_ID_TEMPERATURE);
+
   public:
 
+    UsermodTemperature() { _instance = this; }
+    static UsermodTemperature *getInstance() { return UsermodTemperature::_instance; }
+
     /*
      * API calls te enable data exchange between WLED modules
      */
@@ -215,14 +223,14 @@ void UsermodTemperature::setup() {
     // config says we are enabled
     DEBUG_PRINTLN(F("Allocating temperature pin..."));
     // pin retrieved from cfg.json (readFromConfig()) prior to running setup()
-    if (temperaturePin >= 0 && pinManager.allocatePin(temperaturePin, true, PinOwner::UM_Temperature)) {
+    if (temperaturePin >= 0 && PinManager::allocatePin(temperaturePin, true, PinOwner::UM_Temperature)) {
       oneWire = new OneWire(temperaturePin);
       if (oneWire->reset()) {
         while (!findSensor() && retries--) {
           delay(25); // try to find sensor
         }
       }
-      if (parasite && pinManager.allocatePin(parasitePin, true, PinOwner::UM_Temperature)) {
+      if (parasite && PinManager::allocatePin(parasitePin, true, PinOwner::UM_Temperature)) {
         pinMode(parasitePin, OUTPUT);
         digitalWrite(parasitePin, LOW); // deactivate power (close MOSFET)
       } else {
@@ -234,6 +242,7 @@ void UsermodTemperature::setup() {
       }
       temperaturePin = -1;  // allocation failed
     }
+    if (sensorFound && !initDone) strip.addEffect(255, &mode_temperature, _data_fx);
   }
   lastMeasurement = millis() - readingInterval + 10000;
   initDone = true;
@@ -414,9 +423,9 @@ bool UsermodTemperature::readFromConfig(JsonObject &root) {
       DEBUG_PRINTLN(F("Re-init temperature."));
       // deallocate pin and release memory
       delete oneWire;
-      pinManager.deallocatePin(temperaturePin, PinOwner::UM_Temperature);
+      PinManager::deallocatePin(temperaturePin, PinOwner::UM_Temperature);
       temperaturePin = newTemperaturePin;
-      pinManager.deallocatePin(parasitePin, PinOwner::UM_Temperature);
+      PinManager::deallocatePin(parasitePin, PinOwner::UM_Temperature);
       // initialise
       setup();
     }
@@ -426,10 +435,10 @@ bool UsermodTemperature::readFromConfig(JsonObject &root) {
 }
 
 void UsermodTemperature::appendConfigData() {
-  oappend(SET_F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(SET_F(":")); oappend(String(FPSTR(_parasite)).c_str());
-  oappend(SET_F("',1,'<i>(if no Vcc connected)</i>');"));  // 0 is field type, 1 is actual field
-  oappend(SET_F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(SET_F(":")); oappend(String(FPSTR(_parasitePin)).c_str());
-  oappend(SET_F("',1,'<i>(for external MOSFET)</i>');"));  // 0 is field type, 1 is actual field
+  oappend(F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(F(":")); oappend(String(FPSTR(_parasite)).c_str());
+  oappend(F("',1,'<i>(if no Vcc connected)</i>');"));  // 0 is field type, 1 is actual field
+  oappend(F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(F(":")); oappend(String(FPSTR(_parasitePin)).c_str());
+  oappend(F("',1,'<i>(for external MOSFET)</i>');"));  // 0 is field type, 1 is actual field
 }
 
 float UsermodTemperature::getTemperature() {
@@ -440,6 +449,8 @@ const char *UsermodTemperature::getTemperatureUnit() {
   return degC ? "°C" : "°F";
 }
 
+UsermodTemperature* UsermodTemperature::_instance = nullptr;
+
 // strings to reduce flash memory usage (used more than twice)
 const char UsermodTemperature::_name[]         PROGMEM = "Temperature";
 const char UsermodTemperature::_enabled[]      PROGMEM = "enabled";
@@ -449,4 +460,14 @@ const char UsermodTemperature::_parasitePin[]  PROGMEM = "parasite-pwr-pin";
 const char UsermodTemperature::_domoticzIDX[]  PROGMEM = "domoticz-idx";
 const char UsermodTemperature::_sensor[]       PROGMEM = "sensor";
 const char UsermodTemperature::_temperature[]  PROGMEM = "temperature";
-const char UsermodTemperature::_Temperature[]  PROGMEM = "/temperature";
+const char UsermodTemperature::_Temperature[]  PROGMEM = "/temperature";
+const char UsermodTemperature::_data_fx[]      PROGMEM = "Temperature@Min,Max;;!;01;pal=54,sx=255,ix=0";
+
+static uint16_t mode_temperature() {
+  float low  = roundf(mapf((float)SEGMENT.speed, 0.f, 255.f, -150.f, 150.f));    // default: 15°C, range: -15°C to 15°C
+  float high = roundf(mapf((float)SEGMENT.intensity, 0.f, 255.f, 300.f, 600.f));  // default: 30°C, range 30°C to 60°C
+  float temp = constrain(UsermodTemperature::getInstance()->getTemperatureC()*10.f, low, high);   // get a little better resolution (*10)
+  unsigned i = map(roundf(temp), (unsigned)low, (unsigned)high, 0, 248);
+  SEGMENT.fill(SEGMENT.color_from_palette(i, false, false, 255));
+  return FRAMETIME;
+}

usermods/audioreactive/audio_reactive.h

@@ -75,7 +75,7 @@ static uint8_t  soundAgc = 0;                   // Automagic gain control: 0 - n
 //static float    volumeSmth = 0.0f;              // either sampleAvg or sampleAgc depending on soundAgc; smoothed sample
 static float FFT_MajorPeak = 1.0f;              // FFT: strongest (peak) frequency
 static float FFT_Magnitude = 0.0f;              // FFT: volume (magnitude) of peak frequency
-static bool samplePeak = false;      // Boolean flag for peak - used in effects. Responding routine may reset this flag. Auto-reset after strip.getMinShowDelay()
+static bool samplePeak = false;      // Boolean flag for peak - used in effects. Responding routine may reset this flag. Auto-reset after strip.getFrameTime()
 static bool udpSamplePeak = false;   // Boolean flag for peak. Set at the same time as samplePeak, but reset by transmitAudioData
 static unsigned long timeOfPeak = 0; // time of last sample peak detection.
 static uint8_t fftResult[NUM_GEQ_CHANNELS]= {0};// Our calculated freq. channel result table to be used by effects
@@ -149,7 +149,6 @@ static bool useBandPassFilter = false;                    // if true, enables a
 ////////////////////
 
 // some prototypes, to ensure consistent interfaces
-static float mapf(float x, float in_min, float in_max, float out_min, float out_max); // map function for float
 static float fftAddAvg(int from, int to);   // average of several FFT result bins
 void FFTcode(void * parameter);      // audio processing task: read samples, run FFT, fill GEQ channels from FFT results
 static void runMicFilter(uint16_t numSamples, float *sampleBuffer);          // pre-filtering of raw samples (band-pass)
@@ -192,8 +191,8 @@ constexpr uint16_t samplesFFT_2 = 256;          // meaningfull part of FFT resul
 #define LOG_256  5.54517744f                            // log(256)
 
 // These are the input and output vectors.  Input vectors receive computed results from FFT.
-static float vReal[samplesFFT] = {0.0f};       // FFT sample inputs / freq output -  these are our raw result bins
-static float vImag[samplesFFT] = {0.0f};       // imaginary parts
+static float* vReal = nullptr;                  // FFT sample inputs / freq output -  these are our raw result bins
+static float* vImag = nullptr;                  // imaginary parts
 
 // Create FFT object
 // lib_deps += https://github.com/kosme/arduinoFFT#develop @ 1.9.2
@@ -201,21 +200,11 @@ static float vImag[samplesFFT] = {0.0f};       // imaginary parts
 // #define FFT_SPEED_OVER_PRECISION     // enables use of reciprocals (1/x etc) - not faster on ESP32
 // #define FFT_SQRT_APPROXIMATION       // enables "quake3" style inverse sqrt  - slower on ESP32
 // Below options are forcing ArduinoFFT to use sqrtf() instead of sqrt()
-#define sqrt(x) sqrtf(x)             // little hack that reduces FFT time by 10-50% on ESP32
-#define sqrt_internal sqrtf          // see https://github.com/kosme/arduinoFFT/pull/83
-
-#include <arduinoFFT.h>
-
-/* Create FFT object with weighing factor storage */
-static ArduinoFFT<float> FFT = ArduinoFFT<float>( vReal, vImag, samplesFFT, SAMPLE_RATE, true);
+// #define sqrt_internal sqrtf          // see https://github.com/kosme/arduinoFFT/pull/83 - since v2.0.0 this must be done in build_flags
 
+#include <arduinoFFT.h>             // FFT object is created in FFTcode
 // Helper functions
 
-// float version of map()
-static float mapf(float x, float in_min, float in_max, float out_min, float out_max){
-  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}
-
 // compute average of several FFT result bins
 static float fftAddAvg(int from, int to) {
   float result = 0.0f;
@@ -232,6 +221,18 @@ void FFTcode(void * parameter)
 {
   DEBUGSR_PRINT("FFT started on core: "); DEBUGSR_PRINTLN(xPortGetCoreID());
 
+  // allocate FFT buffers on first call
+  if (vReal == nullptr) vReal = (float*) calloc(sizeof(float), samplesFFT);
+  if (vImag == nullptr) vImag = (float*) calloc(sizeof(float), samplesFFT);
+  if ((vReal == nullptr) || (vImag == nullptr)) {
+    // something went wrong
+    if (vReal) free(vReal); vReal = nullptr;
+    if (vImag) free(vImag); vImag = nullptr;
+    return;
+  }
+  // Create FFT object with weighing factor storage
+  ArduinoFFT<float> FFT = ArduinoFFT<float>( vReal, vImag, samplesFFT, SAMPLE_RATE, true);
+
   // see https://www.freertos.org/vtaskdelayuntil.html
   const TickType_t xFrequency = FFT_MIN_CYCLE * portTICK_PERIOD_MS;  
 
@@ -253,6 +254,7 @@ void FFTcode(void * parameter)
 
     // get a fresh batch of samples from I2S
     if (audioSource) audioSource->getSamples(vReal, samplesFFT);
+    memset(vImag, 0, samplesFFT * sizeof(float));   // set imaginary parts to 0
 
 #if defined(WLED_DEBUG) || defined(SR_DEBUG)
     if (start < esp_timer_get_time()) { // filter out overflows
@@ -271,8 +273,6 @@ void FFTcode(void * parameter)
     // find highest sample in the batch
     float maxSample = 0.0f;                         // max sample from FFT batch
     for (int i=0; i < samplesFFT; i++) {
-	    // set imaginary parts to 0
-      vImag[i] = 0;
 	    // pick our  our current mic sample - we take the max value from all samples that go into FFT
 	    if ((vReal[i] <= (INT16_MAX - 1024)) && (vReal[i] >= (INT16_MIN + 1024)))  //skip extreme values - normally these are artefacts
         if (fabsf((float)vReal[i]) > maxSample) maxSample = fabsf((float)vReal[i]);
@@ -303,7 +303,7 @@ void FFTcode(void * parameter)
 #endif
 
     } else { // noise gate closed - only clear results as FFT was skipped. MIC samples are still valid when we do this.
-      memset(vReal, 0, sizeof(vReal));
+      memset(vReal, 0, samplesFFT * sizeof(float));
       FFT_MajorPeak = 1;
       FFT_Magnitude = 0.001;
     }
@@ -536,8 +536,8 @@ static void detectSamplePeak(void) {
 #endif
 
 static void autoResetPeak(void) {
-  uint16_t MinShowDelay = MAX(50, strip.getMinShowDelay());  // Fixes private class variable compiler error. Unsure if this is the correct way of fixing the root problem. -THATDONFC
-  if (millis() - timeOfPeak > MinShowDelay) {          // Auto-reset of samplePeak after a complete frame has passed.
+  uint16_t peakDelay = max(uint16_t(50), strip.getFrameTime());
+  if (millis() - timeOfPeak > peakDelay) {          // Auto-reset of samplePeak after at least one complete frame has passed.
     samplePeak = false;
     if (audioSyncEnabled == 0) udpSamplePeak = false;  // this is normally reset by transmitAudioData
   }
@@ -1885,57 +1885,59 @@ class AudioReactive : public Usermod {
     }
 
 
-    void appendConfigData() override
+    void appendConfigData(Print& uiScript) override
     {
-#ifdef ARDUINO_ARCH_ESP32   
-      oappend(SET_F("dd=addDropdown('AudioReactive','digitalmic:type');"));
+      uiScript.print(F("ux='AudioReactive';"));         // ux = shortcut for Audioreactive - fingers crossed that "ux" isn't already used as JS var, html post parameter or css style
+#ifdef ARDUINO_ARCH_ESP32
+      uiScript.print(F("uxp=ux+':digitalmic:pin[]';")); // uxp = shortcut for AudioReactive:digitalmic:pin[]
+      uiScript.print(F("dd=addDropdown(ux,'digitalmic:type');"));
     #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
-      oappend(SET_F("addOption(dd,'Generic Analog',0);"));
+      uiScript.print(F("addOption(dd,'Generic Analog',0);"));
     #endif
-      oappend(SET_F("addOption(dd,'Generic I2S',1);"));
-      oappend(SET_F("addOption(dd,'ES7243',2);"));
-      oappend(SET_F("addOption(dd,'SPH0654',3);"));
-      oappend(SET_F("addOption(dd,'Generic I2S with Mclk',4);"));
+      uiScript.print(F("addOption(dd,'Generic I2S',1);"));
+      uiScript.print(F("addOption(dd,'ES7243',2);"));
+      uiScript.print(F("addOption(dd,'SPH0654',3);"));
+      uiScript.print(F("addOption(dd,'Generic I2S with Mclk',4);"));
     #if  !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3)
-      oappend(SET_F("addOption(dd,'Generic I2S PDM',5);"));
+      uiScript.print(F("addOption(dd,'Generic I2S PDM',5);"));
     #endif
-    oappend(SET_F("addOption(dd,'ES8388',6);"));
+    uiScript.print(F("addOption(dd,'ES8388',6);"));
     
-      oappend(SET_F("dd=addDropdown('AudioReactive','config:AGC');"));
-      oappend(SET_F("addOption(dd,'Off',0);"));
-      oappend(SET_F("addOption(dd,'Normal',1);"));
-      oappend(SET_F("addOption(dd,'Vivid',2);"));
-      oappend(SET_F("addOption(dd,'Lazy',3);"));
+      uiScript.print(F("dd=addDropdown(ux,'config:AGC');"));
+      uiScript.print(F("addOption(dd,'Off',0);"));
+      uiScript.print(F("addOption(dd,'Normal',1);"));
+      uiScript.print(F("addOption(dd,'Vivid',2);"));
+      uiScript.print(F("addOption(dd,'Lazy',3);"));
 
-      oappend(SET_F("dd=addDropdown('AudioReactive','dynamics:limiter');"));
-      oappend(SET_F("addOption(dd,'Off',0);"));
-      oappend(SET_F("addOption(dd,'On',1);"));
-      oappend(SET_F("addInfo('AudioReactive:dynamics:limiter',0,' On ');"));  // 0 is field type, 1 is actual field
-      oappend(SET_F("addInfo('AudioReactive:dynamics:rise',1,'ms <i>(&#x266A; effects only)</i>');"));
-      oappend(SET_F("addInfo('AudioReactive:dynamics:fall',1,'ms <i>(&#x266A; effects only)</i>');"));
+      uiScript.print(F("dd=addDropdown(ux,'dynamics:limiter');"));
+      uiScript.print(F("addOption(dd,'Off',0);"));
+      uiScript.print(F("addOption(dd,'On',1);"));
+      uiScript.print(F("addInfo(ux+':dynamics:limiter',0,' On ');"));  // 0 is field type, 1 is actual field
+      uiScript.print(F("addInfo(ux+':dynamics:rise',1,'ms <i>(&#x266A; effects only)</i>');"));
+      uiScript.print(F("addInfo(ux+':dynamics:fall',1,'ms <i>(&#x266A; effects only)</i>');"));
 
-      oappend(SET_F("dd=addDropdown('AudioReactive','frequency:scale');"));
-      oappend(SET_F("addOption(dd,'None',0);"));
-      oappend(SET_F("addOption(dd,'Linear (Amplitude)',2);"));
-      oappend(SET_F("addOption(dd,'Square Root (Energy)',3);"));
-      oappend(SET_F("addOption(dd,'Logarithmic (Loudness)',1);"));
+      uiScript.print(F("dd=addDropdown(ux,'frequency:scale');"));
+      uiScript.print(F("addOption(dd,'None',0);"));
+      uiScript.print(F("addOption(dd,'Linear (Amplitude)',2);"));
+      uiScript.print(F("addOption(dd,'Square Root (Energy)',3);"));
+      uiScript.print(F("addOption(dd,'Logarithmic (Loudness)',1);"));
 #endif
 
-      oappend(SET_F("dd=addDropdown('AudioReactive','sync:mode');"));
-      oappend(SET_F("addOption(dd,'Off',0);"));
+      uiScript.print(F("dd=addDropdown(ux,'sync:mode');"));
+      uiScript.print(F("addOption(dd,'Off',0);"));
 #ifdef ARDUINO_ARCH_ESP32
-      oappend(SET_F("addOption(dd,'Send',1);"));
+      uiScript.print(F("addOption(dd,'Send',1);"));
 #endif
-      oappend(SET_F("addOption(dd,'Receive',2);"));
+      uiScript.print(F("addOption(dd,'Receive',2);"));
 #ifdef ARDUINO_ARCH_ESP32
-      oappend(SET_F("addInfo('AudioReactive:digitalmic:type',1,'<i>requires reboot!</i>');"));  // 0 is field type, 1 is actual field
-      oappend(SET_F("addInfo('AudioReactive:digitalmic:pin[]',0,'<i>sd/data/dout</i>','I2S SD');"));
-      oappend(SET_F("addInfo('AudioReactive:digitalmic:pin[]',1,'<i>ws/clk/lrck</i>','I2S WS');"));
-      oappend(SET_F("addInfo('AudioReactive:digitalmic:pin[]',2,'<i>sck/bclk</i>','I2S SCK');"));
+      uiScript.print(F("addInfo(ux+':digitalmic:type',1,'<i>requires reboot!</i>');"));  // 0 is field type, 1 is actual field
+      uiScript.print(F("addInfo(uxp,0,'<i>sd/data/dout</i>','I2S SD');"));
+      uiScript.print(F("addInfo(uxp,1,'<i>ws/clk/lrck</i>','I2S WS');"));
+      uiScript.print(F("addInfo(uxp,2,'<i>sck/bclk</i>','I2S SCK');"));
       #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
-        oappend(SET_F("addInfo('AudioReactive:digitalmic:pin[]',3,'<i>only use -1, 0, 1 or 3</i>','I2S MCLK');"));
+        uiScript.print(F("addInfo(uxp,3,'<i>only use -1, 0, 1 or 3</i>','I2S MCLK');"));
       #else
-        oappend(SET_F("addInfo('AudioReactive:digitalmic:pin[]',3,'<i>master clock</i>','I2S MCLK');"));
+        uiScript.print(F("addInfo(uxp,3,'<i>master clock</i>','I2S MCLK');"));
       #endif
 #endif
     }

usermods/audioreactive/audio_source.h

@@ -194,8 +194,8 @@ class I2SSource : public AudioSource {
     virtual void initialize(int8_t i2swsPin = I2S_PIN_NO_CHANGE, int8_t i2ssdPin = I2S_PIN_NO_CHANGE, int8_t i2sckPin = I2S_PIN_NO_CHANGE, int8_t mclkPin = I2S_PIN_NO_CHANGE) {
       DEBUGSR_PRINTLN(F("I2SSource:: initialize()."));
       if (i2swsPin != I2S_PIN_NO_CHANGE && i2ssdPin != I2S_PIN_NO_CHANGE) {
-        if (!pinManager.allocatePin(i2swsPin, true, PinOwner::UM_Audioreactive) ||
-            !pinManager.allocatePin(i2ssdPin, false, PinOwner::UM_Audioreactive)) { // #206
+        if (!PinManager::allocatePin(i2swsPin, true, PinOwner::UM_Audioreactive) ||
+            !PinManager::allocatePin(i2ssdPin, false, PinOwner::UM_Audioreactive)) { // #206
           DEBUGSR_PRINTF("\nAR: Failed to allocate I2S pins: ws=%d, sd=%d\n",  i2swsPin, i2ssdPin); 
           return;
         }
@@ -203,7 +203,7 @@ class I2SSource : public AudioSource {
 
       // i2ssckPin needs special treatment, since it might be unused on PDM mics
       if (i2sckPin != I2S_PIN_NO_CHANGE) {
-        if (!pinManager.allocatePin(i2sckPin, true, PinOwner::UM_Audioreactive)) {
+        if (!PinManager::allocatePin(i2sckPin, true, PinOwner::UM_Audioreactive)) {
           DEBUGSR_PRINTF("\nAR: Failed to allocate I2S pins: sck=%d\n",  i2sckPin); 
           return;
         }
@@ -249,7 +249,7 @@ class I2SSource : public AudioSource {
       // Reserve the master clock pin if provided
       _mclkPin = mclkPin;
       if (mclkPin != I2S_PIN_NO_CHANGE) {
-        if(!pinManager.allocatePin(mclkPin, true, PinOwner::UM_Audioreactive)) { 
+        if(!PinManager::allocatePin(mclkPin, true, PinOwner::UM_Audioreactive)) { 
           DEBUGSR_PRINTF("\nAR: Failed to allocate I2S pin: MCLK=%d\n",  mclkPin); 
           return;
         } else
@@ -307,11 +307,11 @@ class I2SSource : public AudioSource {
         DEBUGSR_PRINTF("Failed to uninstall i2s driver: %d\n", err);
         return;
       }
-      if (_pinConfig.ws_io_num   != I2S_PIN_NO_CHANGE) pinManager.deallocatePin(_pinConfig.ws_io_num,   PinOwner::UM_Audioreactive);
-      if (_pinConfig.data_in_num != I2S_PIN_NO_CHANGE) pinManager.deallocatePin(_pinConfig.data_in_num, PinOwner::UM_Audioreactive);
-      if (_pinConfig.bck_io_num  != I2S_PIN_NO_CHANGE) pinManager.deallocatePin(_pinConfig.bck_io_num,  PinOwner::UM_Audioreactive);
+      if (_pinConfig.ws_io_num   != I2S_PIN_NO_CHANGE) PinManager::deallocatePin(_pinConfig.ws_io_num,   PinOwner::UM_Audioreactive);
+      if (_pinConfig.data_in_num != I2S_PIN_NO_CHANGE) PinManager::deallocatePin(_pinConfig.data_in_num, PinOwner::UM_Audioreactive);
+      if (_pinConfig.bck_io_num  != I2S_PIN_NO_CHANGE) PinManager::deallocatePin(_pinConfig.bck_io_num,  PinOwner::UM_Audioreactive);
       // Release the master clock pin
-      if (_mclkPin != I2S_PIN_NO_CHANGE) pinManager.deallocatePin(_mclkPin, PinOwner::UM_Audioreactive);
+      if (_mclkPin != I2S_PIN_NO_CHANGE) PinManager::deallocatePin(_mclkPin, PinOwner::UM_Audioreactive);
     }
 
     virtual void getSamples(float *buffer, uint16_t num_samples) {
@@ -589,7 +589,7 @@ class I2SAdcSource : public I2SSource {
     void initialize(int8_t audioPin, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE) {
       DEBUGSR_PRINTLN(F("I2SAdcSource:: initialize()."));
       _myADCchannel = 0x0F;
-      if(!pinManager.allocatePin(audioPin, false, PinOwner::UM_Audioreactive)) {
+      if(!PinManager::allocatePin(audioPin, false, PinOwner::UM_Audioreactive)) {
          DEBUGSR_PRINTF("failed to allocate GPIO for audio analog input: %d\n", audioPin);
         return;
       }
@@ -717,7 +717,7 @@ class I2SAdcSource : public I2SSource {
     }
 
     void deinitialize() {
-      pinManager.deallocatePin(_audioPin, PinOwner::UM_Audioreactive);
+      PinManager::deallocatePin(_audioPin, PinOwner::UM_Audioreactive);
       _initialized = false;
       _myADCchannel = 0x0F;
       

usermods/audioreactive/readme.md

@@ -30,7 +30,7 @@ There are however plans to create a lightweight audioreactive for the 8266, with
 ### using latest _arduinoFFT_ library version 2.x
 The latest arduinoFFT release version should be used for audioreactive.
 
-* `build_flags` = `-D USERMOD_AUDIOREACTIVE`
+* `build_flags` = `-D USERMOD_AUDIOREACTIVE -D sqrt_internal=sqrtf`
 * `lib_deps`= `kosme/arduinoFFT @ 2.0.1`
 
 ## Configuration

usermods/boblight/boblight.h

@@ -1,459 +1,459 @@
-#pragma once
-
-#include "wled.h"
-
-/*
- * Usermod that implements BobLight "ambilight" protocol
- * 
- * See the accompanying README.md file for more info.
- */
-
-#ifndef BOB_PORT
-  #define BOB_PORT 19333       // Default boblightd port
-#endif
-
-class BobLightUsermod : public Usermod {
-  typedef struct _LIGHT {
-    char lightname[5];
-    float hscan[2];
-    float vscan[2];
-  } light_t;
-
-  private:
-    unsigned long lastTime = 0;
-    bool enabled  = false;
-    bool initDone = false;
-
-    light_t *lights = nullptr;
-    uint16_t numLights = 0;  // 16 + 9 + 16 + 9
-    uint16_t top, bottom, left, right;  // will be filled in readFromConfig()
-    uint16_t pct;
-
-    WiFiClient bobClient;
-    WiFiServer *bob;
-    uint16_t   bobPort = BOB_PORT;
-
-    static const char _name[];
-    static const char _enabled[];
-
-    /*
-    # boblight
-    # Copyright (C) Bob  2009 
-    #
-    # makeboblight.sh created by Adam Boeglin <adamrb@gmail.com>
-    #
-    # boblight is free software: you can redistribute it and/or modify it
-    # under the terms of the GNU General Public License as published by the
-    # Free Software Foundation, either version 3 of the License, or
-    # (at your option) any later version.
-    # 
-    # boblight 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 General Public License for more details.
-    # 
-    # You should have received a copy of the GNU General Public License along
-    # with this program.  If not, see <http://www.gnu.org/licenses/>.
-    */
-
-    // fills the lights[] array with position & depth of scan for each LED
-    void fillBobLights(int bottom, int left, int top, int right, float pct_scan) {
-
-      int lightcount = 0;
-      int total = top+left+right+bottom;
-      int bcount;
-
-      if (total > strip.getLengthTotal()) {
-        DEBUG_PRINTLN(F("BobLight: Too many lights."));
-        return;
-      }
-
-      // start left part of bottom strip (clockwise direction, 1st half)
-      if (bottom > 0) {
-        bcount = 1;
-        float brange = 100.0/bottom;
-        float bcurrent = 50.0;
-        if (bottom < top) {
-          int diff = top - bottom;
-          brange = 100.0/top;
-          bcurrent -= (diff/2)*brange;
-        }
-        while (bcount <= bottom/2) {
-          float btop = bcurrent - brange;
-          String name = "b"+String(bcount);
-          strncpy(lights[lightcount].lightname, name.c_str(), 4);
-          lights[lightcount].hscan[0] = btop;
-          lights[lightcount].hscan[1] = bcurrent;
-          lights[lightcount].vscan[0] = 100 - pct_scan;
-          lights[lightcount].vscan[1] = 100;
-          lightcount+=1;
-          bcurrent = btop;
-          bcount+=1;
-        }
-      }
-
-      // left side
-      if (left > 0) {
-        int lcount = 1;
-        float lrange = 100.0/left;
-        float lcurrent = 100.0;
-        while (lcount <= left) {
-          float ltop = lcurrent - lrange;
-          String name = "l"+String(lcount);
-          strncpy(lights[lightcount].lightname, name.c_str(), 4);
-          lights[lightcount].hscan[0] = 0;
-          lights[lightcount].hscan[1] = pct_scan;
-          lights[lightcount].vscan[0] = ltop;
-          lights[lightcount].vscan[1] = lcurrent;
-          lightcount+=1;
-          lcurrent = ltop;
-          lcount+=1;
-        }
-      }
-
-      // top side
-      if (top > 0) {
-        int tcount = 1;
-        float trange = 100.0/top;
-        float tcurrent = 0;
-        while (tcount <= top) {
-          float ttop = tcurrent + trange;
-          String name = "t"+String(tcount);
-          strncpy(lights[lightcount].lightname, name.c_str(), 4);
-          lights[lightcount].hscan[0] = tcurrent;
-          lights[lightcount].hscan[1] = ttop;
-          lights[lightcount].vscan[0] = 0;
-          lights[lightcount].vscan[1] = pct_scan;
-          lightcount+=1;
-          tcurrent = ttop;
-          tcount+=1;
-        }
-      }
-
-      // right side
-      if (right > 0) {
-        int rcount = 1;
-        float rrange = 100.0/right;
-        float rcurrent = 0;
-        while (rcount <= right) {
-          float rtop = rcurrent + rrange;
-          String name = "r"+String(rcount);
-          strncpy(lights[lightcount].lightname, name.c_str(), 4);
-          lights[lightcount].hscan[0] = 100-pct_scan;
-          lights[lightcount].hscan[1] = 100;
-          lights[lightcount].vscan[0] = rcurrent;
-          lights[lightcount].vscan[1] = rtop;
-          lightcount+=1;
-          rcurrent = rtop;
-          rcount+=1;
-        }
-      }
-      
-      // right side of bottom strip (2nd half)
-      if (bottom > 0) {
-        float brange = 100.0/bottom;
-        float bcurrent = 100;
-        if (bottom < top) {
-          brange = 100.0/top;
-        }
-        while (bcount <= bottom) {
-          float btop = bcurrent - brange;
-          String name = "b"+String(bcount);
-          strncpy(lights[lightcount].lightname, name.c_str(), 4);
-          lights[lightcount].hscan[0] = btop;
-          lights[lightcount].hscan[1] = bcurrent;
-          lights[lightcount].vscan[0] = 100 - pct_scan;
-          lights[lightcount].vscan[1] = 100;
-          lightcount+=1;
-          bcurrent = btop;
-          bcount+=1;
-        }
-      }
-
-      numLights = lightcount;
-
-      #if WLED_DEBUG
-      DEBUG_PRINTLN(F("Fill light data: "));
-      DEBUG_PRINTF_P(PSTR(" lights %d\n"), numLights);
-      for (int i=0; i<numLights; i++) {
-        DEBUG_PRINTF_P(PSTR(" light %s scan %2.1f %2.1f %2.1f %2.1f\n"), lights[i].lightname, lights[i].vscan[0], lights[i].vscan[1], lights[i].hscan[0], lights[i].hscan[1]);
-      }
-      #endif
-    }
-
-    void BobSync()  { yield(); } // allow other tasks, should also be used to force pixel redraw (not with WLED)
-    void BobClear() { for (size_t i=0; i<numLights; i++) setRealtimePixel(i, 0, 0, 0, 0); }
-    void pollBob();
-
-  public:
-
-    void setup() override {
-      uint16_t totalLights = bottom + left + top + right;
-      if ( totalLights > strip.getLengthTotal() ) {
-        DEBUG_PRINTLN(F("BobLight: Too many lights."));
-        DEBUG_PRINTF_P(PSTR("%d+%d+%d+%d>%d\n"), bottom, left, top, right, strip.getLengthTotal());
-        totalLights = strip.getLengthTotal();
-        top = bottom = (uint16_t) roundf((float)totalLights * 16.0f / 50.0f);
-        left = right = (uint16_t) roundf((float)totalLights *  9.0f / 50.0f);
-      }
-      lights = new light_t[totalLights];
-      if (lights) fillBobLights(bottom, left, top, right, float(pct)); // will fill numLights
-      else        enable(false);
-      initDone = true;
-    }
-
-    void connected() override {
-      // we can only start server when WiFi is connected
-      if (!bob) bob = new WiFiServer(bobPort, 1);
-      bob->begin();
-      bob->setNoDelay(true);
-    }
-
-    void loop() override {
-      if (!enabled || strip.isUpdating()) return;
-      if (millis() - lastTime > 10) {
-        lastTime = millis();
-        pollBob();
-      }
-    }
-
-    void enable(bool en) { enabled = en; }
-    
-#ifndef WLED_DISABLE_MQTT
-    /**
-     * handling of MQTT message
-     * topic only contains stripped topic (part after /wled/MAC)
-     * topic should look like: /swipe with amessage of [up|down]
-     */
-    bool onMqttMessage(char* topic, char* payload) override {
-      //if (strlen(topic) == 6 && strncmp_P(topic, PSTR("/subtopic"), 6) == 0) {
-      //  String action = payload;
-      //  if (action == "on") {
-      //    enable(true);
-      //    return true;
-      //  } else if (action == "off") {
-      //    enable(false);
-      //    return true;
-      //  }
-      //}
-      return false;
-    }
-
-    /**
-     * subscribe to MQTT topic for controlling usermod
-     */
-    void onMqttConnect(bool sessionPresent) override {
-      //char subuf[64];
-      //if (mqttDeviceTopic[0] != 0) {
-      //  strcpy(subuf, mqttDeviceTopic);
-      //  strcat_P(subuf, PSTR("/subtopic"));
-      //  mqtt->subscribe(subuf, 0);
-      //}
-    }
-#endif
-
-    void addToJsonInfo(JsonObject& root) override
-    {
-      JsonObject user = root["u"];
-      if (user.isNull()) user = root.createNestedObject("u");
-
-      JsonArray infoArr = user.createNestedArray(FPSTR(_name));
-      String uiDomString = F("<button class=\"btn btn-xs\" onclick=\"requestJson({");
-      uiDomString += FPSTR(_name);
-      uiDomString += F(":{");
-      uiDomString += FPSTR(_enabled);
-      uiDomString += enabled ? F(":false}});\">") : F(":true}});\">");
-      uiDomString += F("<i class=\"icons ");
-      uiDomString += enabled ? "on" : "off";
-      uiDomString += F("\">&#xe08f;</i></button>");
-      infoArr.add(uiDomString);
-    }
-
-    /*
-     * addToJsonState() can be used to add custom entries to the /json/state part of the JSON API (state object).
-     * Values in the state object may be modified by connected clients
-     */
-    void addToJsonState(JsonObject& root) override
-    {
-    }
-
-    /*
-     * readFromJsonState() can be used to receive data clients send to the /json/state part of the JSON API (state object).
-     * Values in the state object may be modified by connected clients
-     */
-    void readFromJsonState(JsonObject& root) override {
-      if (!initDone) return;  // prevent crash on boot applyPreset()
-      bool en = enabled;
-      JsonObject um = root[FPSTR(_name)];
-      if (!um.isNull()) {
-        if (um[FPSTR(_enabled)].is<bool>()) {
-          en = um[FPSTR(_enabled)].as<bool>();
-        } else {
-          String str = um[FPSTR(_enabled)]; // checkbox -> off or on
-          en = (bool)(str!="off"); // off is guaranteed to be present
-        }
-        if (en != enabled && lights) {
-          enable(en);
-          if (!enabled && bob && bob->hasClient()) {
-            if (bobClient) bobClient.stop();
-            bobClient = bob->available();
-            BobClear();
-            exitRealtime();
-          }
-        }
-      }
-    }
-
-    void appendConfigData() override {
-      //oappend(SET_F("dd=addDropdown('usermod','selectfield');"));
-      //oappend(SET_F("addOption(dd,'1st value',0);"));
-      //oappend(SET_F("addOption(dd,'2nd value',1);"));
-      oappend(SET_F("addInfo('BobLight:top',1,'LEDs');"));                // 0 is field type, 1 is actual field
-      oappend(SET_F("addInfo('BobLight:bottom',1,'LEDs');"));             // 0 is field type, 1 is actual field
-      oappend(SET_F("addInfo('BobLight:left',1,'LEDs');"));               // 0 is field type, 1 is actual field
-      oappend(SET_F("addInfo('BobLight:right',1,'LEDs');"));              // 0 is field type, 1 is actual field
-      oappend(SET_F("addInfo('BobLight:pct',1,'Depth of scan [%]');"));   // 0 is field type, 1 is actual field
-    }
-
-    void addToConfig(JsonObject& root) override {
-      JsonObject umData = root.createNestedObject(FPSTR(_name));
-      umData[FPSTR(_enabled)] = enabled;
-      umData[  "port" ]       = bobPort;
-      umData[F("top")]        = top;
-      umData[F("bottom")]     = bottom;
-      umData[F("left")]       = left;
-      umData[F("right")]      = right;
-      umData[F("pct")]        = pct;
-    }
-
-    bool readFromConfig(JsonObject& root) override {
-      JsonObject umData = root[FPSTR(_name)];
-      bool configComplete = !umData.isNull();
-
-      bool en = enabled;
-      configComplete &= getJsonValue(umData[FPSTR(_enabled)], en);
-      enable(en);
-
-      configComplete &= getJsonValue(umData[  "port" ],   bobPort);
-      configComplete &= getJsonValue(umData[F("bottom")], bottom,    16);
-      configComplete &= getJsonValue(umData[F("top")],    top,       16);
-      configComplete &= getJsonValue(umData[F("left")],   left,       9);
-      configComplete &= getJsonValue(umData[F("right")],  right,      9);
-      configComplete &= getJsonValue(umData[F("pct")],    pct,        5); // Depth of scan [%]
-      pct = MIN(50,MAX(1,pct));
-
-      uint16_t totalLights = bottom + left + top + right;
-      if (initDone && numLights != totalLights) {
-        if (lights) delete[] lights;
-        setup();
-      }
-      return configComplete;
-    }
-
-    /*
-     * handleOverlayDraw() is called just before every show() (LED strip update frame) after effects have set the colors.
-     * Use this to blank out some LEDs or set them to a different color regardless of the set effect mode.
-     * Commonly used for custom clocks (Cronixie, 7 segment)
-     */
-    void handleOverlayDraw() override {
-      //strip.setPixelColor(0, RGBW32(0,0,0,0)) // set the first pixel to black
-    }
-
-    uint16_t getId() override { return USERMOD_ID_BOBLIGHT; }
-
-};
-
-// strings to reduce flash memory usage (used more than twice)
-const char BobLightUsermod::_name[]    PROGMEM = "BobLight";
-const char BobLightUsermod::_enabled[] PROGMEM = "enabled";
-
-// main boblight handling (definition here prevents inlining)
-void BobLightUsermod::pollBob() {
-  
-  //check if there are any new clients
-  if (bob && bob->hasClient()) {
-    //find free/disconnected spot
-    if (!bobClient || !bobClient.connected()) {
-      if (bobClient) bobClient.stop();
-      bobClient = bob->available();
-      DEBUG_PRINTLN(F("Boblight: Client connected."));
-    }
-    //no free/disconnected spot so reject
-    WiFiClient bobClientTmp = bob->available();
-    bobClientTmp.stop();
-    BobClear();
-    exitRealtime();
-  }
-  
-  //check clients for data
-  if (bobClient && bobClient.connected()) {
-    realtimeLock(realtimeTimeoutMs); // lock strip as we have a client connected
-
-    //get data from the client
-    while (bobClient.available()) {
-      String input = bobClient.readStringUntil('\n');
-      // DEBUG_PRINT(F("Client: ")); DEBUG_PRINTLN(input); // may be to stressful on Serial
-      if (input.startsWith(F("hello"))) {
-        DEBUG_PRINTLN(F("hello"));
-        bobClient.print(F("hello\n"));
-      } else if (input.startsWith(F("ping"))) {
-        DEBUG_PRINTLN(F("ping 1"));
-        bobClient.print(F("ping 1\n"));
-      } else if (input.startsWith(F("get version"))) {
-        DEBUG_PRINTLN(F("version 5"));
-        bobClient.print(F("version 5\n"));
-      } else if (input.startsWith(F("get lights"))) {
-        char tmp[64];
-        String answer = "";
-        sprintf_P(tmp, PSTR("lights %d\n"), numLights);
-        DEBUG_PRINT(tmp);
-        answer.concat(tmp);
-        for (int i=0; i<numLights; i++) {
-          sprintf_P(tmp, PSTR("light %s scan %2.1f %2.1f %2.1f %2.1f\n"), lights[i].lightname, lights[i].vscan[0], lights[i].vscan[1], lights[i].hscan[0], lights[i].hscan[1]);
-          DEBUG_PRINT(tmp);
-          answer.concat(tmp);
-        }
-        bobClient.print(answer);
-      } else if (input.startsWith(F("set priority"))) {
-        DEBUG_PRINTLN(F("set priority not implemented"));
-        // not implemented
-      } else if (input.startsWith(F("set light "))) { // <id> <cmd in rgb, speed, interpolation> <value> ...
-        input.remove(0,10);
-        String tmp = input.substring(0,input.indexOf(' '));
-        
-        int light_id = -1;
-        for (uint16_t i=0; i<numLights; i++) {
-          if (strncmp(lights[i].lightname, tmp.c_str(), 4) == 0) {
-            light_id = i;
-            break;
-          }
-        }
-        if (light_id == -1) return;
-
-        input.remove(0,input.indexOf(' ')+1);
-        if (input.startsWith(F("rgb "))) {
-          input.remove(0,4);
-          tmp = input.substring(0,input.indexOf(' '));
-          uint8_t red = (uint8_t)(255.0f*tmp.toFloat());
-          input.remove(0,input.indexOf(' ')+1);        // remove first float value
-          tmp = input.substring(0,input.indexOf(' '));
-          uint8_t green = (uint8_t)(255.0f*tmp.toFloat());
-          input.remove(0,input.indexOf(' ')+1);        // remove second float value
-          tmp = input.substring(0,input.indexOf(' '));
-          uint8_t blue = (uint8_t)(255.0f*tmp.toFloat());
-
-          //strip.setPixelColor(light_id, RGBW32(red, green, blue, 0));
-          setRealtimePixel(light_id, red, green, blue, 0);
-        } // currently no support for interpolation or speed, we just ignore this
-      } else if (input.startsWith("sync")) {
-        BobSync();
-      } else {
-        // Client sent gibberish
-        DEBUG_PRINTLN(F("Client sent gibberish."));
-        bobClient.stop();
-        bobClient = bob->available();
-        BobClear();
-      }
-    }
-  }
-}
+#pragma once
+
+#include "wled.h"
+
+/*
+ * Usermod that implements BobLight "ambilight" protocol
+ * 
+ * See the accompanying README.md file for more info.
+ */
+
+#ifndef BOB_PORT
+  #define BOB_PORT 19333       // Default boblightd port
+#endif
+
+class BobLightUsermod : public Usermod {
+  typedef struct _LIGHT {
+    char lightname[5];
+    float hscan[2];
+    float vscan[2];
+  } light_t;
+
+  private:
+    unsigned long lastTime = 0;
+    bool enabled  = false;
+    bool initDone = false;
+
+    light_t *lights = nullptr;
+    uint16_t numLights = 0;  // 16 + 9 + 16 + 9
+    uint16_t top, bottom, left, right;  // will be filled in readFromConfig()
+    uint16_t pct;
+
+    WiFiClient bobClient;
+    WiFiServer *bob;
+    uint16_t   bobPort = BOB_PORT;
+
+    static const char _name[];
+    static const char _enabled[];
+
+    /*
+    # boblight
+    # Copyright (C) Bob  2009 
+    #
+    # makeboblight.sh created by Adam Boeglin <adamrb@gmail.com>
+    #
+    # boblight is free software: you can redistribute it and/or modify it
+    # under the terms of the GNU General Public License as published by the
+    # Free Software Foundation, either version 3 of the License, or
+    # (at your option) any later version.
+    # 
+    # boblight 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 General Public License for more details.
+    # 
+    # You should have received a copy of the GNU General Public License along
+    # with this program.  If not, see <http://www.gnu.org/licenses/>.
+    */
+
+    // fills the lights[] array with position & depth of scan for each LED
+    void fillBobLights(int bottom, int left, int top, int right, float pct_scan) {
+
+      int lightcount = 0;
+      int total = top+left+right+bottom;
+      int bcount;
+
+      if (total > strip.getLengthTotal()) {
+        DEBUG_PRINTLN(F("BobLight: Too many lights."));
+        return;
+      }
+
+      // start left part of bottom strip (clockwise direction, 1st half)
+      if (bottom > 0) {
+        bcount = 1;
+        float brange = 100.0/bottom;
+        float bcurrent = 50.0;
+        if (bottom < top) {
+          int diff = top - bottom;
+          brange = 100.0/top;
+          bcurrent -= (diff/2)*brange;
+        }
+        while (bcount <= bottom/2) {
+          float btop = bcurrent - brange;
+          String name = "b"+String(bcount);
+          strncpy(lights[lightcount].lightname, name.c_str(), 4);
+          lights[lightcount].hscan[0] = btop;
+          lights[lightcount].hscan[1] = bcurrent;
+          lights[lightcount].vscan[0] = 100 - pct_scan;
+          lights[lightcount].vscan[1] = 100;
+          lightcount+=1;
+          bcurrent = btop;
+          bcount+=1;
+        }
+      }
+
+      // left side
+      if (left > 0) {
+        int lcount = 1;
+        float lrange = 100.0/left;
+        float lcurrent = 100.0;
+        while (lcount <= left) {
+          float ltop = lcurrent - lrange;
+          String name = "l"+String(lcount);
+          strncpy(lights[lightcount].lightname, name.c_str(), 4);
+          lights[lightcount].hscan[0] = 0;
+          lights[lightcount].hscan[1] = pct_scan;
+          lights[lightcount].vscan[0] = ltop;
+          lights[lightcount].vscan[1] = lcurrent;
+          lightcount+=1;
+          lcurrent = ltop;
+          lcount+=1;
+        }
+      }
+
+      // top side
+      if (top > 0) {
+        int tcount = 1;
+        float trange = 100.0/top;
+        float tcurrent = 0;
+        while (tcount <= top) {
+          float ttop = tcurrent + trange;
+          String name = "t"+String(tcount);
+          strncpy(lights[lightcount].lightname, name.c_str(), 4);
+          lights[lightcount].hscan[0] = tcurrent;
+          lights[lightcount].hscan[1] = ttop;
+          lights[lightcount].vscan[0] = 0;
+          lights[lightcount].vscan[1] = pct_scan;
+          lightcount+=1;
+          tcurrent = ttop;
+          tcount+=1;
+        }
+      }
+
+      // right side
+      if (right > 0) {
+        int rcount = 1;
+        float rrange = 100.0/right;
+        float rcurrent = 0;
+        while (rcount <= right) {
+          float rtop = rcurrent + rrange;
+          String name = "r"+String(rcount);
+          strncpy(lights[lightcount].lightname, name.c_str(), 4);
+          lights[lightcount].hscan[0] = 100-pct_scan;
+          lights[lightcount].hscan[1] = 100;
+          lights[lightcount].vscan[0] = rcurrent;
+          lights[lightcount].vscan[1] = rtop;
+          lightcount+=1;
+          rcurrent = rtop;
+          rcount+=1;
+        }
+      }
+      
+      // right side of bottom strip (2nd half)
+      if (bottom > 0) {
+        float brange = 100.0/bottom;
+        float bcurrent = 100;
+        if (bottom < top) {
+          brange = 100.0/top;
+        }
+        while (bcount <= bottom) {
+          float btop = bcurrent - brange;
+          String name = "b"+String(bcount);
+          strncpy(lights[lightcount].lightname, name.c_str(), 4);
+          lights[lightcount].hscan[0] = btop;
+          lights[lightcount].hscan[1] = bcurrent;
+          lights[lightcount].vscan[0] = 100 - pct_scan;
+          lights[lightcount].vscan[1] = 100;
+          lightcount+=1;
+          bcurrent = btop;
+          bcount+=1;
+        }
+      }
+
+      numLights = lightcount;
+
+      #if WLED_DEBUG
+      DEBUG_PRINTLN(F("Fill light data: "));
+      DEBUG_PRINTF_P(PSTR(" lights %d\n"), numLights);
+      for (int i=0; i<numLights; i++) {
+        DEBUG_PRINTF_P(PSTR(" light %s scan %2.1f %2.1f %2.1f %2.1f\n"), lights[i].lightname, lights[i].vscan[0], lights[i].vscan[1], lights[i].hscan[0], lights[i].hscan[1]);
+      }
+      #endif
+    }
+
+    void BobSync()  { yield(); } // allow other tasks, should also be used to force pixel redraw (not with WLED)
+    void BobClear() { for (size_t i=0; i<numLights; i++) setRealtimePixel(i, 0, 0, 0, 0); }
+    void pollBob();
+
+  public:
+
+    void setup() override {
+      uint16_t totalLights = bottom + left + top + right;
+      if ( totalLights > strip.getLengthTotal() ) {
+        DEBUG_PRINTLN(F("BobLight: Too many lights."));
+        DEBUG_PRINTF_P(PSTR("%d+%d+%d+%d>%d\n"), bottom, left, top, right, strip.getLengthTotal());
+        totalLights = strip.getLengthTotal();
+        top = bottom = (uint16_t) roundf((float)totalLights * 16.0f / 50.0f);
+        left = right = (uint16_t) roundf((float)totalLights *  9.0f / 50.0f);
+      }
+      lights = new light_t[totalLights];
+      if (lights) fillBobLights(bottom, left, top, right, float(pct)); // will fill numLights
+      else        enable(false);
+      initDone = true;
+    }
+
+    void connected() override {
+      // we can only start server when WiFi is connected
+      if (!bob) bob = new WiFiServer(bobPort, 1);
+      bob->begin();
+      bob->setNoDelay(true);
+    }
+
+    void loop() override {
+      if (!enabled || strip.isUpdating()) return;
+      if (millis() - lastTime > 10) {
+        lastTime = millis();
+        pollBob();
+      }
+    }
+
+    void enable(bool en) { enabled = en; }
+    
+#ifndef WLED_DISABLE_MQTT
+    /**
+     * handling of MQTT message
+     * topic only contains stripped topic (part after /wled/MAC)
+     * topic should look like: /swipe with amessage of [up|down]
+     */
+    bool onMqttMessage(char* topic, char* payload) override {
+      //if (strlen(topic) == 6 && strncmp_P(topic, PSTR("/subtopic"), 6) == 0) {
+      //  String action = payload;
+      //  if (action == "on") {
+      //    enable(true);
+      //    return true;
+      //  } else if (action == "off") {
+      //    enable(false);
+      //    return true;
+      //  }
+      //}
+      return false;
+    }
+
+    /**
+     * subscribe to MQTT topic for controlling usermod
+     */
+    void onMqttConnect(bool sessionPresent) override {
+      //char subuf[64];
+      //if (mqttDeviceTopic[0] != 0) {
+      //  strcpy(subuf, mqttDeviceTopic);
+      //  strcat_P(subuf, PSTR("/subtopic"));
+      //  mqtt->subscribe(subuf, 0);
+      //}
+    }
+#endif
+
+    void addToJsonInfo(JsonObject& root) override
+    {
+      JsonObject user = root["u"];
+      if (user.isNull()) user = root.createNestedObject("u");
+
+      JsonArray infoArr = user.createNestedArray(FPSTR(_name));
+      String uiDomString = F("<button class=\"btn btn-xs\" onclick=\"requestJson({");
+      uiDomString += FPSTR(_name);
+      uiDomString += F(":{");
+      uiDomString += FPSTR(_enabled);
+      uiDomString += enabled ? F(":false}});\">") : F(":true}});\">");
+      uiDomString += F("<i class=\"icons ");
+      uiDomString += enabled ? "on" : "off";
+      uiDomString += F("\">&#xe08f;</i></button>");
+      infoArr.add(uiDomString);
+    }
+
+    /*
+     * addToJsonState() can be used to add custom entries to the /json/state part of the JSON API (state object).
+     * Values in the state object may be modified by connected clients
+     */
+    void addToJsonState(JsonObject& root) override
+    {
+    }
+
+    /*
+     * readFromJsonState() can be used to receive data clients send to the /json/state part of the JSON API (state object).
+     * Values in the state object may be modified by connected clients
+     */
+    void readFromJsonState(JsonObject& root) override {
+      if (!initDone) return;  // prevent crash on boot applyPreset()
+      bool en = enabled;
+      JsonObject um = root[FPSTR(_name)];
+      if (!um.isNull()) {
+        if (um[FPSTR(_enabled)].is<bool>()) {
+          en = um[FPSTR(_enabled)].as<bool>();
+        } else {
+          String str = um[FPSTR(_enabled)]; // checkbox -> off or on
+          en = (bool)(str!="off"); // off is guaranteed to be present
+        }
+        if (en != enabled && lights) {
+          enable(en);
+          if (!enabled && bob && bob->hasClient()) {
+            if (bobClient) bobClient.stop();
+            bobClient = bob->available();
+            BobClear();
+            exitRealtime();
+          }
+        }
+      }
+    }
+
+    void appendConfigData() override {
+      //oappend(F("dd=addDropdown('usermod','selectfield');"));
+      //oappend(F("addOption(dd,'1st value',0);"));
+      //oappend(F("addOption(dd,'2nd value',1);"));
+      oappend(F("addInfo('BobLight:top',1,'LEDs');"));                // 0 is field type, 1 is actual field
+      oappend(F("addInfo('BobLight:bottom',1,'LEDs');"));             // 0 is field type, 1 is actual field
+      oappend(F("addInfo('BobLight:left',1,'LEDs');"));               // 0 is field type, 1 is actual field
+      oappend(F("addInfo('BobLight:right',1,'LEDs');"));              // 0 is field type, 1 is actual field
+      oappend(F("addInfo('BobLight:pct',1,'Depth of scan [%]');"));   // 0 is field type, 1 is actual field
+    }
+
+    void addToConfig(JsonObject& root) override {
+      JsonObject umData = root.createNestedObject(FPSTR(_name));
+      umData[FPSTR(_enabled)] = enabled;
+      umData[  "port" ]       = bobPort;
+      umData[F("top")]        = top;
+      umData[F("bottom")]     = bottom;
+      umData[F("left")]       = left;
+      umData[F("right")]      = right;
+      umData[F("pct")]        = pct;
+    }
+
+    bool readFromConfig(JsonObject& root) override {
+      JsonObject umData = root[FPSTR(_name)];
+      bool configComplete = !umData.isNull();
+
+      bool en = enabled;
+      configComplete &= getJsonValue(umData[FPSTR(_enabled)], en);
+      enable(en);
+
+      configComplete &= getJsonValue(umData[  "port" ],   bobPort);
+      configComplete &= getJsonValue(umData[F("bottom")], bottom,    16);
+      configComplete &= getJsonValue(umData[F("top")],    top,       16);
+      configComplete &= getJsonValue(umData[F("left")],   left,       9);
+      configComplete &= getJsonValue(umData[F("right")],  right,      9);
+      configComplete &= getJsonValue(umData[F("pct")],    pct,        5); // Depth of scan [%]
+      pct = MIN(50,MAX(1,pct));
+
+      uint16_t totalLights = bottom + left + top + right;
+      if (initDone && numLights != totalLights) {
+        if (lights) delete[] lights;
+        setup();
+      }
+      return configComplete;
+    }
+
+    /*
+     * handleOverlayDraw() is called just before every show() (LED strip update frame) after effects have set the colors.
+     * Use this to blank out some LEDs or set them to a different color regardless of the set effect mode.
+     * Commonly used for custom clocks (Cronixie, 7 segment)
+     */
+    void handleOverlayDraw() override {
+      //strip.setPixelColor(0, RGBW32(0,0,0,0)) // set the first pixel to black
+    }
+
+    uint16_t getId() override { return USERMOD_ID_BOBLIGHT; }
+
+};
+
+// strings to reduce flash memory usage (used more than twice)
+const char BobLightUsermod::_name[]    PROGMEM = "BobLight";
+const char BobLightUsermod::_enabled[] PROGMEM = "enabled";
+
+// main boblight handling (definition here prevents inlining)
+void BobLightUsermod::pollBob() {
+  
+  //check if there are any new clients
+  if (bob && bob->hasClient()) {
+    //find free/disconnected spot
+    if (!bobClient || !bobClient.connected()) {
+      if (bobClient) bobClient.stop();
+      bobClient = bob->available();
+      DEBUG_PRINTLN(F("Boblight: Client connected."));
+    }
+    //no free/disconnected spot so reject
+    WiFiClient bobClientTmp = bob->available();
+    bobClientTmp.stop();
+    BobClear();
+    exitRealtime();
+  }
+  
+  //check clients for data
+  if (bobClient && bobClient.connected()) {
+    realtimeLock(realtimeTimeoutMs); // lock strip as we have a client connected
+
+    //get data from the client
+    while (bobClient.available()) {
+      String input = bobClient.readStringUntil('\n');
+      // DEBUG_PRINT(F("Client: ")); DEBUG_PRINTLN(input); // may be to stressful on Serial
+      if (input.startsWith(F("hello"))) {
+        DEBUG_PRINTLN(F("hello"));
+        bobClient.print(F("hello\n"));
+      } else if (input.startsWith(F("ping"))) {
+        DEBUG_PRINTLN(F("ping 1"));
+        bobClient.print(F("ping 1\n"));
+      } else if (input.startsWith(F("get version"))) {
+        DEBUG_PRINTLN(F("version 5"));
+        bobClient.print(F("version 5\n"));
+      } else if (input.startsWith(F("get lights"))) {
+        char tmp[64];
+        String answer = "";
+        sprintf_P(tmp, PSTR("lights %d\n"), numLights);
+        DEBUG_PRINT(tmp);
+        answer.concat(tmp);
+        for (int i=0; i<numLights; i++) {
+          sprintf_P(tmp, PSTR("light %s scan %2.1f %2.1f %2.1f %2.1f\n"), lights[i].lightname, lights[i].vscan[0], lights[i].vscan[1], lights[i].hscan[0], lights[i].hscan[1]);
+          DEBUG_PRINT(tmp);
+          answer.concat(tmp);
+        }
+        bobClient.print(answer);
+      } else if (input.startsWith(F("set priority"))) {
+        DEBUG_PRINTLN(F("set priority not implemented"));
+        // not implemented
+      } else if (input.startsWith(F("set light "))) { // <id> <cmd in rgb, speed, interpolation> <value> ...
+        input.remove(0,10);
+        String tmp = input.substring(0,input.indexOf(' '));
+        
+        int light_id = -1;
+        for (uint16_t i=0; i<numLights; i++) {
+          if (strncmp(lights[i].lightname, tmp.c_str(), 4) == 0) {
+            light_id = i;
+            break;
+          }
+        }
+        if (light_id == -1) return;
+
+        input.remove(0,input.indexOf(' ')+1);
+        if (input.startsWith(F("rgb "))) {
+          input.remove(0,4);
+          tmp = input.substring(0,input.indexOf(' '));
+          uint8_t red = (uint8_t)(255.0f*tmp.toFloat());
+          input.remove(0,input.indexOf(' ')+1);        // remove first float value
+          tmp = input.substring(0,input.indexOf(' '));
+          uint8_t green = (uint8_t)(255.0f*tmp.toFloat());
+          input.remove(0,input.indexOf(' ')+1);        // remove second float value
+          tmp = input.substring(0,input.indexOf(' '));
+          uint8_t blue = (uint8_t)(255.0f*tmp.toFloat());
+
+          //strip.setPixelColor(light_id, RGBW32(red, green, blue, 0));
+          setRealtimePixel(light_id, red, green, blue, 0);
+        } // currently no support for interpolation or speed, we just ignore this
+      } else if (input.startsWith("sync")) {
+        BobSync();
+      } else {
+        // Client sent gibberish
+        DEBUG_PRINTLN(F("Client sent gibberish."));
+        bobClient.stop();
+        bobClient = bob->available();
+        BobClear();
+      }
+    }
+  }
+}

usermods/mpu6050_imu/readme.md

@@ -86,6 +86,6 @@ Example **usermods_list.cpp**:
 
 void registerUsermods()
 {
-  usermods.add(new MPU6050Driver());
+  UsermodManager::add(new MPU6050Driver());
 }
 ```

usermods/mpu6050_imu/usermod_gyro_surge.h

@@ -163,7 +163,7 @@ class GyroSurge : public Usermod {
     void loop() {
       // get IMU data
       um_data_t *um_data;
-      if (!usermods.getUMData(&um_data, USERMOD_ID_IMU)) {
+      if (!UsermodManager::getUMData(&um_data, USERMOD_ID_IMU)) {
         // Apply max
         strip.getSegment(0).fadeToBlackBy(max);
         return;

usermods/mpu6050_imu/usermod_mpu6050_imu.h

@@ -164,7 +164,7 @@ class MPU6050Driver : public Usermod {
       if (i2c_scl<0 || i2c_sda<0) { DEBUG_PRINTLN(F("MPU6050: I2C is no good."));  return; }
       // Check the interrupt pin
       if (config.interruptPin >= 0) {
-        irqBound = pinManager.allocatePin(config.interruptPin, false, PinOwner::UM_IMU);
+        irqBound = PinManager::allocatePin(config.interruptPin, false, PinOwner::UM_IMU);
         if (!irqBound) { DEBUG_PRINTLN(F("MPU6050: IRQ pin already in use.")); return; }
         pinMode(config.interruptPin, INPUT);
       };
@@ -408,7 +408,7 @@ class MPU6050Driver : public Usermod {
         // Previously loaded and config changed
         if (irqBound && ((old_cfg.interruptPin != config.interruptPin) || !config.enabled)) {
           detachInterrupt(old_cfg.interruptPin);
-          pinManager.deallocatePin(old_cfg.interruptPin, PinOwner::UM_IMU);            
+          PinManager::deallocatePin(old_cfg.interruptPin, PinOwner::UM_IMU);            
           irqBound = false;
         }
 

usermods/mqtt_switch_v2/README.md

@@ -19,7 +19,7 @@ Example `usermods_list.cpp`:
 
 void registerUsermods()
 {
-  usermods.add(new UsermodMqttSwitch());
+  UsermodManager::add(new UsermodMqttSwitch());
 }
 ```
 
@@ -33,7 +33,7 @@ board = esp12e
 platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_flags = ${common.build_flags_esp8266} 
-   -D LEDPIN=3
+   -D DATA_PINS=3
    -D BTNPIN=4
    -D RLYPIN=12
    -D RLYMDE=1

usermods/multi_relay/readme.md

@@ -41,7 +41,7 @@ When a relay is switched, a message is published:
 
 ## Usermod installation
 
-1. Register the usermod by adding `#include "../usermods/multi_relay/usermod_multi_relay.h"` at the top and `usermods.add(new MultiRelay());` at the bottom of `usermods_list.cpp`.
+1. Register the usermod by adding `#include "../usermods/multi_relay/usermod_multi_relay.h"` at the top and `UsermodManager::add(new MultiRelay());` at the bottom of `usermods_list.cpp`.
 or
 2. Use `#define USERMOD_MULTI_RELAY` in wled.h or `-D USERMOD_MULTI_RELAY` in your platformio.ini
 
@@ -90,9 +90,9 @@ void registerUsermods()
    * || || ||
    * \/ \/ \/
    */
-  //usermods.add(new MyExampleUsermod());
-  //usermods.add(new UsermodTemperature());
-  usermods.add(new MultiRelay());
+  //UsermodManager::add(new MyExampleUsermod());
+  //UsermodManager::add(new UsermodTemperature());
+  UsermodManager::add(new MultiRelay());
 
 }
 ```

usermods/multi_relay/usermod_multi_relay.h

@@ -264,7 +264,7 @@ void MultiRelay::handleOffTimer() {
 void MultiRelay::InitHtmlAPIHandle() {  // https://github.com/me-no-dev/ESPAsyncWebServer
   DEBUG_PRINTLN(F("Relays: Initialize HTML API"));
 
-  server.on(SET_F("/relays"), HTTP_GET, [this](AsyncWebServerRequest *request) {
+  server.on(F("/relays"), HTTP_GET, [this](AsyncWebServerRequest *request) {
     DEBUG_PRINTLN(F("Relays: HTML API"));
     String janswer;
     String error = "";
@@ -516,7 +516,7 @@ void MultiRelay::setup() {
       if (!_relay[i].external) _relay[i].state = !offMode;
       state |= (uint8_t)(_relay[i].invert ? !_relay[i].state : _relay[i].state) << pin;
     } else if (_relay[i].pin<100 && _relay[i].pin>=0) {
-      if (pinManager.allocatePin(_relay[i].pin,true, PinOwner::UM_MultiRelay)) {
+      if (PinManager::allocatePin(_relay[i].pin,true, PinOwner::UM_MultiRelay)) {
         if (!_relay[i].external) _relay[i].state = !offMode;
         switchRelay(i, _relay[i].state);
         _relay[i].active = false;
@@ -765,10 +765,10 @@ void MultiRelay::addToConfig(JsonObject &root) {
 }
 
 void MultiRelay::appendConfigData() {
-  oappend(SET_F("addInfo('MultiRelay:PCF8574-address',1,'<i>(not hex!)</i>');"));
-  oappend(SET_F("addInfo('MultiRelay:broadcast-sec',1,'(MQTT message)');"));
-  //oappend(SET_F("addInfo('MultiRelay:relay-0:pin',1,'(use -1 for PCF8574)');"));
-  oappend(SET_F("d.extra.push({'MultiRelay':{pin:[['P0',100],['P1',101],['P2',102],['P3',103],['P4',104],['P5',105],['P6',106],['P7',107]]}});"));
+  oappend(F("addInfo('MultiRelay:PCF8574-address',1,'<i>(not hex!)</i>');"));
+  oappend(F("addInfo('MultiRelay:broadcast-sec',1,'(MQTT message)');"));
+  //oappend(F("addInfo('MultiRelay:relay-0:pin',1,'(use -1 for PCF8574)');"));
+  oappend(F("d.extra.push({'MultiRelay':{pin:[['P0',100],['P1',101],['P2',102],['P3',103],['P4',104],['P5',105],['P6',106],['P7',107]]}});"));
 }
 
 /**
@@ -817,7 +817,7 @@ bool MultiRelay::readFromConfig(JsonObject &root) {
     // deallocate all pins 1st
     for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++)
       if (oldPin[i]>=0 && oldPin[i]<100) {
-        pinManager.deallocatePin(oldPin[i], PinOwner::UM_MultiRelay);
+        PinManager::deallocatePin(oldPin[i], PinOwner::UM_MultiRelay);
       }
     // allocate new pins
     setup();

usermods/pixels_dice_tray/pixels_dice_tray.h

@@ -112,15 +112,15 @@ class PixelsDiceTrayUsermod : public Usermod {
     SetSPIPinsFromMacros();
     PinManagerPinType spiPins[] = {
         {spi_mosi, true}, {spi_miso, false}, {spi_sclk, true}};
-    if (!pinManager.allocateMultiplePins(spiPins, 3, PinOwner::HW_SPI)) {
+    if (!PinManager::allocateMultiplePins(spiPins, 3, PinOwner::HW_SPI)) {
       enabled = false;
     } else {
       PinManagerPinType displayPins[] = {
           {TFT_CS, true}, {TFT_DC, true}, {TFT_RST, true}, {TFT_BL, true}};
-      if (!pinManager.allocateMultiplePins(
+      if (!PinManager::allocateMultiplePins(
               displayPins, sizeof(displayPins) / sizeof(PinManagerPinType),
               PinOwner::UM_FourLineDisplay)) {
-        pinManager.deallocateMultiplePins(spiPins, 3, PinOwner::HW_SPI);
+        PinManager::deallocateMultiplePins(spiPins, 3, PinOwner::HW_SPI);
         enabled = false;
       }
     }
@@ -387,23 +387,23 @@ class PixelsDiceTrayUsermod : public Usermod {
     // To work around this, add info text to the end of the preceding item.
     //
     // See addInfo in wled00/data/settings_um.htm for details on what this function does.
-    oappend(SET_F(
+    oappend(F(
         "addInfo('DiceTray:ble_scan_duration',1,'<br><br><i>Set to \"*\" to "
         "connect to any die.<br>Leave Blank to disable.</i><br><i "
         "class=\"warn\">Saving will replace \"*\" with die names.</i>','');"));
 #if USING_TFT_DISPLAY
-    oappend(SET_F("ddr=addDropdown('DiceTray','rotation');"));
-    oappend(SET_F("addOption(ddr,'0 deg',0);"));
-    oappend(SET_F("addOption(ddr,'90 deg',1);"));
-    oappend(SET_F("addOption(ddr,'180 deg',2);"));
-    oappend(SET_F("addOption(ddr,'270 deg',3);"));
-    oappend(SET_F(
+    oappend(F("ddr=addDropdown('DiceTray','rotation');"));
+    oappend(F("addOption(ddr,'0 deg',0);"));
+    oappend(F("addOption(ddr,'90 deg',1);"));
+    oappend(F("addOption(ddr,'180 deg',2);"));
+    oappend(F("addOption(ddr,'270 deg',3);"));
+    oappend(F(
         "addInfo('DiceTray:rotation',1,'<br><i class=\"warn\">DO NOT CHANGE "
         "SPI PINS.</i><br><i class=\"warn\">CHANGES ARE IGNORED.</i>','');"));
-    oappend(SET_F("addInfo('TFT:pin[]',0,'','SPI CS');"));
-    oappend(SET_F("addInfo('TFT:pin[]',1,'','SPI DC');"));
-    oappend(SET_F("addInfo('TFT:pin[]',2,'','SPI RST');"));
-    oappend(SET_F("addInfo('TFT:pin[]',3,'','SPI BL');"));
+    oappend(F("addInfo('TFT:pin[]',0,'','SPI CS');"));
+    oappend(F("addInfo('TFT:pin[]',1,'','SPI DC');"));
+    oappend(F("addInfo('TFT:pin[]',2,'','SPI RST');"));
+    oappend(F("addInfo('TFT:pin[]',3,'','SPI BL');"));
 #endif
   }
 

usermods/pwm_outputs/usermod_pwm_outputs.h

@@ -29,13 +29,13 @@ class PwmOutput {
         return;
 
       DEBUG_PRINTF("pwm_output[%d]: setup to freq %d\n", pin_, freq_);
-      if (!pinManager.allocatePin(pin_, true, PinOwner::UM_PWM_OUTPUTS))
+      if (!PinManager::allocatePin(pin_, true, PinOwner::UM_PWM_OUTPUTS))
         return;
       
-      channel_ = pinManager.allocateLedc(1);
+      channel_ = PinManager::allocateLedc(1);
       if (channel_ == 255) {
         DEBUG_PRINTF("pwm_output[%d]: failed to quire ledc\n", pin_);
-        pinManager.deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
+        PinManager::deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
         return;
       }
 
@@ -49,9 +49,9 @@ class PwmOutput {
       DEBUG_PRINTF("pwm_output[%d]: close\n", pin_);
       if (!enabled_)
         return;
-      pinManager.deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
+      PinManager::deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
       if (channel_ != 255)
-        pinManager.deallocateLedc(channel_, 1);
+        PinManager::deallocateLedc(channel_, 1);
       channel_ = 255;
       duty_ = 0.0f;
       enabled_ = false;

usermods/quinled-an-penta/quinled-an-penta.h

@@ -129,7 +129,7 @@ class QuinLEDAnPentaUsermod : public Usermod
     void initOledDisplay()
     {
       PinManagerPinType pins[5] = { { oledSpiClk, true }, { oledSpiData, true }, { oledSpiCs, true }, { oledSpiDc, true }, { oledSpiRst, true } };
-      if (!pinManager.allocateMultiplePins(pins, 5, PinOwner::UM_QuinLEDAnPenta)) {
+      if (!PinManager::allocateMultiplePins(pins, 5, PinOwner::UM_QuinLEDAnPenta)) {
         DEBUG_PRINTF("[%s] OLED pin allocation failed!\n", _name);
         oledEnabled = oledInitDone = false;
         return;
@@ -164,11 +164,11 @@ class QuinLEDAnPentaUsermod : public Usermod
         oledDisplay->clear();
       }
 
-      pinManager.deallocatePin(oledSpiClk, PinOwner::UM_QuinLEDAnPenta);
-      pinManager.deallocatePin(oledSpiData, PinOwner::UM_QuinLEDAnPenta);
-      pinManager.deallocatePin(oledSpiCs, PinOwner::UM_QuinLEDAnPenta);
-      pinManager.deallocatePin(oledSpiDc, PinOwner::UM_QuinLEDAnPenta);
-      pinManager.deallocatePin(oledSpiRst, PinOwner::UM_QuinLEDAnPenta);
+      PinManager::deallocatePin(oledSpiClk, PinOwner::UM_QuinLEDAnPenta);
+      PinManager::deallocatePin(oledSpiData, PinOwner::UM_QuinLEDAnPenta);
+      PinManager::deallocatePin(oledSpiCs, PinOwner::UM_QuinLEDAnPenta);
+      PinManager::deallocatePin(oledSpiDc, PinOwner::UM_QuinLEDAnPenta);
+      PinManager::deallocatePin(oledSpiRst, PinOwner::UM_QuinLEDAnPenta);
 
       delete oledDisplay;
 
@@ -184,7 +184,7 @@ class QuinLEDAnPentaUsermod : public Usermod
     void initSht30TempHumiditySensor()
     {
       PinManagerPinType pins[2] = { { shtSda, true }, { shtScl, true } };
-      if (!pinManager.allocateMultiplePins(pins, 2, PinOwner::UM_QuinLEDAnPenta)) {
+      if (!PinManager::allocateMultiplePins(pins, 2, PinOwner::UM_QuinLEDAnPenta)) {
         DEBUG_PRINTF("[%s] SHT30 pin allocation failed!\n", _name);
         shtEnabled = shtInitDone = false;
         return;
@@ -212,8 +212,8 @@ class QuinLEDAnPentaUsermod : public Usermod
         sht30TempHumidSensor->reset();
       }
 
-      pinManager.deallocatePin(shtSda, PinOwner::UM_QuinLEDAnPenta);
-      pinManager.deallocatePin(shtScl, PinOwner::UM_QuinLEDAnPenta);
+      PinManager::deallocatePin(shtSda, PinOwner::UM_QuinLEDAnPenta);
+      PinManager::deallocatePin(shtScl, PinOwner::UM_QuinLEDAnPenta);
 
       delete sht30TempHumidSensor;
 

usermods/rgb-rotary-encoder/readme.md

@@ -9,7 +9,7 @@ The actual / original code that controls the LED modes is from Adam Zeloof. I ta
 It was quite a bit more work than I hoped, but I got there eventually :)
 
 ## Requirements
-* "ESP Rotary" by Lennart Hennigs, v1.5.0 or higher: https://github.com/LennartHennigs/ESPRotary
+* "ESP Rotary" by Lennart Hennigs, v2.1.1 or higher: https://github.com/LennartHennigs/ESPRotary
 
 ## Usermod installation
 Simply copy the below block (build task) to your `platformio_override.ini` and compile WLED using this new build task. Or use an existing one and add the buildflag `-D RGB_ROTARY_ENCODER`.
@@ -20,7 +20,7 @@ ESP32:
 extends = env:esp32dev
 build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32 -D RGB_ROTARY_ENCODER
 lib_deps = ${esp32.lib_deps}
-    lennarthennigs/ESP Rotary@^1.5.0
+    lennarthennigs/ESP Rotary@^2.1.1
 ```
 
 ESP8266 / D1 Mini:
@@ -29,7 +29,7 @@ ESP8266 / D1 Mini:
 extends = env:d1_mini
 build_flags = ${common.build_flags_esp8266} -D RGB_ROTARY_ENCODER
 lib_deps = ${esp8266.lib_deps}
-    lennarthennigs/ESP Rotary@^1.5.0
+    lennarthennigs/ESP Rotary@^2.1.1
 ```
 
 ## How to connect the board to your ESP

usermods/rgb-rotary-encoder/rgb-rotary-encoder.h

@@ -40,7 +40,7 @@ class RgbRotaryEncoderUsermod : public Usermod
     void initRotaryEncoder()
     {
       PinManagerPinType pins[2] = { { eaIo, false }, { ebIo, false } };
-      if (!pinManager.allocateMultiplePins(pins, 2, PinOwner::UM_RGBRotaryEncoder)) {
+      if (!PinManager::allocateMultiplePins(pins, 2, PinOwner::UM_RGBRotaryEncoder)) {
         eaIo = -1;
         ebIo = -1;
         cleanup();
@@ -108,11 +108,11 @@ class RgbRotaryEncoderUsermod : public Usermod
     {
       // Only deallocate pins if we allocated them ;)
       if (eaIo != -1) {
-        pinManager.deallocatePin(eaIo, PinOwner::UM_RGBRotaryEncoder);
+        PinManager::deallocatePin(eaIo, PinOwner::UM_RGBRotaryEncoder);
         eaIo = -1;
       }
       if (ebIo != -1) {
-        pinManager.deallocatePin(ebIo, PinOwner::UM_RGBRotaryEncoder);
+        PinManager::deallocatePin(ebIo, PinOwner::UM_RGBRotaryEncoder);
         ebIo = -1;
       }
 
@@ -303,8 +303,8 @@ class RgbRotaryEncoderUsermod : public Usermod
           }
 
           if (eaIo != oldEaIo || ebIo != oldEbIo || stepsPerClick != oldStepsPerClick || incrementPerClick != oldIncrementPerClick) {
-            pinManager.deallocatePin(oldEaIo, PinOwner::UM_RGBRotaryEncoder);
-            pinManager.deallocatePin(oldEbIo, PinOwner::UM_RGBRotaryEncoder);
+            PinManager::deallocatePin(oldEaIo, PinOwner::UM_RGBRotaryEncoder);
+            PinManager::deallocatePin(oldEbIo, PinOwner::UM_RGBRotaryEncoder);
             
             delete rotaryEncoder;
             initRotaryEncoder();

usermods/sd_card/usermod_sd_card.h

@@ -45,7 +45,7 @@ class UsermodSdCard : public Usermod {
         { configPinPico, true }
         };
 
-        if (!pinManager.allocateMultiplePins(pins, 4, PinOwner::UM_SdCard)) {
+        if (!PinManager::allocateMultiplePins(pins, 4, PinOwner::UM_SdCard)) {
             DEBUG_PRINTF("[%s] SD (SPI) pin allocation failed!\n", _name);
             sdInitDone = false;
             return;
@@ -75,10 +75,10 @@ class UsermodSdCard : public Usermod {
         SD_ADAPTER.end();
 
         DEBUG_PRINTF("[%s] deallocate pins!\n", _name);
-        pinManager.deallocatePin(configPinSourceSelect, PinOwner::UM_SdCard);
-        pinManager.deallocatePin(configPinSourceClock,  PinOwner::UM_SdCard);
-        pinManager.deallocatePin(configPinPoci,         PinOwner::UM_SdCard);
-        pinManager.deallocatePin(configPinPico,         PinOwner::UM_SdCard);
+        PinManager::deallocatePin(configPinSourceSelect, PinOwner::UM_SdCard);
+        PinManager::deallocatePin(configPinSourceClock,  PinOwner::UM_SdCard);
+        PinManager::deallocatePin(configPinPoci,         PinOwner::UM_SdCard);
+        PinManager::deallocatePin(configPinPico,         PinOwner::UM_SdCard);
 
         sdInitDone = false;
       }

usermods/seven_segment_display_reloaded/usermod_seven_segment_reloaded.h

@@ -385,7 +385,7 @@ public:
     _setAllFalse();
 
     #ifdef USERMOD_SN_PHOTORESISTOR
-      ptr = (Usermod_SN_Photoresistor*) usermods.lookup(USERMOD_ID_SN_PHOTORESISTOR);
+      ptr = (Usermod_SN_Photoresistor*) UsermodManager::lookup(USERMOD_ID_SN_PHOTORESISTOR);
     #endif
     DEBUG_PRINTLN(F("Setup done"));
   }

usermods/sht/usermod_sht.h

@@ -310,22 +310,22 @@ void ShtUsermod::onMqttConnect(bool sessionPresent) {
  * @return void
  */
 void ShtUsermod::appendConfigData() {
-  oappend(SET_F("dd=addDropdown('"));
+  oappend(F("dd=addDropdown('"));
   oappend(_name);
-  oappend(SET_F("','"));
+  oappend(F("','"));
   oappend(_shtType);
-  oappend(SET_F("');"));
-  oappend(SET_F("addOption(dd,'SHT30',0);"));
-  oappend(SET_F("addOption(dd,'SHT31',1);"));
-  oappend(SET_F("addOption(dd,'SHT35',2);"));
-  oappend(SET_F("addOption(dd,'SHT85',3);"));
-  oappend(SET_F("dd=addDropdown('"));
+  oappend(F("');"));
+  oappend(F("addOption(dd,'SHT30',0);"));
+  oappend(F("addOption(dd,'SHT31',1);"));
+  oappend(F("addOption(dd,'SHT35',2);"));
+  oappend(F("addOption(dd,'SHT85',3);"));
+  oappend(F("dd=addDropdown('"));
   oappend(_name);
-  oappend(SET_F("','"));
+  oappend(F("','"));
   oappend(_unitOfTemp);
-  oappend(SET_F("');"));
-  oappend(SET_F("addOption(dd,'Celsius',0);"));
-  oappend(SET_F("addOption(dd,'Fahrenheit',1);"));
+  oappend(F("');"));
+  oappend(F("addOption(dd,'Celsius',0);"));
+  oappend(F("addOption(dd,'Fahrenheit',1);"));
 }
 
 /**

usermods/stairway_wipe_basic/stairway-wipe-usermod-v2.h

@@ -96,7 +96,7 @@ void setup() {
     jsonTransitionOnce = true;
     strip.setTransition(0); //no transition
     effectCurrent = FX_MODE_COLOR_WIPE;
-    resetTimebase(); //make sure wipe starts from beginning
+    strip.resetTimebase(); //make sure wipe starts from beginning
 
     //set wipe direction
     Segment& seg = strip.getSegment(0);

usermods/stairway_wipe_basic/wled06_usermod.ino

@@ -86,7 +86,7 @@ void startWipe()
   bri = briLast; //turn on
   transitionDelayTemp = 0; //no transition
   effectCurrent = FX_MODE_COLOR_WIPE;
-  resetTimebase(); //make sure wipe starts from beginning
+  strip.resetTimebase(); //make sure wipe starts from beginning
 
   //set wipe direction
   Segment& seg = strip.getSegment(0);

usermods/usermod_rotary_brightness_color/usermod_rotary_brightness_color.h

@@ -95,9 +95,9 @@ public:
           }
           else
           {
-            fastled_col.red = col[0];
-            fastled_col.green = col[1];
-            fastled_col.blue = col[2];
+            fastled_col.red = colPri[0];
+            fastled_col.green = colPri[1];
+            fastled_col.blue = colPri[2];
             prim_hsv = rgb2hsv_approximate(fastled_col);
             new_val = (int16_t)prim_hsv.h + fadeAmount;
             if (new_val > 255)
@@ -106,9 +106,9 @@ public:
               new_val += 255; // roll-over if smaller than 0
             prim_hsv.h = (byte)new_val;
             hsv2rgb_rainbow(prim_hsv, fastled_col);
-            col[0] = fastled_col.red;
-            col[1] = fastled_col.green;
-            col[2] = fastled_col.blue;
+            colPri[0] = fastled_col.red;
+            colPri[1] = fastled_col.green;
+            colPri[2] = fastled_col.blue;
           }
         }
         else if (Enc_B == LOW)
@@ -120,9 +120,9 @@ public:
           }
           else
           {
-            fastled_col.red = col[0];
-            fastled_col.green = col[1];
-            fastled_col.blue = col[2];
+            fastled_col.red = colPri[0];
+            fastled_col.green = colPri[1];
+            fastled_col.blue = colPri[2];
             prim_hsv = rgb2hsv_approximate(fastled_col);
             new_val = (int16_t)prim_hsv.h - fadeAmount;
             if (new_val > 255)
@@ -131,9 +131,9 @@ public:
               new_val += 255; // roll-over if smaller than 0
             prim_hsv.h = (byte)new_val;
             hsv2rgb_rainbow(prim_hsv, fastled_col);
-            col[0] = fastled_col.red;
-            col[1] = fastled_col.green;
-            col[2] = fastled_col.blue;
+            colPri[0] = fastled_col.red;
+            colPri[1] = fastled_col.green;
+            colPri[2] = fastled_col.blue;
           }
         }
         //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)

usermods/usermod_v2_HttpPullLightControl/readme.md

@@ -93,7 +93,7 @@ After getting the URL (it can be a static file like static.json or a mylogic.php
 -  -D ABL_MILLIAMPS_DEFAULT=450
 -  -D DEFAULT_LED_COUNT=60 ; For a LED Ring of 60 LEDs
 -  -D BTNPIN=41  ; The M5Stack Atom S3 Lite has a button on GPIO41
--  -D LEDPIN=2 ; The M5Stack Atom S3 Lite has a Grove connector on the front, we use this GPIO2
+-  -D DATA_PINS=2 ; The M5Stack Atom S3 Lite has a Grove connector on the front, we use this GPIO2
 -  -D STATUSLED=35 ; The M5Stack Atom S3 Lite has a Multi-Color LED on GPIO35, although I didnt managed to control it
 -  -D IRPIN=4  ; The M5Stack Atom S3 Lite has a IR LED on GPIO4
 

usermods/usermod_v2_auto_save/usermod_v2_auto_save.h

@@ -103,7 +103,7 @@ class AutoSaveUsermod : public Usermod {
       #ifdef USERMOD_FOUR_LINE_DISPLAY    
       // This Usermod has enhanced functionality if
       // FourLineDisplayUsermod is available.
-      display = (FourLineDisplayUsermod*) usermods.lookup(USERMOD_ID_FOUR_LINE_DISP);
+      display = (FourLineDisplayUsermod*) UsermodManager::lookup(USERMOD_ID_FOUR_LINE_DISP);
       #endif
       initDone = true;
       if (enabled && applyAutoSaveOnBoot) applyPreset(autoSavePreset);

usermods/usermod_v2_four_line_display_ALT/platformio_override.sample.ini

@@ -7,11 +7,12 @@ platform = ${esp32.platform}
 build_unflags = ${common.build_unflags}
 build_flags =
     ${common.build_flags_esp32}
-    -D USERMOD_FOUR_LINE_DISPLAY -D USE_ALT_DISPlAY
-    -D USERMOD_ROTARY_ENCODER_UI -D ENCODER_DT_PIN=18 -D ENCODER_CLK_PIN=5 -D ENCODER_SW_PIN=19
-upload_speed = 460800
+    -D USERMOD_FOUR_LINE_DISPLAY
+    -D FLD_TYPE=SH1106
+    -D I2CSCLPIN=27
+    -D I2CSDAPIN=26
+
 lib_deps =
     ${esp32.lib_deps}
     U8g2@~2.34.4
     Wire
-

usermods/usermod_v2_four_line_display_ALT/readme.md

@@ -1,16 +1,8 @@
 # I2C/SPI 4 Line Display Usermod ALT
 
-Thank you to the authors of the original version of these usermods. It would not have been possible without them!
-"usermod_v2_four_line_display"
-"usermod_v2_rotary_encoder_ui"
+This usermod could be used in compination with `usermod_v2_rotary_encoder_ui_ALT`.
 
-The core of these usermods are a copy of the originals. The main changes are to the FourLineDisplay usermod.
-The display usermod UI has been completely changed.
-
-
-The changes made to the RotaryEncoder usermod were made to support the new UI in the display usermod.
-Without the display, it functions identical to the original.
-The original "usermod_v2_auto_save" will not work with the display just yet.
+## Functionalities
 
 Press the encoder to cycle through the options:
 * Brightness
@@ -18,26 +10,18 @@ Press the encoder to cycle through the options:
 * Intensity
 * Palette
 * Effect
-* Main Color (only if display is used)
-* Saturation (only if display is used)
+* Main Color
+* Saturation
 
-Press and hold the encoder to display Network Info. If AP is active, it will display AP, SSID and password
+Press and hold the encoder to display Network Info. If AP is active, it will display the AP, SSID and Password
 
-Also shows if the timer is enabled
+Also shows if the timer is enabled.
 
 [See the pair of usermods in action](https://www.youtube.com/watch?v=ulZnBt9z3TI)
 
 ## Installation
 
-Please refer to the original `usermod_v2_rotary_encoder_ui` readme for the main instructions.
-
-Copy the example `platformio_override.sample.ini` from the usermod_v2_rotary_encoder_ui_ALT folder to the root directory of your particular build and rename it to `platformio_override.ini`.
-
-This file should be placed in the same directory as `platformio.ini`.
-
-Then, to activate this alternative usermod, add `#define USE_ALT_DISPlAY` (NOTE: CASE SENSITIVE) to the `usermods_list.cpp` file,
-                                        or add `-D USE_ALT_DISPlAY` to the original `platformio_override.ini.sample` file
-
+Copy the example `platformio_override.sample.ini` to the root directory of your particular build.
 
 ## Configuration
 

usermods/usermod_v2_four_line_display_ALT/usermod_v2_four_line_display_ALT.h

@@ -543,7 +543,7 @@ void FourLineDisplayUsermod::setup() {
       type = NONE;
     } else {
       PinManagerPinType cspins[3] = { { ioPin[0], true }, { ioPin[1], true }, { ioPin[2], true } };
-      if (!pinManager.allocateMultiplePins(cspins, 3, PinOwner::UM_FourLineDisplay)) { type = NONE; }
+      if (!PinManager::allocateMultiplePins(cspins, 3, PinOwner::UM_FourLineDisplay)) { type = NONE; }
     }
   } else {
     if (i2c_scl<0 || i2c_sda<0) { type=NONE; }
@@ -569,7 +569,7 @@ void FourLineDisplayUsermod::setup() {
   if (nullptr == u8x8) {
     DEBUG_PRINTLN(F("Display init failed."));
     if (isSPI) {
-      pinManager.deallocateMultiplePins((const uint8_t*)ioPin, 3, PinOwner::UM_FourLineDisplay);
+      PinManager::deallocateMultiplePins((const uint8_t*)ioPin, 3, PinOwner::UM_FourLineDisplay);
     }
     type = NONE;
     return;
@@ -1202,21 +1202,21 @@ void FourLineDisplayUsermod::onUpdateBegin(bool init) {
 //}
 
 void FourLineDisplayUsermod::appendConfigData() {
-  oappend(SET_F("dd=addDropdown('4LineDisplay','type');"));
-  oappend(SET_F("addOption(dd,'None',0);"));
-  oappend(SET_F("addOption(dd,'SSD1306',1);"));
-  oappend(SET_F("addOption(dd,'SH1106',2);"));
-  oappend(SET_F("addOption(dd,'SSD1306 128x64',3);"));
-  oappend(SET_F("addOption(dd,'SSD1305',4);"));
-  oappend(SET_F("addOption(dd,'SSD1305 128x64',5);"));
-  oappend(SET_F("addOption(dd,'SSD1309 128x64',9);"));
-  oappend(SET_F("addOption(dd,'SSD1306 SPI',6);"));
-  oappend(SET_F("addOption(dd,'SSD1306 SPI 128x64',7);"));
-  oappend(SET_F("addOption(dd,'SSD1309 SPI 128x64',8);"));
-  oappend(SET_F("addInfo('4LineDisplay:type',1,'<br><i class=\"warn\">Change may require reboot</i>','');"));
-  oappend(SET_F("addInfo('4LineDisplay:pin[]',0,'','SPI CS');"));
-  oappend(SET_F("addInfo('4LineDisplay:pin[]',1,'','SPI DC');"));
-  oappend(SET_F("addInfo('4LineDisplay:pin[]',2,'','SPI RST');"));
+  oappend(F("dd=addDropdown('4LineDisplay','type');"));
+  oappend(F("addOption(dd,'None',0);"));
+  oappend(F("addOption(dd,'SSD1306',1);"));
+  oappend(F("addOption(dd,'SH1106',2);"));
+  oappend(F("addOption(dd,'SSD1306 128x64',3);"));
+  oappend(F("addOption(dd,'SSD1305',4);"));
+  oappend(F("addOption(dd,'SSD1305 128x64',5);"));
+  oappend(F("addOption(dd,'SSD1309 128x64',9);"));
+  oappend(F("addOption(dd,'SSD1306 SPI',6);"));
+  oappend(F("addOption(dd,'SSD1306 SPI 128x64',7);"));
+  oappend(F("addOption(dd,'SSD1309 SPI 128x64',8);"));
+  oappend(F("addInfo('4LineDisplay:type',1,'<br><i class=\"warn\">Change may require reboot</i>','');"));
+  oappend(F("addInfo('4LineDisplay:pin[]',0,'','SPI CS');"));
+  oappend(F("addInfo('4LineDisplay:pin[]',1,'','SPI DC');"));
+  oappend(F("addInfo('4LineDisplay:pin[]',2,'','SPI RST');"));
 }
 
 /*
@@ -1307,7 +1307,7 @@ bool FourLineDisplayUsermod::readFromConfig(JsonObject& root) {
       bool isSPI = (type == SSD1306_SPI || type == SSD1306_SPI64 || type == SSD1309_SPI64);
       bool newSPI = (newType == SSD1306_SPI || newType == SSD1306_SPI64 || newType == SSD1309_SPI64);
       if (isSPI) {
-        if (pinsChanged || !newSPI) pinManager.deallocateMultiplePins((const uint8_t*)oldPin, 3, PinOwner::UM_FourLineDisplay);
+        if (pinsChanged || !newSPI) PinManager::deallocateMultiplePins((const uint8_t*)oldPin, 3, PinOwner::UM_FourLineDisplay);
         if (!newSPI) {
           // was SPI but is no longer SPI
           if (i2c_scl<0 || i2c_sda<0) { newType=NONE; }
@@ -1315,7 +1315,7 @@ bool FourLineDisplayUsermod::readFromConfig(JsonObject& root) {
           // still SPI but pins changed
           PinManagerPinType cspins[3] = { { ioPin[0], true }, { ioPin[1], true }, { ioPin[2], true } };
           if (ioPin[0]<0 || ioPin[1]<0 || ioPin[1]<0) { newType=NONE; }
-          else if (!pinManager.allocateMultiplePins(cspins, 3, PinOwner::UM_FourLineDisplay)) { newType=NONE; }
+          else if (!PinManager::allocateMultiplePins(cspins, 3, PinOwner::UM_FourLineDisplay)) { newType=NONE; }
         }
       } else if (newSPI) {
         // was I2C but is now SPI
@@ -1324,7 +1324,7 @@ bool FourLineDisplayUsermod::readFromConfig(JsonObject& root) {
         } else {
           PinManagerPinType pins[3] = { { ioPin[0], true }, { ioPin[1], true }, { ioPin[2], true } };
           if (ioPin[0]<0 || ioPin[1]<0 || ioPin[1]<0) { newType=NONE; }
-          else if (!pinManager.allocateMultiplePins(pins, 3, PinOwner::UM_FourLineDisplay)) { newType=NONE; }
+          else if (!PinManager::allocateMultiplePins(pins, 3, PinOwner::UM_FourLineDisplay)) { newType=NONE; }
         }
       } else {
         // just I2C type changed

usermods/usermod_v2_rotary_encoder_ui_ALT/platformio_override.sample.ini

@@ -0,0 +1,14 @@
+[platformio]
+default_envs = esp32dev
+
+[env:esp32dev]
+board = esp32dev
+platform = ${esp32.platform}
+build_unflags = ${common.build_unflags}
+build_flags =
+    ${common.build_flags_esp32}
+    -D USERMOD_ROTARY_ENCODER_UI
+    -D USERMOD_ROTARY_ENCODER_GPIO=INPUT
+    -D ENCODER_DT_PIN=21
+    -D ENCODER_CLK_PIN=23
+    -D ENCODER_SW_PIN=0

usermods/usermod_v2_rotary_encoder_ui_ALT/readme.md

@@ -1,16 +1,8 @@
 # Rotary Encoder UI Usermod ALT
 
-Thank you to the authors of the original version of these usermods. It would not have been possible without them!
-"usermod_v2_four_line_display"
-"usermod_v2_rotary_encoder_ui"
+This usermod supports the UI of the `usermod_v2_rotary_encoder_ui_ALT`.
 
-The core of these usermods are a copy of the originals. The main changes are to the FourLineDisplay usermod.
-The display usermod UI has been completely changed.
-
-
-The changes made to the RotaryEncoder usermod were made to support the new UI in the display usermod.
-Without the display, it functions identical to the original.
-The original "usermod_v2_auto_save" will not work with the display just yet.
+## Functionalities
 
 Press the encoder to cycle through the options:
 * Brightness
@@ -21,8 +13,7 @@ Press the encoder to cycle through the options:
 * Main Color (only if display is used)
 * Saturation (only if display is used)
 
-Press and hold the encoder to display Network Info
-    if AP is active, it will display the AP, SSID and Password
+Press and hold the encoder to display Network Info. If AP is active, it will display the AP, SSID and Password
 
 Also shows if the timer is enabled.
 
@@ -30,9 +21,7 @@ Also shows if the timer is enabled.
 
 ## Installation
 
-Copy the example `platformio_override.sample.ini` to the root directory of your particular build and rename it to `platformio_override.ini`.
-
-To activate this alternative usermod, add `#define USE_ALT_DISPlAY` (NOTE: CASE SENSITIVE) to the `usermods_list.cpp` file, or add `-D USE_ALT_DISPlAY` to your `platformio_override.ini` file
+Copy the example `platformio_override.sample.ini` to the root directory of your particular build.
 
 ### Define Your Options
 
@@ -40,7 +29,6 @@ To activate this alternative usermod, add `#define USE_ALT_DISPlAY` (NOTE: CASE
 * `USERMOD_FOUR_LINE_DISPLAY`       - define this to have this the Four Line Display mod included wled00\usermods_list.cpp
                                         also tells this usermod that the display is available
                                         (see the Four Line Display usermod `readme.md` for more details)
-* `USE_ALT_DISPlAY`                 - Mandatory to use Four Line Display
 * `ENCODER_DT_PIN`                  - defaults to 18
 * `ENCODER_CLK_PIN`                 - defaults to 5
 * `ENCODER_SW_PIN`                  - defaults to 19
@@ -50,7 +38,7 @@ To activate this alternative usermod, add `#define USE_ALT_DISPlAY` (NOTE: CASE
 
 ### PlatformIO requirements
 
-Note: the Four Line Display usermod requires the libraries `U8g2` and `Wire`.
+No special requirements.
 
 ## Change Log
 

usermods/usermod_v2_rotary_encoder_ui_ALT/usermod_v2_rotary_encoder_ui_ALT.h

@@ -489,7 +489,7 @@ void RotaryEncoderUIUsermod::setup()
       enabled = false;
       return;
     } else {
-      if (pinIRQ >= 0 && pinManager.allocatePin(pinIRQ, false, PinOwner::UM_RotaryEncoderUI)) {
+      if (pinIRQ >= 0 && PinManager::allocatePin(pinIRQ, false, PinOwner::UM_RotaryEncoderUI)) {
         pinMode(pinIRQ, INPUT_PULLUP);
         attachInterrupt(pinIRQ, i2cReadingISR, FALLING); // RISING, FALLING, CHANGE, ONLOW, ONHIGH
         DEBUG_PRINTLN(F("Interrupt attached."));
@@ -502,7 +502,7 @@ void RotaryEncoderUIUsermod::setup()
     }
   } else {
     PinManagerPinType pins[3] = { { pinA, false }, { pinB, false }, { pinC, false } };
-    if (pinA<0 || pinB<0 || !pinManager.allocateMultiplePins(pins, 3, PinOwner::UM_RotaryEncoderUI)) {
+    if (pinA<0 || pinB<0 || !PinManager::allocateMultiplePins(pins, 3, PinOwner::UM_RotaryEncoderUI)) {
       pinA = pinB = pinC = -1;
       enabled = false;
       return;
@@ -518,14 +518,14 @@ void RotaryEncoderUIUsermod::setup()
 
   loopTime = millis();
 
-  currentCCT = (approximateKelvinFromRGB(RGBW32(col[0], col[1], col[2], col[3])) - 1900) >> 5;
+  currentCCT = (approximateKelvinFromRGB(RGBW32(colPri[0], colPri[1], colPri[2], colPri[3])) - 1900) >> 5;
 
   if (!initDone) sortModesAndPalettes();
 
 #ifdef USERMOD_FOUR_LINE_DISPLAY
   // This Usermod uses FourLineDisplayUsermod for the best experience.
   // But it's optional. But you want it.
-  display = (FourLineDisplayUsermod*) usermods.lookup(USERMOD_ID_FOUR_LINE_DISP);
+  display = (FourLineDisplayUsermod*) UsermodManager::lookup(USERMOD_ID_FOUR_LINE_DISP);
   if (display != nullptr) {
     display->setMarkLine(1, 0);
   }
@@ -920,17 +920,17 @@ void RotaryEncoderUIUsermod::changeHue(bool increase){
   display->updateRedrawTime();
 #endif
   currentHue1 = max(min((increase ? currentHue1+fadeAmount : currentHue1-fadeAmount), 255), 0);
-  colorHStoRGB(currentHue1*256, currentSat1, col);
+  colorHStoRGB(currentHue1*256, currentSat1, colPri);
   stateChanged = true; 
   if (applyToAll) {
     for (unsigned i=0; i<strip.getSegmentsNum(); i++) {
       Segment& seg = strip.getSegment(i);
       if (!seg.isActive()) continue;
-      seg.colors[0] = RGBW32(col[0], col[1], col[2], col[3]);
+      seg.colors[0] = RGBW32(colPri[0], colPri[1], colPri[2], colPri[3]);
     }
   } else {
     Segment& seg = strip.getSegment(strip.getMainSegmentId());
-    seg.colors[0] = RGBW32(col[0], col[1], col[2], col[3]);
+    seg.colors[0] = RGBW32(colPri[0], colPri[1], colPri[2], colPri[3]);
   }
   lampUdated();
 #ifdef USERMOD_FOUR_LINE_DISPLAY
@@ -950,16 +950,16 @@ void RotaryEncoderUIUsermod::changeSat(bool increase){
   display->updateRedrawTime();
 #endif
   currentSat1 = max(min((increase ? currentSat1+fadeAmount : currentSat1-fadeAmount), 255), 0);
-  colorHStoRGB(currentHue1*256, currentSat1, col);
+  colorHStoRGB(currentHue1*256, currentSat1, colPri);
   if (applyToAll) {
     for (unsigned i=0; i<strip.getSegmentsNum(); i++) {
       Segment& seg = strip.getSegment(i);
       if (!seg.isActive()) continue;
-      seg.colors[0] = RGBW32(col[0], col[1], col[2], col[3]);
+      seg.colors[0] = RGBW32(colPri[0], colPri[1], colPri[2], colPri[3]);
     }
   } else {
     Segment& seg = strip.getSegment(strip.getMainSegmentId());
-    seg.colors[0] = RGBW32(col[0], col[1], col[2], col[3]);
+    seg.colors[0] = RGBW32(colPri[0], colPri[1], colPri[2], colPri[3]);
   }
   lampUdated();
 #ifdef USERMOD_FOUR_LINE_DISPLAY
@@ -1090,8 +1090,8 @@ void RotaryEncoderUIUsermod::addToConfig(JsonObject &root) {
 }
 
 void RotaryEncoderUIUsermod::appendConfigData() {
-  oappend(SET_F("addInfo('Rotary-Encoder:PCF8574-address',1,'<i>(not hex!)</i>');"));
-  oappend(SET_F("d.extra.push({'Rotary-Encoder':{pin:[['P0',100],['P1',101],['P2',102],['P3',103],['P4',104],['P5',105],['P6',106],['P7',107]]}});"));
+  oappend(F("addInfo('Rotary-Encoder:PCF8574-address',1,'<i>(not hex!)</i>');"));
+  oappend(F("d.extra.push({'Rotary-Encoder':{pin:[['P0',100],['P1',101],['P2',102],['P3',103],['P4',104],['P5',105],['P6',106],['P7',107]]}});"));
 }
 
 /**
@@ -1138,14 +1138,14 @@ bool RotaryEncoderUIUsermod::readFromConfig(JsonObject &root) {
       if (oldPcf8574) {
         if (pinIRQ >= 0) {
           detachInterrupt(pinIRQ);
-          pinManager.deallocatePin(pinIRQ, PinOwner::UM_RotaryEncoderUI);
+          PinManager::deallocatePin(pinIRQ, PinOwner::UM_RotaryEncoderUI);
           DEBUG_PRINTLN(F("Deallocated old IRQ pin."));
         }
         pinIRQ = newIRQpin<100 ? newIRQpin : -1; // ignore PCF8574 pins
       } else {
-        pinManager.deallocatePin(pinA, PinOwner::UM_RotaryEncoderUI);
-        pinManager.deallocatePin(pinB, PinOwner::UM_RotaryEncoderUI);
-        pinManager.deallocatePin(pinC, PinOwner::UM_RotaryEncoderUI);
+        PinManager::deallocatePin(pinA, PinOwner::UM_RotaryEncoderUI);
+        PinManager::deallocatePin(pinB, PinOwner::UM_RotaryEncoderUI);
+        PinManager::deallocatePin(pinC, PinOwner::UM_RotaryEncoderUI);
         DEBUG_PRINTLN(F("Deallocated old pins."));
       }
       pinA = newDTpin;

usermods/usermod_v2_word_clock/usermod_v2_word_clock.h

@@ -433,8 +433,8 @@ class WordClockUsermod : public Usermod
 
     void appendConfigData()
     {
-      oappend(SET_F("addInfo('WordClockUsermod:ledOffset', 1, 'Number of LEDs before the letters');"));
-      oappend(SET_F("addInfo('WordClockUsermod:Norddeutsch', 1, 'Viertel vor instead of Dreiviertel');"));
+      oappend(F("addInfo('WordClockUsermod:ledOffset', 1, 'Number of LEDs before the letters');"));
+      oappend(F("addInfo('WordClockUsermod:Norddeutsch', 1, 'Viertel vor instead of Dreiviertel');"));
     }
 
     /*

usermods/wireguard/wireguard.h

@@ -54,13 +54,13 @@ class WireguardUsermod : public Usermod {
     }
 
     void appendConfigData() {
-        oappend(SET_F("addInfo('WireGuard:host',1,'Server Hostname');"));           // 0 is field type, 1 is actual field
-        oappend(SET_F("addInfo('WireGuard:port',1,'Server Port');"));               // 0 is field type, 1 is actual field
-        oappend(SET_F("addInfo('WireGuard:ip',1,'Device IP');"));                   // 0 is field type, 1 is actual field
-        oappend(SET_F("addInfo('WireGuard:psk',1,'Pre Shared Key (optional)');"));  // 0 is field type, 1 is actual field
-        oappend(SET_F("addInfo('WireGuard:pem',1,'Private Key');"));                // 0 is field type, 1 is actual field
-        oappend(SET_F("addInfo('WireGuard:pub',1,'Public Key');"));                 // 0 is field type, 1 is actual field
-        oappend(SET_F("addInfo('WireGuard:tz',1,'POSIX timezone string');"));       // 0 is field type, 1 is actual field
+        oappend(F("addInfo('WireGuard:host',1,'Server Hostname');"));           // 0 is field type, 1 is actual field
+        oappend(F("addInfo('WireGuard:port',1,'Server Port');"));               // 0 is field type, 1 is actual field
+        oappend(F("addInfo('WireGuard:ip',1,'Device IP');"));                   // 0 is field type, 1 is actual field
+        oappend(F("addInfo('WireGuard:psk',1,'Pre Shared Key (optional)');"));  // 0 is field type, 1 is actual field
+        oappend(F("addInfo('WireGuard:pem',1,'Private Key');"));                // 0 is field type, 1 is actual field
+        oappend(F("addInfo('WireGuard:pub',1,'Public Key');"));                 // 0 is field type, 1 is actual field
+        oappend(F("addInfo('WireGuard:tz',1,'POSIX timezone string');"));       // 0 is field type, 1 is actual field
     }
 
     void addToConfig(JsonObject& root) {

wled00/FX.h

@@ -1,33 +1,23 @@
+#pragma once
 /*
   WS2812FX.h - Library for WS2812 LED effects.
   Harm Aldick - 2016
   www.aldick.org
-  LICENSE
-  The MIT License (MIT)
+
   Copyright (c) 2016  Harm Aldick
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  Licensed under the EUPL v. 1.2 or later
+  Adapted from code originally licensed under the MIT license
 
   Modified for WLED
+
+  Segment class/struct (c) 2022 Blaz Kristan (@blazoncek)
 */
 
 #ifndef WS2812FX_h
 #define WS2812FX_h
 
 #include <vector>
+#include "wled.h"
 
 #include "const.h"
 
@@ -60,30 +50,42 @@
 #define WLED_FPS         42
 #define FRAMETIME_FIXED  (1000/WLED_FPS)
 #define FRAMETIME        strip.getFrameTime()
+#if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S2)
+  #define MIN_FRAME_DELAY  2                                              // minimum wait between repaints, to keep other functions like WiFi alive 
+#elif defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C3)
+  #define MIN_FRAME_DELAY  3                                              // S2/C3 are slower than normal esp32, and only have one core
+#else
+  #define MIN_FRAME_DELAY  8                                              // 8266 legacy MIN_SHOW_DELAY
+#endif
+#define FPS_UNLIMITED    0
+
+// FPS calculation (can be defined as compile flag for debugging)
+#ifndef FPS_CALC_AVG
+#define FPS_CALC_AVG 7 // average FPS calculation over this many frames (moving average)
+#endif
+#ifndef FPS_MULTIPLIER
+#define FPS_MULTIPLIER 1 // dev option: multiplier to get sub-frame FPS without floats
+#endif
+#define FPS_CALC_SHIFT 7 // bit shift for fixed point math
 
 /* each segment uses 82 bytes of SRAM memory, so if you're application fails because of
   insufficient memory, decreasing MAX_NUM_SEGMENTS may help */
 #ifdef ESP8266
-  #define MAX_NUM_SEGMENTS    16
+  #define MAX_NUM_SEGMENTS  16
   /* How much data bytes all segments combined may allocate */
   #define MAX_SEGMENT_DATA  5120
+#elif defined(CONFIG_IDF_TARGET_ESP32S2)
+  #define MAX_NUM_SEGMENTS  20
+  #define MAX_SEGMENT_DATA  (MAX_NUM_SEGMENTS*512)  // 10k by default (S2 is short on free RAM)
 #else
-  #ifndef MAX_NUM_SEGMENTS
-    #define MAX_NUM_SEGMENTS  32
-  #endif
-  #if defined(ARDUINO_ARCH_ESP32S2)
-    #define MAX_SEGMENT_DATA  MAX_NUM_SEGMENTS*768 // 24k by default (S2 is short on free RAM)
-  #else
-    #define MAX_SEGMENT_DATA  MAX_NUM_SEGMENTS*1280 // 40k by default
-  #endif
+  #define MAX_NUM_SEGMENTS  32  // warning: going beyond 32 may consume too much RAM for stable operation
+  #define MAX_SEGMENT_DATA  (MAX_NUM_SEGMENTS*1280) // 40k by default
 #endif
 
 /* How much data bytes each segment should max allocate to leave enough space for other segments,
   assuming each segment uses the same amount of data. 256 for ESP8266, 640 for ESP32. */
 #define FAIR_DATA_PER_SEG (MAX_SEGMENT_DATA / strip.getMaxSegments())
 
-#define MIN_SHOW_DELAY   (_frametime < 16 ? 8 : 15)
-
 #define NUM_COLORS       3 /* number of colors per segment */
 #define SEGMENT          strip._segments[strip.getCurrSegmentId()]
 #define SEGENV           strip._segments[strip.getCurrSegmentId()]
@@ -517,68 +519,72 @@ typedef struct Segment {
 #endif
 
     inline bool     getOption(uint8_t n) const { return ((options >> n) & 0x01); }
-    inline bool     isSelected(void)     const { return selected; }
-    inline bool     isInTransition(void) const { return _t != nullptr; }
-    inline bool     isActive(void)       const { return stop > start; }
-    inline bool     is2D(void)           const { return (width()>1 && height()>1); }
-    inline bool     hasRGB(void)         const { return _isRGB; }
-    inline bool     hasWhite(void)       const { return _hasW; }
-    inline bool     isCCT(void)          const { return _isCCT; }
-    inline uint16_t width(void)          const { return isActive() ? (stop - start) : 0; }  // segment width in physical pixels (length if 1D)
-    inline uint16_t height(void)         const { return stopY - startY; }                   // segment height (if 2D) in physical pixels (it *is* always >=1)
-    inline uint16_t length(void)         const { return width() * height(); }               // segment length (count) in physical pixels
-    inline uint16_t groupLength(void)    const { return grouping + spacing; }
-    inline uint8_t  getLightCapabilities(void) const { return _capabilities; }
+    inline bool     isSelected()         const { return selected; }
+    inline bool     isInTransition()     const { return _t != nullptr; }
+    inline bool     isActive()           const { return stop > start; }
+    inline bool     is2D()               const { return (width()>1 && height()>1); }
+    inline bool     hasRGB()             const { return _isRGB; }
+    inline bool     hasWhite()           const { return _hasW; }
+    inline bool     isCCT()              const { return _isCCT; }
+    inline uint16_t width()              const { return isActive() ? (stop - start) : 0; }  // segment width in physical pixels (length if 1D)
+    inline uint16_t height()             const { return stopY - startY; }                   // segment height (if 2D) in physical pixels (it *is* always >=1)
+    inline uint16_t length()             const { return width() * height(); }               // segment length (count) in physical pixels
+    inline uint16_t groupLength()        const { return grouping + spacing; }
+    inline uint8_t  getLightCapabilities() const { return _capabilities; }
+    inline void     deactivate()               { setGeometry(0,0); }
+    inline Segment &clearName()                { if (name) free(name); name = nullptr; return *this; }
+    inline Segment &setName(const String &name) { return setName(name.c_str()); }
 
-    static uint16_t getUsedSegmentData(void)    { return _usedSegmentData; }
-    static void     addUsedSegmentData(int len) { _usedSegmentData += len; }
+    inline static uint16_t getUsedSegmentData()    { return _usedSegmentData; }
+    inline static void addUsedSegmentData(int len) { _usedSegmentData += len; }
     #ifndef WLED_DISABLE_MODE_BLEND
-    static void     modeBlend(bool blend)       { _modeBlend = blend; }
+    inline static void modeBlend(bool blend)       { _modeBlend = blend; }
     #endif
     static void     handleRandomPalette();
-    inline static const CRGBPalette16 &getCurrentPalette(void) { return Segment::_currentPalette; }
+    inline static const CRGBPalette16 &getCurrentPalette() { return Segment::_currentPalette; }
 
-    void    setUp(uint16_t i1, uint16_t i2, uint8_t grp=1, uint8_t spc=0, uint16_t ofs=UINT16_MAX, uint16_t i1Y=0, uint16_t i2Y=1);
-    bool    setColor(uint8_t slot, uint32_t c); //returns true if changed
-    void    setCCT(uint16_t k);
-    void    setOpacity(uint8_t o);
-    void    setOption(uint8_t n, bool val);
-    void    setMode(uint8_t fx, bool loadDefaults = false);
-    void    setPalette(uint8_t pal);
-    uint8_t differs(Segment& b) const;
-    void    refreshLightCapabilities(void);
+    void    setGeometry(uint16_t i1, uint16_t i2, uint8_t grp=1, uint8_t spc=0, uint16_t ofs=UINT16_MAX, uint16_t i1Y=0, uint16_t i2Y=1, uint8_t m12 = 0);
+    Segment &setColor(uint8_t slot, uint32_t c);
+    Segment &setCCT(uint16_t k);
+    Segment &setOpacity(uint8_t o);
+    Segment &setOption(uint8_t n, bool val);
+    Segment &setMode(uint8_t fx, bool loadDefaults = false);
+    Segment &setPalette(uint8_t pal);
+    Segment &setName(const char* name);
+    uint8_t differs(const Segment& b) const;
+    void    refreshLightCapabilities();
 
     // runtime data functions
-    inline uint16_t dataSize(void) const { return _dataLen; }
+    inline uint16_t dataSize() const { return _dataLen; }
     bool allocateData(size_t len);  // allocates effect data buffer in heap and clears it
-    void deallocateData(void);      // deallocates (frees) effect data buffer from heap
-    void resetIfRequired(void);     // sets all SEGENV variables to 0 and clears data buffer
+    void deallocateData();          // deallocates (frees) effect data buffer from heap
+    void resetIfRequired();         // sets all SEGENV variables to 0 and clears data buffer
     /**
       * Flags that before the next effect is calculated,
       * the internal segment state should be reset.
       * Call resetIfRequired before calling the next effect function.
       * Safe to call from interrupts and network requests.
       */
-    inline void markForReset(void) { reset = true; }  // setOption(SEG_OPTION_RESET, true)
+    inline Segment &markForReset() { reset = true; return *this; }  // setOption(SEG_OPTION_RESET, true)
 
     // transition functions
     void     startTransition(uint16_t dur);     // transition has to start before actual segment values change
-    void     stopTransition(void);              // ends transition mode by destroying transition structure (does nothing if not in transition)
-    inline void handleTransition(void) { if (progress() == 0xFFFFU) stopTransition(); }
+    void     stopTransition();                  // ends transition mode by destroying transition structure (does nothing if not in transition)
+    inline void handleTransition() { if (progress() == 0xFFFFU) stopTransition(); }
     #ifndef WLED_DISABLE_MODE_BLEND
     void     swapSegenv(tmpsegd_t &tmpSegD);    // copies segment data into specifed buffer, if buffer is not a transition buffer, segment data is overwritten from transition buffer
     void     restoreSegenv(tmpsegd_t &tmpSegD); // restores segment data from buffer, if buffer is not transition buffer, changed values are copied to transition buffer
     #endif
-    uint16_t progress(void) const;                  // transition progression between 0-65535
-    uint8_t  currentBri(bool useCct = false) const; // current segment brightness/CCT (blended while in transition)
-    uint8_t  currentMode(void) const;               // currently active effect/mode (while in transition)
-    uint32_t currentColor(uint8_t slot) const;      // currently active segment color (blended while in transition)
+    [[gnu::hot]] uint16_t progress() const;                  // transition progression between 0-65535
+    [[gnu::hot]] uint8_t  currentBri(bool useCct = false) const; // current segment brightness/CCT (blended while in transition)
+    uint8_t  currentMode() const;                            // currently active effect/mode (while in transition)
+    [[gnu::hot]] uint32_t currentColor(uint8_t slot) const;  // currently active segment color (blended while in transition)
     CRGBPalette16 &loadPalette(CRGBPalette16 &tgt, uint8_t pal);
-    void     setCurrentPalette(void);
+    void     setCurrentPalette();
 
     // 1D strip
-    uint16_t virtualLength(void) const;
-    void setPixelColor(int n, uint32_t c); // set relative pixel within segment with color
+    [[gnu::hot]] uint16_t virtualLength() const;
+    [[gnu::hot]] void setPixelColor(int n, uint32_t c); // set relative pixel within segment with color
     inline void setPixelColor(unsigned n, uint32_t c)                    { setPixelColor(int(n), c); }
     inline void setPixelColor(int n, byte r, byte g, byte b, byte w = 0) { setPixelColor(n, RGBW32(r,g,b,w)); }
     inline void setPixelColor(int n, CRGB c)                             { setPixelColor(n, RGBW32(c.r,c.g,c.b,0)); }
@@ -587,7 +593,7 @@ typedef struct Segment {
     inline void setPixelColor(float i, uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0, bool aa = true) { setPixelColor(i, RGBW32(r,g,b,w), aa); }
     inline void setPixelColor(float i, CRGB c, bool aa = true)                                         { setPixelColor(i, RGBW32(c.r,c.g,c.b,0), aa); }
     #endif
-    uint32_t getPixelColor(int i) const;
+    [[gnu::hot]] uint32_t getPixelColor(int i) const;
     // 1D support functions (some implement 2D as well)
     void blur(uint8_t, bool smear = false);
     void fill(uint32_t c);
@@ -599,8 +605,8 @@ typedef struct Segment {
     inline void addPixelColor(int n, byte r, byte g, byte b, byte w = 0, bool fast = false) { addPixelColor(n, RGBW32(r,g,b,w), fast); }
     inline void addPixelColor(int n, CRGB c, bool fast = false)          { addPixelColor(n, RGBW32(c.r,c.g,c.b,0), fast); }
     inline void fadePixelColor(uint16_t n, uint8_t fade)                 { setPixelColor(n, color_fade(getPixelColor(n), fade, true)); }
-    uint32_t color_from_palette(uint16_t, bool mapping, bool wrap, uint8_t mcol, uint8_t pbri = 255) const;
-    uint32_t color_wheel(uint8_t pos) const;
+    [[gnu::hot]] uint32_t color_from_palette(uint16_t, bool mapping, bool wrap, uint8_t mcol, uint8_t pbri = 255) const;
+    [[gnu::hot]] uint32_t color_wheel(uint8_t pos) const;
 
     // 2D Blur: shortcuts for bluring columns or rows only (50% faster than full 2D blur)
     inline void blurCols(fract8 blur_amount, bool smear = false) { // blur all columns
@@ -613,12 +619,18 @@ typedef struct Segment {
     }
 
     // 2D matrix
-    uint16_t virtualWidth(void)  const; // segment width in virtual pixels (accounts for groupping and spacing)
-    uint16_t virtualHeight(void) const; // segment height in virtual pixels (accounts for groupping and spacing)
-    uint16_t nrOfVStrips(void) const;   // returns number of virtual vertical strips in 2D matrix (used to expand 1D effects into 2D)
+    [[gnu::hot]] unsigned virtualWidth()  const; // segment width in virtual pixels (accounts for groupping and spacing)
+    [[gnu::hot]] unsigned virtualHeight() const; // segment height in virtual pixels (accounts for groupping and spacing)
+    inline unsigned nrOfVStrips() const {        // returns number of virtual vertical strips in 2D matrix (used to expand 1D effects into 2D)
+    #ifndef WLED_DISABLE_2D
+      return (is2D() &&  map1D2D == M12_pBar) ? virtualWidth() : 1;
+    #else
+      return 1;
+    #endif
+    }
   #ifndef WLED_DISABLE_2D
-    uint16_t XY(uint16_t x, uint16_t y); // support function to get relative index within segment
-    void setPixelColorXY(int x, int y, uint32_t c); // set relative pixel within segment with color
+    [[gnu::hot]] uint16_t XY(int x, int y);      // support function to get relative index within segment
+    [[gnu::hot]] void setPixelColorXY(int x, int y, uint32_t c); // set relative pixel within segment with color
     inline void setPixelColorXY(unsigned x, unsigned y, uint32_t c)               { setPixelColorXY(int(x), int(y), c); }
     inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColorXY(x, y, RGBW32(r,g,b,w)); }
     inline void setPixelColorXY(int x, int y, CRGB c)                             { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0)); }
@@ -628,7 +640,7 @@ typedef struct Segment {
     inline void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColorXY(x, y, RGBW32(r,g,b,w), aa); }
     inline void setPixelColorXY(float x, float y, CRGB c, bool aa = true)                             { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0), aa); }
     #endif
-    uint32_t getPixelColorXY(int x, int y) const;
+    [[gnu::hot]] uint32_t getPixelColorXY(int x, int y) const;
     // 2D support functions
     inline void blendPixelColorXY(uint16_t x, uint16_t y, uint32_t color, uint8_t blend) { setPixelColorXY(x, y, color_blend(getPixelColorXY(x,y), color, blend)); }
     inline void blendPixelColorXY(uint16_t x, uint16_t y, CRGB c, uint8_t blend)         { blendPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0), blend); }
@@ -697,8 +709,8 @@ typedef struct Segment {
 
 // main "strip" class
 class WS2812FX {  // 96 bytes
-  typedef uint16_t (*mode_ptr)(void); // pointer to mode function
-  typedef void (*show_callback)(void); // pre show callback
+  typedef uint16_t (*mode_ptr)(); // pointer to mode function
+  typedef void (*show_callback)(); // pre show callback
   typedef struct ModeData {
     uint8_t     _id;   // mode (effect) id
     mode_ptr    _fcn;  // mode (effect) function
@@ -720,7 +732,11 @@ class WS2812FX {  // 96 bytes
 #ifndef WLED_DISABLE_2D
       panels(1),
 #endif
+#ifdef WLED_AUTOSEGMENTS
+      autoSegments(true),
+#else
       autoSegments(false),
+#endif
       correctWB(false),
       cctFromRgb(false),
       // semi-private (just obscured) used in effect functions through macros
@@ -733,7 +749,7 @@ class WS2812FX {  // 96 bytes
       _transitionDur(750),
       _targetFps(WLED_FPS),
       _frametime(FRAMETIME_FIXED),
-      _cumulativeFps(2),
+      _cumulativeFps(50 << FPS_CALC_SHIFT),
       _isServicing(false),
       _isOffRefreshRequired(false),
       _hasWhiteChannel(false),
@@ -743,6 +759,7 @@ class WS2812FX {  // 96 bytes
       customMappingTable(nullptr),
       customMappingSize(0),
       _lastShow(0),
+      _lastServiceShow(0),
       _segment_index(0),
       _mainSegment(0)
     {
@@ -764,104 +781,103 @@ class WS2812FX {  // 96 bytes
       customPalettes.clear();
     }
 
-    static WS2812FX* getInstance(void) { return instance; }
+    static WS2812FX* getInstance() { return instance; }
 
     void
 #ifdef WLED_DEBUG
       printSize(),                                // prints memory usage for strip components
 #endif
       finalizeInit(),                             // initialises strip components
-      service(void),                              // executes effect functions when due and calls strip.show()
+      service(),                                  // executes effect functions when due and calls strip.show()
       setMode(uint8_t segid, uint8_t m),          // sets effect/mode for given segment (high level API)
       setColor(uint8_t slot, uint32_t c),         // sets color (in slot) for given segment (high level API)
       setCCT(uint16_t k),                         // sets global CCT (either in relative 0-255 value or in K)
       setBrightness(uint8_t b, bool direct = false),    // sets strip brightness
       setRange(uint16_t i, uint16_t i2, uint32_t col),  // used for clock overlay
-      purgeSegments(void),                        // removes inactive segments from RAM (may incure penalty and memory fragmentation but reduces vector footprint)
+      purgeSegments(),                            // removes inactive segments from RAM (may incure penalty and memory fragmentation but reduces vector footprint)
       setSegment(uint8_t n, uint16_t start, uint16_t stop, uint8_t grouping = 1, uint8_t spacing = 0, uint16_t offset = UINT16_MAX, uint16_t startY=0, uint16_t stopY=1),
       setMainSegmentId(uint8_t n),
       resetSegments(),                            // marks all segments for reset
       makeAutoSegments(bool forceReset = false),  // will create segments based on configured outputs
       fixInvalidSegments(),                       // fixes incorrect segment configuration
       setPixelColor(unsigned n, uint32_t c),      // paints absolute strip pixel with index n and color c
-      show(void),                                 // initiates LED output
+      show(),                                     // initiates LED output
       setTargetFps(uint8_t fps),
-      setupEffectData(void);                      // add default effects to the list; defined in FX.cpp
+      setupEffectData();                          // add default effects to the list; defined in FX.cpp
 
-    inline void restartRuntime()          { for (Segment &seg : _segments) seg.markForReset(); }
+    inline void resetTimebase()           { timebase = 0UL - millis(); }
+    inline void restartRuntime()          { for (Segment &seg : _segments) { seg.markForReset().resetIfRequired(); } }
     inline void setTransitionMode(bool t) { for (Segment &seg : _segments) seg.startTransition(t ? _transitionDur : 0); }
     inline void setColor(uint8_t slot, uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0)    { setColor(slot, RGBW32(r,g,b,w)); }
     inline void setPixelColor(unsigned n, uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { setPixelColor(n, RGBW32(r,g,b,w)); }
     inline void setPixelColor(unsigned n, CRGB c)                                         { setPixelColor(n, c.red, c.green, c.blue); }
     inline void fill(uint32_t c)          { for (unsigned i = 0; i < getLengthTotal(); i++) setPixelColor(i, c); } // fill whole strip with color (inline)
-    inline void trigger(void)                                 { _triggered = true; }  // Forces the next frame to be computed on all active segments.
+    inline void trigger()                                     { _triggered = true; }  // Forces the next frame to be computed on all active segments.
     inline void setShowCallback(show_callback cb)             { _callback = cb; }
     inline void setTransition(uint16_t t)                     { _transitionDur = t; } // sets transition time (in ms)
     inline void appendSegment(const Segment &seg = Segment()) { if (_segments.size() < getMaxSegments()) _segments.push_back(seg); }
-    inline void suspend(void)                                 { _suspend = true; }    // will suspend (and canacel) strip.service() execution
-    inline void resume(void)                                  { _suspend = false; }   // will resume strip.service() execution
+    inline void suspend()                                     { _suspend = true; }    // will suspend (and canacel) strip.service() execution
+    inline void resume()                                      { _suspend = false; }   // will resume strip.service() execution
 
     bool
       paletteFade,
-      checkSegmentAlignment(void),
-      hasRGBWBus(void) const,
-      hasCCTBus(void) const,
-      isUpdating(void) const, // return true if the strip is being sent pixel updates
+      checkSegmentAlignment(),
+      hasRGBWBus() const,
+      hasCCTBus() const,
+      isUpdating() const, // return true if the strip is being sent pixel updates
       deserializeMap(uint8_t n=0);
 
-    inline bool isServicing(void) const          { return _isServicing; }           // returns true if strip.service() is executing
-    inline bool hasWhiteChannel(void) const      { return _hasWhiteChannel; }       // returns true if strip contains separate white chanel
-    inline bool isOffRefreshRequired(void) const { return _isOffRefreshRequired; }  // returns true if strip requires regular updates (i.e. TM1814 chipset)
-    inline bool isSuspended(void) const          { return _suspend; }               // returns true if strip.service() execution is suspended
-    inline bool needsUpdate(void) const          { return _triggered; }             // returns true if strip received a trigger() request
+    inline bool isServicing() const          { return _isServicing; }           // returns true if strip.service() is executing
+    inline bool hasWhiteChannel() const      { return _hasWhiteChannel; }       // returns true if strip contains separate white chanel
+    inline bool isOffRefreshRequired() const { return _isOffRefreshRequired; }  // returns true if strip requires regular updates (i.e. TM1814 chipset)
+    inline bool isSuspended() const          { return _suspend; }               // returns true if strip.service() execution is suspended
+    inline bool needsUpdate() const          { return _triggered; }             // returns true if strip received a trigger() request
 
     uint8_t
       paletteBlend,
       cctBlending,
-      getActiveSegmentsNum(void) const,
-      getFirstSelectedSegId(void) const,
-      getLastActiveSegmentId(void) const,
+      getActiveSegmentsNum() const,
+      getFirstSelectedSegId() const,
+      getLastActiveSegmentId() const,
       getActiveSegsLightCapabilities(bool selectedOnly = false) const,
       addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name);         // add effect to the list; defined in FX.cpp;
 
-    inline uint8_t getBrightness(void) const    { return _brightness; }       // returns current strip brightness
-    inline uint8_t getMaxSegments(void) const   { return MAX_NUM_SEGMENTS; }  // returns maximum number of supported segments (fixed value)
-    inline uint8_t getSegmentsNum(void) const   { return _segments.size(); }  // returns currently present segments
-    inline uint8_t getCurrSegmentId(void) const { return _segment_index; }    // returns current segment index (only valid while strip.isServicing())
-    inline uint8_t getMainSegmentId(void) const { return _mainSegment; }      // returns main segment index
-    inline uint8_t getPaletteCount() const      { return 13 + GRADIENT_PALETTE_COUNT + customPalettes.size(); }
-    inline uint8_t getTargetFps() const         { return _targetFps; }        // returns rough FPS value for las 2s interval
-    inline uint8_t getModeCount() const         { return _modeCount; }        // returns number of registered modes/effects
+    inline uint8_t getBrightness() const    { return _brightness; }       // returns current strip brightness
+    inline uint8_t getMaxSegments() const   { return MAX_NUM_SEGMENTS; }  // returns maximum number of supported segments (fixed value)
+    inline uint8_t getSegmentsNum() const   { return _segments.size(); }  // returns currently present segments
+    inline uint8_t getCurrSegmentId() const { return _segment_index; }    // returns current segment index (only valid while strip.isServicing())
+    inline uint8_t getMainSegmentId() const { return _mainSegment; }      // returns main segment index
+    inline uint8_t getPaletteCount() const  { return 13 + GRADIENT_PALETTE_COUNT + customPalettes.size(); }
+    inline uint8_t getTargetFps() const     { return _targetFps; }        // returns rough FPS value for las 2s interval
+    inline uint8_t getModeCount() const     { return _modeCount; }        // returns number of registered modes/effects
 
     uint16_t
-      getLengthPhysical(void) const,
-      getLengthTotal(void) const, // will include virtual/nonexistent pixels in matrix
+      getLengthPhysical() const,
+      getLengthTotal() const, // will include virtual/nonexistent pixels in matrix
       getFps() const,
       getMappedPixelIndex(uint16_t index) const;
 
-    inline uint16_t getFrameTime(void) const    { return _frametime; }        // returns amount of time a frame should take (in ms)
-    inline uint16_t getMinShowDelay(void) const { return MIN_SHOW_DELAY; }    // returns minimum amount of time strip.service() can be delayed (constant)
-    inline uint16_t getLength(void) const       { return _length; }           // returns actual amount of LEDs on a strip (2D matrix may have less LEDs than W*H)
-    inline uint16_t getTransition(void) const   { return _transitionDur; }    // returns currently set transition time (in ms)
+    inline uint16_t getFrameTime() const    { return _frametime; }        // returns amount of time a frame should take (in ms)
+    inline uint16_t getMinShowDelay() const { return MIN_FRAME_DELAY; }   // returns minimum amount of time strip.service() can be delayed (constant)
+    inline uint16_t getLength() const       { return _length; }           // returns actual amount of LEDs on a strip (2D matrix may have less LEDs than W*H)
+    inline uint16_t getTransition() const   { return _transitionDur; }    // returns currently set transition time (in ms)
 
-    uint32_t
-      now,
-      timebase,
-      getPixelColor(uint16_t) const;
+    unsigned long now, timebase;
+    uint32_t getPixelColor(unsigned) const;
 
-    inline uint32_t getLastShow(void) const   { return _lastShow; }           // returns millis() timestamp of last strip.show() call
+    inline uint32_t getLastShow() const       { return _lastShow; }           // returns millis() timestamp of last strip.show() call
     inline uint32_t segColor(uint8_t i) const { return _colors_t[i]; }        // returns currently valid color (for slot i) AKA SEGCOLOR(); may be blended between two colors while in transition
 
     const char *
       getModeData(uint8_t id = 0) const { return (id && id<_modeCount) ? _modeData[id] : PSTR("Solid"); }
 
     const char **
-      getModeDataSrc(void) { return &(_modeData[0]); } // vectors use arrays for underlying data
+      getModeDataSrc() { return &(_modeData[0]); } // vectors use arrays for underlying data
 
     Segment&        getSegment(uint8_t id);
-    inline Segment& getFirstSelectedSeg(void) { return _segments[getFirstSelectedSegId()]; }  // returns reference to first segment that is "selected"
-    inline Segment& getMainSegment(void)      { return _segments[getMainSegmentId()]; }       // returns reference to main segment
-    inline Segment* getSegments(void)         { return &(_segments[0]); }                     // returns pointer to segment vector structure (warning: use carefully)
+    inline Segment& getFirstSelectedSeg() { return _segments[getFirstSelectedSegId()]; }  // returns reference to first segment that is "selected"
+    inline Segment& getMainSegment()      { return _segments[getMainSegmentId()]; }       // returns reference to main segment
+    inline Segment* getSegments()         { return &(_segments[0]); }                     // returns pointer to segment vector structure (warning: use carefully)
 
   // 2D support (panels)
     bool
@@ -908,7 +924,7 @@ class WS2812FX {  // 96 bytes
 
   // end 2D support
 
-    void loadCustomPalettes(void); // loads custom palettes from JSON
+    void loadCustomPalettes(); // loads custom palettes from JSON
     std::vector<CRGBPalette16> customPalettes; // TODO: move custom palettes out of WS2812FX class
 
     struct {
@@ -954,6 +970,7 @@ class WS2812FX {  // 96 bytes
     uint16_t  customMappingSize;
 
     unsigned long _lastShow;
+    unsigned long _lastServiceShow;
 
     uint8_t _segment_index;
     uint8_t _mainSegment;

wled00/FX_2Dfcn.cpp

@@ -1,24 +1,9 @@
 /*
   FX_2Dfcn.cpp contains all 2D utility functions
 
-  LICENSE
-  The MIT License (MIT)
   Copyright (c) 2022  Blaz Kristan (https://blaz.at/home)
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  Licensed under the EUPL v. 1.2 or later
+  Adapted from code originally licensed under the MIT license
 
   Parts of the code adapted from WLED Sound Reactive
 */
@@ -161,7 +146,7 @@ void WS2812FX::setUpMatrix() {
 #ifndef WLED_DISABLE_2D
 
 // XY(x,y) - gets pixel index within current segment (often used to reference leds[] array element)
-uint16_t IRAM_ATTR_YN Segment::XY(uint16_t x, uint16_t y)
+uint16_t IRAM_ATTR_YN Segment::XY(int x, int y)
 {
   unsigned width  = virtualWidth();   // segment width in logical pixels (can be 0 if segment is inactive)
   unsigned height = virtualHeight();  // segment height in logical pixels (is always >= 1)
@@ -171,7 +156,7 @@ uint16_t IRAM_ATTR_YN Segment::XY(uint16_t x, uint16_t y)
 void IRAM_ATTR_YN Segment::setPixelColorXY(int x, int y, uint32_t col)
 {
   if (!isActive()) return; // not active
-  if (x >= virtualWidth() || y >= virtualHeight() || x<0 || y<0) return;  // if pixel would fall out of virtual segment just exit
+  if ((unsigned)x >= virtualWidth() || (unsigned)y >= virtualHeight() || x<0 || y<0) return;  // if pixel would fall out of virtual segment just exit
 
   uint8_t _bri_t = currentBri();
   if (_bri_t < 255) {
@@ -266,7 +251,7 @@ void Segment::setPixelColorXY(float x, float y, uint32_t col, bool aa)
 // returns RGBW values of pixel
 uint32_t IRAM_ATTR_YN Segment::getPixelColorXY(int x, int y) const {
   if (!isActive()) return 0; // not active
-  if (x >= virtualWidth() || y >= virtualHeight() || x<0 || y<0) return 0;  // if pixel would fall out of virtual segment just exit
+  if ((unsigned)x >= virtualWidth() || (unsigned)y >= virtualHeight() || x<0 || y<0) return 0;  // if pixel would fall out of virtual segment just exit
   if (reverse  ) x = virtualWidth()  - x - 1;
   if (reverse_y) y = virtualHeight() - y - 1;
   if (transpose) { std::swap(x,y); } // swap X & Y if segment transposed
@@ -704,11 +689,14 @@ void Segment::wu_pixel(uint32_t x, uint32_t y, CRGB c) {      //awesome wu_pixel
                    WU_WEIGHT(ix, yy), WU_WEIGHT(xx, yy)};
   // multiply the intensities by the colour, and saturating-add them to the pixels
   for (int i = 0; i < 4; i++) {
-    CRGB led = getPixelColorXY((x >> 8) + (i & 1), (y >> 8) + ((i >> 1) & 1));
+    int wu_x = (x >> 8) + (i & 1);        // precalculate x
+    int wu_y = (y >> 8) + ((i >> 1) & 1); // precalculate y
+    CRGB led = getPixelColorXY(wu_x, wu_y);
+    CRGB oldLed = led;
     led.r = qadd8(led.r, c.r * wu[i] >> 8);
     led.g = qadd8(led.g, c.g * wu[i] >> 8);
     led.b = qadd8(led.b, c.b * wu[i] >> 8);
-    setPixelColorXY(int((x >> 8) + (i & 1)), int((y >> 8) + ((i >> 1) & 1)), led);
+    if (led != oldLed) setPixelColorXY(wu_x, wu_y, led); // don't repaint if same color
   }
 }
 #undef WU_WEIGHT

wled00/FX_fcn.cpp

@@ -2,24 +2,10 @@
   WS2812FX_fcn.cpp contains all utility functions
   Harm Aldick - 2016
   www.aldick.org
-  LICENSE
-  The MIT License (MIT)
+
   Copyright (c) 2016  Harm Aldick
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  Licensed under the EUPL v. 1.2 or later
+  Adapted from code originally licensed under the MIT license
 
   Modified heavily for WLED
 */
@@ -43,21 +29,16 @@
   19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 29, 28, 27, 26, 25]}
 */
 
-//factory defaults LED setup
-//#define PIXEL_COUNTS 30, 30, 30, 30
-//#define DATA_PINS 16, 1, 3, 4
-//#define DEFAULT_LED_TYPE TYPE_WS2812_RGB
-
 #ifndef PIXEL_COUNTS
   #define PIXEL_COUNTS DEFAULT_LED_COUNT
 #endif
 
 #ifndef DATA_PINS
-  #define DATA_PINS LEDPIN
+  #define DATA_PINS DEFAULT_LED_PIN
 #endif
 
-#ifndef DEFAULT_LED_TYPE
-  #define DEFAULT_LED_TYPE TYPE_WS2812_RGB
+#ifndef LED_TYPES
+  #define LED_TYPES DEFAULT_LED_TYPE
 #endif
 
 #ifndef DEFAULT_LED_COLOR_ORDER
@@ -69,6 +50,18 @@
   #error "Max segments must be at least max number of busses!"
 #endif
 
+static constexpr unsigned sumPinsRequired(const unsigned* current, size_t count) {
+ return (count > 0) ? (Bus::getNumberOfPins(*current) + sumPinsRequired(current+1,count-1)) : 0;
+}
+
+static constexpr bool validatePinsAndTypes(const unsigned* types, unsigned numTypes, unsigned numPins ) {
+  // Pins provided < pins required -> always invalid
+  // Pins provided = pins required -> always valid
+  // Pins provided > pins required -> valid if excess pins are a product of last type pins since it will be repeated
+  return (sumPinsRequired(types, numTypes) > numPins) ? false :
+          (numPins - sumPinsRequired(types, numTypes)) % Bus::getNumberOfPins(types[numTypes-1]) == 0;
+}
+
 
 ///////////////////////////////////////////////////////////////////////////////
 // Segment class implementation
@@ -176,11 +169,7 @@ void IRAM_ATTR_YN Segment::deallocateData() {
   if ((Segment::getUsedSegmentData() > 0) && (_dataLen > 0)) { // check that we don't have a dangling / inconsistent data pointer
     free(data);
   } else {
-    DEBUG_PRINT(F("---- Released data "));
-    DEBUG_PRINTF_P(PSTR("(%p): "), this);
-    DEBUG_PRINT(F("inconsistent UsedSegmentData "));
-    DEBUG_PRINTF_P(PSTR("(%d/%d)"), _dataLen, Segment::getUsedSegmentData());
-    DEBUG_PRINTLN(F(", cowardly refusing to free nothing."));
+    DEBUG_PRINTF_P(PSTR("---- Released data (%p): inconsistent UsedSegmentData (%d/%d), cowardly refusing to free nothing.\n"), this, _dataLen, Segment::getUsedSegmentData());
   }
   data = nullptr;
   Segment::addUsedSegmentData(_dataLen <= Segment::getUsedSegmentData() ? -_dataLen : -Segment::getUsedSegmentData());
@@ -202,7 +191,7 @@ void Segment::resetIfRequired() {
   reset = false;
 }
 
-CRGBPalette16 IRAM_ATTR_YN &Segment::loadPalette(CRGBPalette16 &targetPalette, uint8_t pal) {
+CRGBPalette16 &Segment::loadPalette(CRGBPalette16 &targetPalette, uint8_t pal) {
   if (pal < 245 && pal > GRADIENT_PALETTE_COUNT+13) pal = 0;
   if (pal > 245 && (strip.customPalettes.size() == 0 || 255U-pal > strip.customPalettes.size()-1)) pal = 0; // TODO remove strip dependency by moving customPalettes out of strip
   //default palette. Differs depending on effect
@@ -417,7 +406,7 @@ uint8_t IRAM_ATTR Segment::currentBri(bool useCct) const {
   return (useCct ? cct : (on ? opacity : 0));
 }
 
-uint8_t IRAM_ATTR_YN Segment::currentMode() const {
+uint8_t Segment::currentMode() const {
 #ifndef WLED_DISABLE_MODE_BLEND
   unsigned prog = progress();
   if (modeBlending && prog < 0xFFFFU) return _t->_modeT;
@@ -449,37 +438,44 @@ void Segment::setCurrentPalette() {
 
 // relies on WS2812FX::service() to call it for each frame
 void Segment::handleRandomPalette() {
+  uint16_t time_ms = millis();
+  uint16_t time_s  = millis()/1000U;
   // is it time to generate a new palette?
-  if ((uint16_t)((uint16_t)(millis() / 1000U) - _lastPaletteChange) > randomPaletteChangeTime){
-        _newRandomPalette = useHarmonicRandomPalette ? generateHarmonicRandomPalette(_randomPalette) : generateRandomPalette();
-        _lastPaletteChange = (uint16_t)(millis() / 1000U);
-        _lastPaletteBlend = (uint16_t)((uint16_t)millis() - 512); // starts blending immediately   
+  if ((uint16_t)(time_s - _lastPaletteChange) > randomPaletteChangeTime) {
+    _newRandomPalette = useHarmonicRandomPalette ? generateHarmonicRandomPalette(_randomPalette) : generateRandomPalette();
+    _lastPaletteChange = time_s;
+    _lastPaletteBlend = time_ms - 512; // starts blending immediately
   }
 
   // if palette transitions is enabled, blend it according to Transition Time (if longer than minimum given by service calls)
   if (strip.paletteFade) {
     // assumes that 128 updates are sufficient to blend a palette, so shift by 7 (can be more, can be less)
     // in reality there need to be 255 blends to fully blend two entirely different palettes
-    if ((uint16_t)((uint16_t)millis() - _lastPaletteBlend) < strip.getTransition() >> 7) return; // not yet time to fade, delay the update
+    if ((uint16_t)(time_ms - _lastPaletteBlend) < strip.getTransition() >> 7) return; // not yet time to fade, delay the update
     _lastPaletteBlend = (uint16_t)millis();
   }
   nblendPaletteTowardPalette(_randomPalette, _newRandomPalette, 48);
 }
 
 // segId is given when called from network callback, changes are queued if that segment is currently in its effect function
-void Segment::setUp(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, uint16_t ofs, uint16_t i1Y, uint16_t i2Y) {
+void Segment::setGeometry(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, uint16_t ofs, uint16_t i1Y, uint16_t i2Y, uint8_t m12) {
   // return if neither bounds nor grouping have changed
   bool boundsUnchanged = (start == i1 && stop == i2);
   #ifndef WLED_DISABLE_2D
   if (Segment::maxHeight>1) boundsUnchanged &= (startY == i1Y && stopY == i2Y); // 2D
   #endif
+
+  m12 = constrain(m12, 0, 7);
+  if (stop && (spc > 0 || m12 != map1D2D)) fill(BLACK);
+  if (m12 != map1D2D) map1D2D = m12;
+/*
   if (boundsUnchanged
       && (!grp || (grouping == grp && spacing == spc))
-      && (ofs == UINT16_MAX || ofs == offset)) return;
-
+      && (m12 == map1D2D)
+     ) return;
+*/
   stateChanged = true; // send UDP/WS broadcast
 
-  if (stop) fill(BLACK); // turn old segment range off (clears pixels if changing spacing)
   if (grp) { // prevent assignment of 0
     grouping = grp;
     spacing = spc;
@@ -489,12 +485,9 @@ void Segment::setUp(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, uint16_t
   }
   if (ofs < UINT16_MAX) offset = ofs;
 
-  DEBUG_PRINT(F("setUp segment: ")); DEBUG_PRINT(i1);
-  DEBUG_PRINT(','); DEBUG_PRINT(i2);
-  DEBUG_PRINT(F(" -> ")); DEBUG_PRINT(i1Y);
-  DEBUG_PRINT(','); DEBUG_PRINTLN(i2Y);
-  markForReset();
+  DEBUG_PRINTF_P(PSTR("Segment geometry: %d,%d -> %d,%d\n"), (int)i1, (int)i2, (int)i1Y, (int)i2Y);
   if (boundsUnchanged) return;
+  markForReset();
 
   // apply change immediately
   if (i2 <= i1) { //disable segment
@@ -520,46 +513,53 @@ void Segment::setUp(uint16_t i1, uint16_t i2, uint8_t grp, uint8_t spc, uint16_t
 }
 
 
-bool Segment::setColor(uint8_t slot, uint32_t c) { //returns true if changed
-  if (slot >= NUM_COLORS || c == colors[slot]) return false;
+Segment &Segment::setColor(uint8_t slot, uint32_t c) {
+  if (slot >= NUM_COLORS || c == colors[slot]) return *this;
   if (!_isRGB && !_hasW) {
-    if (slot == 0 && c == BLACK) return false; // on/off segment cannot have primary color black
-    if (slot == 1 && c != BLACK) return false; // on/off segment cannot have secondary color non black
+    if (slot == 0 && c == BLACK) return *this; // on/off segment cannot have primary color black
+    if (slot == 1 && c != BLACK) return *this; // on/off segment cannot have secondary color non black
   }
   if (fadeTransition) startTransition(strip.getTransition()); // start transition prior to change
   colors[slot] = c;
   stateChanged = true; // send UDP/WS broadcast
-  return true;
+  return *this;
 }
 
-void Segment::setCCT(uint16_t k) {
+Segment &Segment::setCCT(uint16_t k) {
   if (k > 255) { //kelvin value, convert to 0-255
     if (k < 1900)  k = 1900;
     if (k > 10091) k = 10091;
     k = (k - 1900) >> 5;
   }
-  if (cct == k) return;
-  if (fadeTransition) startTransition(strip.getTransition()); // start transition prior to change
-  cct = k;
-  stateChanged = true; // send UDP/WS broadcast
+  if (cct != k) {
+    //DEBUGFX_PRINTF_P(PSTR("- Starting CCT transition: %d\n"), k);
+    startTransition(strip.getTransition()); // start transition prior to change
+    cct = k;
+    stateChanged = true; // send UDP/WS broadcast
+  }
+  return *this;
 }
 
-void Segment::setOpacity(uint8_t o) {
-  if (opacity == o) return;
-  if (fadeTransition) startTransition(strip.getTransition()); // start transition prior to change
-  opacity = o;
-  stateChanged = true; // send UDP/WS broadcast
+Segment &Segment::setOpacity(uint8_t o) {
+  if (opacity != o) {
+    //DEBUGFX_PRINTF_P(PSTR("- Starting opacity transition: %d\n"), o);
+    startTransition(strip.getTransition()); // start transition prior to change
+    opacity = o;
+    stateChanged = true; // send UDP/WS broadcast
+  }
+  return *this;
 }
 
-void Segment::setOption(uint8_t n, bool val) {
+Segment &Segment::setOption(uint8_t n, bool val) {
   bool prevOn = on;
   if (fadeTransition && n == SEG_OPTION_ON && val != prevOn) startTransition(strip.getTransition()); // start transition prior to change
   if (val) options |=   0x01 << n;
   else     options &= ~(0x01 << n);
   if (!(n == SEG_OPTION_SELECTED || n == SEG_OPTION_RESET)) stateChanged = true; // send UDP/WS broadcast
+  return *this;
 }
 
-void Segment::setMode(uint8_t fx, bool loadDefaults) {
+Segment &Segment::setMode(uint8_t fx, bool loadDefaults) {
   // skip reserved
   while (fx < strip.getModeCount() && strncmp_P("RSVD", strip.getModeData(fx), 4) == 0) fx++;
   if (fx >= strip.getModeCount()) fx = 0; // set solid mode
@@ -591,9 +591,10 @@ void Segment::setMode(uint8_t fx, bool loadDefaults) {
     markForReset();
     stateChanged = true; // send UDP/WS broadcast
   }
+  return *this;
 }
 
-void Segment::setPalette(uint8_t pal) {
+Segment &Segment::setPalette(uint8_t pal) {
   if (pal < 245 && pal > GRADIENT_PALETTE_COUNT+13) pal = 0; // built in palettes
   if (pal > 245 && (strip.customPalettes.size() == 0 || 255U-pal > strip.customPalettes.size()-1)) pal = 0; // custom palettes
   if (pal != palette) {
@@ -601,37 +602,38 @@ void Segment::setPalette(uint8_t pal) {
     palette = pal;
     stateChanged = true; // send UDP/WS broadcast
   }
+  return *this;
+}
+
+Segment &Segment::setName(const char *newName) {
+  if (newName) {
+    const int newLen = min(strlen(newName), (size_t)WLED_MAX_SEGNAME_LEN);
+    if (newLen) {
+      if (name) name = static_cast<char*>(realloc(name, newLen+1));
+      else      name = static_cast<char*>(malloc(newLen+1));
+      if (name) strlcpy(name, newName, newLen+1);
+      name[newLen] = 0;
+      return *this;
+    }
+  }
+  return clearName();
 }
 
 // 2D matrix
-uint16_t IRAM_ATTR Segment::virtualWidth() const {
+unsigned IRAM_ATTR Segment::virtualWidth() const {
   unsigned groupLen = groupLength();
   unsigned vWidth = ((transpose ? height() : width()) + groupLen - 1) / groupLen;
   if (mirror) vWidth = (vWidth + 1) /2;  // divide by 2 if mirror, leave at least a single LED
   return vWidth;
 }
 
-uint16_t IRAM_ATTR Segment::virtualHeight() const {
+unsigned IRAM_ATTR Segment::virtualHeight() const {
   unsigned groupLen = groupLength();
   unsigned vHeight = ((transpose ? width() : height()) + groupLen - 1) / groupLen;
   if (mirror_y) vHeight = (vHeight + 1) /2;  // divide by 2 if mirror, leave at least a single LED
   return vHeight;
 }
 
-uint16_t IRAM_ATTR_YN Segment::nrOfVStrips() const {
-  unsigned vLen = 1;
-#ifndef WLED_DISABLE_2D
-  if (is2D()) {
-    switch (map1D2D) {
-      case M12_pBar:
-        vLen = virtualWidth();
-        break;
-    }
-  }
-#endif
-  return vLen;
-}
-
 // Constants for mapping mode "Pinwheel"
 #ifndef WLED_DISABLE_2D
 constexpr int Pinwheel_Steps_Small = 72;       // no holes up to 16x16
@@ -967,7 +969,7 @@ uint32_t IRAM_ATTR_YN Segment::getPixelColor(int i) const
   return strip.getPixelColor(i);
 }
 
-uint8_t Segment::differs(Segment& b) const {
+uint8_t Segment::differs(const Segment& b) const {
   uint8_t d = 0;
   if (start != b.start)         d |= SEG_DIFFERS_BOUNDS;
   if (stop != b.stop)           d |= SEG_DIFFERS_BOUNDS;
@@ -1027,7 +1029,6 @@ void Segment::refreshLightCapabilities() {
     if (bus->getStart() >= segStopIdx) continue;
     if (bus->getStart() + bus->getLength() <= segStartIdx) continue;
 
-    //uint8_t type = bus->getType();
     if (bus->hasRGB() || (strip.cctFromRgb && bus->hasCCT())) capabilities |= SEG_CAPABILITY_RGB;
     if (!strip.cctFromRgb && bus->hasCCT())                   capabilities |= SEG_CAPABILITY_CCT;
     if (strip.correctWB && (bus->hasRGB() || bus->hasCCT()))  capabilities |= SEG_CAPABILITY_CCT; //white balance correction (CCT slider)
@@ -1064,36 +1065,25 @@ void Segment::fade_out(uint8_t rate) {
   const int cols = is2D() ? virtualWidth() : virtualLength();
   const int rows = virtualHeight(); // will be 1 for 1D
 
-  rate = (255-rate) >> 1;
-  float mappedRate = 1.0f / (float(rate) + 1.1f);
-
-  uint32_t color = colors[1]; // SEGCOLOR(1); // target color
-  int w2 = W(color);
-  int r2 = R(color);
-  int g2 = G(color);
-  int b2 = B(color);
+  rate = (256-rate) >> 1;
+  const int mappedRate = 256 / (rate + 1);
 
   for (int y = 0; y < rows; y++) for (int x = 0; x < cols; x++) {
-    color = is2D() ? getPixelColorXY(x, y) : getPixelColor(x);
+    uint32_t color = is2D() ? getPixelColorXY(x, y) : getPixelColor(x);
     if (color == colors[1]) continue; // already at target color
-    int w1 = W(color);
-    int r1 = R(color);
-    int g1 = G(color);
-    int b1 = B(color);
-
-    int wdelta = (w2 - w1) * mappedRate;
-    int rdelta = (r2 - r1) * mappedRate;
-    int gdelta = (g2 - g1) * mappedRate;
-    int bdelta = (b2 - b1) * mappedRate;
-
-    // if fade isn't complete, make sure delta is at least 1 (fixes rounding issues)
-    wdelta += (w2 == w1) ? 0 : (w2 > w1) ? 1 : -1;
-    rdelta += (r2 == r1) ? 0 : (r2 > r1) ? 1 : -1;
-    gdelta += (g2 == g1) ? 0 : (g2 > g1) ? 1 : -1;
-    bdelta += (b2 == b1) ? 0 : (b2 > b1) ? 1 : -1;
-
-    if (is2D()) setPixelColorXY(x, y, r1 + rdelta, g1 + gdelta, b1 + bdelta, w1 + wdelta);
-    else        setPixelColor(x, r1 + rdelta, g1 + gdelta, b1 + bdelta, w1 + wdelta);
+    for (int i = 0; i < 32; i += 8) {
+      uint8_t c2 = (colors[1]>>i);  // get background channel
+      uint8_t c1 = (color>>i);      // get foreground channel
+      // we can't use bitshift since we are using int
+      int delta = (c2 - c1) * mappedRate / 256;
+      // if fade isn't complete, make sure delta is at least 1 (fixes rounding issues)
+      if (delta == 0) delta += (c2 == c1) ? 0 : (c2 > c1) ? 1 : -1;
+      // stuff new value back into color
+      color &= ~(0xFF<<i);
+      color |= ((c1 + delta) & 0xFF) << i;
+    }
+    if (is2D()) setPixelColorXY(x, y, color);
+    else        setPixelColor(x, color);
   }
 }
 
@@ -1197,12 +1187,9 @@ uint32_t Segment::color_from_palette(uint16_t i, bool mapping, bool wrap, uint8_
 ///////////////////////////////////////////////////////////////////////////////
 
 //do not call this method from system context (network callback)
-void WS2812FX::finalizeInit(void) {
+void WS2812FX::finalizeInit() {
   //reset segment runtimes
-  for (segment &seg : _segments) {
-    seg.markForReset();
-    seg.resetIfRequired();
-  }
+  restartRuntime();
 
   // for the lack of better place enumerate ledmaps here
   // if we do it in json.cpp (serializeInfo()) we are getting flashes on LEDs
@@ -1212,34 +1199,125 @@ void WS2812FX::finalizeInit(void) {
 
   _hasWhiteChannel = _isOffRefreshRequired = false;
 
+  unsigned digitalCount = 0;
+  #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3)
+  // determine if it is sensible to use parallel I2S outputs on ESP32 (i.e. more than 5 outputs = 1 I2S + 4 RMT)
+  unsigned maxLedsOnBus = 0;
+  unsigned busType = 0;
+  for (const auto &bus : busConfigs) {
+    if (Bus::isDigital(bus.type) && !Bus::is2Pin(bus.type)) {
+      digitalCount++;
+      if (busType == 0) busType = bus.type; // remember first bus type
+      if (busType != bus.type) {
+        DEBUG_PRINTF_P(PSTR("Mixed digital bus types detected! Forcing single I2S output.\n"));
+        useParallelI2S = false; // mixed bus types, no parallel I2S
+      }
+      if (bus.count > maxLedsOnBus) maxLedsOnBus = bus.count;
+    }
+  }
+  DEBUG_PRINTF_P(PSTR("Maximum LEDs on a bus: %u\nDigital buses: %u\n"), maxLedsOnBus, digitalCount);
+  // we may remove 600 LEDs per bus limit when NeoPixelBus is updated beyond 2.8.3
+  if (digitalCount > 1 && maxLedsOnBus <= 600 && useParallelI2S) BusManager::useParallelOutput(); // must call before creating buses
+  else useParallelI2S = false; // enforce single I2S
+  digitalCount = 0;
+  #endif
+
+  // create buses/outputs
+  unsigned mem = 0;
+  for (const auto &bus : busConfigs) {
+    mem += bus.memUsage(Bus::isDigital(bus.type) && !Bus::is2Pin(bus.type) ? digitalCount++ : 0); // includes global buffer
+    if (mem <= MAX_LED_MEMORY) {
+      if (BusManager::add(bus) == -1) break;
+    } else DEBUG_PRINTF_P(PSTR("Out of LED memory! Bus %d (%d) #%u not created."), (int)bus.type, (int)bus.count, digitalCount);
+  }
+  busConfigs.clear();
+  busConfigs.shrink_to_fit();
+
   //if busses failed to load, add default (fresh install, FS issue, ...)
   if (BusManager::getNumBusses() == 0) {
     DEBUG_PRINTLN(F("No busses, init default"));
-    const unsigned defDataPins[] = {DATA_PINS};
-    const unsigned defCounts[] = {PIXEL_COUNTS};
-    const unsigned defNumPins = ((sizeof defDataPins) / (sizeof defDataPins[0]));
-    const unsigned defNumCounts = ((sizeof defCounts) / (sizeof defCounts[0]));
-    // if number of pins is divisible by counts, use number of counts to determine number of buses, otherwise use pins
-    const unsigned defNumBusses = defNumPins > defNumCounts && defNumPins%defNumCounts == 0 ? defNumCounts : defNumPins;
-    const unsigned pinsPerBus = defNumPins / defNumBusses;
+    constexpr unsigned defDataTypes[] = {LED_TYPES};
+    constexpr unsigned defDataPins[] = {DATA_PINS};
+    constexpr unsigned defCounts[] = {PIXEL_COUNTS};
+    constexpr unsigned defNumTypes = ((sizeof defDataTypes) / (sizeof defDataTypes[0]));
+    constexpr unsigned defNumPins = ((sizeof defDataPins) / (sizeof defDataPins[0]));
+    constexpr unsigned defNumCounts = ((sizeof defCounts) / (sizeof defCounts[0]));
+
+    static_assert(validatePinsAndTypes(defDataTypes, defNumTypes, defNumPins),
+                  "The default pin list defined in DATA_PINS does not match the pin requirements for the default buses defined in LED_TYPES");
+    
     unsigned prevLen = 0;
-    for (unsigned i = 0; i < defNumBusses && i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) {
-      uint8_t defPin[5]; // max 5 pins
-      for (unsigned j = 0; j < pinsPerBus; j++) defPin[j] = defDataPins[i*pinsPerBus + j];
-      // when booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
-      // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), etc
-      if (pinManager.isPinAllocated(defPin[0])) {
-        defPin[0] = 1; // start with GPIO1 and work upwards
-        while (pinManager.isPinAllocated(defPin[0]) && defPin[0] < WLED_NUM_PINS) defPin[0]++;
+    unsigned pinsIndex = 0;
+    digitalCount = 0;
+    for (unsigned i = 0; i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) {
+      uint8_t defPin[OUTPUT_MAX_PINS];
+      // if we have less types than requested outputs and they do not align, use last known type to set current type
+      unsigned dataType = defDataTypes[(i < defNumTypes) ? i : defNumTypes -1];
+      unsigned busPins = Bus::getNumberOfPins(dataType);
+
+      // if we need more pins than available all outputs have been configured
+      if (pinsIndex + busPins > defNumPins) break;
+      
+      // Assign all pins first so we can check for conflicts on this bus
+      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) defPin[j] = defDataPins[pinsIndex + j];
+
+      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) {
+        bool validPin = true;
+        // When booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
+        // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
+        // Pin should not be already allocated, read/only or defined for current bus
+        while (PinManager::isPinAllocated(defPin[j]) || !PinManager::isPinOk(defPin[j],true)) {
+          if (validPin) {
+            DEBUG_PRINTLN(F("Some of the provided pins cannot be used to configure this LED output."));
+            defPin[j] = 1; // start with GPIO1 and work upwards
+            validPin = false;
+          } else if (defPin[j] < WLED_NUM_PINS) {
+            defPin[j]++;
+          } else {
+            DEBUG_PRINTLN(F("No available pins left! Can't configure output."));
+            return;
+          }
+          // is the newly assigned pin already defined or used previously?
+          // try next in line until there are no clashes or we run out of pins
+          bool clash;
+          do {
+            clash = false;
+            // check for conflicts on current bus
+            for (const auto &pin : defPin) {
+              if (&pin != &defPin[j] && pin == defPin[j]) {
+                clash = true;
+                break;
+              }
+            }
+            // We already have a clash on current bus, no point checking next buses
+            if (!clash) {
+              // check for conflicts in defined pins
+              for (const auto &pin : defDataPins) {
+                if (pin == defPin[j]) {
+                  clash = true;
+                  break;
+                }
+              }
+            }
+            if (clash) defPin[j]++;
+            if (defPin[j] >= WLED_NUM_PINS) break;
+          } while (clash);
+        }
       }
+      pinsIndex += busPins;
+
       unsigned start = prevLen;
       // if we have less counts than pins and they do not align, use last known count to set current count
       unsigned count = defCounts[(i < defNumCounts) ? i : defNumCounts -1];
+      // analog always has length 1
+      if (Bus::isPWM(dataType) || Bus::isOnOff(dataType)) count = 1;
       prevLen += count;
-      BusConfig defCfg = BusConfig(DEFAULT_LED_TYPE, defPin, start, count, DEFAULT_LED_COLOR_ORDER, false, 0, RGBW_MODE_MANUAL_ONLY, 0, useGlobalLedBuffer);
+      BusConfig defCfg = BusConfig(dataType, defPin, start, count, DEFAULT_LED_COLOR_ORDER, false, 0, RGBW_MODE_MANUAL_ONLY, 0, useGlobalLedBuffer);
+      mem += defCfg.memUsage(Bus::isDigital(dataType) && !Bus::is2Pin(dataType) ? digitalCount++ : 0);
       if (BusManager::add(defCfg) == -1) break;
     }
   }
+  DEBUG_PRINTF_P(PSTR("LED buffer size: %uB/%uB\n"), mem, BusManager::memUsage());
 
   _length = 0;
   for (int i=0; i<BusManager::getNumBusses(); i++) {
@@ -1249,18 +1327,14 @@ void WS2812FX::finalizeInit(void) {
     //RGBW mode is enabled if at least one of the strips is RGBW
     _hasWhiteChannel |= bus->hasWhite();
     //refresh is required to remain off if at least one of the strips requires the refresh.
-    _isOffRefreshRequired |= bus->isOffRefreshRequired();
+    _isOffRefreshRequired |= bus->isOffRefreshRequired() && !bus->isPWM(); // use refresh bit for phase shift with analog
     unsigned busEnd = bus->getStart() + bus->getLength();
     if (busEnd > _length) _length = busEnd;
-    #ifdef ESP8266
-    // why do we need to reinitialise GPIO3???
-    //if ((!IS_DIGITAL(bus->getType()) || IS_2PIN(bus->getType()))) continue;
-    //uint8_t pins[5];
-    //if (!bus->getPins(pins)) continue;
-    //BusDigital* bd = static_cast<BusDigital*>(bus);
-    //if (pins[0] == 3) bd->reinit();
-    #endif
+
+    // This must be done after all buses have been created, as some kinds (parallel I2S) interact
+    bus->begin();
   }
+  DEBUG_PRINTF_P(PSTR("Heap after buses: %d\n"), ESP.getFreeHeap());
 
   Segment::maxWidth  = _length;
   Segment::maxHeight = 1;
@@ -1275,14 +1349,21 @@ void WS2812FX::finalizeInit(void) {
 void WS2812FX::service() {
   unsigned long nowUp = millis(); // Be aware, millis() rolls over every 49 days
   now = nowUp + timebase;
-  if (nowUp - _lastShow < MIN_SHOW_DELAY || _suspend) return;
+  if (_suspend) return;
+  unsigned long elapsed = nowUp - _lastServiceShow;
+
+  if (elapsed <= MIN_FRAME_DELAY) return;                                        // keep wifi alive - no matter if triggered or unlimited
+  if ( !_triggered && (_targetFps != FPS_UNLIMITED)) {                           // unlimited mode = no frametime
+    if (elapsed < _frametime) return;                                            // too early for service
+  }
+
   bool doShow = false;
 
   _isServicing = true;
   _segment_index = 0;
 
   for (segment &seg : _segments) {
-    if (_suspend) return; // immediately stop processing segments if suspend requested during service()
+    if (_suspend) break; // immediately stop processing segments if suspend requested during service()
 
     // process transition (mode changes in the middle of transition)
     seg.handleTransition();
@@ -1292,10 +1373,10 @@ void WS2812FX::service() {
     if (!seg.isActive()) continue;
 
     // last condition ensures all solid segments are updated at the same time
-    if (nowUp > seg.next_time || _triggered || (doShow && seg.mode == FX_MODE_STATIC))
+    if (nowUp >= seg.next_time || _triggered || (doShow && seg.mode == FX_MODE_STATIC))
     {
       doShow = true;
-      unsigned delay = FRAMETIME;
+      unsigned frameDelay = FRAMETIME;
 
       if (!seg.freeze) { //only run effect function if not frozen
         int oldCCT = BusManager::getSegmentCCT(); // store original CCT value (actually it is not Segment based)
@@ -1315,7 +1396,7 @@ void WS2812FX::service() {
         // overwritten by later effect. To enable seamless blending for every effect, additional LED buffer
         // would need to be allocated for each effect and then blended together for each pixel.
         [[maybe_unused]] uint8_t tmpMode = seg.currentMode();  // this will return old mode while in transition
-        delay = (*_mode[seg.mode])();         // run new/current mode
+        frameDelay = (*_mode[seg.mode])();         // run new/current mode
 #ifndef WLED_DISABLE_MODE_BLEND
         if (modeBlending && seg.mode != tmpMode) {
           Segment::tmpsegd_t _tmpSegData;
@@ -1324,16 +1405,16 @@ void WS2812FX::service() {
           _virtualSegmentLength = seg.virtualLength(); // update SEGLEN (mapping may have changed)
           unsigned d2 = (*_mode[tmpMode])();  // run old mode
           seg.restoreSegenv(_tmpSegData);     // restore mode state (will also update transitional state)
-          delay = MIN(delay,d2);              // use shortest delay
+          frameDelay = min(frameDelay,d2);              // use shortest delay
           Segment::modeBlend(false);          // unset semaphore
         }
 #endif
         seg.call++;
-        if (seg.isInTransition() && delay > FRAMETIME) delay = FRAMETIME; // force faster updates during transition
+        if (seg.isInTransition() && frameDelay > FRAMETIME) frameDelay = FRAMETIME; // force faster updates during transition
         BusManager::setSegmentCCT(oldCCT); // restore old CCT for ABL adjustments
       }
 
-      seg.next_time = nowUp + delay;
+      seg.next_time = nowUp + frameDelay;
     }
     _segment_index++;
   }
@@ -1342,15 +1423,16 @@ void WS2812FX::service() {
   _triggered = false;
 
   #ifdef WLED_DEBUG
-  if (millis() - nowUp > _frametime) DEBUG_PRINTF_P(PSTR("Slow effects %u/%d.\n"), (unsigned)(millis()-nowUp), (int)_frametime);
+  if ((_targetFps != FPS_UNLIMITED) && (millis() - nowUp > _frametime)) DEBUG_PRINTF_P(PSTR("Slow effects %u/%d.\n"), (unsigned)(millis()-nowUp), (int)_frametime);
   #endif
   if (doShow) {
     yield();
     Segment::handleRandomPalette(); // slowly transition random palette; move it into for loop when each segment has individual random palette
-    show();
+    _lastServiceShow = nowUp; // update timestamp, for precise FPS control
+    if (!_suspend) show();
   }
   #ifdef WLED_DEBUG
-  if (millis() - nowUp > _frametime) DEBUG_PRINTF_P(PSTR("Slow strip %u/%d.\n"), (unsigned)(millis()-nowUp), (int)_frametime);
+  if ((_targetFps != FPS_UNLIMITED) && (millis() - nowUp > _frametime)) DEBUG_PRINTF_P(PSTR("Slow strip %u/%d.\n"), (unsigned)(millis()-nowUp), (int)_frametime);
   #endif
 }
 
@@ -1360,28 +1442,30 @@ void IRAM_ATTR WS2812FX::setPixelColor(unsigned i, uint32_t col) {
   BusManager::setPixelColor(i, col);
 }
 
-uint32_t IRAM_ATTR WS2812FX::getPixelColor(uint16_t i) const {
+uint32_t IRAM_ATTR WS2812FX::getPixelColor(unsigned i) const {
   i = getMappedPixelIndex(i);
   if (i >= _length) return 0;
   return BusManager::getPixelColor(i);
 }
 
-void WS2812FX::show(void) {
+void WS2812FX::show() {
   // avoid race condition, capture _callback value
   show_callback callback = _callback;
   if (callback) callback();
+  unsigned long showNow = millis();
 
   // some buses send asynchronously and this method will return before
   // all of the data has been sent.
   // See https://github.com/Makuna/NeoPixelBus/wiki/ESP32-NeoMethods#neoesp32rmt-methods
   BusManager::show();
 
-  unsigned long showNow = millis();
   size_t diff = showNow - _lastShow;
-  size_t fpsCurr = 200;
-  if (diff > 0) fpsCurr = 1000 / diff;
-  _cumulativeFps = (3 * _cumulativeFps + fpsCurr +2) >> 2;   // "+2" for proper rounding (2/4 = 0.5)
-  _lastShow = showNow;
+
+  if (diff > 0) { // skip calculation if no time has passed
+    size_t fpsCurr = (1000 << FPS_CALC_SHIFT) / diff; // fixed point math
+    _cumulativeFps = (FPS_CALC_AVG * _cumulativeFps + fpsCurr + FPS_CALC_AVG / 2) / (FPS_CALC_AVG + 1);   // "+FPS_CALC_AVG/2" for proper rounding
+    _lastShow = showNow;
+  }
 }
 
 /**
@@ -1398,12 +1482,13 @@ bool WS2812FX::isUpdating() const {
  */
 uint16_t WS2812FX::getFps() const {
   if (millis() - _lastShow > 2000) return 0;
-  return _cumulativeFps +1;
+  return (FPS_MULTIPLIER * _cumulativeFps) >> FPS_CALC_SHIFT; // _cumulativeFps is stored in fixed point
 }
 
 void WS2812FX::setTargetFps(uint8_t fps) {
-  if (fps > 0 && fps <= 120) _targetFps = fps;
-  _frametime = 1000 / _targetFps;
+  if (fps <= 250) _targetFps = fps;
+  if (_targetFps > 0) _frametime = 1000 / _targetFps;
+  else _frametime = MIN_FRAME_DELAY;     // unlimited mode
 }
 
 void WS2812FX::setMode(uint8_t segid, uint8_t m) {
@@ -1451,7 +1536,7 @@ void WS2812FX::setBrightness(uint8_t b, bool direct) {
   BusManager::setBrightness(b);
   if (!direct) {
     unsigned long t = millis();
-    if (_segments[0].next_time > t + 22 && t - _lastShow > MIN_SHOW_DELAY) trigger(); //apply brightness change immediately if no refresh soon
+    if (_segments[0].next_time > t + 22 && t - _lastShow > MIN_FRAME_DELAY) trigger(); //apply brightness change immediately if no refresh soon
   }
 }
 
@@ -1463,7 +1548,7 @@ uint8_t WS2812FX::getActiveSegsLightCapabilities(bool selectedOnly) const {
   return totalLC;
 }
 
-uint8_t WS2812FX::getFirstSelectedSegId(void) const {
+uint8_t WS2812FX::getFirstSelectedSegId() const {
   size_t i = 0;
   for (const segment &seg : _segments) {
     if (seg.isActive() && seg.isSelected()) return i;
@@ -1481,14 +1566,14 @@ void WS2812FX::setMainSegmentId(uint8_t n) {
   return;
 }
 
-uint8_t WS2812FX::getLastActiveSegmentId(void) const {
+uint8_t WS2812FX::getLastActiveSegmentId() const {
   for (size_t i = _segments.size() -1; i > 0; i--) {
     if (_segments[i].isActive()) return i;
   }
   return 0;
 }
 
-uint8_t WS2812FX::getActiveSegmentsNum(void) const {
+uint8_t WS2812FX::getActiveSegmentsNum() const {
   uint8_t c = 0;
   for (size_t i = 0; i < _segments.size(); i++) {
     if (_segments[i].isActive()) c++;
@@ -1496,17 +1581,17 @@ uint8_t WS2812FX::getActiveSegmentsNum(void) const {
   return c;
 }
 
-uint16_t WS2812FX::getLengthTotal(void) const {
+uint16_t WS2812FX::getLengthTotal() const {
   unsigned len = Segment::maxWidth * Segment::maxHeight; // will be _length for 1D (see finalizeInit()) but should cover whole matrix for 2D
   if (isMatrix && _length > len) len = _length; // for 2D with trailing strip
   return len;
 }
 
-uint16_t WS2812FX::getLengthPhysical(void) const {
+uint16_t WS2812FX::getLengthPhysical() const {
   unsigned len = 0;
   for (size_t b = 0; b < BusManager::getNumBusses(); b++) {
     Bus *bus = BusManager::getBus(b);
-    if (bus->getType() >= TYPE_NET_DDP_RGB) continue; //exclude non-physical network busses
+    if (bus->isVirtual()) continue; //exclude non-physical network busses
     len += bus->getLength();
   }
   return len;
@@ -1515,7 +1600,7 @@ uint16_t WS2812FX::getLengthPhysical(void) const {
 //used for JSON API info.leds.rgbw. Little practical use, deprecate with info.leds.rgbw.
 //returns if there is an RGBW bus (supports RGB and White, not only white)
 //not influenced by auto-white mode, also true if white slider does not affect output white channel
-bool WS2812FX::hasRGBWBus(void) const {
+bool WS2812FX::hasRGBWBus() const {
   for (size_t b = 0; b < BusManager::getNumBusses(); b++) {
     Bus *bus = BusManager::getBus(b);
     if (bus == nullptr || bus->getLength()==0) break;
@@ -1524,7 +1609,7 @@ bool WS2812FX::hasRGBWBus(void) const {
   return false;
 }
 
-bool WS2812FX::hasCCTBus(void) const {
+bool WS2812FX::hasCCTBus() const {
   if (cctFromRgb && !correctWB) return false;
   for (size_t b = 0; b < BusManager::getNumBusses(); b++) {
     Bus *bus = BusManager::getBus(b);
@@ -1561,7 +1646,7 @@ void WS2812FX::setSegment(uint8_t segId, uint16_t i1, uint16_t i2, uint8_t group
     segId = getSegmentsNum()-1; // segments are added at the end of list
   }
   suspend();
-  _segments[segId].setUp(i1, i2, grouping, spacing, offset, startY, stopY);
+  _segments[segId].setGeometry(i1, i2, grouping, spacing, offset, startY, stopY);
   resume();
   if (segId > 0 && segId == getSegmentsNum()-1 && i2 <= i1) _segments.pop_back(); // if last segment was deleted remove it from vector
 }

wled00/bus_manager.h

@@ -1,3 +1,4 @@
+#pragma once
 #ifndef BusManager_h
 #define BusManager_h
 
@@ -6,6 +7,31 @@
  */
 
 #include "const.h"
+#include <vector>
+#include <memory>
+
+// enable additional debug output
+#if defined(WLED_DEBUG_HOST)
+  #include "net_debug.h"
+  #define DEBUGOUT NetDebug
+#else
+  #define DEBUGOUT Serial
+#endif
+
+#ifdef WLED_DEBUG_BUS
+  #ifndef ESP8266
+  #include <rom/rtc.h>
+  #endif
+  #define DEBUGBUS_PRINT(x) DEBUGOUT.print(x)
+  #define DEBUGBUS_PRINTLN(x) DEBUGOUT.println(x)
+  #define DEBUGBUS_PRINTF(x...) DEBUGOUT.printf(x)
+  #define DEBUGBUS_PRINTF_P(x...) DEBUGOUT.printf_P(x)
+#else
+  #define DEBUGBUS_PRINT(x)
+  #define DEBUGBUS_PRINTLN(x)
+  #define DEBUGBUS_PRINTF(x...)
+  #define DEBUGBUS_PRINTF_P(x...)
+#endif
 
 //colors.cpp
 uint16_t approximateKelvinFromRGB(uint32_t rgb);
@@ -21,6 +47,304 @@ uint16_t approximateKelvinFromRGB(uint32_t rgb);
 #define IC_INDEX_WS2812_2CH_3X(i)  ((i)*2/3)
 #define WS2812_2CH_3X_SPANS_2_ICS(i) ((i)&0x01)    // every other LED zone is on two different ICs
 
+struct BusConfig; // forward declaration
+
+// Defines an LED Strip and its color ordering.
+typedef struct {
+  uint16_t start;
+  uint16_t len;
+  uint8_t colorOrder;
+} ColorOrderMapEntry;
+
+struct ColorOrderMap {
+    bool add(uint16_t start, uint16_t len, uint8_t colorOrder);
+
+    inline uint8_t count() const { return _mappings.size(); }
+    inline void reserve(size_t num) { _mappings.reserve(num); }
+
+    void reset() {
+      _mappings.clear();
+      _mappings.shrink_to_fit();
+    }
+
+    const ColorOrderMapEntry* get(uint8_t n) const {
+      if (n >= count()) return nullptr;
+      return &(_mappings[n]);
+    }
+
+    [[gnu::hot]] uint8_t getPixelColorOrder(uint16_t pix, uint8_t defaultColorOrder) const;
+
+  private:
+    std::vector<ColorOrderMapEntry> _mappings;
+};
+
+
+typedef struct {
+  uint8_t id;
+  const char *type;
+  const char *name;
+} LEDType;
+
+
+//parent class of BusDigital, BusPwm, and BusNetwork
+class Bus {
+  public:
+    Bus(uint8_t type, uint16_t start, uint8_t aw, uint16_t len = 1, bool reversed = false, bool refresh = false)
+    : _type(type)
+    , _bri(255)
+    , _start(start)
+    , _len(len)
+    , _reversed(reversed)
+    , _valid(false)
+    , _needsRefresh(refresh)
+    , _data(nullptr) // keep data access consistent across all types of buses
+    {
+      _autoWhiteMode = Bus::hasWhite(type) ? aw : RGBW_MODE_MANUAL_ONLY;
+    };
+
+    virtual ~Bus() {} //throw the bus under the bus (derived class needs to freeData())
+
+    virtual void     begin()                                    {};
+    virtual void     show() = 0;
+    virtual bool     canShow() const                            { return true; }
+    virtual void     setStatusPixel(uint32_t c)                 {}
+    virtual void     setPixelColor(unsigned pix, uint32_t c) = 0;
+    virtual void     setBrightness(uint8_t b)                   { _bri = b; };
+    virtual void     setColorOrder(uint8_t co)                  {}
+    virtual uint32_t getPixelColor(unsigned pix) const          { return 0; }
+    virtual unsigned getPins(uint8_t* pinArray = nullptr) const { return 0; }
+    virtual uint16_t getLength() const                          { return isOk() ? _len : 0; }
+    virtual uint8_t  getColorOrder() const                      { return COL_ORDER_RGB; }
+    virtual unsigned skippedLeds() const                        { return 0; }
+    virtual uint16_t getFrequency() const                       { return 0U; }
+    virtual uint16_t getLEDCurrent() const                      { return 0; }
+    virtual uint16_t getUsedCurrent() const                     { return 0; }
+    virtual uint16_t getMaxCurrent() const                      { return 0; }
+    virtual unsigned getBusSize() const                         { return sizeof(Bus); }
+
+    inline  bool     hasRGB() const                             { return _hasRgb; }
+    inline  bool     hasWhite() const                           { return _hasWhite; }
+    inline  bool     hasCCT() const                             { return _hasCCT; }
+    inline  bool     isDigital() const                          { return isDigital(_type); }
+    inline  bool     is2Pin() const                             { return is2Pin(_type); }
+    inline  bool     isOnOff() const                            { return isOnOff(_type); }
+    inline  bool     isPWM() const                              { return isPWM(_type); }
+    inline  bool     isVirtual() const                          { return isVirtual(_type); }
+    inline  bool     is16bit() const                            { return is16bit(_type); }
+    inline  bool     mustRefresh() const                        { return mustRefresh(_type); }
+    inline  void     setReversed(bool reversed)                 { _reversed = reversed; }
+    inline  void     setStart(uint16_t start)                   { _start = start; }
+    inline  void     setAutoWhiteMode(uint8_t m)                { if (m < 5) _autoWhiteMode = m; }
+    inline  uint8_t  getAutoWhiteMode() const                   { return _autoWhiteMode; }
+    inline  unsigned getNumberOfChannels() const                { return hasWhite() + 3*hasRGB() + hasCCT(); }
+    inline  uint16_t getStart() const                           { return _start; }
+    inline  uint8_t  getType() const                            { return _type; }
+    inline  bool     isOk() const                               { return _valid; }
+    inline  bool     isReversed() const                         { return _reversed; }
+    inline  bool     isOffRefreshRequired() const               { return _needsRefresh; }
+    inline  bool     containsPixel(uint16_t pix) const          { return pix >= _start && pix < _start + _len; }
+
+    static inline std::vector<LEDType> getLEDTypes()            { return {{TYPE_NONE, "", PSTR("None")}}; } // not used. just for reference for derived classes
+    static constexpr unsigned getNumberOfPins(uint8_t type)     { return isVirtual(type) ? 4 : isPWM(type) ? numPWMPins(type) : is2Pin(type) + 1; } // credit @PaoloTK
+    static constexpr unsigned getNumberOfChannels(uint8_t type) { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
+    static constexpr bool hasRGB(uint8_t type) {
+      return !((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) || type == TYPE_ANALOG_1CH || type == TYPE_ANALOG_2CH || type == TYPE_ONOFF);
+    }
+    static constexpr bool hasWhite(uint8_t type) {
+      return  (type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) ||
+              type == TYPE_SK6812_RGBW || type == TYPE_TM1814 || type == TYPE_UCS8904 ||
+              type == TYPE_FW1906 || type == TYPE_WS2805 || type == TYPE_SM16825 ||        // digital types with white channel
+              (type > TYPE_ONOFF && type <= TYPE_ANALOG_5CH && type != TYPE_ANALOG_3CH) || // analog types with white channel
+              type == TYPE_NET_DDP_RGBW || type == TYPE_NET_ARTNET_RGBW;                   // network types with white channel
+    }
+    static constexpr bool hasCCT(uint8_t type) {
+      return  type == TYPE_WS2812_2CH_X3 || type == TYPE_WS2812_WWA ||
+              type == TYPE_ANALOG_2CH    || type == TYPE_ANALOG_5CH ||
+              type == TYPE_FW1906        || type == TYPE_WS2805     ||
+              type == TYPE_SM16825;
+    }
+    static constexpr bool  isTypeValid(uint8_t type)  { return (type > 15 && type < 128); }
+    static constexpr bool  isDigital(uint8_t type)    { return (type >= TYPE_DIGITAL_MIN && type <= TYPE_DIGITAL_MAX) || is2Pin(type); }
+    static constexpr bool  is2Pin(uint8_t type)       { return (type >= TYPE_2PIN_MIN && type <= TYPE_2PIN_MAX); }
+    static constexpr bool  isOnOff(uint8_t type)      { return (type == TYPE_ONOFF); }
+    static constexpr bool  isPWM(uint8_t type)        { return (type >= TYPE_ANALOG_MIN && type <= TYPE_ANALOG_MAX); }
+    static constexpr bool  isVirtual(uint8_t type)    { return (type >= TYPE_VIRTUAL_MIN && type <= TYPE_VIRTUAL_MAX); }
+    static constexpr bool  is16bit(uint8_t type)      { return type == TYPE_UCS8903 || type == TYPE_UCS8904 || type == TYPE_SM16825; }
+    static constexpr bool  mustRefresh(uint8_t type)  { return type == TYPE_TM1814; }
+    static constexpr int   numPWMPins(uint8_t type)   { return (type - 40); }
+
+    static inline int16_t  getCCT()                   { return _cct; }
+    static inline void     setGlobalAWMode(uint8_t m) { if (m < 5) _gAWM = m; else _gAWM = AW_GLOBAL_DISABLED; }
+    static inline uint8_t  getGlobalAWMode()          { return _gAWM; }
+    static inline void     setCCT(int16_t cct)        { _cct = cct; }
+    static inline uint8_t  getCCTBlend()              { return _cctBlend; }
+    static inline void     setCCTBlend(uint8_t b) {
+      _cctBlend = (std::min((int)b,100) * 127) / 100;
+      //compile-time limiter for hardware that can't power both white channels at max
+      #ifdef WLED_MAX_CCT_BLEND
+        if (_cctBlend > WLED_MAX_CCT_BLEND) _cctBlend = WLED_MAX_CCT_BLEND;
+      #endif
+    }
+    static void calculateCCT(uint32_t c, uint8_t &ww, uint8_t &cw);
+
+  protected:
+    uint8_t  _type;
+    uint8_t  _bri;
+    uint16_t _start;
+    uint16_t _len;
+    //struct { //using bitfield struct adds abour 250 bytes to binary size
+      bool _reversed;//     : 1;
+      bool _valid;//        : 1;
+      bool _needsRefresh;// : 1;
+      bool _hasRgb;//       : 1;
+      bool _hasWhite;//     : 1;
+      bool _hasCCT;//       : 1;
+    //} __attribute__ ((packed));
+    uint8_t  _autoWhiteMode;
+    uint8_t  *_data;
+    // global Auto White Calculation override
+    static uint8_t _gAWM;
+    // _cct has the following menaings (see calculateCCT() & BusManager::setSegmentCCT()):
+    //    -1 means to extract approximate CCT value in K from RGB (in calcualteCCT())
+    //    [0,255] is the exact CCT value where 0 means warm and 255 cold
+    //    [1900,10060] only for color correction expressed in K (colorBalanceFromKelvin())
+    static int16_t _cct;
+    // _cctBlend determines WW/CW blending:
+    //    0 - linear (CCT 127 => 50% warm, 50% cold)
+    //   63 - semi additive/nonlinear (CCT 127 => 66% warm, 66% cold)
+    //  127 - additive CCT blending (CCT 127 => 100% warm, 100% cold)
+    static uint8_t _cctBlend;
+
+    uint32_t autoWhiteCalc(uint32_t c) const;
+    uint8_t *allocateData(size_t size = 1);
+    void     freeData();
+};
+
+
+class BusDigital : public Bus {
+  public:
+    BusDigital(const BusConfig &bc, uint8_t nr, const ColorOrderMap &com);
+    ~BusDigital() { cleanup(); }
+
+    void show() override;
+    bool canShow() const override;
+    void setBrightness(uint8_t b) override;
+    void setStatusPixel(uint32_t c) override;
+    [[gnu::hot]] void setPixelColor(unsigned pix, uint32_t c) override;
+    void setColorOrder(uint8_t colorOrder) override;
+    [[gnu::hot]] uint32_t getPixelColor(unsigned pix) const override;
+    uint8_t  getColorOrder() const override  { return _colorOrder; }
+    unsigned getPins(uint8_t* pinArray = nullptr) const override;
+    unsigned skippedLeds() const override    { return _skip; }
+    uint16_t getFrequency() const override   { return _frequencykHz; }
+    uint16_t getLEDCurrent() const override  { return _milliAmpsPerLed; }
+    uint16_t getUsedCurrent() const override { return _milliAmpsTotal; }
+    uint16_t getMaxCurrent() const override  { return _milliAmpsMax; }
+    unsigned getBusSize() const override;
+    void begin() override;
+    void cleanup();
+
+    static std::vector<LEDType> getLEDTypes();
+
+  private:
+    uint8_t _skip;
+    uint8_t _colorOrder;
+    uint8_t _pins[2];
+    uint8_t _iType;
+    uint16_t _frequencykHz;
+    uint8_t _milliAmpsPerLed;
+    uint16_t _milliAmpsMax;
+    void * _busPtr;
+    const ColorOrderMap &_colorOrderMap;
+
+    static uint16_t _milliAmpsTotal; // is overwitten/recalculated on each show()
+
+    inline uint32_t restoreColorLossy(uint32_t c, uint8_t restoreBri) const {
+      if (restoreBri < 255) {
+        uint8_t* chan = (uint8_t*) &c;
+        for (uint_fast8_t i=0; i<4; i++) {
+          uint_fast16_t val = chan[i];
+          chan[i] = ((val << 8) + restoreBri) / (restoreBri + 1); //adding _bri slightly improves recovery / stops degradation on re-scale
+        }
+      }
+      return c;
+    }
+
+    uint8_t  estimateCurrentAndLimitBri() const;
+};
+
+
+class BusPwm : public Bus {
+  public:
+    BusPwm(const BusConfig &bc);
+    ~BusPwm() { cleanup(); }
+
+    void setPixelColor(unsigned pix, uint32_t c) override;
+    uint32_t getPixelColor(unsigned pix) const override; //does no index check
+    unsigned getPins(uint8_t* pinArray = nullptr) const override;
+    uint16_t getFrequency() const override { return _frequency; }
+    unsigned getBusSize() const override   { return sizeof(BusPwm); }
+    void show() override;
+    inline void cleanup() { deallocatePins(); _data = nullptr; }
+
+    static std::vector<LEDType> getLEDTypes();
+
+  private:
+    uint8_t _pins[OUTPUT_MAX_PINS];
+    uint8_t _pwmdata[OUTPUT_MAX_PINS];
+    #ifdef ARDUINO_ARCH_ESP32
+    uint8_t _ledcStart;
+    #endif
+    uint8_t _depth;
+    uint16_t _frequency;
+
+    void deallocatePins();
+};
+
+
+class BusOnOff : public Bus {
+  public:
+    BusOnOff(const BusConfig &bc);
+    ~BusOnOff() { cleanup(); }
+
+    void setPixelColor(unsigned pix, uint32_t c) override;
+    uint32_t getPixelColor(unsigned pix) const override;
+    unsigned getPins(uint8_t* pinArray) const override;
+    unsigned getBusSize() const override { return sizeof(BusOnOff); }
+    void show() override;
+    inline void cleanup() { PinManager::deallocatePin(_pin, PinOwner::BusOnOff); _data = nullptr; }
+
+    static std::vector<LEDType> getLEDTypes();
+
+  private:
+    uint8_t _pin;
+    uint8_t _onoffdata;
+};
+
+
+class BusNetwork : public Bus {
+  public:
+    BusNetwork(const BusConfig &bc);
+    ~BusNetwork() { cleanup(); }
+
+    bool canShow() const override  { return !_broadcastLock; } // this should be a return value from UDP routine if it is still sending data out
+    [[gnu::hot]] void setPixelColor(unsigned pix, uint32_t c) override;
+    [[gnu::hot]] uint32_t getPixelColor(unsigned pix) const override;
+    unsigned getPins(uint8_t* pinArray = nullptr) const override;
+    unsigned getBusSize() const override  { return sizeof(BusNetwork) + (isOk() ? _len * _UDPchannels : 0); }
+    void show() override;
+    void cleanup();
+
+    static std::vector<LEDType> getLEDTypes();
+
+  private:
+    IPAddress _client;
+    uint8_t   _UDPtype;
+    uint8_t   _UDPchannels;
+    bool      _broadcastLock;
+};
+
+
 //temporary struct for passing bus configuration to bus
 struct BusConfig {
   uint8_t type;
@@ -51,11 +375,18 @@ struct BusConfig {
   {
     refreshReq = (bool) GET_BIT(busType,7);
     type = busType & 0x7F;  // bit 7 may be/is hacked to include refresh info (1=refresh in off state, 0=no refresh)
-    size_t nPins = 1;
-    if (IS_VIRTUAL(type))   nPins = 4; //virtual network bus. 4 "pins" store IP address
-    else if (IS_2PIN(type)) nPins = 2;
-    else if (IS_PWM(type))  nPins = NUM_PWM_PINS(type);
+    size_t nPins = Bus::getNumberOfPins(type);
     for (size_t i = 0; i < nPins; i++) pins[i] = ppins[i];
+    DEBUGBUS_PRINTF_P(PSTR("Bus: Config (%d-%d, type:%d, CO:%d, rev:%d, skip:%d, AW:%d kHz:%d, mA:%d/%d)\n"),
+      (int)start, (int)(start+len),
+      (int)type,
+      (int)colorOrder,
+      (int)reversed,
+      (int)skipAmount,
+      (int)autoWhite,
+      (int)frequency,
+      (int)milliAmpsPerLed, (int)milliAmpsMax
+    );
   }
 
   //validates start and length and extends total if needed
@@ -69,342 +400,73 @@ struct BusConfig {
     if (start + count > total) total = start + count;
     return true;
   }
+
+  unsigned memUsage(unsigned nr = 0) const;
 };
 
 
-// Defines an LED Strip and its color ordering.
-struct ColorOrderMapEntry {
-  uint16_t start;
-  uint16_t len;
-  uint8_t colorOrder;
-};
-
-struct ColorOrderMap {
-    void add(uint16_t start, uint16_t len, uint8_t colorOrder);
-
-    uint8_t count() const { return _count; }
-
-    void reset() {
-      _count = 0;
-      memset(_mappings, 0, sizeof(_mappings));
-    }
-
-    const ColorOrderMapEntry* get(uint8_t n) const {
-      if (n > _count) {
-        return nullptr;
-      }
-      return &(_mappings[n]);
-    }
-
-    uint8_t getPixelColorOrder(uint16_t pix, uint8_t defaultColorOrder) const;
-
-  private:
-    uint8_t _count;
-    ColorOrderMapEntry _mappings[WLED_MAX_COLOR_ORDER_MAPPINGS];
-};
-
-
-//parent class of BusDigital, BusPwm, and BusNetwork
-class Bus {
-  public:
-    Bus(uint8_t type, uint16_t start, uint8_t aw, uint16_t len = 1, bool reversed = false, bool refresh = false)
-    : _type(type)
-    , _bri(255)
-    , _start(start)
-    , _len(len)
-    , _reversed(reversed)
-    , _valid(false)
-    , _needsRefresh(refresh)
-    , _data(nullptr) // keep data access consistent across all types of buses
-    {
-      _autoWhiteMode = Bus::hasWhite(type) ? aw : RGBW_MODE_MANUAL_ONLY;
-    };
-
-    virtual ~Bus() {} //throw the bus under the bus
-
-    virtual void     show() = 0;
-    virtual bool     canShow()                   { return true; }
-    virtual void     setStatusPixel(uint32_t c)  {}
-    virtual void     setPixelColor(uint16_t pix, uint32_t c) = 0;
-    virtual uint32_t getPixelColor(uint16_t pix) { return 0; }
-    virtual void     setBrightness(uint8_t b)    { _bri = b; };
-    virtual uint8_t  getPins(uint8_t* pinArray)  { return 0; }
-    virtual uint16_t getLength()                 { return isOk() ? _len : 0; }
-    virtual void     setColorOrder(uint8_t co)   {}
-    virtual uint8_t  getColorOrder()             { return COL_ORDER_RGB; }
-    virtual uint8_t  skippedLeds()               { return 0; }
-    virtual uint16_t getFrequency()              { return 0U; }
-    virtual uint16_t getLEDCurrent()             { return 0; }
-    virtual uint16_t getUsedCurrent()            { return 0; }
-    virtual uint16_t getMaxCurrent()             { return 0; }
-    virtual uint8_t  getNumberOfChannels()       { return hasWhite(_type) + 3*hasRGB(_type) + hasCCT(_type); }
-    static inline uint8_t getNumberOfChannels(uint8_t type) { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
-    inline  void     setReversed(bool reversed)  { _reversed = reversed; }
-    inline  uint16_t getStart()                  { return _start; }
-    inline  void     setStart(uint16_t start)    { _start = start; }
-    inline  uint8_t  getType()                   { return _type; }
-    inline  bool     isOk()                      { return _valid; }
-    inline  bool     isReversed()                { return _reversed; }
-    inline  bool     isOffRefreshRequired()      { return _needsRefresh; }
-            bool     containsPixel(uint16_t pix) { return pix >= _start && pix < _start+_len; }
-
-    virtual bool hasRGB(void) { return Bus::hasRGB(_type); }
-    static  bool hasRGB(uint8_t type) {
-      if ((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) || type == TYPE_ANALOG_1CH || type == TYPE_ANALOG_2CH || type == TYPE_ONOFF) return false;
-      return true;
-    }
-    virtual bool hasWhite(void) { return Bus::hasWhite(_type); }
-    static  bool hasWhite(uint8_t type) {
-      if ((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) ||
-          type == TYPE_SK6812_RGBW || type == TYPE_TM1814 || type == TYPE_UCS8904 ||
-          type == TYPE_FW1906 || type == TYPE_WS2805 || type == TYPE_SM16825) return true; // digital types with white channel
-      if (type > TYPE_ONOFF && type <= TYPE_ANALOG_5CH && type != TYPE_ANALOG_3CH) return true; // analog types with white channel
-      if (type == TYPE_NET_DDP_RGBW || type == TYPE_NET_ARTNET_RGBW) return true; // network types with white channel
-      return false;
-    }
-    virtual bool hasCCT(void) { return Bus::hasCCT(_type); }
-    static  bool hasCCT(uint8_t type) {
-      if (type == TYPE_WS2812_2CH_X3 || type == TYPE_WS2812_WWA ||
-          type == TYPE_ANALOG_2CH    || type == TYPE_ANALOG_5CH ||
-          type == TYPE_FW1906        || type == TYPE_WS2805     ||
-          type == TYPE_SM16825) return true;
-      return false;
-    }
-    static inline int16_t getCCT() { return _cct; }
-    static void setCCT(int16_t cct) {
-      _cct = cct;
-    }
-    static inline uint8_t getCCTBlend() { return _cctBlend; }
-    static void setCCTBlend(uint8_t b) {
-      if (b > 100) b = 100;
-      _cctBlend = (b * 127) / 100;
-      //compile-time limiter for hardware that can't power both white channels at max
-      #ifdef WLED_MAX_CCT_BLEND
-        if (_cctBlend > WLED_MAX_CCT_BLEND) _cctBlend = WLED_MAX_CCT_BLEND;
-      #endif
-    }
-    static void calculateCCT(uint32_t c, uint8_t &ww, uint8_t &cw) {
-      uint8_t cct = 0; //0 - full warm white, 255 - full cold white
-      uint8_t w = byte(c >> 24);
-
-      if (_cct > -1) {
-        if (_cct >= 1900)    cct = (_cct - 1900) >> 5;
-        else if (_cct < 256) cct = _cct;
-      } else {
-        cct = (approximateKelvinFromRGB(c) - 1900) >> 5;
-      }
-      
-      //0 - linear (CCT 127 = 50% warm, 50% cold), 127 - additive CCT blending (CCT 127 = 100% warm, 100% cold)
-      if (cct       < _cctBlend) ww = 255;
-      else                       ww = ((255-cct) * 255) / (255 - _cctBlend);
-      if ((255-cct) < _cctBlend) cw = 255;
-      else                       cw = (cct * 255) / (255 - _cctBlend);
-
-      ww = (w * ww) / 255; //brightness scaling
-      cw = (w * cw) / 255;
-    }
-    inline        void    setAutoWhiteMode(uint8_t m) { if (m < 5) _autoWhiteMode = m; }
-    inline        uint8_t getAutoWhiteMode()          { return _autoWhiteMode; }
-    inline static void    setGlobalAWMode(uint8_t m)  { if (m < 5) _gAWM = m; else _gAWM = AW_GLOBAL_DISABLED; }
-    inline static uint8_t getGlobalAWMode()           { return _gAWM; }
-
-  protected:
-    uint8_t  _type;
-    uint8_t  _bri;
-    uint16_t _start;
-    uint16_t _len;
-    bool     _reversed;
-    bool     _valid;
-    bool     _needsRefresh;
-    uint8_t  _autoWhiteMode;
-    uint8_t  *_data;
-    // global Auto White Calculation override
-    static uint8_t _gAWM;
-    // _cct has the following menaings (see calculateCCT() & BusManager::setSegmentCCT()):
-    //    -1 means to extract approximate CCT value in K from RGB (in calcualteCCT())
-    //    [0,255] is the exact CCT value where 0 means warm and 255 cold
-    //    [1900,10060] only for color correction expressed in K (colorBalanceFromKelvin())
-    static int16_t _cct;
-    // _cctBlend determines WW/CW blending:
-    //    0 - linear (CCT 127 => 50% warm, 50% cold)
-    //   63 - semi additive/nonlinear (CCT 127 => 66% warm, 66% cold)
-    //  127 - additive CCT blending (CCT 127 => 100% warm, 100% cold)
-    static uint8_t _cctBlend;
-
-    uint32_t autoWhiteCalc(uint32_t c);
-    uint8_t *allocData(size_t size = 1);
-    void     freeData() { if (_data != nullptr) free(_data); _data = nullptr; }
-};
-
-
-class BusDigital : public Bus {
-  public:
-    BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com);
-    ~BusDigital() { cleanup(); }
-
-    void show() override;
-    bool canShow() override;
-    void setBrightness(uint8_t b) override;
-    void setStatusPixel(uint32_t c) override;
-    void setPixelColor(uint16_t pix, uint32_t c) override;
-    void setColorOrder(uint8_t colorOrder) override;
-    uint32_t getPixelColor(uint16_t pix) override;
-    uint8_t  getColorOrder() override  { return _colorOrder; }
-    uint8_t  getPins(uint8_t* pinArray) override;
-    uint8_t  skippedLeds() override    { return _skip; }
-    uint16_t getFrequency() override   { return _frequencykHz; }
-    uint8_t  estimateCurrentAndLimitBri();
-    uint16_t getLEDCurrent() override  { return _milliAmpsPerLed; }
-    uint16_t getUsedCurrent() override { return _milliAmpsTotal; }
-    uint16_t getMaxCurrent() override  { return _milliAmpsMax; }
-    void reinit();
-    void cleanup();
-
-  private:
-    uint8_t _skip;
-    uint8_t _colorOrder;
-    uint8_t _pins[2];
-    uint8_t _iType;
-    uint16_t _frequencykHz;
-    uint8_t _milliAmpsPerLed;
-    uint16_t _milliAmpsMax;
-    void * _busPtr;
-    const ColorOrderMap &_colorOrderMap;
-
-    static uint16_t _milliAmpsTotal; // is overwitten/recalculated on each show()
-
-    inline uint32_t restoreColorLossy(uint32_t c, uint8_t restoreBri) {
-      if (restoreBri < 255) {
-        uint8_t* chan = (uint8_t*) &c;
-        for (uint_fast8_t i=0; i<4; i++) {
-          uint_fast16_t val = chan[i];
-          chan[i] = ((val << 8) + restoreBri) / (restoreBri + 1); //adding _bri slightly improves recovery / stops degradation on re-scale
-        }
-      }
-      return c;
-    }
-};
-
-
-class BusPwm : public Bus {
-  public:
-    BusPwm(BusConfig &bc);
-    ~BusPwm() { cleanup(); }
-
-    void setPixelColor(uint16_t pix, uint32_t c) override;
-    uint32_t getPixelColor(uint16_t pix) override; //does no index check
-    uint8_t  getPins(uint8_t* pinArray) override;
-    uint16_t getFrequency() override { return _frequency; }
-    void show() override;
-    void cleanup() { deallocatePins(); }
-
-  private:
-    uint8_t _pins[5];
-    uint8_t _pwmdata[5];
-    #ifdef ARDUINO_ARCH_ESP32
-    uint8_t _ledcStart;
-    #endif
-    uint8_t _depth;
-    uint16_t _frequency;
-
-    void deallocatePins();
-};
-
-
-class BusOnOff : public Bus {
-  public:
-    BusOnOff(BusConfig &bc);
-    ~BusOnOff() { cleanup(); }
-
-    void setPixelColor(uint16_t pix, uint32_t c) override;
-    uint32_t getPixelColor(uint16_t pix) override;
-    uint8_t  getPins(uint8_t* pinArray) override;
-    void show() override;
-    void cleanup() { pinManager.deallocatePin(_pin, PinOwner::BusOnOff); }
-
-  private:
-    uint8_t _pin;
-    uint8_t _onoffdata;
-};
-
-
-class BusNetwork : public Bus {
-  public:
-    BusNetwork(BusConfig &bc);
-    ~BusNetwork() { cleanup(); }
-
-    bool hasRGB() override   { return true; }
-    bool hasWhite() override { return _rgbw; }
-    bool canShow() override  { return !_broadcastLock; } // this should be a return value from UDP routine if it is still sending data out
-    void setPixelColor(uint16_t pix, uint32_t c) override;
-    uint32_t getPixelColor(uint16_t pix) override;
-    uint8_t  getPins(uint8_t* pinArray) override;
-    void show() override;
-    void cleanup();
-
-  private:
-    IPAddress _client;
-    uint8_t   _UDPtype;
-    uint8_t   _UDPchannels;
-    bool      _rgbw;
-    bool      _broadcastLock;
-};
-
+//fine tune power estimation constants for your setup
+//you can set it to 0 if the ESP is powered by USB and the LEDs by external
+#ifndef MA_FOR_ESP
+  #ifdef ESP8266
+    #define MA_FOR_ESP         80 //how much mA does the ESP use (Wemos D1 about 80mA)
+  #else
+    #define MA_FOR_ESP        120 //how much mA does the ESP use (ESP32 about 120mA)
+  #endif
+#endif
 
 class BusManager {
   public:
     BusManager() {};
 
-    //utility to get the approx. memory usage of a given BusConfig
-    static uint32_t memUsage(BusConfig &bc);
-    static uint32_t memUsage(unsigned channels, unsigned count, unsigned buses = 1);
-    static uint16_t currentMilliamps(void) { return _milliAmpsUsed; }
-    static uint16_t ablMilliampsMax(void)  { return _milliAmpsMax; }
+    static unsigned memUsage();
+    static uint16_t currentMilliamps() { return _milliAmpsUsed + MA_FOR_ESP; }
+    static uint16_t ablMilliampsMax()  { return _milliAmpsMax; }
 
-    static int add(BusConfig &bc);
-    static void useParallelOutput(void); // workaround for inaccessible PolyBus
+    static int add(const BusConfig &bc);
+    static void useParallelOutput(); // workaround for inaccessible PolyBus
+    static bool hasParallelOutput(); // workaround for inaccessible PolyBus
 
     //do not call this method from system context (network callback)
     static void removeAll();
 
-    static void on(void);
-    static void off(void);
+    static void on();
+    static void off();
 
     static void show();
     static bool canAllShow();
     static void setStatusPixel(uint32_t c);
-    static void setPixelColor(uint16_t pix, uint32_t c);
+    [[gnu::hot]] static void setPixelColor(unsigned pix, uint32_t c);
     static void setBrightness(uint8_t b);
     // for setSegmentCCT(), cct can only be in [-1,255] range; allowWBCorrection will convert it to K
     // WARNING: setSegmentCCT() is a misleading name!!! much better would be setGlobalCCT() or just setCCT()
     static void setSegmentCCT(int16_t cct, bool allowWBCorrection = false);
-    static void setMilliampsMax(uint16_t max) { _milliAmpsMax = max;}
-    static uint32_t getPixelColor(uint16_t pix);
+    static inline void setMilliampsMax(uint16_t max) { _milliAmpsMax = max;}
+    static uint32_t getPixelColor(unsigned pix);
     static inline int16_t getSegmentCCT() { return Bus::getCCT(); }
 
     static Bus* getBus(uint8_t busNr);
 
     //semi-duplicate of strip.getLengthTotal() (though that just returns strip._length, calculated in finalizeInit())
     static uint16_t getTotalLength();
-    static uint8_t getNumBusses() { return numBusses; }
+    static inline uint8_t getNumBusses() { return busses.size(); }
+    static String getLEDTypesJSONString();
 
-    static void                 updateColorOrderMap(const ColorOrderMap &com) { memcpy(&colorOrderMap, &com, sizeof(ColorOrderMap)); }
-    static const ColorOrderMap& getColorOrderMap() { return colorOrderMap; }
+    static inline ColorOrderMap& getColorOrderMap() { return colorOrderMap; }
 
   private:
-    static uint8_t numBusses;
-    static Bus* busses[WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES];
+    //static std::vector<std::unique_ptr<Bus>> busses; // we'd need C++ >11
+    static std::vector<Bus*> busses;
     static ColorOrderMap colorOrderMap;
     static uint16_t _milliAmpsUsed;
     static uint16_t _milliAmpsMax;
-    static uint8_t _parallelOutputs;
 
     #ifdef ESP32_DATA_IDLE_HIGH
-    static void    esp32RMTInvertIdle();
+    static void    esp32RMTInvertIdle() ;
     #endif
     static uint8_t getNumVirtualBusses() {
       int j = 0;
-      for (int i=0; i<numBusses; i++) if (busses[i]->getType() >= TYPE_NET_DDP_RGB && busses[i]->getType() < 96) j++;
+      for (const auto &bus : busses) j += bus->isVirtual();
       return j;
     }
 };

wled00/button.cpp

@@ -40,7 +40,7 @@ void longPressAction(uint8_t b)
 {
   if (!macroLongPress[b]) {
     switch (b) {
-      case 0: setRandomColor(col); colorUpdated(CALL_MODE_BUTTON); break;
+      case 0: setRandomColor(colPri); colorUpdated(CALL_MODE_BUTTON); break;
       case 1: 
         if(buttonBriDirection) {
           if (bri == 255) break; // avoid unnecessary updates to brightness
@@ -215,6 +215,7 @@ void handleAnalog(uint8_t b)
         briLast = bri;
         bri = 0;
       } else {
+        if (bri == 0) strip.restartRuntime();
         bri = aRead;
       }
     } else if (macroDoublePress[b] == 249) {
@@ -229,7 +230,7 @@ void handleAnalog(uint8_t b)
       effectPalette = constrain(effectPalette, 0, strip.getPaletteCount()-1);  // map is allowed to "overshoot", so we need to contrain the result
     } else if (macroDoublePress[b] == 200) {
       // primary color, hue, full saturation
-      colorHStoRGB(aRead*256,255,col);
+      colorHStoRGB(aRead*256,255,colPri);
     } else {
       // otherwise use "double press" for segment selection
       Segment& seg = strip.getSegment(macroDoublePress[b]);
@@ -267,7 +268,7 @@ void handleButton()
     if (btnPin[b]<0 || buttonType[b] == BTN_TYPE_NONE) continue;
     #endif
 
-    if (usermods.handleButton(b)) continue; // did usermod handle buttons
+    if (UsermodManager::handleButton(b)) continue; // did usermod handle buttons
 
     if (buttonType[b] == BTN_TYPE_ANALOG || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) { // button is not a button but a potentiometer
       if (now - lastAnalogRead > ANALOG_BTN_READ_CYCLE) {
@@ -374,6 +375,7 @@ void handleIO()
       if (rlyPin>=0) {
         pinMode(rlyPin, rlyOpenDrain ? OUTPUT_OPEN_DRAIN : OUTPUT);
         digitalWrite(rlyPin, rlyMde);
+        delay(50); // wait for relay to switch and power to stabilize
       }
       offMode = false;
     }

wled00/cfg.cpp

@@ -118,6 +118,9 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   Bus::setCCTBlend(strip.cctBlending);
   strip.setTargetFps(hw_led["fps"]); //NOP if 0, default 42 FPS
   CJSON(useGlobalLedBuffer, hw_led[F("ld")]);
+  #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3)
+  CJSON(useParallelI2S, hw_led[F("prl")]);
+  #endif
 
   #ifndef WLED_DISABLE_2D
   // 2D Matrix Settings
@@ -162,34 +165,6 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
     DEBUG_PRINTF_P(PSTR("Heap before buses: %d\n"), ESP.getFreeHeap());
     int s = 0;  // bus iterator
     if (fromFS) BusManager::removeAll(); // can't safely manipulate busses directly in network callback
-    unsigned mem = 0;
-
-    // determine if it is sensible to use parallel I2S outputs on ESP32 (i.e. more than 5 outputs = 1 I2S + 4 RMT)
-    bool useParallel = false;
-    #if defined(ARDUINO_ARCH_ESP32) && !defined(ARDUINO_ARCH_ESP32S2) && !defined(ARDUINO_ARCH_ESP32S3) && !defined(ARDUINO_ARCH_ESP32C3)
-    unsigned digitalCount = 0;
-    unsigned maxLedsOnBus = 0;
-    unsigned maxChannels = 0;
-    for (JsonObject elm : ins) {
-      unsigned type = elm["type"] | TYPE_WS2812_RGB;
-      unsigned len = elm["len"] | DEFAULT_LED_COUNT;
-      if (!IS_DIGITAL(type)) continue;
-      if (!IS_2PIN(type)) {
-        digitalCount++;
-        unsigned channels = Bus::getNumberOfChannels(type);
-        if (len > maxLedsOnBus)     maxLedsOnBus = len;
-        if (channels > maxChannels) maxChannels  = channels;
-      }
-    }
-    DEBUG_PRINTF_P(PSTR("Maximum LEDs on a bus: %u\nDigital buses: %u\n"), maxLedsOnBus, digitalCount);
-    // we may remove 300 LEDs per bus limit when NeoPixelBus is updated beyond 2.9.0
-    if (maxLedsOnBus <= 300 && digitalCount > 5) {
-      DEBUG_PRINTLN(F("Switching to parallel I2S."));
-      useParallel = true;
-      BusManager::useParallelOutput();
-      mem = BusManager::memUsage(maxChannels, maxLedsOnBus, 8); // use alternate memory calculation
-    }
-    #endif
 
     for (JsonObject elm : ins) {
       if (s >= WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES) break;
@@ -215,46 +190,29 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
       uint8_t maPerLed = elm[F("ledma")] | LED_MILLIAMPS_DEFAULT;
       uint16_t maMax = elm[F("maxpwr")] | (ablMilliampsMax * length) / total; // rough (incorrect?) per strip ABL calculation when no config exists
       // To disable brightness limiter we either set output max current to 0 or single LED current to 0 (we choose output max current)
-      if (IS_PWM(ledType) || IS_ONOFF(ledType) || IS_VIRTUAL(ledType)) { // analog and virtual
+      if (Bus::isPWM(ledType) || Bus::isOnOff(ledType) || Bus::isVirtual(ledType)) { // analog and virtual
         maPerLed = 0;
         maMax = 0;
       }
       ledType |= refresh << 7; // hack bit 7 to indicate strip requires off refresh
-      if (fromFS) {
-        BusConfig bc = BusConfig(ledType, pins, start, length, colorOrder, reversed, skipFirst, AWmode, freqkHz, useGlobalLedBuffer, maPerLed, maMax);
-        if (useParallel && s < 8) {
-          // if for some unexplained reason the above pre-calculation was wrong, update
-          unsigned memT = BusManager::memUsage(bc); // includes x8 memory allocation for parallel I2S
-          if (memT > mem) mem = memT; // if we have unequal LED count use the largest
-        } else
-          mem += BusManager::memUsage(bc); // includes global buffer
-        if (mem <= MAX_LED_MEMORY) if (BusManager::add(bc) == -1) break;  // finalization will be done in WLED::beginStrip()
-      } else {
-        if (busConfigs[s] != nullptr) delete busConfigs[s];
-        busConfigs[s] = new BusConfig(ledType, pins, start, length, colorOrder, reversed, skipFirst, AWmode, freqkHz, useGlobalLedBuffer, maPerLed, maMax);
-        doInitBusses = true;  // finalization done in beginStrip()
-      }
+
+      busConfigs.push_back(std::move(BusConfig(ledType, pins, start, length, colorOrder, reversed, skipFirst, AWmode, freqkHz, useGlobalLedBuffer, maPerLed, maMax)));
+      doInitBusses = true;  // finalization done in beginStrip()
       s++;
     }
-    DEBUG_PRINTF_P(PSTR("LED buffer size: %uB\n"), mem);
-    DEBUG_PRINTF_P(PSTR("Heap after buses: %d\n"), ESP.getFreeHeap());
   }
   if (hw_led["rev"]) BusManager::getBus(0)->setReversed(true); //set 0.11 global reversed setting for first bus
 
   // read color order map configuration
   JsonArray hw_com = hw[F("com")];
   if (!hw_com.isNull()) {
-    ColorOrderMap com = {};
-    unsigned s = 0;
+    BusManager::getColorOrderMap().reserve(std::min(hw_com.size(), (size_t)WLED_MAX_COLOR_ORDER_MAPPINGS));
     for (JsonObject entry : hw_com) {
-      if (s > WLED_MAX_COLOR_ORDER_MAPPINGS) break;
       uint16_t start = entry["start"] | 0;
       uint16_t len = entry["len"] | 0;
       uint8_t colorOrder = (int)entry[F("order")];
-      com.add(start, len, colorOrder);
-      s++;
+      if (!BusManager::getColorOrderMap().add(start, len, colorOrder)) break;
     }
-    BusManager::updateColorOrderMap(com);
   }
 
   // read multiple button configuration
@@ -265,12 +223,12 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   JsonArray hw_btn_ins = btn_obj["ins"];
   if (!hw_btn_ins.isNull()) {
     // deallocate existing button pins
-    for (unsigned b = 0; b < WLED_MAX_BUTTONS; b++) pinManager.deallocatePin(btnPin[b], PinOwner::Button); // does nothing if trying to deallocate a pin with PinOwner != Button
+    for (unsigned b = 0; b < WLED_MAX_BUTTONS; b++) PinManager::deallocatePin(btnPin[b], PinOwner::Button); // does nothing if trying to deallocate a pin with PinOwner != Button
     unsigned s = 0;
     for (JsonObject btn : hw_btn_ins) {
       CJSON(buttonType[s], btn["type"]);
       int8_t pin = btn["pin"][0] | -1;
-      if (pin > -1 && pinManager.allocatePin(pin, false, PinOwner::Button)) {
+      if (pin > -1 && PinManager::allocatePin(pin, false, PinOwner::Button)) {
         btnPin[s] = pin;
       #ifdef ARDUINO_ARCH_ESP32
         // ESP32 only: check that analog button pin is a valid ADC gpio
@@ -279,7 +237,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
             // not an ADC analog pin
             DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for analog button #%d is not an analog pin!\n"), btnPin[s], s);
             btnPin[s] = -1;
-            pinManager.deallocatePin(pin,PinOwner::Button);
+            PinManager::deallocatePin(pin,PinOwner::Button);
           } else {
             analogReadResolution(12); // see #4040
           }
@@ -290,7 +248,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
             // not a touch pin
             DEBUG_PRINTF_P(PSTR("PIN ALLOC error: GPIO%d for touch button #%d is not a touch pin!\n"), btnPin[s], s);
             btnPin[s] = -1;
-            pinManager.deallocatePin(pin,PinOwner::Button);
+            PinManager::deallocatePin(pin,PinOwner::Button);
           }          
           //if touch pin, enable the touch interrupt on ESP32 S2 & S3
           #ifdef SOC_TOUCH_VERSION_2    // ESP32 S2 and S3 have a function to check touch state but need to attach an interrupt to do so
@@ -335,7 +293,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
     if (fromFS) {
       // relies upon only being called once with fromFS == true, which is currently true.
       for (size_t s = 0; s < WLED_MAX_BUTTONS; s++) {
-        if (buttonType[s] == BTN_TYPE_NONE || btnPin[s] < 0 || !pinManager.allocatePin(btnPin[s], false, PinOwner::Button)) {
+        if (buttonType[s] == BTN_TYPE_NONE || btnPin[s] < 0 || !PinManager::allocatePin(btnPin[s], false, PinOwner::Button)) {
           btnPin[s]     = -1;
           buttonType[s] = BTN_TYPE_NONE;
         }
@@ -362,8 +320,8 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   #ifndef WLED_DISABLE_INFRARED
   int hw_ir_pin = hw["ir"]["pin"] | -2; // 4
   if (hw_ir_pin > -2) {
-    pinManager.deallocatePin(irPin, PinOwner::IR);
-    if (pinManager.allocatePin(hw_ir_pin, false, PinOwner::IR)) {
+    PinManager::deallocatePin(irPin, PinOwner::IR);
+    if (PinManager::allocatePin(hw_ir_pin, false, PinOwner::IR)) {
       irPin = hw_ir_pin;
     } else {
       irPin = -1;
@@ -378,8 +336,8 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   rlyOpenDrain  = relay[F("odrain")] | rlyOpenDrain;
   int hw_relay_pin = relay["pin"] | -2;
   if (hw_relay_pin > -2) {
-    pinManager.deallocatePin(rlyPin, PinOwner::Relay);
-    if (pinManager.allocatePin(hw_relay_pin,true, PinOwner::Relay)) {
+    PinManager::deallocatePin(rlyPin, PinOwner::Relay);
+    if (PinManager::allocatePin(hw_relay_pin,true, PinOwner::Relay)) {
       rlyPin = hw_relay_pin;
       pinMode(rlyPin, rlyOpenDrain ? OUTPUT_OPEN_DRAIN : OUTPUT);
     } else {
@@ -398,7 +356,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   CJSON(i2c_sda, hw_if_i2c[0]);
   CJSON(i2c_scl, hw_if_i2c[1]);
   PinManagerPinType i2c[2] = { { i2c_sda, true }, { i2c_scl, true } };
-  if (i2c_scl >= 0 && i2c_sda >= 0 && pinManager.allocateMultiplePins(i2c, 2, PinOwner::HW_I2C)) {
+  if (i2c_scl >= 0 && i2c_sda >= 0 && PinManager::allocateMultiplePins(i2c, 2, PinOwner::HW_I2C)) {
     #ifdef ESP32
     if (!Wire.setPins(i2c_sda, i2c_scl)) { i2c_scl = i2c_sda = -1; } // this will fail if Wire is initialised (Wire.begin() called prior)
     else Wire.begin();
@@ -414,7 +372,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   CJSON(spi_sclk, hw_if_spi[1]);
   CJSON(spi_miso, hw_if_spi[2]);
   PinManagerPinType spi[3] = { { spi_mosi, true }, { spi_miso, true }, { spi_sclk, true } };
-  if (spi_mosi >= 0 && spi_sclk >= 0 && pinManager.allocateMultiplePins(spi, 3, PinOwner::HW_SPI)) {
+  if (spi_mosi >= 0 && spi_sclk >= 0 && PinManager::allocateMultiplePins(spi, 3, PinOwner::HW_SPI)) {
     #ifdef ESP32
     SPI.begin(spi_sclk, spi_miso, spi_mosi);  // SPI global uses VSPI on ESP32 and FSPI on C3, S3
     #else
@@ -486,6 +444,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   CJSON(receiveNotificationBrightness, if_sync_recv["bri"]);
   CJSON(receiveNotificationColor, if_sync_recv["col"]);
   CJSON(receiveNotificationEffects, if_sync_recv["fx"]);
+  CJSON(receiveNotificationPalette, if_sync_recv["pal"]);
   CJSON(receiveGroups, if_sync_recv["grp"]);
   CJSON(receiveSegmentOptions, if_sync_recv["seg"]);
   CJSON(receiveSegmentBounds, if_sync_recv["sb"]);
@@ -667,7 +626,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   DEBUG_PRINTLN(F("Starting usermod config."));
   JsonObject usermods_settings = doc["um"];
   if (!usermods_settings.isNull()) {
-    needsSave = !usermods.readFromConfig(usermods_settings);
+    needsSave = !UsermodManager::readFromConfig(usermods_settings);
   }
 
   if (fromFS) return needsSave;
@@ -677,19 +636,42 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   return (doc["sv"] | true);
 }
 
-
 static const char s_cfg_json[] PROGMEM = "/cfg.json";
 
-void deserializeConfigFromFS() {
-  bool success = deserializeConfigSec();
+bool backupConfig() {
+  return backupFile(s_cfg_json);
+}
+
+bool restoreConfig() {
+  return restoreFile(s_cfg_json);
+}
+
+bool verifyConfig() {
+  return validateJsonFile(s_cfg_json);
+}
+
+// rename config file and reboot
+// if the cfg file doesn't exist, such as after a reset, do nothing
+void resetConfig() {
+  if (WLED_FS.exists(s_cfg_json)) {
+    DEBUG_PRINTLN(F("Reset config"));
+    char backupname[32];
+    snprintf_P(backupname, sizeof(backupname), PSTR("/rst.%s"), &s_cfg_json[1]);
+    WLED_FS.rename(s_cfg_json, backupname);
+    doReboot = true;
+  }
+}
+
+bool deserializeConfigFromFS() {
+  [[maybe_unused]] bool success = deserializeConfigSec();
   #ifdef WLED_ADD_EEPROM_SUPPORT
   if (!success) { //if file does not exist, try reading from EEPROM
     deEEPSettings();
-    return;
+    return true;
   }
   #endif
 
-  if (!requestJSONBufferLock(1)) return;
+  if (!requestJSONBufferLock(1)) return false;
 
   DEBUG_PRINTLN(F("Reading settings from /cfg.json..."));
 
@@ -699,17 +681,11 @@ void deserializeConfigFromFS() {
     #ifdef WLED_ADD_EEPROM_SUPPORT
     deEEPSettings();
     #endif
-
-    // save default values to /cfg.json
-    // call readFromConfig() with an empty object so that usermods can initialize to defaults prior to saving
-    JsonObject empty = JsonObject();
-    usermods.readFromConfig(empty);
-    serializeConfig();
     // init Ethernet (in case default type is set at compile time)
     #ifdef WLED_USE_ETHERNET
     WLED::instance().initEthernet();
     #endif
-    return;
+    return true; // config does not exist (we will need to save it once strip is initialised)
   }
 
   // NOTE: This routine deserializes *and* applies the configuration
@@ -718,11 +694,12 @@ void deserializeConfigFromFS() {
   bool needsSave = deserializeConfig(root, true);
   releaseJSONBufferLock();
 
-  if (needsSave) serializeConfig(); // usermods required new parameters
+  return needsSave;
 }
 
 void serializeConfig() {
   serializeConfigSec();
+  backupConfig(); // backup before writing new config
 
   DEBUG_PRINTLN(F("Writing settings to /cfg.json..."));
 
@@ -827,6 +804,9 @@ void serializeConfig() {
   hw_led["fps"] = strip.getTargetFps();
   hw_led[F("rgbwm")] = Bus::getGlobalAWMode(); // global auto white mode override
   hw_led[F("ld")] = useGlobalLedBuffer;
+  #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32C3)
+  hw_led[F("prl")] = BusManager::hasParallelOutput();
+  #endif
 
   #ifndef WLED_DISABLE_2D
   // 2D Matrix Settings
@@ -851,8 +831,19 @@ void serializeConfig() {
   JsonArray hw_led_ins = hw_led.createNestedArray("ins");
 
   for (size_t s = 0; s < BusManager::getNumBusses(); s++) {
+    DEBUG_PRINTF_P(PSTR("Cfg: Saving bus #%u\n"), s);
     Bus *bus = BusManager::getBus(s);
     if (!bus || bus->getLength()==0) break;
+    DEBUG_PRINTF_P(PSTR("  (%d-%d, type:%d, CO:%d, rev:%d, skip:%d, AW:%d kHz:%d, mA:%d/%d)\n"),
+      (int)bus->getStart(), (int)(bus->getStart()+bus->getLength()),
+      (int)(bus->getType() & 0x7F),
+      (int)bus->getColorOrder(),
+      (int)bus->isReversed(),
+      (int)bus->skippedLeds(),
+      (int)bus->getAutoWhiteMode(),
+      (int)bus->getFrequency(),
+      (int)bus->getLEDCurrent(), (int)bus->getMaxCurrent()
+    );
     JsonObject ins = hw_led_ins.createNestedObject();
     ins["start"] = bus->getStart();
     ins["len"] = bus->getLength();
@@ -973,6 +964,7 @@ void serializeConfig() {
   if_sync_recv["bri"] = receiveNotificationBrightness;
   if_sync_recv["col"] = receiveNotificationColor;
   if_sync_recv["fx"]  = receiveNotificationEffects;
+  if_sync_recv["pal"] = receiveNotificationPalette;
   if_sync_recv["grp"] = receiveGroups;
   if_sync_recv["seg"] = receiveSegmentOptions;
   if_sync_recv["sb"]  = receiveSegmentBounds;
@@ -1123,7 +1115,7 @@ void serializeConfig() {
   #endif
 
   JsonObject usermods_settings = root.createNestedObject("um");
-  usermods.addToConfig(usermods_settings);
+  UsermodManager::addToConfig(usermods_settings);
 
   File f = WLED_FS.open(FPSTR(s_cfg_json), "w");
   if (f) serializeJson(root, f);

wled00/colors.cpp

@@ -37,6 +37,8 @@ uint32_t color_blend(uint32_t color1, uint32_t color2, uint16_t blend, bool b16)
  */
 uint32_t color_add(uint32_t c1, uint32_t c2, bool fast)
 {
+  if (c1 == BLACK) return c2;
+  if (c2 == BLACK) return c1;
   if (fast) {
     uint8_t r = R(c1);
     uint8_t g = G(c1);
@@ -68,17 +70,18 @@ uint32_t color_add(uint32_t c1, uint32_t c2, bool fast)
 
 uint32_t color_fade(uint32_t c1, uint8_t amount, bool video)
 {
+  if (c1 == BLACK || amount + video == 0) return BLACK;
   uint32_t scaledcolor; // color order is: W R G B from MSB to LSB
   uint32_t r = R(c1);
   uint32_t g = G(c1);
   uint32_t b = B(c1);
   uint32_t w = W(c1);
-  uint32_t scale = amount + !video; // 32bit for faster calculation
+  uint32_t scale = amount; // 32bit for faster calculation
   if (video) {
-    scaledcolor  = (((r * scale) >> 8) << 16) + ((r && scale) ? 1 : 0);
-    scaledcolor |= (((g * scale) >> 8) << 8)  + ((g && scale) ? 1 : 0);
-    scaledcolor |=  ((b * scale) >> 8)        + ((b && scale) ? 1 : 0);
-    scaledcolor |= (((w * scale) >> 8) << 24) + ((w && scale) ? 1 : 0);
+    scaledcolor  = (((r * scale) >> 8) + ((r && scale) ? 1 : 0)) << 16;
+    scaledcolor |= (((g * scale) >> 8) + ((g && scale) ? 1 : 0)) << 8;
+    scaledcolor |=  ((b * scale) >> 8) + ((b && scale) ? 1 : 0);
+    scaledcolor |= (((w * scale) >> 8) + ((w && scale) ? 1 : 0)) << 24;
   } else {
     scaledcolor  = ((r * scale) >> 8) << 16;
     scaledcolor |= ((g * scale) >> 8) << 8;
@@ -195,7 +198,7 @@ CRGBPalette16 generateHarmonicRandomPalette(CRGBPalette16 &basepalette)
                        RGBpalettecolors[3]);
 }
 
-CRGBPalette16 generateRandomPalette(void)  //generate fully random palette
+CRGBPalette16 generateRandomPalette()  //generate fully random palette
 {
   return CRGBPalette16(CHSV(random8(), random8(160, 255), random8(128, 255)),
                        CHSV(random8(), random8(160, 255), random8(128, 255)),
@@ -476,14 +479,14 @@ void NeoGammaWLEDMethod::calcGammaTable(float gamma)
   }
 }
 
-uint8_t NeoGammaWLEDMethod::Correct(uint8_t value)
+uint8_t IRAM_ATTR_YN NeoGammaWLEDMethod::Correct(uint8_t value)
 {
   if (!gammaCorrectCol) return value;
   return gammaT[value];
 }
 
 // used for color gamma correction
-uint32_t NeoGammaWLEDMethod::Correct32(uint32_t color)
+uint32_t IRAM_ATTR_YN NeoGammaWLEDMethod::Correct32(uint32_t color)
 {
   if (!gammaCorrectCol) return color;
   uint8_t w = W(color);

wled00/const.h

@@ -37,7 +37,7 @@
 #endif
 
 #ifndef WLED_MAX_USERMODS
-  #ifdef ESP8266
+  #if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32S2)
     #define WLED_MAX_USERMODS 4
   #else
     #define WLED_MAX_USERMODS 6
@@ -49,30 +49,31 @@
     #define WLED_MAX_DIGITAL_CHANNELS 3
     #define WLED_MAX_ANALOG_CHANNELS 5
     #define WLED_MAX_BUSSES 4                 // will allow 3 digital & 1 analog RGB
-    #define WLED_MIN_VIRTUAL_BUSSES 2
+    #define WLED_MIN_VIRTUAL_BUSSES 3
   #else
+    #define WLED_MAX_ANALOG_CHANNELS (LEDC_CHANNEL_MAX*LEDC_SPEED_MODE_MAX)
     #if defined(CONFIG_IDF_TARGET_ESP32C3)    // 2 RMT, 6 LEDC, only has 1 I2S but NPB does not support it ATM
-      #define WLED_MAX_BUSSES 4               // will allow 2 digital & 2 analog RGB
+      #define WLED_MAX_BUSSES 6               // will allow 2 digital & 2 analog RGB or 6 PWM white
       #define WLED_MAX_DIGITAL_CHANNELS 2
-      #define WLED_MAX_ANALOG_CHANNELS 6
-      #define WLED_MIN_VIRTUAL_BUSSES 3
+      //#define WLED_MAX_ANALOG_CHANNELS 6
+      #define WLED_MIN_VIRTUAL_BUSSES 4
     #elif defined(CONFIG_IDF_TARGET_ESP32S2)  // 4 RMT, 8 LEDC, only has 1 I2S bus, supported in NPB
       // the 5th bus (I2S) will prevent Audioreactive usermod from functioning (it is last used though)
-      #define WLED_MAX_BUSSES 7               // will allow 5 digital & 2 analog RGB
-      #define WLED_MAX_DIGITAL_CHANNELS 5
-      #define WLED_MAX_ANALOG_CHANNELS 8
-      #define WLED_MIN_VIRTUAL_BUSSES 3
-    #elif defined(CONFIG_IDF_TARGET_ESP32S3)  // 4 RMT, 8 LEDC, has 2 I2S but NPB does not support them ATM
-      #define WLED_MAX_BUSSES 6               // will allow 4 digital & 2 analog RGB
-      #define WLED_MAX_DIGITAL_CHANNELS 4
-      #define WLED_MAX_ANALOG_CHANNELS 8
+      #define WLED_MAX_BUSSES 14              // will allow 12 digital & 2 analog RGB
+      #define WLED_MAX_DIGITAL_CHANNELS 12    // x4 RMT + x1/x8 I2S0
+      //#define WLED_MAX_ANALOG_CHANNELS 8
       #define WLED_MIN_VIRTUAL_BUSSES 4
+    #elif defined(CONFIG_IDF_TARGET_ESP32S3)  // 4 RMT, 8 LEDC, has 2 I2S but NPB supports parallel x8 LCD on I2S1
+      #define WLED_MAX_BUSSES 14              // will allow 12 digital & 2 analog RGB
+      #define WLED_MAX_DIGITAL_CHANNELS 12    // x4 RMT + x8 I2S-LCD
+      //#define WLED_MAX_ANALOG_CHANNELS 8
+      #define WLED_MIN_VIRTUAL_BUSSES 6
     #else
       // the last digital bus (I2S0) will prevent Audioreactive usermod from functioning
-      #define WLED_MAX_BUSSES 20              // will allow 17 digital & 3 analog RGB
-      #define WLED_MAX_DIGITAL_CHANNELS 17
-      #define WLED_MAX_ANALOG_CHANNELS 10
-      #define WLED_MIN_VIRTUAL_BUSSES 4
+      #define WLED_MAX_BUSSES 19              // will allow 16 digital & 3 analog RGB
+      #define WLED_MAX_DIGITAL_CHANNELS 16    // x1/x8 I2S1 + x8 RMT
+      //#define WLED_MAX_ANALOG_CHANNELS 16
+      #define WLED_MIN_VIRTUAL_BUSSES 6
     #endif
   #endif
 #else
@@ -114,7 +115,7 @@
   #endif
 #endif
 
-#ifdef ESP8266
+#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32S2)
 #define WLED_MAX_COLOR_ORDER_MAPPINGS 5
 #else
 #define WLED_MAX_COLOR_ORDER_MAPPINGS 10
@@ -124,7 +125,7 @@
   #undef WLED_MAX_LEDMAPS
 #endif
 #ifndef WLED_MAX_LEDMAPS
-  #ifdef ESP8266
+  #if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32S2)
     #define WLED_MAX_LEDMAPS 10
   #else
     #define WLED_MAX_LEDMAPS 16
@@ -281,6 +282,7 @@
 #define TYPE_NONE                 0            //light is not configured
 #define TYPE_RESERVED             1            //unused. Might indicate a "virtual" light
 //Digital types (data pin only) (16-39)
+#define TYPE_DIGITAL_MIN         16            // first usable digital type
 #define TYPE_WS2812_1CH          18            //white-only chips (1 channel per IC) (unused)
 #define TYPE_WS2812_1CH_X3       19            //white-only chips (3 channels per IC)
 #define TYPE_WS2812_2CH_X3       20            //CCT chips (1st IC controls WW + CW of 1st zone and CW of 2nd zone, 2nd IC controls WW of 2nd zone and WW + CW of 3rd zone)
@@ -298,26 +300,36 @@
 #define TYPE_WS2805              32            //RGB + WW + CW
 #define TYPE_TM1914              33            //RGB
 #define TYPE_SM16825             34            //RGB + WW + CW
+#define TYPE_DIGITAL_MAX         39            // last usable digital type
 //"Analog" types (40-47)
 #define TYPE_ONOFF               40            //binary output (relays etc.; NOT PWM)
+#define TYPE_ANALOG_MIN          41            // first usable analog type
 #define TYPE_ANALOG_1CH          41            //single channel PWM. Uses value of brightest RGBW channel
 #define TYPE_ANALOG_2CH          42            //analog WW + CW
 #define TYPE_ANALOG_3CH          43            //analog RGB
 #define TYPE_ANALOG_4CH          44            //analog RGBW
 #define TYPE_ANALOG_5CH          45            //analog RGB + WW + CW
+#define TYPE_ANALOG_6CH          46            //analog RGB + A + WW + CW
+#define TYPE_ANALOG_MAX          47            // last usable analog type
 //Digital types (data + clock / SPI) (48-63)
+#define TYPE_2PIN_MIN            48
 #define TYPE_WS2801              50
 #define TYPE_APA102              51
 #define TYPE_LPD8806             52
 #define TYPE_P9813               53
 #define TYPE_LPD6803             54
+#define TYPE_2PIN_MAX            63
 //Network types (master broadcast) (80-95)
+#define TYPE_VIRTUAL_MIN         80
 #define TYPE_NET_DDP_RGB         80            //network DDP RGB bus (master broadcast bus)
 #define TYPE_NET_E131_RGB        81            //network E131 RGB bus (master broadcast bus, unused)
 #define TYPE_NET_ARTNET_RGB      82            //network ArtNet RGB bus (master broadcast bus, unused)
 #define TYPE_NET_DDP_RGBW        88            //network DDP RGBW bus (master broadcast bus)
 #define TYPE_NET_ARTNET_RGBW     89            //network ArtNet RGB bus (master broadcast bus, unused)
+#define TYPE_VIRTUAL_MAX         95
 
+/*
+// old macros that have been moved to Bus class
 #define IS_TYPE_VALID(t) ((t) > 15 && (t) < 128)
 #define IS_DIGITAL(t)    (((t) > 15 && (t) < 40) || ((t) > 47 && (t) < 64)) //digital are 16-39 and 48-63
 #define IS_2PIN(t)       ((t) > 47 && (t) < 64)
@@ -326,6 +338,7 @@
 #define IS_PWM(t)        ((t) > 40 && (t) < 46)     //does not include on/Off type
 #define NUM_PWM_PINS(t)  ((t) - 40)                 //for analog PWM 41-45 only
 #define IS_VIRTUAL(t)    ((t) >= 80 && (t) < 96)    //this was a poor choice a better would be 96-111
+*/
 
 //Color orders
 #define COL_ORDER_GRB             0           //GRB(w),defaut
@@ -453,10 +466,15 @@
 #define NTP_PACKET_SIZE 48       // size of NTP receive buffer
 #define NTP_MIN_PACKET_SIZE 48   // min expected size - NTP v4 allows for "extended information" appended to the standard fields
 
+// Maximum number of pins per output. 5 for RGBCCT analog LEDs.
+#define OUTPUT_MAX_PINS 5
+
 //maximum number of rendered LEDs - this does not have to match max. physical LEDs, e.g. if there are virtual busses
 #ifndef MAX_LEDS
 #ifdef ESP8266
 #define MAX_LEDS 1664 //can't rely on memory limit to limit this to 1600 LEDs
+#elif defined(CONFIG_IDF_TARGET_ESP32S2)
+#define MAX_LEDS 2048 //due to memory constraints
 #else
 #define MAX_LEDS 8192
 #endif
@@ -466,7 +484,9 @@
   #ifdef ESP8266
     #define MAX_LED_MEMORY 4000
   #else
-    #if defined(ARDUINO_ARCH_ESP32S2) || defined(ARDUINO_ARCH_ESP32C3)
+    #if defined(ARDUINO_ARCH_ESP32S2)
+      #define MAX_LED_MEMORY 16000
+    #elif defined(ARDUINO_ARCH_ESP32C3)
       #define MAX_LED_MEMORY 32000
     #else
       #define MAX_LED_MEMORY 64000
@@ -480,7 +500,7 @@
 
 // string temp buffer (now stored in stack locally)
 #ifdef ESP8266
-#define SETTINGS_STACK_BUF_SIZE 2048
+#define SETTINGS_STACK_BUF_SIZE 2560
 #else
 #define SETTINGS_STACK_BUF_SIZE 3840  // warning: quite a large value for stack (640 * WLED_MAX_USERMODS)
 #endif
@@ -520,7 +540,11 @@
 #ifdef ESP8266
   #define WLED_PWM_FREQ    880 //PWM frequency proven as good for LEDs
 #else
-  #define WLED_PWM_FREQ  19531
+  #ifdef SOC_LEDC_SUPPORT_XTAL_CLOCK
+    #define WLED_PWM_FREQ 9765    // XTAL clock is 40MHz (this will allow 12 bit resolution)
+  #else
+    #define WLED_PWM_FREQ  19531  // APB clock is 80MHz
+  #endif
 #endif
 #endif
 
@@ -547,26 +571,19 @@
   #define WLED_MAX_NODES 150
 #endif
 
-//this is merely a default now and can be changed at runtime
-#ifndef LEDPIN
-#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)  //|| (defined(ARDUINO_ARCH_ESP32) && defined(BOARD_HAS_PSRAM)) || defined(ARDUINO_ESP32_PICO)
-  #define LEDPIN 2    // GPIO2 (D4) on Wemos D1 mini compatible boards, safe to use on any board
+// Defaults pins, type and counts to configure LED output
+#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)
+  #ifdef WLED_ENABLE_DMX
+    #define DEFAULT_LED_PIN 1
+    #warning "Compiling with DMX. The default LED pin has been changed to pin 1."
+  #else
+    #define DEFAULT_LED_PIN 2    // GPIO2 (D4) on Wemos D1 mini compatible boards, safe to use on any board
+  #endif
 #else
-  #define LEDPIN 16   // aligns with GPIO2 (D4) on Wemos D1 mini32 compatible boards (if it is unusable it will be reassigned in WS2812FX::finalizeInit())
-#endif
-#endif
-
-#ifdef WLED_ENABLE_DMX
-#if (LEDPIN == 2)
-  #undef LEDPIN
-  #define LEDPIN 1
-  #warning "Pin conflict compiling with DMX and LEDs on pin 2. The default LED pin has been changed to pin 1."
-#endif
-#endif
-
-#ifndef DEFAULT_LED_COUNT
-  #define DEFAULT_LED_COUNT 30
+  #define DEFAULT_LED_PIN 16   // aligns with GPIO2 (D4) on Wemos D1 mini32 compatible boards (if it is unusable it will be reassigned in WS2812FX::finalizeInit())
 #endif
+#define DEFAULT_LED_TYPE TYPE_WS2812_RGB
+#define DEFAULT_LED_COUNT 30
 
 #define INTERFACE_UPDATE_COOLDOWN 1000 // time in ms to wait between websockets, alexa, and MQTT updates
 

wled00/data/common.js

@@ -0,0 +1,118 @@
+var d=document;
+var loc = false, locip, locproto = "http:";
+
+function H(pg="")   { window.open("https://kno.wled.ge/"+pg); }
+function GH()       { window.open("https://github.com/Aircoookie/WLED"); }
+function gId(c)     { return d.getElementById(c); } // getElementById
+function cE(e)      { return d.createElement(e); } // createElement
+function gEBCN(c)   { return d.getElementsByClassName(c); } // getElementsByClassName
+function gN(s)      { return d.getElementsByName(s)[0]; } // getElementsByName
+function isE(o)     { return Object.keys(o).length === 0; } // isEmpty
+function isO(i)     { return (i && typeof i === 'object' && !Array.isArray(i)); } // isObject
+function isN(n)     { return !isNaN(parseFloat(n)) && isFinite(n); } // isNumber
+// https://stackoverflow.com/questions/3885817/how-do-i-check-that-a-number-is-float-or-integer
+function isF(n)     { return n === +n && n !== (n|0); } // isFloat
+function isI(n)     { return n === +n && n === (n|0); } // isInteger
+function toggle(el) { gId(el).classList.toggle("hide"); gId('No'+el).classList.toggle("hide"); }
+function tooltip(cont=null) {
+	d.querySelectorAll((cont?cont+" ":"")+"[title]").forEach((element)=>{
+		element.addEventListener("pointerover", ()=>{
+			// save title
+			element.setAttribute("data-title", element.getAttribute("title"));
+			const tooltip = d.createElement("span");
+			tooltip.className = "tooltip";
+			tooltip.textContent = element.getAttribute("title");
+
+			// prevent default title popup
+			element.removeAttribute("title");
+
+			let { top, left, width } = element.getBoundingClientRect();
+
+			d.body.appendChild(tooltip);
+
+			const { offsetHeight, offsetWidth } = tooltip;
+
+			const offset = element.classList.contains("sliderwrap") ? 4 : 10;
+			top -= offsetHeight + offset;
+			left += (width - offsetWidth) / 2;
+
+			tooltip.style.top = top + "px";
+			tooltip.style.left = left + "px";
+			tooltip.classList.add("visible");
+		});
+
+		element.addEventListener("pointerout", ()=>{
+			d.querySelectorAll('.tooltip').forEach((tooltip)=>{
+				tooltip.classList.remove("visible");
+				d.body.removeChild(tooltip);
+			});
+			// restore title
+			element.setAttribute("title", element.getAttribute("data-title"));
+		});
+	});
+};
+// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
+function loadJS(FILE_URL, async = true, preGetV = undefined, postGetV = undefined) {
+	let scE = d.createElement("script");
+	scE.setAttribute("src", FILE_URL);
+	scE.setAttribute("type", "text/javascript");
+	scE.setAttribute("async", async);
+	d.body.appendChild(scE);
+	// success event 
+	scE.addEventListener("load", () => {
+		//console.log("File loaded");
+		if (preGetV) preGetV();
+		GetV();
+		if (postGetV) postGetV();
+	});
+	// error event
+	scE.addEventListener("error", (ev) => {
+		console.log("Error on loading file", ev);
+		alert("Loading of configuration script failed.\nIncomplete page data!");
+	});
+}
+function getLoc() {
+	let l = window.location;
+	if (l.protocol == "file:") {
+		loc = true;
+		locip = localStorage.getItem('locIp');
+		if (!locip) {
+			locip = prompt("File Mode. Please enter WLED IP!");
+			localStorage.setItem('locIp', locip);
+		}
+	} else {
+		// detect reverse proxy
+		let path = l.pathname;
+		let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
+		if (paths.length > 1) paths.pop(); // remove subpage (or "settings")
+		if (paths.length > 0 && paths[paths.length-1]=="settings") paths.pop(); // remove "settings"
+		if (paths.length > 1) {
+			locproto = l.protocol;
+			loc = true;
+			locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
+		}
+	}
+}
+function getURL(path) { return (loc ? locproto + "//" + locip : "") + path; }
+function B()          { window.open(getURL("/settings"),"_self"); }
+var timeout;
+function showToast(text, error = false) {
+	var x = gId("toast");
+	if (!x) return;
+	x.innerHTML = text;
+	x.className = error ? "error":"show";
+	clearTimeout(timeout);
+	x.style.animation = 'none';
+	timeout = setTimeout(function(){ x.className = x.className.replace("show", ""); }, 2900);
+}
+function uploadFile(fileObj, name) {
+	var req = new XMLHttpRequest();
+	req.addEventListener('load', function(){showToast(this.responseText,this.status >= 400)});
+	req.addEventListener('error', function(e){showToast(e.stack,true);});
+	req.open("POST", "/upload");
+	var formData = new FormData();
+	formData.append("data", fileObj.files[0], name);
+	req.send(formData);
+	fileObj.value = '';
+	return false;
+}

wled00/data/cpal/cpal.htm

@@ -608,8 +608,8 @@
   }
 
   function generatePaletteDivs() {
-    const palettesDiv = d.getElementById("palettes");
-    const staticPalettesDiv = d.getElementById("staticPalettes");
+    const palettesDiv = gId("palettes");
+    const staticPalettesDiv = gId("staticPalettes");
     const paletteDivs = Array.from(palettesDiv.children).filter((child) => {
       return child.id.match(/^palette\d$/); // match only elements with id starting with "palette" followed by a single digit
     });
@@ -620,25 +620,25 @@
 
     for (let i = 0; i < paletteArray.length; i++) {
       const palette = paletteArray[i];
-      const paletteDiv = d.createElement("div");
+      const paletteDiv = cE("div");
       paletteDiv.id = `palette${i}`;
       paletteDiv.classList.add("palette");
       const thisKey = Object.keys(palette)[0];
       paletteDiv.dataset.colarray = JSON.stringify(palette[thisKey]);
 
-      const gradientDiv = d.createElement("div");
+      const gradientDiv = cE("div");
       gradientDiv.id = `paletteGradient${i}`
-      const buttonsDiv = d.createElement("div");
+      const buttonsDiv = cE("div");
       buttonsDiv.id = `buttonsDiv${i}`;
       buttonsDiv.classList.add("buttonsDiv")
 
-      const sendSpan = d.createElement("span");
+      const sendSpan = cE("span");
       sendSpan.id = `sendSpan${i}`;
       sendSpan.onclick = function() {initiateUpload(i)};
       sendSpan.setAttribute('title', `Send current editor to slot ${i}`); // perhaps Save instead of Send?
       sendSpan.innerHTML = svgSave;
       sendSpan.classList.add("sendSpan")
-      const editSpan = d.createElement("span");
+      const editSpan = cE("span");
       editSpan.id = `editSpan${i}`;
       editSpan.onclick = function() {loadForEdit(i)};
       editSpan.setAttribute('title', `Copy slot ${i} palette to editor`);

wled00/data/index.css

@@ -35,6 +35,7 @@
 	--sgp: "block";
 	--bmt: 0;
 	--sti: 42px;
+	--stp: 42px;
 }
 
 html {
@@ -143,7 +144,7 @@ button {
 }
 
 .huge {
-	font-size: 42px;
+	font-size: 60px !important;
 }
 
 .segt, .plentry TABLE {
@@ -468,7 +469,7 @@ button {
 	padding: 4px 2px;
 	position: relative;
 	opacity: 1;
-	transition: opacity .5s linear, height .25s, transform .25s;
+	transition: opacity .25s linear, height .2s, transform .2s;
 }
 
 .filter {
@@ -583,6 +584,10 @@ button {
 	z-index: 3;
 }
 
+#rover .ibtn {
+	margin: 5px;
+}
+
 #ndlt {
 	margin: 12px 0;
 }
@@ -623,7 +628,7 @@ button {
   padding-bottom: 8px;
 }
 
-.infobtn {
+#info .ibtn {
 	margin: 5px;
 }
 
@@ -847,7 +852,7 @@ input[type=range]::-moz-range-thumb {
 	width: 135px;
 }
 
-#nodes .infobtn {
+#nodes .ibtn {
 	margin: 0;
 }
 
@@ -1035,7 +1040,7 @@ textarea {
 
 .segname .flr, .pname .flr {
 	transform: rotate(0deg);
-	right: -6px;
+	/*right: -6px;*/
 }
 
 /* segment power wrapper */
@@ -1330,15 +1335,22 @@ TD .checkmark, TD .radiomark {
 	box-shadow: 0 0 10px 4px var(--c-1);
 }
 
+.lstI .flr:hover {
+    background: var(--c-6);
+    border-radius: 100%;
+}
+
 #pcont .selected:not([class*="expanded"]) {
 	bottom: 52px;
 	top: 42px;
 }
 
-#fxlist .lstI.selected,
-#pallist .lstI.selected {
+#fxlist .lstI.selected {
 	top: calc(var(--sti) + 42px);
 }
+#pallist .lstI.selected {
+	top: calc(var(--stp) + 42px);
+}
 
 dialog::backdrop {
 	backdrop-filter: blur(10px);
@@ -1353,10 +1365,12 @@ dialog {
 	color: var(--c-f);
 }
 
-#fxlist .lstI.sticky,
-#pallist .lstI.sticky {
+#fxlist .lstI.sticky {
 	top: var(--sti);
 }
+#pallist .lstI.sticky {
+	top: var(--stp);
+}
 
 /* list item content */
 .lstIcontent {
@@ -1519,7 +1533,7 @@ dialog {
 	#info table .btn, #nodes table .btn {
 		width: 200px;
 	}
-	#info .infobtn, #nodes .infobtn {
+	#info .ibtn, #nodes .ibtn {
 		width: 145px;
 	}
 	#info div, #nodes div, #nodes a.btn {

wled00/data/index.htm

@@ -128,7 +128,7 @@
 		<div style="padding: 8px 0;" id="btns">
 			<button class="btn btn-xs" title="File editor" type="button" id="edit" onclick="window.location.href=getURL('/edit')"><i class="icons btn-icon">&#xe2c6;</i></button>
 			<button class="btn btn-xs" title="Pixel Magic Tool" type="button" id="pxmb" onclick="window.location.href=getURL('/pxmagic.htm')"><i class="icons btn-icon">&#xe410;</i></button>
-			<button class="btn btn-xs" title="Add custom palette" type="button" onclick="window.location.href=getURL('/cpal.htm')"><i class="icons btn-icon">&#xe18a;</i></button>
+			<button class="btn btn-xs" title="Add custom palette" type="button" id="adPal" onclick="window.location.href=getURL('/cpal.htm')"><i class="icons btn-icon">&#xe18a;</i></button>
 			<button class="btn btn-xs" title="Remove last custom palette" type="button" id="rmPal" onclick="palettesData=null;localStorage.removeItem('wledPalx');requestJson({rmcpal:true});setTimeout(loadPalettes,250,loadPalettesData);"><i class="icons btn-icon">&#xe037;</i></button>
 		</div>
 		<p class="labels hd" id="pall"><i class="icons sel-icon" onclick="tglHex()">&#xe2b3;</i> Color palette</p>
@@ -304,10 +304,10 @@
 	</div>
 	<div id="kv">Loading...</div><br>
 	<div>
-		<button class="btn infobtn" onclick="requestJson()">Refresh</button>
-		<button class="btn infobtn" onclick="toggleNodes()">Instance List</button>
-		<button class="btn infobtn" onclick="window.open(getURL('/update'),'_self');">Update WLED</button>
-		<button class="btn infobtn" id="resetbtn" onclick="cnfReset()">Reboot WLED</button>
+		<button class="btn ibtn" onclick="requestJson()">Refresh</button>
+		<button class="btn ibtn" onclick="toggleNodes()">Instance List</button>
+		<button class="btn ibtn" onclick="window.open(getURL('/update'),'_self');">Update WLED</button>
+		<button class="btn ibtn" id="resetbtn" onclick="cnfReset()">Reboot WLED</button>
 	</div>
 	<br>
 	<span class="h">Made with&#32;<span id="heart">&#10084;&#xFE0E;</span>&#32;by&#32;<a href="https://github.com/Aircoookie/" target="_blank">Aircoookie</a>&#32;and the&#32;<a href="https://wled.discourse.group/" target="_blank">WLED community</a></span>
@@ -318,7 +318,7 @@
 	<div id="ndlt">WLED instances</div>
 	<div id="kn">Loading...</div>
 	<div style="position:sticky;bottom:0;">
-		<button class="btn infobtn" onclick="loadNodes()">Refresh</button>
+		<button class="btn ibtn" onclick="loadNodes()">Refresh</button>
 	</div>
 </div>
 
@@ -331,8 +331,8 @@
 	<div id="lv">?</div><br><br>
 	To use built-in effects, use an override button below.<br>
 	You can return to realtime mode by pressing the star in the top left corner.<br>
-	<button class="btn" onclick="setLor(1)">Override once</button>
-	<button class="btn" onclick="setLor(2)">Override until reboot</button><br>
+	<button class="btn ibtn" onclick="setLor(1)">Override once</button>
+	<button class="btn ibtn" onclick="setLor(2)">Override until reboot</button><br>
 	<span class="h">For best performance, it is recommended to turn off the streaming source when not in use.</span>
 </div>
 

wled00/data/index.js

@@ -773,8 +773,8 @@ function populateSegments(s)
 		}
 
 		let segp = `<div id="segp${i}" class="sbs">`+
-						`<i class="icons slider-icon pwr ${inst.on ? "act":""}" id="seg${i}pwr" onclick="setSegPwr(${i})">&#xe08f;</i>`+
-						`<div class="sliderwrap il">`+
+						`<i class="icons slider-icon pwr ${inst.on ? "act":""}" id="seg${i}pwr" title="Power" onclick="setSegPwr(${i})">&#xe08f;</i>`+
+						`<div class="sliderwrap il" title="Opacity/Brightness">`+
 							`<input id="seg${i}bri" class="noslide" onchange="setSegBri(${i})" oninput="updateTrail(this)" max="255" min="1" type="range" value="${inst.bri}" />`+
 							`<div class="sliderdisplay"></div>`+
 						`</div>`+
@@ -810,7 +810,7 @@ function populateSegments(s)
 		cn += `<div class="seg lstI ${i==s.mainseg && !simplifiedUI ? 'selected' : ''} ${exp ? "expanded":""}" id="seg${i}" data-set="${inst.set}">`+
 				`<label class="check schkl ${smpl}">`+
 					`<input type="checkbox" id="seg${i}sel" onchange="selSeg(${i})" ${inst.sel ? "checked":""}>`+
-					`<span class="checkmark"></span>`+
+					`<span class="checkmark" title="Select"></span>`+
 				`</label>`+
 				`<div class="segname ${smpl}" onclick="selSegEx(${i})">`+
 					`<i class="icons e-icon frz" id="seg${i}frz" title="(un)Freeze" onclick="event.preventDefault();tglFreeze(${i});">&#x${inst.frz ? (li.live && li.liveseg==i?'e410':'e0e8') : 'e325'};</i>`+
@@ -1659,13 +1659,17 @@ function setEffectParameters(idx)
 			paOnOff[0] = paOnOff[0].substring(0,dPos);
 		}
 		if (paOnOff.length>0 && paOnOff[0] != "!") text = paOnOff[0];
+		gId("adPal").classList.remove("hide");
+		if (lastinfo.cpalcount>0) gId("rmPal").classList.remove("hide");
 	} else {
 		// disable palette list
 		text += ' not used';
 		palw.style.display = "none";
+		gId("adPal").classList.add("hide");
+		gId("rmPal").classList.add("hide");
 		// Close palette dialog if not available
-		if (gId("palw").lastElementChild.tagName == "DIALOG") {
-			gId("palw").lastElementChild.close();
+		if (palw.lastElementChild.tagName == "DIALOG") {
+			palw.lastElementChild.close();
 		}
 	}
 	pall.innerHTML = icon + text;
@@ -1879,7 +1883,7 @@ function makeSeg()
 function resetUtil(off=false)
 {
 	gId('segutil').innerHTML = `<div class="seg btn btn-s${off?' off':''}" style="padding:0;margin-bottom:12px;">`
-	+ '<label class="check schkl"><input type="checkbox" id="selall" onchange="selSegAll(this)"><span class="checkmark"></span></label>'
+	+ '<label class="check schkl"><input type="checkbox" id="selall" onchange="selSegAll(this)"><span class="checkmark" title="Select all"></span></label>'
 	+ `<div class="segname" ${off?'':'onclick="makeSeg()"'}><i class="icons btn-icon">&#xe18a;</i>Add segment</div>`
 	+ '<div class="pop hide" onclick="event.stopPropagation();">'
 	+ `<i class="icons g-icon" title="Select group" onclick="this.nextElementSibling.classList.toggle('hide');">&#xE34B;</i>`
@@ -2649,28 +2653,28 @@ function fromRgb()
 	var g = gId('sliderG').value;
 	var b = gId('sliderB').value;
 	setPicker(`rgb(${r},${g},${b})`);
-	let cd = gId('csl').children; // color slots
-	cd[csel].dataset.r = r;
-	cd[csel].dataset.g = g;
-	cd[csel].dataset.b = b;
-	setCSL(cd[csel]);
+	let cd = gId('csl').children[csel]; // color slots
+	cd.dataset.r = r;
+	cd.dataset.g = g;
+	cd.dataset.b = b;
+	setCSL(cd);
 }
 
 function fromW()
 {
 	let w = gId('sliderW');
-	let cd = gId('csl').children; // color slots
-	cd[csel].dataset.w = w.value;
-	setCSL(cd[csel]);
+	let cd = gId('csl').children[csel]; // color slots
+	cd.dataset.w = w.value;
+	setCSL(cd);
 	updateTrail(w);
 }
 
 // sr 0: from RGB sliders, 1: from picker, 2: from hex
 function setColor(sr)
 {
-	var cd = gId('csl').children; // color slots
-	let cdd = cd[csel].dataset;
-	let w = 0, r,g,b;
+	var cd = gId('csl').children[csel]; // color slots
+	let cdd = cd.dataset;
+	let w = parseInt(cdd.w), r = parseInt(cdd.r), g = parseInt(cdd.g), b = parseInt(cdd.b);
 	if (sr == 1 && isRgbBlack(cdd)) cpick.color.setChannel('hsv', 'v', 100);
 	if (sr != 2 && hasWhite) w = parseInt(gId('sliderW').value);
 	var col = cpick.color.rgb;
@@ -2678,7 +2682,7 @@ function setColor(sr)
 	cdd.g = g = hasRGB ? col.g : w;
 	cdd.b = b = hasRGB ? col.b : w;
 	cdd.w = w;
-	setCSL(cd[csel]);
+	setCSL(cd);
 	var obj = {"seg": {"col": [[],[],[]]}};
 	obj.seg.col[csel] = [r, g, b, w];
 	requestJson(obj);
@@ -2827,8 +2831,13 @@ function search(field, listId = null) {
 
 	// restore default preset sorting if no search term is entered
 	if (!search) {
-		if (listId === 'pcont')   { populatePresets(); return; }
-		if (listId === 'pallist') { populatePalettes(); return; }
+		if (listId === 'pcont') { populatePresets(); return; }
+		if (listId === 'pallist') {
+			let id = parseInt(d.querySelector('#pallist input[name="palette"]:checked').value); // preserve selected palette
+			populatePalettes();
+			updateSelectedPalette(id);
+			return;
+		}
 	}
 
 	// clear filter if searching in fxlist
@@ -2841,12 +2850,16 @@ function search(field, listId = null) {
 
 	// filter list items but leave (Default & Solid) always visible
 	const listItems = gId(listId).querySelectorAll('.lstI');
-	listItems.forEach((listItem,i)=>{
-		if (listId!=='pcont' && i===0) return;
+	listItems.forEach((listItem, i) => {
+		if (listId !== 'pcont' && i === 0) return;
 		const listItemName = listItem.querySelector('.lstIname').innerText.toUpperCase();
 		const searchIndex = listItemName.indexOf(field.value.toUpperCase());
-		listItem.style.display = (searchIndex < 0) ? 'none' : '';
-		listItem.dataset.searchIndex = searchIndex;
+		if (searchIndex < 0) {
+			listItem.dataset.searchIndex = Number.MAX_SAFE_INTEGER;
+		} else {
+			listItem.dataset.searchIndex = searchIndex;
+		}
+		listItem.style.display = (searchIndex < 0) && !listItem.classList.contains("selected") ? 'none' : '';
 	});
 
 	// sort list items by search index and name
@@ -2887,18 +2900,25 @@ function initFilters() {
 
 function filterFocus(e) {
 	const f = gId("filters");
-	if (e.type === "focus") f.classList.remove('fade');	// immediately show (still has transition)
-	// compute sticky top (with delay for transition)
-	setTimeout(() => {
-		const sti = parseInt(getComputedStyle(d.documentElement).getPropertyValue('--sti')) + (e.type === "focus" ? 1 : -1) * f.offsetHeight;
-		sCol('--sti', sti + "px");
-	}, 252);
+	const c = !!f.querySelectorAll("input[type=checkbox]:checked").length;
+	const h = f.offsetHeight;
+	const sti = parseInt(getComputedStyle(d.documentElement).getPropertyValue('--sti'));
+	if (e.type === "focus") {
+		// compute sticky top (with delay for transition)
+		if (!h) setTimeout(() => {
+			sCol('--sti', (sti+f.offsetHeight) + "px"); // has an unpleasant consequence on palette offset
+		}, 255);
+		f.classList.remove('fade');	// immediately show (still has transition)
+	}
 	if (e.type === "blur") {
 		setTimeout(() => {
 			if (e.target === document.activeElement && document.hasFocus()) return;
 			// do not hide if filter is active
-			if (gId("filters").querySelectorAll("input[type=checkbox]:checked").length) return;
-			f.classList.add('fade');
+			if (!c) {
+				// compute sticky top
+				sCol('--sti', (sti-h) + "px"); // has an unpleasant consequence on palette offset
+				f.classList.add('fade');
+			}
 		}, 255);	// wait with hiding
 	}
 }
@@ -2908,11 +2928,11 @@ function filterFx() {
 	inputField.value = '';
 	inputField.focus();
 	clean(inputField.nextElementSibling);
-	gId("fxlist").querySelectorAll('.lstI').forEach((listItem,i) => {
+	gId("fxlist").querySelectorAll('.lstI').forEach((listItem, i) => {
 		const listItemName = listItem.querySelector('.lstIname').innerText;
 		let hide = false;
-		gId("filters").querySelectorAll("input[type=checkbox]").forEach((e) => { if (e.checked && !listItemName.includes(e.dataset.flt)) hide = true; });
-		listItem.style.display = hide ? 'none' : '';
+		gId("filters").querySelectorAll("input[type=checkbox]").forEach((e) => { if (e.checked && !listItemName.includes(e.dataset.flt)) hide = i > 0 /*true*/; });
+		listItem.style.display = hide && !listItem.classList.contains("selected") ? 'none' : '';
 	});
 }
 
@@ -3098,10 +3118,9 @@ function mergeDeep(target, ...sources)
 	return mergeDeep(target, ...sources);
 }
 
-function tooltip(cont=null)
-{
+function tooltip(cont=null) {
 	d.querySelectorAll((cont?cont+" ":"")+"[title]").forEach((element)=>{
-		element.addEventListener("mouseover", ()=>{
+		element.addEventListener("pointerover", ()=>{
 			// save title
 			element.setAttribute("data-title", element.getAttribute("title"));
 			const tooltip = d.createElement("span");
@@ -3126,7 +3145,7 @@ function tooltip(cont=null)
 			tooltip.classList.add("visible");
 		});
 
-		element.addEventListener("mouseout", ()=>{
+		element.addEventListener("pointerout", ()=>{
 			d.querySelectorAll('.tooltip').forEach((tooltip)=>{
 				tooltip.classList.remove("visible");
 				d.body.removeChild(tooltip);
@@ -3201,7 +3220,7 @@ function simplifyUI() {
 	createDropdown("palw", "Change palette");
 	createDropdown("fx", "Change effect", [gId("fxFind"), gId("fxlist")]);
 
-	// Hide pallete label
+	// Hide palette label
 	gId("pall").style.display = "none";
 	gId("Colors").insertBefore(document.createElement("br"), gId("pall"));
 	// Hide effect label

wled00/data/pxmagic/pxmagic.htm

@@ -882,10 +882,8 @@
       hostnameLabel();
     })();
 
-    function gId(id) {
-      return d.getElementById(id);
-    }
-
+    function gId(e) {return d.getElementById(e);}
+    function cE(e) {return d.createElement(e);}
     function hostnameLabel() {
       const link = gId("wledEdit");
       link.href = WLED_URL + "/edit";
@@ -1675,7 +1673,7 @@
     }
 
     function createCanvas(width, height) {
-      const canvas = d.createElement("canvas");
+      const canvas = cE("canvas");
 
       canvas.width = width;
       canvas.height = height;
@@ -1719,7 +1717,7 @@
       const blob = new Blob([text], { type: mimeType });
       const url = URL.createObjectURL(blob);
 
-      const anchorElement = d.createElement("a");
+      const anchorElement = cE("a");
       anchorElement.href = url;
       anchorElement.download = `${filename}.${fileExtension}`;
 
@@ -1790,7 +1788,7 @@
       hideElement = "preview"
     ) {
       const hide = gId(hideElement);
-      const toast = d.createElement("div");
+      const toast = cE("div");
       const wait = 100;
 
       toast.style.animation = "fadeIn";
@@ -1799,14 +1797,14 @@
 
       toast.classList.add("toast", type);
 
-      const body = d.createElement("span");
+      const body = cE("span");
       body.classList.add("toast-body");
 
       body.textContent = message;
 
       toast.appendChild(body);
 
-      const progress = d.createElement("div");
+      const progress = cE("div");
       progress.classList.add("toast-progress");
 
       progress.style.animation = "progress";
@@ -1831,7 +1829,7 @@
 
     function carousel(id, images, delay = 3000) {
       let index = 0;
-      const carousel = d.createElement("div");
+      const carousel = cE("div");
       carousel.classList.add("carousel");
 
       images.forEach((canvas, i) => {
@@ -1959,7 +1957,7 @@
           let errorElement = parent.querySelector(".error-message");
 
           if (!errorElement) {
-            errorElement = d.createElement("div");
+            errorElement = cE("div");
             errorElement.classList.add("error-message");
             parent.appendChild(errorElement);
           }

wled00/data/settings.htm

@@ -4,53 +4,12 @@
 	<meta charset="UTF-8">
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<title>WLED Settings</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-		var d=document;
-		var loc = false, locip, locproto = "http:";
-		function gId(n){return d.getElementById(n);}
-		// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-		function loadJS(FILE_URL, async = true) {
-			let scE = d.createElement("script");
-			scE.setAttribute("src", FILE_URL);
-			scE.setAttribute("type", "text/javascript");
-			scE.setAttribute("async", async);
-			d.body.appendChild(scE);
-			// success event 
-			scE.addEventListener("load", () => {
-				//console.log("File loaded");
-				GetV();
-			});
-			// error event
-			scE.addEventListener("error", (ev) => {
-				console.log("Error on loading file", ev);
-				alert("Loading of configuration script failed.\nIncomplete page data!");
-			});
-		}
 		function S() {
-			let l = window.location;
-			if (l.protocol == "file:") {
-				loc = true;
-				locip = localStorage.getItem('locIp');
-				if (!locip) {
-					locip = prompt("File Mode. Please enter WLED IP!");
-					localStorage.setItem('locIp', locip);
-				}
-			} else {
-				// detect reverse proxy
-				let path = l.pathname;
-				let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-				if (paths.length > 1) {
-					paths.pop(); // remove "settings"
-					locproto = l.protocol;
-					loc = true;
-					locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-				}
-			}
+			getLoc();
 			loadJS(getURL('/settings/s.js?p=0'), false);	// If we set async false, file is loaded and executed, then next statement is processed
 		}
-		function getURL(path) {
-			return (loc ? locproto + "//" + locip : "") + path;
-		}
 	</script>
 	<style>
 		body {

wled00/data/settings_2D.htm

@@ -4,62 +4,19 @@
 	<meta charset="utf-8">
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<title>2D Set-up</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-	var d=document;
-	var loc = false, locip, locproto = "http:";
 	var maxPanels=64;
-	var ctx = null; // WLEDMM
-	function H(){window.open("https://kno.wled.ge/features/2D");}
-	function B(){window.open(getURL("/settings"),"_self");}
-	function gId(n){return d.getElementById(n);}
+	var ctx = null;
 	function fS(){d.Sf.submit();} // <button type=submit> sometimes didn't work
-	// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-	function loadJS(FILE_URL, async = true) {
-		let scE = d.createElement("script");
-		scE.setAttribute("src", FILE_URL);
-		scE.setAttribute("type", "text/javascript");
-		scE.setAttribute("async", async);
-		d.body.appendChild(scE);
-		// success event 
-		scE.addEventListener("load", () => {
-			//console.log("File loaded");
-			GetV();
+	function S() {
+		getLoc();
+		loadJS(getURL('/settings/s.js?p=10'), false, undefined, ()=>{
 			UI();
 			Sf.MPC.setAttribute("max",maxPanels);
-		});
-		// error event
-		scE.addEventListener("error", (ev) => {
-			console.log("Error on loading file", ev);
-			alert("Loading of configuration script failed.\nIncomplete page data!");
-		});
-	}
-	function S() {
-		let l = window.location;
-		if (l.protocol == "file:") {
-			loc = true;
-			locip = localStorage.getItem('locIp');
-			if (!locip) {
-				locip = prompt("File Mode. Please enter WLED IP!");
-				localStorage.setItem('locIp', locip);
-			}
-		} else {
-			// detect reverse proxy
-			let path = l.pathname;
-			let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-			if (paths.length > 2) {
-				paths.pop(); // remove "2d"
-				paths.pop(); // remove "settings"
-				locproto = l.protocol;
-				loc = true;
-				locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-			}
-		}
-		loadJS(getURL('/settings/s.js?p=10'), false);	// If we set async false, file is loaded and executed, then next statement is processed
+		});	// If we set async false, file is loaded and executed, then next statement is processed
 		if (loc) d.Sf.action = getURL('/settings/2D');
 	}
-	function getURL(path) {
-			return (loc ? locproto + "//" + locip : "") + path;
-	}
 
 	function UI() {
 		if (gId("somp").value === "0") {
@@ -71,29 +28,6 @@
 		draw();
 	}
 
-	var timeout;
-	function showToast(text, error = false)
-	{
-		var x = gId("toast");
-		x.innerHTML = text;
-		x.className = error ? "error":"show";
-		clearTimeout(timeout);
-		x.style.animation = 'none';
-		timeout = setTimeout(function(){ x.className = x.className.replace("show", ""); }, 2900);
-	}
-
-	function uploadFile(name) {
-		var req = new XMLHttpRequest();
-		req.addEventListener('load', function(){showToast(this.responseText,this.status >= 400)});
-		req.addEventListener('error', function(e){showToast(e.stack,true);});
-		req.open("POST", "/upload");
-		var formData = new FormData();
-		formData.append("data", d.Sf.data.files[0], name);
-		req.send(formData);
-		d.Sf.data.value = '';
-		return false;
-	}
-
 	function addPanels() {
 		let c = parseInt(d.Sf.MPC.value);
 		let i = gId("panels").children.length;
@@ -308,7 +242,7 @@ Y:<input name="P${i}Y" type="number" min="0" max="255" value="0" oninput="UI()">
 <body onload="S()">
 	<form id="form_s" name="Sf" method="post">
 	<div class="toprow">
-		<div class="helpB"><button type="button" onclick="H()">?</button></div>
+		<div class="helpB"><button type="button" onclick="H('features/2D')">?</button></div>
 		<button type="button" onclick="B()">Back</button><button type="button" onclick="fS()">Save</button><hr>
 	</div>
 	<h2>2D setup</h2>
@@ -351,7 +285,7 @@ Y:<input name="P${i}Y" type="number" min="0" max="255" value="0" oninput="UI()">
 		<hr class="sml">
 		<div id="MD"></div>
 		<canvas id="canvas"></canvas>
-		<div id="json" >Gap file: <input type="file" name="data" accept=".json"><button type="button" class="sml" onclick="uploadFile('/2d-gaps.json')">Upload</button></div>
+		<div id="json" >Gap file: <input type="file" name="data" accept=".json"><button type="button" class="sml" onclick="uploadFile(d.Sf.data,'/2d-gaps.json')">Upload</button></div>
 		<i>Note: Gap file is a <b>.json</b> file containing an array with number of elements equal to the matrix size.<br>
 			A value of -1 means that pixel at that position is missing, a value of 0 means never paint that pixel, and 1 means regular pixel.</i>
 	</div>

wled00/data/settings_dmx.htm

@@ -4,88 +4,46 @@
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<meta charset="utf-8">
 	<title>DMX Settings</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-	var d=document;
-	var loc = false, locip, locproto = "http:";
-	function H(){window.open("https://github.com/Aircoookie/WLED/wiki/DMX");}
-	function B(){window.open(getURL("/settings"),"_self");}
+	function HW(){window.open("https://github.com/Aircoookie/WLED/wiki/DMX");}
 	function GCH(num) {
-		d.getElementById('dmxchannels').innerHTML += "";
+		gId('dmxchannels').innerHTML += "";
 		for (i=0;i<num;i++) {
-			d.getElementById('dmxchannels').innerHTML += "<span id=CH" + (i+1) + "s >Channel " + (i+1) + ": <select name=CH" + (i+1) + " id=\"CH" + (i+1) + "\"><option value=0>Set to 0</option><option value=1>Red</option><option value=2>Green</option><option value=3>Blue</option><option value=4>White</option><option value=5>Shutter (Brightness)</option><option value=6>Set to 255</option></select></span><br />\n";
+			gId('dmxchannels').innerHTML += "<span id=CH" + (i+1) + "s >Channel " + (i+1) + ": <select name=CH" + (i+1) + " id=\"CH" + (i+1) + "\"><option value=0>Set to 0</option><option value=1>Red</option><option value=2>Green</option><option value=3>Blue</option><option value=4>White</option><option value=5>Shutter (Brightness)</option><option value=6>Set to 255</option></select></span><br />\n";
 		}
 	}
 	function mMap(){
 		numCh=document.Sf.CN.value;
 		numGap=document.Sf.CG.value;
 		if (parseInt(numCh)>parseInt(numGap)) {
-			d.getElementById("gapwarning").style.display="block";
+			gId("gapwarning").style.display="block";
 		} else {
-			d.getElementById("gapwarning").style.display="none";
+			gId("gapwarning").style.display="none";
 		}
 		for (i=0;i<15;i++) {
 			if (i>=numCh) {
-				d.getElementById("CH"+(i+1) + "s").style.opacity = "0.5";
-				d.getElementById("CH"+(i+1)).disabled = true;
+				gId("CH"+(i+1) + "s").style.opacity = "0.5";
+				gId("CH"+(i+1)).disabled = true;
 				
 			} else {
-				d.getElementById("CH"+(i+1) + "s").style.opacity = "1";
-				d.getElementById("CH"+(i+1)).disabled = false;
+				gId("CH"+(i+1) + "s").style.opacity = "1";
+				gId("CH"+(i+1)).disabled = false;
 			}
 		}
 	}
-	// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-	function loadJS(FILE_URL, async = true) {
-		let scE = d.createElement("script");
-		scE.setAttribute("src", FILE_URL);
-		scE.setAttribute("type", "text/javascript");
-		scE.setAttribute("async", async);
-		d.body.appendChild(scE);
-		// success event 
-		scE.addEventListener("load", () => {
-			//console.log("File loaded");
-			GCH(15);GetV();mMap();
-		});
-		// error event
-		scE.addEventListener("error", (ev) => {
-			console.log("Error on loading file", ev);
-			alert("Loading of configuration script failed.\nIncomplete page data!");
-		});
-	}
 	function S(){
-		let l = window.location;
-		if (l.protocol == "file:") {
-			loc = true;
-			locip = localStorage.getItem('locIp');
-			if (!locip) {
-				locip = prompt("File Mode. Please enter WLED IP!");
-				localStorage.setItem('locIp', locip);
-			}
-		} else {
-			// detect reverse proxy
-			let path = l.pathname;
-			let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-			if (paths.length > 2) {
-				paths.pop(); // remove "dmx"
-				paths.pop(); // remove "settings"
-				locproto = l.protocol;
-				loc = true;
-				locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-			}
-		}
-		loadJS(getURL('/settings/s.js?p=7'), false);	// If we set async false, file is loaded and executed, then next statement is processed
+		getLoc();
+		loadJS(getURL('/settings/s.js?p=7'), false, ()=>{GCH(15);}, ()=>{mMap();}); // If we set async false, file is loaded and executed, then next statement is processed
 		if (loc) d.Sf.action = getURL('/settings/dmx');
 	}
-	function getURL(path) {
-		return (loc ? locproto + "//" + locip : "") + path;
-	}
 	</script>
 	<style>@import url("style.css");</style>
 </head>
 <body onload="S()">
 <form id="form_s" name="Sf" method="post">
 <div class="toprow">
-<div class="helpB"><button type="button" onclick="H()">?</button></div>
+<div class="helpB"><button type="button" onclick="HW()">?</button></div>
 <button type="button" onclick="B()">Back</button><button type="submit">Save</button><hr>
 </div>
 <h2>Imma firin ma lazer (if it has DMX support)</h2><!-- TODO: Change to something less-meme-related //-->

wled00/data/settings_leds.htm

@@ -4,71 +4,58 @@
 	<meta charset="utf-8">
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<title>LED Settings</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-		var d=document,laprev=55,maxB=1,maxD=1,maxA=1,maxV=0,maxM=4000,maxPB=4096,maxL=1333,maxCO=10,maxLbquot=0; //maximum bytes for LED allocation: 4kB for 8266, 32kB for 32
-		var oMaxB=1;
-		d.um_p = [];
-		d.rsvd = [];
-		d.ro_gpio = [];
-		d.max_gpio = 50;
+		var maxB=1,maxD=1,maxA=1,maxV=0,maxM=4000,maxPB=2048,maxL=1664,maxCO=5; //maximum bytes for LED allocation: 4kB for 8266, 32kB for 32
 		var customStarts=false,startsDirty=[];
-		var loc = false, locip, locproto = "http:";
-		function H(){window.open("https://kno.wled.ge/features/settings/#led-settings");}
-		function B(){window.open(getURL("/settings"),"_self");}
-		function gId(n){return d.getElementById(n);}
-		function off(n){d.getElementsByName(n)[0].value = -1;}
+		function off(n)    { gN(n).value = -1;}
 		// these functions correspond to C macros found in const.h
-		function isPWM(t) { return t > 40 && t < 46; }                      // is PWM type
-		function isAna(t) { return t == 40 || isPWM(t); }                   // is analog type
-		function isDig(t) { return (t > 15 && t < 40) || isD2P(t); }        // is digital type
-		function isD2P(t) { return t > 47 && t < 64; }                      // is digital 2 pin type
-		function is16b(t) { return t == 26 || t == 29 || t == 34; }         // is digital 16 bit type
-		function isVir(t) { return t >= 80 && t < 96; }                     // is virtual type
-		function hasW(t)  { return (t >= 18 && t <= 21) || (t >= 28 && t <= 32) || t == 34 || (t >= 44 && t <= 45) || (t >= 88 && t <= 89); }
-		function hasCCT(t) { return t == 20 || t == 21 || t == 42 || t == 45 || t == 28 || t == 32 || t == 34; }
-		// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-		function loadJS(FILE_URL, async = true) {
-			let scE = d.createElement("script");
-			scE.setAttribute("src", FILE_URL);
-			scE.setAttribute("type", "text/javascript");
-			scE.setAttribute("async", async);
-			d.body.appendChild(scE);
-			// success event 
-			scE.addEventListener("load", () => {
-				GetV();
+		function gT(t)     { for (let type of d.ledTypes) if (t == type.i) return type; } // getType from available ledTypes
+		function isPWM(t)  { return gT(t).t.charAt(0) === "A"; }    // is PWM type
+		function isAna(t)  { return gT(t).t === "" || isPWM(t); }   // is analog type
+		function isDig(t)  { return gT(t).t === "D" || isD2P(t); }  // is digital type
+		function isD2P(t)  { return gT(t).t === "2P"; }             // is digital 2 pin type
+		function isNet(t)  { return gT(t).t === "N"; }              // is network type
+		function isVir(t)  { return gT(t).t === "V" || isNet(t); }  // is virtual type
+		function hasRGB(t) { return !!(gT(t).c & 0x01); }           // has RGB
+		function hasW(t)   { return !!(gT(t).c & 0x02); }           // has white channel
+		function hasCCT(t) { return !!(gT(t).c & 0x04); }           // is white CCT enabled
+		function is16b(t)  { return !!(gT(t).c & 0x10); }           // is digital 16 bit type
+		function mustR(t)  { return !!(gT(t).c & 0x20); }           // Off refresh is mandatory
+		function numPins(t){ return Math.max(gT(t).t.length, 1); }  // type length determines number of GPIO pins
+		function chrID(x)  { return String.fromCharCode((x<10?48:55)+x); }
+		function S() {
+			getLoc();
+			loadJS(getURL('/settings/s.js?p=2'), false, ()=>{
+				d.ledTypes = [/*{i:22,c:1,t:"D",n:"WS2812"},{i:42,c:6,t:"AA",n:"PWM CCT"}*/]; // filled from GetV()
+				d.um_p = [];
+				d.rsvd = [];
+				d.ro_gpio = [];
+				d.max_gpio = 50;
+			}, ()=>{
 				checkSi();
 				setABL();
 				d.Sf.addEventListener("submit", trySubmit);
 				if (d.um_p[0]==-1) d.um_p.shift();
 				pinDropdowns();
-			});
-			// error event
-			scE.addEventListener("error", (ev) => {
-				console.log("Error on loading file", ev);
-				alert("Loading of configuration script failed.\nIncomplete page data!");
-			});
-		}
-		var timeout;
-		function showToast(text, error = false)
-		{
-			var x = gId("toast");
-			x.innerHTML = text;
-			x.className = error ? "error":"show";
-			clearTimeout(timeout);
-			x.style.animation = 'none';
-			timeout = setTimeout(function(){ x.className = x.className.replace("show", ""); }, 2900);
+			});	// If we set async false, file is loaded and executed, then next statement is processed
+			if (loc) d.Sf.action = getURL('/settings/leds');
 		}
 		function bLimits(b,v,p,m,l,o=5,d=2,a=6) {
-			// maxB - max buses (can be changed if using ESP32 parallel I2S)
-			// maxD - max digital channels (can be changed if using ESP32 parallel I2S)
-			// maxA - max analog channels
-			// maxV - min virtual buses
-			// maxPB - max LEDs per bus
-			// maxM - max LED memory
-			// maxL - max LEDs
-			// maxCO - max Color Order mappings
-			oMaxB = maxB = b; maxD = d, maxA = a, maxV = v; maxM = m; maxPB = p; maxL = l; maxCO = o;
+			maxB  = b; // maxB - max physical (analog + digital) buses: 32 - ESP32, 14 - S3/S2, 6 - C3, 4 - 8266
+			maxD  = d; // maxD - max digital channels (can be changed if using ESP32 parallel I2S): 16 - ESP32, 12 - S3/S2, 2 - C3, 3 - 8266
+			maxA  = a; // maxA - max analog channels: 16 - ESP32, 8 - S3/S2, 6 - C3, 5 - 8266
+			maxV  = v; // maxV - min virtual buses: 4 - ESP32/S3, 3 - S2/C3, 2 - ESP8266
+			maxPB = p; // maxPB - max LEDs per bus
+			maxM  = m; // maxM - max LED memory
+			maxL  = l; // maxL - max LEDs (will serve to determine ESP >1664 == ESP32)
+			maxCO = o; // maxCO - max Color Order mappings
 		}
+		function is8266() { return maxA ==  5 && maxD ==  3; } // NOTE: see const.h
+		function is32()   { return maxA == 16 && maxD == 16; } // NOTE: see const.h
+		function isC3()   { return maxA ==  6 && maxD ==  2; } // NOTE: see const.h
+		function isS2()   { return maxA ==  8 && maxD == 12 && maxV == 4; } // NOTE: see const.h
+		function isS3()   { return maxA ==  8 && maxD == 12 && maxV == 6; } // NOTE: see const.h
 		function pinsOK() {
 			var ok = true;
 			var nList = d.Sf.querySelectorAll("#mLC input[name^=L]");
@@ -79,7 +66,7 @@
 				let t = parseInt(d.Sf["LT"+n].value, 10); // LED type SELECT
 				// ignore IP address
 				if (nm=="L0" || nm=="L1" || nm=="L2" || nm=="L3") {
-					if (t>=80) return;
+					if (isNet(t)) return;
 				}
 				//check for pin conflicts
 				if (nm=="L0" || nm=="L1" || nm=="L2" || nm=="L3" || nm=="L4")
@@ -136,7 +123,12 @@
 			var en = d.Sf.ABL.checked;
 			gId('abl').style.display = (en) ? 'inline':'none';
 			gId('psu2').style.display = (en) ? 'inline':'none';
-			if (!en) d.Sf.PPL.checked = false;
+			if (!en) {
+				// limiter disabled
+				d.Sf.PPL.checked = false;
+//				d.Sf.querySelectorAll("#mLC select[name^=LAsel]").forEach((e)=>{e.selectedIndex = 0;}); // select default LED mA
+//				d.Sf.querySelectorAll("#mLC input[name^=LA]").forEach((e)=>{e.min = 0; e.value = 0;}); // set min & value to 0
+			}
 			UI();
 		}
 		// enable per port limiter and calculate current
@@ -149,46 +141,51 @@
 			d.Sf.MA.min = abl && !ppl ? 250 : 0;
 			gId("psuMA").style.display = ppl ? 'none' : 'inline';
 			gId("ppldis").style.display = ppl ? 'inline' : 'none';
-			// set PPL minimum value and clear actual PPL limit if ABL disabled
+			// set PPL minimum value and clear actual PPL limit if ABL is disabled
 			d.Sf.querySelectorAll("#mLC input[name^=MA]").forEach((i,x)=>{
-				var n = String.fromCharCode((x<10?48:55)+x);
+				var n = chrID(x);
 				gId("PSU"+n).style.display = ppl ? "inline" : "none";
 				const t = parseInt(d.Sf["LT"+n].value); // LED type SELECT
 				const c = parseInt(d.Sf["LC"+n].value); //get LED count
-				i.min = ppl && !(isVir(t) || isAna(t)) ? 250 : 0;
-				if (!abl || isVir(t) || isAna(t)) i.value = 0;
+				i.min = ppl && isDig(t) ? 250 : 0;
+				if (!abl || !isDig(t)) i.value = 0;
 				else if (ppl) sumMA += parseInt(i.value,10);
 				else if (sDI) i.value = Math.round(parseInt(d.Sf.MA.value,10)*c/sDI);
 			});
 			if (ppl) d.Sf.MA.value = sumMA; // populate UI ABL value if PPL used
 		}
+		// enable and update LED Amps
 		function enLA(s,n)
 		{
+			const abl = d.Sf.ABL.checked;
 			const t = parseInt(d.Sf["LT"+n].value); // LED type SELECT
-			gId('LAdis'+n).style.display = s.selectedIndex==5 ? "inline" : "none";
-			if (s.value!=="0") d.Sf["LA"+n].value = s.value;
-			d.Sf["LA"+n].min = (isVir(t) || isAna(t)) ? 0 : 1;
+			gId('LAdis'+n).style.display = s.selectedIndex==5 ? "inline" : "none"; // show/hide custom mA field
+			if (s.value!=="0") d.Sf["LA"+n].value = s.value; // set value from select object
+			d.Sf["LA"+n].min = (!isDig(t) || !abl) ? 0 : 1; // set minimum value for validation
 		}
 		function setABL()
 		{
-			d.Sf.ABL.checked = parseInt(d.Sf.MA.value) > 0;
+			let en = parseInt(d.Sf.MA.value) > 0;
 			// check if ABL is enabled (max mA entered per output)
 			d.Sf.querySelectorAll("#mLC input[name^=MA]").forEach((i,n)=>{
-				if (parseInt(i.value) > 0) d.Sf.ABL.checked = true;
+				if (parseInt(i.value) > 0) en = true;
 			});
+			d.Sf.ABL.checked = en;
 			// select appropriate LED current
 			d.Sf.querySelectorAll("#mLC select[name^=LAsel]").forEach((sel,x)=>{
 				sel.value = 0; // set custom
-				var n = String.fromCharCode((x<10?48:55)+x);
-				switch (parseInt(d.Sf["LA"+n].value)) {
-					case 0: break; // disable ABL
-					case 15: sel.value = 15; break;
-					case 30: sel.value = 30; break;
-					case 35: sel.value = 35; break;
-					case 55: sel.value = 55; break;
-					case 255: sel.value = 255; break;
-				}
-				enLA(sel,n);
+				var n = chrID(x);
+				if (en)
+					switch (parseInt(d.Sf["LA"+n].value)) {
+						case 0: break; // disable ABL
+						case 15: sel.value = 15; break;
+						case 30: sel.value = 30; break;
+						case 35: sel.value = 35; break;
+						case 55: sel.value = 55; break;
+						case 255: sel.value = 255; break;
+					}
+				else sel.value = 0;
+				enLA(sel,n); // configure individual limiter
 			});
 			enABL();
 			gId('m1').innerHTML = maxM;
@@ -199,21 +196,18 @@
 			let len = parseInt(d.getElementsByName("LC"+n)[0].value);
 			len += parseInt(d.getElementsByName("SL"+n)[0].value); // skipped LEDs are allocated too
 			let dbl = 0;
-			let ch = 3;
+			let ch = 3*hasRGB(t) + hasW(t) + hasCCT(t);
 			let mul = 1;
+			if (d.Sf.LD.checked) dbl = len * ch; // global buffer
 			if (isDig(t)) {
 				if (is16b(t)) len *= 2; // 16 bit LEDs
-				if (t > 28 && t < 40) ch = 4; //RGBW
-				if (t == 28) ch = 5; //GRBCW
 				if (maxM < 10000 && d.getElementsByName("L0"+n)[0].value == 3) { //8266 DMA uses 5x the mem
 					mul = 5;
 				}
 				if (maxM >= 10000) { //ESP32 RMT uses double buffer?
 					mul = 2;
 				}
-				if (d.Sf.LD.checked) dbl = len * ch; // double buffering
 			}
-			if (isVir(t) && t == 88) ch = 4;
 			return len * ch * mul + dbl;
 		}
 
@@ -222,59 +216,75 @@
 			let gRGBW = false, memu = 0;
 			let busMA = 0;
 			let sLC = 0, sPC = 0, sDI = 0, maxLC = 0;
-			const ablEN = d.Sf.ABL.checked;
-			maxB = oMaxB; // TODO make sure we start with all possible buses
+			const abl = d.Sf.ABL.checked;
+			let setPinConfig = (n,t) => {
+				let p0d = "GPIO:";
+				let p1d = "";
+				let off = "Off Refresh";
+				switch (gT(t).t.charAt(0)) {
+					case '2': // 2 pin digital
+						p1d = "Clock "+p0d;
+						// fallthrough
+					case 'D': // digital
+						p0d = "Data "+p0d;
+						break;
+					case 'A': // PWM analog
+						if (numPins(t) > 1) p0d = "GPIOs:";
+						off = "Dithering";
+						break;
+					case 'N': // network
+						p0d = "IP address:";
+						break;
+					case 'V': // virtual/non-GPIO based
+						p0d = "Config:"
+						break;
+				}
+				gId("p0d"+n).innerText = p0d;
+				gId("p1d"+n).innerText = p1d;
+				gId("off"+n).innerText = off;
+				// secondary pins show/hide (type string length is equivalent to number of pins used; except for network and on/off)
+				let pins = Math.max(gT(t).t.length,1) + 3*isNet(t); // fixes network pins to 4
+				for (let p=1; p<5; p++) {
+					var LK = d.Sf["L"+p+n];
+					if (!LK) continue;
+					LK.style.display = (p < pins) ? "inline" : "none";
+					LK.required = (p < pins);
+					if (p >= pins) LK.value="";
+				}
+			}
 
 			// enable/disable LED fields
+			let dC = 0; // count of digital buses (for parallel I2S)
 			let LTs = d.Sf.querySelectorAll("#mLC select[name^=LT]");
 			LTs.forEach((s,i)=>{
 				if (i < LTs.length-1) s.disabled = true; // prevent changing type (as we can't update options)
 				// is the field a LED type?
 				var n = s.name.substring(2);
 				var t = parseInt(s.value);
-				gId("p0d"+n).innerHTML = isVir(t) ? "IP address:" : isD2P(t) ? "Data GPIO:" : (t > 41) ? "GPIOs:" : "GPIO:";
-				gId("p1d"+n).innerHTML = isD2P(t) ? "Clk GPIO:" : "";
-				gId("abl"+n).style.display = (!ablEN || isVir(t) || isAna(t)) ? "none" : "inline";
-				//var LK = d.getElementsByName("L1"+n)[0]; // clock pin
-
 				memu += getMem(t, n); // calc memory
-
-				// enumerate pins
-				for (p=1; p<5; p++) {
-					var LK = d.Sf["L"+p+n]; // secondary pins
-					if (!LK) continue;
-					if ((isVir(t) && p<4) || (isD2P(t) && p==1) || (isPWM(t) && (p+40 < t))) // TYPE_xxxx values from const.h
-					{
-						// display pin field
-						LK.style.display = "inline";
-						LK.required = true;
-					} else {
-						// hide pin field
-						LK.style.display = "none";
-						LK.required = false;
-						LK.value="";
-					}
+				dC += (isDig(t) && !isD2P(t));
+				setPinConfig(n,t);
+				gId("abl"+n).style.display = (!abl || !isDig(t)) ? "none" : "inline"; // show/hide individual ABL settings
+				if (change) { // did we change LED type?
+					gId("rf"+n).checked = (gId("rf"+n).checked || t == 31); // LEDs require data in off state (mandatory for TM1814)
+					if (isAna(t)) d.Sf["LC"+n].value = 1;                   // for sanity change analog count just to 1 LED
+					d.Sf["LA"+n].min = (!isDig(t) || !abl) ? 0 : 1;         // set minimum value for LED mA
+					d.Sf["MA"+n].min = (!isDig(t)) ? 0 : 250;               // set minimum value for PSU mA
 				}
-				if (change) {
-					gId("rf"+n).checked = (gId("rf"+n).checked || t == 31); // LEDs require data in off state
-					if (isAna(t)) d.Sf["LC"+n].value = 1; // for sanity change analog count just to 1 LED
-					d.Sf["LA"+n].min = (isVir(t) || isAna(t)) ? 0 : 1;
-					d.Sf["MA"+n].min = (isVir(t) || isAna(t)) ? 0 : 250;
-				}
-				gId("rf"+n).onclick = (t == 31) ? (()=>{return false}) : (()=>{});  // prevent change for TM1814
-				gRGBW |= hasW(t); // RGBW checkbox, TYPE_xxxx values from const.h
-				gId("co"+n).style.display = (isVir(t) || isAna(t)) ? "none":"inline";  // hide color order for PWM
-				gId("dig"+n+"w").style.display = (isDig(t) && hasW(t)) ? "inline":"none"; // show swap channels dropdown
-				gId("dig"+n+"w").querySelector("[data-opt=CCT]").disabled = !hasCCT(t);   // disable WW/CW swapping	
-				if (!(isDig(t) && hasW(t))) d.Sf["WO"+n].value = 0; // reset swapping
-				gId("dig"+n+"c").style.display = (isAna(t)) ? "none":"inline";  // hide count for analog
-				gId("dig"+n+"r").style.display = (isVir(t)) ? "none":"inline";  // hide reversed for virtual
+				gId("rf"+n).onclick = mustR(t) ? (()=>{return false}) : (()=>{});           // prevent change change of "Refresh" checkmark when mandatory
+				gRGBW |= hasW(t);                                                           // RGBW checkbox
+				gId("co"+n).style.display = (isVir(t) || isAna(t)) ? "none":"inline";       // hide color order for PWM
+				gId("dig"+n+"w").style.display = (isDig(t) && hasW(t)) ? "inline":"none";   // show swap channels dropdown
+				gId("dig"+n+"w").querySelector("[data-opt=CCT]").disabled = !hasCCT(t);     // disable WW/CW swapping
+				if (!(isDig(t) && hasW(t))) d.Sf["WO"+n].value = 0;                         // reset swapping
+				gId("dig"+n+"c").style.display = (isAna(t)) ? "none":"inline";              // hide count for analog
+				gId("dig"+n+"r").style.display = (isVir(t)) ? "none":"inline";              // hide reversed for virtual
 				gId("dig"+n+"s").style.display = (isVir(t) || isAna(t)) ? "none":"inline";  // hide skip 1st for virtual & analog
-				gId("dig"+n+"f").style.display = (isDig(t)) ? "inline":"none";  // hide refresh
-				gId("dig"+n+"a").style.display = (hasW(t)) ? "inline":"none";   // auto calculate white
+				gId("dig"+n+"f").style.display = (isDig(t) || (isPWM(t) && maxL>2048)) ? "inline":"none"; // hide refresh (PWM hijacks reffresh for dithering on ESP32)
+				gId("dig"+n+"a").style.display = (hasW(t)) ? "inline":"none";               // auto calculate white
 				gId("dig"+n+"l").style.display = (isD2P(t) || isPWM(t)) ? "inline":"none";  // bus clock speed / PWM speed (relative) (not On/Off)
-				gId("rev"+n).innerHTML = isAna(t) ? "Inverted output":"Reversed (rotated 180°)";  // change reverse text for analog
-				//gId("psd"+n).innerHTML = isAna(t) ? "Index:":"Start:";    // change analog start description
+				gId("rev"+n).innerHTML = isAna(t) ? "Inverted output":"Reversed";           // change reverse text for analog else (rotated 180°)
+				//gId("psd"+n).innerHTML = isAna(t) ? "Index:":"Start:";                      // change analog start description
 			});
 			// display global white channel overrides
 			gId("wc").style.display = (gRGBW) ? 'inline':'none';
@@ -283,23 +293,27 @@
 				d.Sf.CR.checked = false;
 			}
 			// update start indexes, max values, calculate current, etc
+			let sameType = 0;
 			var nList = d.Sf.querySelectorAll("#mLC input[name^=L]");
 			nList.forEach((LC,i)=>{
 				let nm = LC.name.substring(0,2);  // field name
 				let n  = LC.name.substring(2);    // bus number
 				let t  = parseInt(d.Sf["LT"+n].value); // LED type SELECT
+				if (isDig(t)) {
+					if (sameType == 0) sameType = t; // first bus type
+					else if (sameType != t) sameType = -1; // different bus type
+				}
 				// do we have a led count field
 				if (nm=="LC") {
 					let c = parseInt(LC.value,10); //get LED count
-					if (c > 300 && i < 8) maxB = oMaxB - Math.max(maxD-7,0); //TODO: hard limit for buses when using ESP32 parallel I2S
-					if (!customStarts || !startsDirty[n]) gId("ls"+n).value=sLC; //update start value
+					if (!customStarts || !startsDirty[n]) gId("ls"+n).value = sLC; //update start value
 					gId("ls"+n).disabled = !customStarts; //enable/disable field editing
 					if (c) {
 						let s = parseInt(gId("ls"+n).value); //start value
 						if (s+c > sLC) sLC = s+c; //update total count
 						if (c > maxLC) maxLC = c; //max per output
 						if (!isVir(t)) sPC += c; //virtual out busses do not count towards physical LEDs
-						if (!(isVir(t) || isAna(t))) {
+						if (isDig(t)) {
 							sDI += c; // summarize digital LED count
 							let maPL = parseInt(d.Sf["LA"+n].value);
 							if (maPL == 255) maPL = 12;
@@ -346,6 +360,13 @@
 						else LC.style.color = d.ro_gpio.some((e)=>e==parseInt(LC.value)) ? "orange" : "#fff";
 					}
 			});
+			if (is32() || isS2() || isS3()) {
+				if (maxLC > 600 || dC < 2 || sameType <= 0) {
+					d.Sf["PR"].checked = false;
+					gId("prl").classList.add("hide");
+				} else
+					gId("prl").classList.remove("hide");
+			} else d.Sf["PR"].checked = false;
 			// distribute ABL current if not using PPL
 			enPPL(sDI);
 
@@ -375,10 +396,15 @@
 			gId('psu').innerHTML = s;
 			gId('psu2').innerHTML = s2;
 			gId("json").style.display = d.Sf.IT.value==8 ? "" : "none";
+
+			// show/hide FPS warning messages
+			gId('fpsNone').style.display = (d.Sf.FR.value == 0) ? 'block':'none';
+			gId('fpsWarn').style.display = (d.Sf.FR.value == 0) || (d.Sf.FR.value >= 80) ? 'block':'none';
+			gId('fpsHigh').style.display = (d.Sf.FR.value >= 80) ? 'block':'none';
 		}
 		function lastEnd(i) {
 			if (i-- < 1) return 0;
-			var s = String.fromCharCode((i<10?48:55)+i);
+			var s = chrID(i);
 			v = parseInt(d.getElementsByName("LS"+s)[0].value) + parseInt(d.getElementsByName("LC"+s)[0].value);
 			var t = parseInt(d.getElementsByName("LT"+s)[0].value);
 			if (isPWM(t)) v = 1; //PWM busses
@@ -386,7 +412,7 @@
 		}
 		function addLEDs(n,init=true)
 		{
-			var o = d.getElementsByClassName("iST");
+			var o = gEBCN("iST");
 			var i = o.length;
 			let disable = (sel,opt) => { sel.querySelectorAll(opt).forEach((o)=>{o.disabled=true;}); }
 
@@ -396,50 +422,19 @@
 				let t = s.value;
 				if (isDig(t) && !isD2P(t)) digitalB++;
 				if (isD2P(t)) twopinB++;
-				if (isPWM(t)) analogB += t-40; // type defines PWM pins
+				if (isPWM(t)) analogB += numPins(t); // each GPIO is assigned to a channel
 				if (isVir(t)) virtB++;
 			});
 
 			if ((n==1 && i>=maxB+maxV) || (n==-1 && i==0)) return;
-			var s = String.fromCharCode((i<10?48:55)+i);
+			var s = chrID(i);
 
 			if (n==1) {
 // npm run build has trouble minimizing spaces inside string
 				var cn = `<div class="iST">
 <hr class="sml">
 ${i+1}:
-<select name="LT${s}" onchange="UI(true)">${i>=maxB && false ? '' :
-'<option value="22" data-type="D">WS281x</option>\
-<option value="30" data-type="D">SK6812/WS2814 RGBW</option>\
-<option value="31" data-type="D">TM1814</option>\
-<option value="24" data-type="D">400kHz</option>\
-<option value="25" data-type="D">TM1829</option>\
-<option value="26" data-type="D">UCS8903</option>\
-<option value="27" data-type="D">APA106/PL9823</option>\
-<option value="33" data-type="D">TM1914</option>\
-<option value="28" data-type="D">FW1906 GRBCW</option>\
-<option value="29" data-type="D">UCS8904 RGBW</option>\
-<option value="32" data-type="D">WS2805 RGBCW</option>\
-<option value="34" data-type="D">SM16825 RGBCW</option>\
-<option value="50" data-type="2P">WS2801</option>\
-<option value="51" data-type="2P">APA102</option>\
-<option value="52" data-type="2P">LPD8806</option>\
-<option value="54" data-type="2P">LPD6803</option>\
-<option value="53" data-type="2P">P9813</option>\
-<option value="19" data-type="D">WS2811 White</option>\
-<option value="40">On/Off</option>\
-<option value="41" data-type="A">PWM White</option>\
-<option value="42" data-type="AA">PWM CCT</option>\
-<option value="43" data-type="AAA">PWM RGB</option>\
-<option value="44" data-type="AAAA">PWM RGBW</option>\
-<option value="45" data-type="AAAAA">PWM RGB+CCT</option>\
-<!--option value="46" data-type="AAAAAA">PWM RGB+DCCT</option-->'}
-<option value="80" data-type="V">DDP RGB (network)</option>
-<!--option value="81" data-type="V">E1.31 RGB (network)</option-->
-<option value="82" data-type="V">Art-Net RGB (network)</option>
-<option value="88" data-type="V">DDP RGBW (network)</option>
-<option value="89" data-type="V">Art-Net RGBW (network)</option>
-</select><br>
+<select name="LT${s}" onchange="UI(true)"></select><br>
 <div id="abl${s}">
 mA/LED: <select name="LAsel${s}" onchange="enLA(this,'${s}');UI();">
 <option value="55" selected>55mA (typ. 5V WS281x)</option>
@@ -474,14 +469,32 @@ mA/LED: <select name="LAsel${s}" onchange="enLA(this,'${s}');UI();">
 <span id="p4d${s}"></span><input type="number" name="L4${s}" class="s" onchange="UI();pinUpd(this);"/>
 <div id="dig${s}r" style="display:inline"><br><span id="rev${s}">Reversed</span>: <input type="checkbox" name="CV${s}"></div>
 <div id="dig${s}s" style="display:inline"><br>Skip first LEDs: <input type="number" name="SL${s}" min="0" max="255" value="0" oninput="UI()"></div>
-<div id="dig${s}f" style="display:inline"><br>Off Refresh: <input id="rf${s}" type="checkbox" name="RF${s}"></div>
-<div id="dig${s}a" style="display:inline"><br>Auto-calculate white channel from RGB:<br><select name="AW${s}"><option value=0>None</option><option value=1>Brighter</option><option value=2>Accurate</option><option value=3>Dual</option><option value=4>Max</option></select>&nbsp;</div>
+<div id="dig${s}f" style="display:inline"><br><span id="off${s}">Off Refresh</span>: <input id="rf${s}" type="checkbox" name="RF${s}"></div>
+<div id="dig${s}a" style="display:inline"><br>Auto-calculate W channel from RGB:<br><select name="AW${s}"><option value=0>None</option><option value=1>Brighter</option><option value=2>Accurate</option><option value=3>Dual</option><option value=4>Max</option></select>&nbsp;</div>
 </div>`;
 				f.insertAdjacentHTML("beforeend", cn);
-				let sel = d.getElementsByName("LT"+s)[0]
-				if (i >= maxB || digitalB >= maxD) disable(sel,'option[data-type="D"]');
-				if (i >= maxB || twopinB >= 1)     disable(sel,'option[data-type="2P"]');
-				disable(sel,`option[data-type^="${'A'.repeat(maxA-analogB+1)}"]`);
+				// fill led types (credit @netmindz)
+				f.querySelectorAll("select[name^=LT]").forEach((sel,n)=>{
+					if (sel.length == 0) { // ignore already updated
+						for (let type of d.ledTypes) {
+							let opt = cE("option");
+							opt.value = type.i;
+							opt.text = type.n;
+							if (type.t != undefined && type.t != "") {
+								opt.setAttribute('data-type', type.t);
+							}
+							sel.appendChild(opt);
+						}
+					}
+				});
+				enLA(d.Sf["LAsel"+s],s); // update LED mA
+				// disable inappropriate LED types
+				let sel = d.getElementsByName("LT"+s)[0];
+				// 32 & S2 supports mono I2S as well as parallel so we need to take that into account; S3 only supports parallel
+				let maxDB = maxD - (is32() || isS2() || isS3() ? (!d.Sf["PR"].checked)*8 - (!isS3()) : 0); // adjust max digital buses if parallel I2S is not used
+				if (digitalB >= maxDB) disable(sel,'option[data-type="D"]'); // NOTE: see isDig()
+				if (twopinB  >= 2)     disable(sel,'option[data-type="2P"]'); // NOTE: see isD2P() (we will only allow 2 2pin buses)
+				disable(sel,`option[data-type^="${'A'.repeat(maxA-analogB+1)}"]`); // NOTE: see isPWM()
 				sel.selectedIndex = sel.querySelector('option:not(:disabled)').index;
 			}
 			if (n==-1) {
@@ -498,9 +511,9 @@ mA/LED: <select name="LAsel${s}" onchange="enLA(this,'${s}');UI();">
 		}
 
 		function addCOM(start=0,len=1,co=0) {
-			var i = d.getElementsByClassName("com_entry").length;
+			var i = gEBCN("com_entry").length;
 			if (i >= maxCO) return;
-			var s = String.fromCharCode((i<10?48:55)+i);
+			var s = chrID(i);
 			var b = `<div class="com_entry">
 <hr class="sml">
 ${i+1}: Start: <input type="number" name="XS${s}" id="xs${s}" class="l starts" min="0" max="65535" value="${start}" oninput="UI();" required="">&nbsp;
@@ -529,7 +542,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 		}
 
 		function remCOM() {
-			var entries = d.getElementsByClassName("com_entry");
+			var entries = gEBCN("com_entry");
 			var i = entries.length;
 			if (i === 0) return;
 			entries[i-1].remove();
@@ -541,7 +554,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 			if (_newMaxCOOverrides) {
 				maxCO = _newMaxCOOverrides;
 			}
-			for (let e of d.getElementsByClassName("com_entry")) {
+			for (let e of gEBCN("com_entry")) {
 				e.remove();
 			}
 			btnCOM(0);
@@ -554,7 +567,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 
 		function addBtn(i,p,t) {
 			var c = gId("btns").innerHTML;
-			var s = String.fromCharCode((i<10?48:55)+i);
+			var s = chrID(i);
 			c += `Button ${i} GPIO: <input type="number" name="BT${s}" onchange="UI()" class="xs" value="${p}">`;
 			c += `&nbsp;<select name="BE${s}">`
 			c += `<option value="0" ${t==0?"selected":""}>Disabled</option>`;
@@ -577,25 +590,16 @@ Swap: <select id="xw${s}" name="XW${s}">
 		}
 		function checkSi() { //on load, checks whether there are custom start fields
 			var cs = false;
-			for (var i=1; i < d.getElementsByClassName("iST").length; i++) {
-				var v = parseInt(gId("ls"+(i-1)).value) + parseInt(d.getElementsByName("LC"+(i-1))[0].value);
-				if (v != parseInt(gId("ls"+i).value)) {cs = true; startsDirty[i] = true;}
+			for (var i=1; i < gEBCN("iST").length; i++) {
+				var s = chrID(i);
+				var p = chrID(i-1); // cover edge case 'A' previous char being '9'
+				var v = parseInt(gId("ls"+p).value) + parseInt(gN("LC"+p).value);
+				if (v != parseInt(gId("ls"+s).value)) {cs = true; startsDirty[i] = true;}
 			}
 			if (gId("ls0") && parseInt(gId("ls0").value) != 0) {cs = true; startsDirty[0] = true;}
 			gId("si").checked = cs;
 			tglSi(cs);
 		}
-		function uploadFile(name) {
-			var req = new XMLHttpRequest();
-			req.addEventListener('load', function(){showToast(this.responseText,this.status >= 400)});
-			req.addEventListener('error', function(e){showToast(e.stack,true);});
-			req.open("POST", "/upload");
-			var formData = new FormData();
-			formData.append("data", d.Sf.data.files[0], name);
-			req.send(formData);
-			d.Sf.data.value = '';
-			return false;
-		}
 		// https://stackoverflow.com/questions/7346563/loading-local-json-file
 		function loadCfg(o) {
 			var f, fr;
@@ -619,10 +623,10 @@ Swap: <select id="xw${s}" name="XW${s}">
 
 			function receivedText(e) {
 				let lines = e.target.result;
-				var c = JSON.parse(lines); 
+				var c = JSON.parse(lines);
 				if (c.hw) {
 					if (c.hw.led) {
-						for (var i=0; i<10; i++) addLEDs(-1);
+						for (var i=0; i<oMaxB+maxV; i++) addLEDs(-1);
 						var l = c.hw.led;
 						l.ins.forEach((v,i,a)=>{
 							addLEDs(1);
@@ -670,7 +674,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 				if (i.type === "number" && fields.includes(i.name)) { //select all pin select elements
 					let v = parseInt(i.value);
 					let sel = addDropdown(i.name,0);
-					for (var j = -1; j <= d.max_gpio; j++) {
+					for (var j = -1; j < d.max_gpio; j++) {
 						if (d.rsvd.includes(j)) continue;
 						let foundPin = d.um_p.indexOf(j);
 						let txt = (j === -1) ? "unused" : `${j}`;
@@ -724,7 +728,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 		}
 		// https://stackoverflow.com/questions/39729741/javascript-change-input-text-to-select-option
 		function addDropdown(field) {
-			let sel = d.createElement('select');
+			let sel = cE('select');
 			sel.classList.add("pin");
 			let inp = d.getElementsByName(field)[0];
 			if (inp && inp.tagName === "INPUT" && (inp.type === "text" || inp.type === "number")) {  // may also use nodeName
@@ -749,7 +753,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 		}
 		function addOption(sel,txt,val) {
 			if (sel===null) return; // select object missing
-			let opt = d.createElement("option");
+			let opt = cE("option");
 			opt.value = val;
 			opt.text = txt;
 			sel.appendChild(opt);
@@ -759,40 +763,13 @@ Swap: <select id="xw${s}" name="XW${s}">
 			}
 			return opt;
 		}
-		function S() {
-			let l = window.location;
-			if (l.protocol == "file:") {
-				loc = true;
-				locip = localStorage.getItem('locIp');
-				if (!locip) {
-					locip = prompt("File Mode. Please enter WLED IP!");
-					localStorage.setItem('locIp', locip);
-				}
-			} else {
-				// detect reverse proxy
-				let path = l.pathname;
-				let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-				if (paths.length > 2) {
-					paths.pop(); // remove "leds"
-					paths.pop(); // remove "settings"
-					locproto = l.protocol;
-					loc = true;
-					locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-				}
-			}
-			loadJS(getURL('/settings/s.js?p=2'), false);	// If we set async false, file is loaded and executed, then next statement is processed
-			if (loc) d.Sf.action = getURL('/settings/leds');
-		}
-		function getURL(path) {
-			return (loc ? locproto + "//" + locip : "") + path;
-		}
 	</script>
 	<style>@import url("style.css");</style>
 </head>
 <body onload="S()">
 	<form id="form_s" name="Sf" method="post">
 		<div class="toprow">
-		<div class="helpB"><button type="button" onclick="H()">?</button></div>
+		<div class="helpB"><button type="button" onclick="H('features/settings/#led-settings')">?</button></div>
 		<button type="button" onclick="B()">Back</button><button type="submit">Save</button><hr>
 		</div>
 		<h2>LED &amp; Hardware setup</h2>
@@ -821,8 +798,11 @@ Swap: <select id="xw${s}" name="XW${s}">
 			</div>
 		</div>
 		<h3>Hardware setup</h3>
-		<div id="mLC">LED outputs:</div>
-		<hr class="sml">
+		<div id="mLC">
+			LED outputs:<br>
+			<hr class="sml">
+			<i>Only last output can be changed. Remove to edit others.</i><br>
+		</div>
 		<button type="button" id="+" onclick="addLEDs(1,false)">+</button>
 		<button type="button" id="-" onclick="addLEDs(-1,false)">-</button><br>
 		LED memory usage: <span id="m0">0</span> / <span id="m1">?</span> B<br>
@@ -832,6 +812,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 			Use less than <span id="wreason">800 LEDs per output</span> for the best experience!<br>
 		</div>
 		<hr class="sml">
+		<div id="prl" class="hide">Use parallel I2S: <input type="checkbox" name="PR"><br></div>
 		Make a segment for each output: <input type="checkbox" name="MS"><br>
 		Custom bus start indices: <input type="checkbox" onchange="tglSi(this.checked)" id="si"><br>
 		Use global LED buffer: <input type="checkbox" name="LD" onchange="UI()"><br>
@@ -860,7 +841,7 @@ Swap: <select id="xw${s}" name="XW${s}">
 		<option value=8>JSON remote</option>
 		</select><span style="cursor: pointer;" onclick="off('IR')">&nbsp;&#x2715;</span><br>
 		Apply IR change to main segment only: <input type="checkbox" name="MSO"><br>
-		<div id="json" style="display:none;">JSON file: <input type="file" name="data" accept=".json"><button type="button" class="sml" onclick="uploadFile('/ir.json')">Upload</button><br></div>
+		<div id="json" style="display:none;">JSON file: <input type="file" name="data" accept=".json"><button type="button" class="sml" onclick="uploadFile(d.Sf.data,'/ir.json')">Upload</button><br></div>
 		<a href="https://kno.wled.ge/interfaces/infrared/" target="_blank">IR info</a><br>
 		<hr class="sml">
 		Relay GPIO: <input type="number" min="-1" max="48" name="RL" onchange="UI()" class="xs"><span style="cursor: pointer;" onclick="off('RL')">&nbsp;&#x2715;</span><br>
@@ -908,7 +889,8 @@ Swap: <select id="xw${s}" name="XW${s}">
 			<br>
 			Calculate CCT from RGB: <input type="checkbox" name="CR"><br>
 			CCT IC used (Athom 15W): <input type="checkbox" name="IC"><br>
-			CCT additive blending: <input type="number" class="s" min="0" max="100" name="CB" required> %
+			CCT additive blending: <input type="number" class="s" min="0" max="100" name="CB" onchange="UI()" required> %<br>
+			<i class="warn">WARNING: When using H-bridge for reverse polarity (2-wire) CCT LED strip<br><b>make sure this value is 0</b>.<br>(ESP32 variants only, ESP8266 does not support H-bridges)</i>
 		</div>
 		<h3>Advanced</h3>
 		Palette wrapping:
@@ -918,7 +900,10 @@ Swap: <select id="xw${s}" name="XW${s}">
 			<option value="2">Linear (never wrap)</option>
 			<option value="3">None (not recommended)</option>
 		</select><br>
-		Target refresh rate: <input type="number" class="s" min="1" max="120" name="FR" required> FPS
+		Target refresh rate: <input type="number" class="s" min="0" max="250" name="FR" oninput="UI()" required> FPS
+		<div id="fpsNone" class="warn" style="display: none;">&#9888; Unlimited FPS Mode  is experimental &#9888;<br></div>
+		<div id="fpsHigh" class="warn" style="display: none;">&#9888; High FPS Mode is experimental.<br></div>
+		<div id="fpsWarn" class="warn" style="display: none;">Please <a class="lnk" href="sec#backup">backup</a> WLED configuration and presets first!<br></div>
 		<hr class="sml">
 		<div id="cfg">Config template: <input type="file" name="data2" accept=".json"><button type="button" class="sml" onclick="loadCfg(d.Sf.data2)">Apply</button><br></div>
 		<hr>

wled00/data/settings_sec.htm

@@ -4,55 +4,9 @@
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<meta charset="utf-8">
 	<title>Misc Settings</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-		var d = document;
-		var loc = false, locip, locproto = "http:";
-		function H() { window.open("https://kno.wled.ge/features/settings/#security-settings"); }
-		function B() { window.open(getURL("/settings"),"_self"); }
 		function U() { window.open(getURL("/update"),"_self"); }
-		function gId(s) { return d.getElementById(s); }
-		function isObj(o) { return (o && typeof o === 'object' && !Array.isArray(o)); }
-		// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-		function loadJS(FILE_URL, async = true) {
-			let scE = d.createElement("script");
-			scE.setAttribute("src", FILE_URL);
-			scE.setAttribute("type", "text/javascript");
-			scE.setAttribute("async", async);
-			d.body.appendChild(scE);
-			// success event 
-			scE.addEventListener("load", () => {
-				//console.log("File loaded");
-				GetV();
-				setBckFilename(gId("bckcfg"));
-				setBckFilename(gId("bckpresets"));
-			});
-			// error event
-			scE.addEventListener("error", (ev) => {
-				console.log("Error on loading file", ev);
-				alert("Loading of configuration script failed.\nIncomplete page data!");
-			});
-		}
-		var timeout;
-		function showToast(text, error = false)
-		{
-			var x = gId("toast");
-			x.innerHTML = text;
-			x.classList.add(error ? "error":"show");
-			clearTimeout(timeout);
-			x.style.animation = 'none';
-			timeout = setTimeout(function(){ x.classList.remove("show"); }, 2900);
-		}
-		function uploadFile(fO,name) {
-			var req = new XMLHttpRequest();
-			req.addEventListener('load', function(){showToast(this.responseText,this.status >= 400)});
-			req.addEventListener('error', function(e){showToast(e.stack,true);});
-			req.open("POST", getURL("/upload"));
-			var formData = new FormData();
-			formData.append("data", fO.files[0], name);
-			req.send(formData);
-			fO.value = '';
-			return false;
-		}
 		function checkNum(o) {
 			const specialkeys = ["Backspace", "Tab", "Enter", "Shift", "Control", "Alt", "Pause", "CapsLock", "Escape", "Space", "PageUp", "PageDown", "End", "Home", "ArrowLeft", "ArrowUp", "ArrowRight", "ArrowDown", "Insert", "Delete"];
 			// true if key is a number or a special key
@@ -64,36 +18,17 @@
 			x.setAttribute("download","wled_" + x.getAttribute("download") + (sd=="WLED"?"":("_" +sd)));
 		}
 		function S() {
-			let l = window.location;
-			if (l.protocol == "file:") {
-				loc = true;
-				locip = localStorage.getItem('locIp');
-				if (!locip) {
-					locip = prompt("File Mode. Please enter WLED IP!");
-					localStorage.setItem('locIp', locip);
-				}
-			} else {
-				// detect reverse proxy
-				let path = l.pathname;
-				let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-				if (paths.length > 2) {
-					paths.pop(); // remove "sec"
-					paths.pop(); // remove "settings"
-					locproto = l.protocol;
-					loc = true;
-					locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-				}
-			}
+			getLoc();
 			if (loc) {
 				gId("bckcfg").setAttribute('href',getURL(gId("bckcfg").pathname));
 				gId("bckpresets").setAttribute('href',getURL(gId("bckpresets").pathname));
 			}
-			loadJS(getURL('/settings/s.js?p=6'), false);	// If we set async false, file is loaded and executed, then next statement is processed
+			loadJS(getURL('/settings/s.js?p=6'), false, undefined, ()=>{
+				setBckFilename(gId("bckcfg"));
+				setBckFilename(gId("bckpresets"));
+			});	// If we set async false, file is loaded and executed, then next statement is processed
 			if (loc) d.Sf.action = getURL('/settings/sec');
 		}
-		function getURL(path) {
-			return (loc ? locproto + "//" + locip : "") + path;
-		}
 	</script>
 	<style>
 		@import url("style.css");
@@ -102,7 +37,7 @@
 <body onload="S()">
 	<form id="form_s" name="Sf" method="post">
 		<div class="toprow">
-		<div class="helpB"><button type="button" onclick="H()">?</button></div>
+		<div class="helpB"><button type="button" onclick="H('features/settings/#security-settings')">?</button></div>
 		<button type="button" onclick="B()">Back</button><button type="submit">Save</button><hr>
 		</div>
 		<h2>Security & Update setup</h2>
@@ -122,11 +57,11 @@
 		<h3>Software Update</h3>
 		<button type="button" onclick="U()">Manual OTA Update</button><br>
 		Enable ArduinoOTA: <input type="checkbox" name="AO">
-		<hr>
+		<hr id="backup">
 		<h3>Backup & Restore</h3>
 		<div class="warn">&#9888; Restoring presets/configuration will OVERWRITE your current presets/configuration.<br>
-		Incorrect upload or configuration may require a factory reset or re-flashing of your ESP.</div>
-		For security reasons, passwords are not backed up.
+		Incorrect upload or configuration may require a factory reset or re-flashing of your ESP.<br>
+		For security reasons, passwords are not backed up.</div>
 		<a class="btn lnk" id="bckcfg" href="/presets.json" download="presets">Backup presets</a><br>
 		<div>Restore presets<br><input type="file" name="data" accept=".json"> <button type="button" onclick="uploadFile(d.Sf.data,'/presets.json');">Upload</button><br></div><br>
 		<a class="btn lnk" id="bckpresets" href="/cfg.json" download="cfg">Backup configuration</a><br>
@@ -137,10 +72,10 @@
 		<a href="https://github.com/Aircoookie/WLED/wiki/Contributors-and-credits" target="_blank">Contributors, dependencies and special thanks</a><br>
 		A huge thank you to everyone who helped me create WLED!<br><br>
 		(c) 2016-2024 Christian Schwinne <br>
-		<i>Licensed under the <a href="https://github.com/Aircoookie/WLED/blob/master/LICENSE" target="_blank">MIT license</a></i><br><br>
-		Server message: <span class="sip"> Response error! </span><hr>
+		<i>Licensed under the <a href="https://github.com/Aircoookie/WLED/blob/master/LICENSE" target="_blank">EUPL v1.2 license</a></i><br><br>
+		Installed version: <span class="sip">WLED ##VERSION##</span><hr>
 		<div id="toast"></div>
 		<button type="button" onclick="B()">Back</button><button type="submit">Save</button>
 	</form>
 </body>
-</html>
+</html>

wled00/data/settings_sync.htm

@@ -4,32 +4,10 @@
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<meta charset="utf-8">
 	<title>Sync Settings</title>
-	<script>var d=document;
-	var loc = false, locip, locproto = "http:";
-	function gId(s){return d.getElementById(s);}
-	function toggle(el){gId(el).classList.toggle("hide"); gId('No'+el).classList.toggle("hide");}
-	function H(){window.open("https://kno.wled.ge/interfaces/udp-notifier/");}
-	function B(){window.open(getURL("/settings"),"_self");}
+	<script src="common.js" async type="text/javascript"></script>
+	<script>
 	function adj(){if (d.Sf.DI.value == 6454) {if (d.Sf.EU.value == 1) d.Sf.EU.value = 0;}
 					else if (d.Sf.DI.value == 5568) {if (d.Sf.DA.value == 0) d.Sf.DA.value = 1; if (d.Sf.EU.value == 0) d.Sf.EU.value = 1;} }
-	// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-	function loadJS(FILE_URL, async = true) {
-		let scE = d.createElement("script");
-		scE.setAttribute("src", FILE_URL);
-		scE.setAttribute("type", "text/javascript");
-		scE.setAttribute("async", async);
-		d.body.appendChild(scE);
-		// success event
-		scE.addEventListener("load", () => {
-			//console.log("File loaded");
-			GetV();SetVal();
-		});
-		// error event
-		scE.addEventListener("error", (ev) => {
-			console.log("Error on loading file", ev);
-			alert("Loading of configuration script failed.\nIncomplete page data!");
-		});
-	}
 	function FC()
 	{
 		for(j=0;j<8;j++)
@@ -55,26 +33,8 @@
 	function SP(){var p = d.Sf.DI.value; gId("xp").style.display = (p > 0)?"none":"block"; if (p > 0) d.Sf.EP.value = p;}
 	function SetVal(){switch(parseInt(d.Sf.EP.value)){case 5568: d.Sf.DI.value = 5568; break; case 6454: d.Sf.DI.value = 6454; break; case 4048: d.Sf.DI.value = 4048; break; }; SP();FC();}
 	function S(){
-		let l = window.location;
-		if (l.protocol == "file:") {
-			loc = true;
-			locip = localStorage.getItem('locIp');
-			if (!locip) {
-				locip = prompt("File Mode. Please enter WLED IP!");
-				localStorage.setItem('locIp', locip);
-			}
-		} else {
-			// detect reverse proxy
-			let paths = l.pathname.slice(1,l.pathname.endsWith('/')?-1:undefined).split("/");
-			if (paths.length > 2) {
-				paths.pop(); // remove "sync"
-				paths.pop(); // remove "settings"
-				locproto = l.protocol;
-				loc = true;
-				locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-			}
-		}
-		loadJS(getURL('/settings/s.js?p=4'), false);	// If we set async false, file is loaded and executed, then next statement is processed
+		getLoc();
+		loadJS(getURL('/settings/s.js?p=4'), false, undefined, ()=>{SetVal();});	// If we set async false, file is loaded and executed, then next statement is processed
 		if (loc) d.Sf.action = getURL('/settings/sync');
 	}
 	function getURL(path) {
@@ -86,7 +46,7 @@
 <body onload="S()">
 <form id="form_s" name="Sf" method="post" onsubmit="GC()">
 <div class="toprow">
-<div class="helpB"><button type="button" onclick="H()">?</button></div>
+<div class="helpB"><button type="button" onclick="H('interfaces/udp-notifier/')">?</button></div>
 <button type="button" onclick="B()">Back</button><button type="submit">Save</button><hr>
 </div>
 <h2>Sync setup</h2>
@@ -138,7 +98,7 @@ Use ESP-NOW sync: <input type="checkbox" name="EN"><br><i>(in AP mode or no WiFi
 	</tr>
 </table>
 <h3>Receive</h3>
-<nowrap><input type="checkbox" name="RB">Brightness,</nowrap> <nowrap><input type="checkbox" name="RC">Color,</nowrap> <nowrap>and <input type="checkbox" name="RX">Effects</nowrap><br>
+<nowrap><input type="checkbox" name="RB">Brightness,</nowrap> <nowrap><input type="checkbox" name="RC">Color,</nowrap> <nowrap><input type="checkbox" name="RX">Effects,</nowrap> <nowrap>and <input type="checkbox" name="RP">Palette</nowrap><br>
 <input type="checkbox" name="SO"> Segment options, <input type="checkbox" name="SG"> bounds
 <h3>Send</h3>
 Enable Sync on start: <input type="checkbox" name="SS"><br>
@@ -199,7 +159,7 @@ Realtime LED offset: <input name="WO" type="number" min="-255" max="255" require
 <div id="Alexa">
 Emulate Alexa device: <input type="checkbox" name="AL"><br>
 Alexa invocation name: <input type="text" name="AI" maxlength="32"><br>
-Also emulate devices to call the first <input name="AP" type="number" class="s" min="0" max="9" required> presets<br><br>
+Also emulate devices to call the first <input name="AP" type="number" class="s" min="0" max="9"> presets<br><br>
 </div>
 <hr class="sml">
 <div class="warn">&#9888; <b>MQTT and Hue sync all connect to external hosts!<br>
@@ -245,6 +205,10 @@ Hue Bridge IP:<br>
 Hue status: <span class="sip"> Disabled in this build </span>
 </div>
 <h3>Serial</h3>
+<div id="NoSerial" class="hide">
+	<em class="warn">This firmware build does not support Serial interface.<br></em>
+</div>
+<div id="Serial">
 Baud rate:
 <select name=BD>
 <option value=1152>115200</option>
@@ -257,6 +221,7 @@ Baud rate:
 <option value=15000>1500000</option>
 </select><br>
 <i>Keep at 115200 to use Improv. Some boards may not support high rates.</i>
+</div>
 <hr>
 <button type="button" onclick="B()">Back</button><button type="submit">Save</button>
 </form>

wled00/data/settings_time.htm

@@ -4,60 +4,19 @@
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<meta charset="utf-8">
 	<title>Time Settings</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-	var d=document;
-	var loc = false, locip, locproto = "http:";
 	var el=false;
 	var ms=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
-	function H() { window.open("https://kno.wled.ge/features/settings/#time-settings"); }
-	function B() { window.open(getURL("/settings"),"_self"); }
-	function gId(s) { return d.getElementById(s); }
-	function gN(s) { return d.getElementsByName(s)[0]; }
-	// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-	function loadJS(FILE_URL, async = true) {
-		let scE = d.createElement("script");
-		scE.setAttribute("src", FILE_URL);
-		scE.setAttribute("type", "text/javascript");
-		scE.setAttribute("async", async);
-		d.body.appendChild(scE);
-		// success event 
-		scE.addEventListener("load", () => {
-			//console.log("File loaded");
-			BTa();GetV();updLoc();Cs();FC();
-		});
-		// error event
-		scE.addEventListener("error", (ev) => {
-			console.log("Error on loading file", ev);
-			alert("Loading of configuration script failed.\nIncomplete page data!");
-		});
-	}
 	function S() {
-		let l = window.location;
-		if (l.protocol == "file:") {
-			loc = true;
-			locip = localStorage.getItem('locIp');
-			if (!locip) {
-				locip = prompt("File Mode. Please enter WLED IP!");
-				localStorage.setItem('locIp', locip);
-			}
-		} else {
-			// detect reverse proxy
-			let path = l.pathname;
-			let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-			if (paths.length > 2) {
-				paths.pop(); // remove "time"
-				paths.pop(); // remove "settings"
-				locproto = l.protocol;
-				loc = true;
-				locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-			}
-		}
-		loadJS(getURL('/settings/s.js?p=5'), false);	// If we set async false, file is loaded and executed, then next statement is processed
+		getLoc();
+		loadJS(getURL('/settings/s.js?p=5'), false, ()=>{BTa();}, ()=>{
+			updLatLon();
+			Cs();
+			FC();
+		});	// If we set async false, file is loaded and executed, then next statement is processed
 		if (loc) d.Sf.action = getURL('/settings/time');
 	}
-	function getURL(path) {
-		return (loc ? locproto + "//" + locip : "") + path;
-	}
 	function expand(o,i)
 	{
 		var t = gId("WD"+i);
@@ -141,21 +100,21 @@
 		td = tr.insertCell(3);
 		td.innerHTML = `<input name="MD${b}" type="number" class="s" min="0" max="250" value="${d}" required>`;
 	}
-	function getLoc() {
+	function getLatLon() {
 		if (!el) {
 			window.addEventListener("message", (event) => {
 				if (event.origin !== "https://locate.wled.me") return;
 				if (event.data instanceof Object) {
 					d.Sf.LT.value = event.data.lat;
 					d.Sf.LN.value = event.data.lon;
-					updLoc();
+					updLatLon();
 				}
 			}, false);
 			el = true;
 		}
 		window.open("https://locate.wled.me","_blank");
 	}
-	function updLoc(i) {
+	function updLatLon(i) {
 		if (parseFloat(d.Sf.LT.value)<0) { d.Sf.LTR.value = "S"; d.Sf.LT.value = -1*parseFloat(d.Sf.LT.value); } else d.Sf.LTR.value = "N";
 		if (parseFloat(d.Sf.LN.value)<0) { d.Sf.LNR.value = "W"; d.Sf.LN.value = -1*parseFloat(d.Sf.LN.value); } else d.Sf.LNR.value = "E";
 	}
@@ -165,7 +124,7 @@
 <body onload="S()">
 	<form id="form_s" name="Sf" method="post" onsubmit="Wd()">
 		<div class="toprow">
-		<div class="helpB"><button type="button" onclick="H()">?</button></div>
+		<div class="helpB"><button type="button" onclick="H('features/settings/#time-settings')">?</button></div>
 		<button type="button" onclick="B()">Back</button><button type="submit">Save</button><hr>
 		</div>
 		<h2>Time setup</h2>
@@ -197,12 +156,13 @@
 			<option value="20">AKST/AKDT (Anchorage)</option>
 			<option value="21">MX-CST</option>
 			<option value="22">PKT (Pakistan)</option>
+			<option value="23">BRT (Brasília)</option>
 		</select><br>
 		UTC offset: <input name="UO" type="number" min="-65500" max="65500" required> seconds (max. 18 hours)<br>
 		Current local time is <span class="times">unknown</span>.<br>
 		Latitude: <select name="LTR"><option value="N">N</option><option value="S">S</option></select><input name="LT" type="number" class="xl" min="0" max="66.6" step="0.01"><br>
 		Longitude: <select name="LNR"><option value="E">E</option><option value="W">W</option></select><input name="LN" type="number" class="xl" min="0" max="180" step="0.01"><br>
-		<button type="button" id="locbtn" onclick="getLoc()">Get location</button>
+		<button type="button" id="locbtn" onclick="getLatLon()">Get location</button>
 		<div><i>(opens new tab, only works in browser)</i></div>
 		<div id="sun" class="times"></div>
 		<h3>Clock</h3>

wled00/data/settings_ui.htm

@@ -4,9 +4,8 @@
 	<meta charset="utf-8">
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<title>UI Settings</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-	var d = document;
-	var loc = false, locip, locproto = "http:";
 	var initial_ds, initial_st, initial_su, oldUrl;
 	var sett = null;
 	var l = {
@@ -47,11 +46,6 @@
 			}
 		}
 	};
-	function gId(s) { return d.getElementById(s); }
-	function toggle(el) { gId(el).classList.toggle("hide"); gId('No'+el).classList.toggle("hide"); }
-	function isObject(item) {
-		return (item && typeof item === 'object' && !Array.isArray(item));
-	}
 	function set(path, obj, val) {
 		var tar = obj;
 		var pList = path.split('_');
@@ -63,23 +57,13 @@
 		}
 		tar[pList[len-1]] = val;
 	}
-	var timeout;
-	function showToast(text, error = false)
-	{
-		var x = gId("toast");
-		x.innerHTML = text;
-		x.classList.add(error ? "error":"show");
-		clearTimeout(timeout);
-		x.style.animation = 'none';
-		timeout = setTimeout(function(){ x.classList.remove("show"); }, 2900);
-	}
 	function addRec(s, path = "", label = null)
 	{
 		var str = "";
 		for (let i in s)
 		{
 			var fk = path + (path?'_':'') + i;
-			if (isObject(s[i])) {
+			if (isO(s[i])) {
 				if (label && label[i] && label[i]["LABEL"]) str += `<h3>${label[i]["LABEL"]}</h3>`;
 				str += addRec(s[i], fk, label? label[i] : null);
 			} else {
@@ -174,57 +158,16 @@
 		if (d.Sf.DS.value != initial_ds || /*d.Sf.ST.checked != initial_st ||*/ d.Sf.SU.checked != initial_su) d.Sf.submit();
 	}
 	
-	// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-	function loadJS(FILE_URL, async = true) {
-		let scE = d.createElement("script");
-		scE.setAttribute("src", FILE_URL);
-		scE.setAttribute("type", "text/javascript");
-		scE.setAttribute("async", async);
-		d.body.appendChild(scE);
-		// success event 
-		scE.addEventListener("load", () => {
-			//console.log("File loaded");
-			GetV(); 
+	function S() {
+		getLoc();
+		loadJS(getURL('/settings/s.js?p=3'), false, undefined, ()=>{
 			initial_ds = d.Sf.DS.value;
 			//initial_st = d.Sf.ST.checked;
 			initial_su = d.Sf.SU.checked;
 			GetLS();
-		});
-		// error event
-		scE.addEventListener("error", (ev) => {
-			console.log("Error on loading file", ev);
-			alert("Loading of configuration script failed.\nIncomplete page data!");
-		});
-	}
-	function S() {
-		let l = window.location;
-		if (l.protocol == "file:") {
-			loc = true;
-			locip = localStorage.getItem('locIp');
-			if (!locip) {
-				locip = prompt("File Mode. Please enter WLED IP!");
-				localStorage.setItem('locIp', locip);
-			}
-		} else {
-			// detect reverse proxy
-			let path = l.pathname;
-			let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-			if (paths.length > 2) {
-				paths.pop(); // remove "ui"
-				paths.pop(); // remove "settings"
-				locproto = l.protocol;
-				loc = true;
-				locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-			}
-		}
-		loadJS(getURL('/settings/s.js?p=3'), false);	// If we set async false, file is loaded and executed, then next statement is processed
+		});	// If we set async false, file is loaded and executed, then next statement is processed
 		if (loc) d.Sf.action = getURL('/settings/ui');
 	}
-	function getURL(path) {
-		return (loc ? locproto + "//" + locip : "") + path;
-	}
-	function H() { window.open("https://kno.wled.ge/features/settings/#user-interface-settings"); }
-	function B() { window.open(getURL("/settings"),"_self"); }
 	function UI()
 	{
 		gId('idonthateyou').style.display = (gId('dm').checked) ? 'inline':'none';
@@ -264,25 +207,13 @@
 		if (gId("theme_bg_rnd").checked) toggle("Image");
 		gId("theme_bg_rnd").checked = false;
 	}
-
-	function uploadFile(fO,name) {
-		var req = new XMLHttpRequest();
-		req.addEventListener('load', function(){showToast(this.responseText,this.status >= 400)});
-		req.addEventListener('error', function(e){showToast(e.stack,true);});
-		req.open("POST", "/upload");
-		var formData = new FormData();
-		formData.append("data", fO.files[0], name);
-		req.send(formData);
-		fO.value = '';
-		return false;
-	}
 	</script>
 	<style>@import url("style.css");</style>
 </head>
 <body onload="S()">
 	<form id="form_s" name="Sf" method="post">
 		<div class="toprow">
-		<div class="helpB"><button type="button" onclick="H()">?</button></div>
+		<div class="helpB"><button type="button" onclick="H('features/settings/#user-interface-settings')">?</button></div>
 		<button type="button" onclick="B()">Back</button><button type="button" onclick="Save()">Save</button><br>
 		<span id="lssuc" style="color:green; display:none">&#10004; Local UI settings saved!</span>
 		<span id="lserr" style="color:red; display:none">&#9888; Could not access local storage. Make sure it is enabled in your browser.</span><hr>

wled00/data/settings_um.htm

@@ -4,75 +4,55 @@
 	<meta charset="utf-8">
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<title>Usermod Settings</title>
+	<script src="common.js" async type="text/javascript"></script>
 	<script>
-	var d = document;
-	d.max_gpio = 50;
-	d.um_p = [];
-	d.rsvd = [];
-	d.ro_gpio = [];
-	d.extra = [];
 	var umCfg = {};
 	var pins = [], pinO = [], owner;
-	var loc = false, locip, locproto = "http:";
 	var urows;
 	var numM = 0;
-	function gId(s) { return d.getElementById(s); }
-	function isO(i) { return (i && typeof i === 'object' && !Array.isArray(i)); }
-	function H() { window.open("https://github.com/Aircoookie/WLED/wiki/Settings#usermod-settings"); }
-	function B() { window.open(getURL("/settings"),"_self"); }
-	// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
-	function loadJS(FILE_URL, async = true) {
-		let scE = d.createElement("script");
-		scE.setAttribute("src", FILE_URL);
-		scE.setAttribute("type", "text/javascript");
-		scE.setAttribute("async", async);
-		d.body.appendChild(scE);
-		// success event 
-		scE.addEventListener("load", () => {
-			GetV();
-			for (let r of d.rsvd) { pins.push(r); pinO.push("rsvd"); } // reserved pins
-			if (d.um_p[0]==-1) d.um_p.shift();	// remove filler
-			d.Sf.SDA.max = d.Sf.SCL.max = d.Sf.MOSI.max = d.Sf.SCLK.max = d.Sf.MISO.max = d.max_gpio;
-			//for (let i of d.getElementsByTagName("input")) if (i.type === "number" && i.name.replace("[]","").substr(-3) === "pin") i.max = d.max_gpio;
-			pinDD(); // convert INPUT to SELECT for pins
-		});
-		// error event
-		scE.addEventListener("error", (ev) => {
-			console.log("Error on loading file", ev);
-			alert("Loading of configuration script failed.\nIncomplete page data!");
-		});
-	}
 	function S() {
-		let l = window.location;
-		if (l.protocol == "file:") {
-			loc = true;
-			locip = localStorage.getItem('locIp');
-			if (!locip) {
-				locip = prompt("File Mode. Please enter WLED IP!");
-				localStorage.setItem('locIp', locip);
+		getLoc();
+		// load settings and insert values into DOM
+		fetch(getURL('/cfg.json'), {
+			method: 'get'
+		})
+		.then(res => {
+			if (!res.ok) gId('lserr').style.display = "inline";
+			return res.json();
+		})
+		.then(json => {
+			umCfg = json.um;
+			getPins(json);
+			urows="";
+			if (isO(umCfg)) {
+				for (const [k,o] of Object.entries(umCfg)) {
+					urows += `<hr><h3>${k}</h3>`;
+					addField(k,'unknown',o);
+				}
 			}
-		} else {
-			// detect reverse proxy
-			let path = l.pathname;
-			let paths = path.slice(1,path.endsWith('/')?-1:undefined).split("/");
-			if (paths.length > 2) {
-				paths.pop(); // remove "um"
-				paths.pop(); // remove "settings"
-				locproto = l.protocol;
-				loc = true;
-				locip = l.hostname + (l.port ? ":" + l.port : "") + "/" + paths.join('/');
-			}
-		}
-		ldS();
+			if (urows==="") urows = "Usermods configuration not found.<br>Press <i>Save</i> to initialize defaults.";
+			gId("um").innerHTML = urows;
+			loadJS(getURL('/settings/s.js?p=8'), false, ()=>{
+				d.max_gpio = 50;
+				d.um_p = [];
+				d.rsvd = [];
+				d.ro_gpio = [];
+				d.extra = [];
+			}, ()=>{
+				for (let r of d.rsvd) { pins.push(r); pinO.push("rsvd"); } // reserved pins
+				if (d.um_p[0]==-1) d.um_p.shift();	// remove filler
+				d.Sf.SDA.max = d.Sf.SCL.max = d.Sf.MOSI.max = d.Sf.SCLK.max = d.Sf.MISO.max = d.max_gpio;
+				//for (let i of d.getElementsByTagName("input")) if (i.type === "number" && i.name.replace("[]","").substr(-3) === "pin") i.max = d.max_gpio;
+				pinDD(); // convert INPUT to SELECT for pins
+			});	// If we set async false, file is loaded and executed, then next statement is processed
+		})
+		.catch((error)=>{
+			gId('lserr').style.display = "inline";
+			console.log(error);
+		});
 		if (!numM) gId("um").innerHTML = "No Usermods installed.";
 		if (loc) d.Sf.action = getURL('/settings/um');
 	}
-	function getURL(path) {
-		return (loc ? locproto + "//" + locip : "") + path;
-	}
-	// https://stackoverflow.com/questions/3885817/how-do-i-check-that-a-number-is-float-or-integer
-	function isF(n) { return n === +n && n !== (n|0); }
-	function isI(n) { return n === +n && n === (n|0); }
 	function check(o,k) {   // input object, pin owner key
 		/* no longer necessary with pin dropdown fields
 		var n = o.name.replace("[]","").substr(-3);
@@ -80,7 +60,7 @@
 			for (var i=0; i<pins.length; i++) {
 				if (k==pinO[i]) continue;
 				if (o.value==pins[i] && pinO[i]==="if") { o.style.color="lime"; break; }
-				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
+				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio-1) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
 			}
 		} else {
 			switch (o.name) {
@@ -94,7 +74,7 @@
 			for (var i=0; i<pins.length; i++) {
 				//if (k==pinO[i]) continue; // same owner
 				if (o.value==pins[i] && pinO[i]==="if") { o.style.color="tomato"; break; }
-				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
+				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio-1) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
 			}
 		}
 		*/
@@ -148,7 +128,7 @@
 				case "number":
 					c = `value="${o}"`;
 					if (f.substr(-3)==="pin") {
-						c += ` max="${d.max_gpio}" min="-1" class="s"`;
+						c += ` max="${d.max_gpio-1}" min="-1" class="s"`;
 						t = "int";
 					} else {
 						c += ' step="any" class="xxl"';
@@ -170,7 +150,7 @@
 			if (i.type === "number" && (i.name.includes("pin") || ["SDA","SCL","MOSI","MISO","SCLK"].includes(i.name))) { //select all pin select elements
 				let v = parseInt(i.value);
 				let sel = addDD(i.name,0);
-				for (var j = -1; j <= d.max_gpio; j++) {
+				for (var j = -1; j < d.max_gpio; j++) {
 					if (d.rsvd.includes(j)) continue;
 					let foundPin = pins.indexOf(j);
 					let txt = (j === -1) ? "unused" : `${j}`;
@@ -220,7 +200,7 @@
 	}
 	// https://stackoverflow.com/questions/39729741/javascript-change-input-text-to-select-option
 	function addDD(um,fld) {
-		let sel = d.createElement('select');
+		let sel = cE('select');
 		if (typeof(fld) === "string") {	// parameter from usermod (field name)
 			if (fld.includes("pin")) sel.classList.add("pin");
 			um += ":"+fld;
@@ -258,7 +238,7 @@
 	var addDropdown = addDD; // backwards compatibility
 	function addO(sel,txt,val) {
 		if (sel===null) return; // select object missing
-		let opt = d.createElement("option");
+		let opt = cE("option");
 		opt.value = val;
 		opt.text = txt;
 		sel.appendChild(opt);
@@ -284,34 +264,6 @@
 	function addHB(um) {
 		addI(um + ':help',0,`<button onclick="location.href='https://kno.wled.ge/usermods/${um}'" type="button">?</button>`);
 	}
-	// load settings and insert values into DOM
-	function ldS() {
-		fetch(getURL('/cfg.json'), {
-			method: 'get'
-		})
-		.then(res => {
-			if (!res.ok) gId('lserr').style.display = "inline";
-			return res.json();
-		})
-		.then(json => {
-			umCfg = json.um;
-			getPins(json);
-			urows="";
-			if (isO(umCfg)) {
-				for (const [k,o] of Object.entries(umCfg)) {
-					urows += `<hr><h3>${k}</h3>`;
-					addField(k,'unknown',o);
-				}
-			}
-			if (urows==="") urows = "Usermods configuration not found.<br>Press <i>Save</i> to initialize defaults.";
-			gId("um").innerHTML = urows;
-			loadJS(getURL('/settings/s.js?p=8'), false);	// If we set async false, file is loaded and executed, then next statement is processed
-		})
-		.catch((error)=>{
-			gId('lserr').style.display = "inline";
-			console.log(error);
-		});
-	}
 	function svS(e) {
 		e.preventDefault();
 		if (d.Sf.checkValidity()) d.Sf.submit(); //https://stackoverflow.com/q/37323914