Initial new settings page test commit

2021-10-07 23:09:23 +02:00
336 changed files with 25182 additions and 74382 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -1,2 +1,2 @@
-github: [Aircoookie,blazoncek]
+github: [Aircoookie]
-custom: ['https://paypal.me/Aircoookie','https://paypal.me/blazoncek']
+custom: ['https://paypal.me/Aircoookie']
--- a/.github/ISSUE_TEMPLATE/bug.md
+++ b/.github/ISSUE_TEMPLATE/bug.md
@ -0,0 +1,27 @@
 ---
 name: Bug
 about: Noticed an issue with your lights?
 title: ''
 labels: bug
 assignees: ''
 ---
 **Describe the bug**
 A clear and concise description of what the bug is. Please quickly search existing issues first!
 **To Reproduce**
 Steps to reproduce the behavior, if consistently possible
 **Expected behavior**
 A clear and concise description of what you expected to happen.
 **WLED version**
 - Board: [e.g. Wemos D1, ESP32 dev]
 - Version [e.g. 0.10.0, dev200603]
 - Format [e.g. Binary, self-compiled]
 **Additional context**
 Anything else you'd like to say about the problem?
 Thank you for your help!
--- a/.github/ISSUE_TEMPLATE/bug.yml
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@ -1,86 +0,0 @@
 name: Bug Report
 description: File a bug report
 labels: ["bug"]
 body:
  - type: markdown
    attributes:
      value: |
        Please quickly search existing issues first before submitting a bug.
  - type: textarea
    id: what-happened
    attributes:
      label: What happened?
      description: A clear and concise description of what the bug is.
      placeholder: Tell us what the problem is.
    validations:
      required: true
  - type: textarea
    id: how-to-reproduce
    attributes:
      label: To Reproduce Bug
      description: Steps to reproduce the behavior, if consistently possible.
      placeholder: Tell us how to make the bug appear.
    validations:
      required: true
  - type: textarea
    id: expected-behavior
    attributes:
      label: Expected Behavior
      description: A clear and concise description of what you expected to happen.
      placeholder: Tell us what you expected to happen.
    validations:
      required: true
  - type: dropdown
    id: install_format
    attributes:
      label: Install Method
      description: How did you install WLED?
      options:
        - Binary from WLED.me
        - Self-Compiled
    validations:
      required: true
  - type: input
    id: version
    attributes:
      label: What version of WLED?
      description: You can find this in by going to Config -> Security & Updates -> Scroll to Bottom. Copy and paste the entire line after "Server message"
      placeholder: "e.g. WLED 0.13.1 (build 2203150)"
    validations:
      required: true
  - type: dropdown
    id: Board
    attributes:
      label: Which microcontroller/board are you seeing the problem on?
      multiple: true
      options:
        - ESP8266
        - ESP32
        - ESP32-S3
        - ESP32-S2
        - ESP32-C3
        - Other
    validations:
      required: true
  - type: textarea
    id: logs
    attributes:
      label: Relevant log/trace output
      description: Please copy and paste any relevant log output if you have it. This will be automatically formatted into code, so no need for backticks.
      render: shell
  - type: textarea
    attributes:
      label: Anything else?
      description: |
        Links? References? Anything that will give us more context about the issue you are encountering!
        Tip: You can attach images or log files by clicking this area to highlight it and then dragging files in.
    validations:
      required: false
  - type: checkboxes
    id: terms
    attributes:
      label: Code of Conduct
      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/Aircoookie/WLED/blob/master/CODE_OF_CONDUCT.md)
      options:
        - label: I agree to follow this project's Code of Conduct
          required: true
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@ -1,11 +0,0 @@
 blank_issues_enabled: false
 contact_links:
  - name: WLED Discord community
    url: https://discord.gg/KuqP7NE
    about: Please ask and answer questions and discuss setup issues here!
  - name: WLED community forum
    url: https://wled.discourse.group/
    about: For issues and ideas that might need longer discussion.
  - name: kno.wled.ge base
    url:  https://kno.wled.ge/basics/faq/
    about: Take a look at the frequently asked questions and documentation, perhaps your question is already answered!
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@ -0,0 +1,19 @@
 ---
 name: Question
 about: Have a question about using WLED?
 title: ''
 labels: question
 assignees: ''
 ---
 **Take a look at the wiki and FAQ, perhaps your question is already answered!**
 [FAQ](https://github.com/Aircoookie/WLED/wiki/FAQ)
 **Please consider asking your question on the WLED forum or Discord**
 [Forum](https://wled.discourse.group/)
 [Discord](https://discord.gg/KuqP7NE)
 [What to post where?](https://github.com/Aircoookie/WLED/issues/658)
 **If you do not like to use these platforms, delete this template and ask away!**
 Please keep in mind though that the issue section is generally not the preferred place for general questions.
--- a/.github/workflows/wled-ci.yml
+++ b/.github/workflows/wled-ci.yml
@ -8,23 +8,21 @@ jobs:
    name: Gather Environments
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2
    - name: Cache pip
-      uses: actions/cache@v3
+      uses: actions/cache@v2
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
        restore-keys: |
          ${{ runner.os }}-pip-
-    - uses: actions/setup-python@v4
+    - uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    - 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
+        echo "::set-output name=environments::$(pio project config --json-output | jq -cr '.[0][1][0][1]')"
    outputs:
      environments: ${{ steps.envs.outputs.environments }}
@ -34,27 +32,24 @@ jobs:
    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@v3
+    - uses: actions/checkout@v2
    - name: Cache pip
-      uses: actions/cache@v3
+      uses: actions/cache@v2
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
        restore-keys: |
          ${{ runner.os }}-pip-
    - name: Cache PlatformIO
-      uses: actions/cache@v3
+      uses: actions/cache@v2
      with:
        path: ~/.platformio
        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
    - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v2
      with:
          python-version: '3.9'
    - name: Install PlatformIO
      run: pip install -r requirements.txt
    - name: Build firmware
--- a/.gitignore
+++ b/.gitignore
@ -1,24 +1,17 @@
 .cache
 .clang-format
 .direnv
 .DS_Store
 .gitignore
 .idea
 .pio
 .cache
 .pioenvs
 .piolibdeps
 .vscode
-
+!.vscode/extensions.json
 esp01-update.sh
 platformio_override.ini
 replace_fs.py
 wled-update.sh
 /build_output/
 /node_modules/
 /wled00/extLibs
 /wled00/LittleFS
 /wled00/my_config.h
 /wled00/Release
-/wled00/wled00.ino.cpp
+/wled00/extLibs
 /platformio_override.ini
 /wled00/my_config.h
 /build_output
 .DS_Store
 .gitignore
 .clang-format
 node_modules
 .idea
 .direnv
--- a/.gitpod.Dockerfile
+++ b/.gitpod.Dockerfile
@ -1,3 +1,5 @@
 FROM gitpod/workspace-full
 USER gitpod
 RUN pip3 install -U platformio
--- a/.gitpod.yml
+++ b/.gitpod.yml
@ -1,11 +1,12 @@
 tasks:
-  - command: pip3 install -U platformio && platformio run
+  - command: platformio run
 image:
  file: .gitpod.Dockerfile
 vscode:
  extensions:
-    - Atishay-Jain.All-Autocomplete
+    - ms-vscode.cpptools@0.26.3:u3GsZ5PK12Ddr79vh4TWgQ==
-    - esbenp.prettier-vscode
+    - eamodio.gitlens@10.2.1:e0IYyp0efFqVsrZwsIe8CA==
-    - shardulm94.trailing-spaces
+    - Atishay-Jain.All-Autocomplete@0.0.23:fbZNfSpnd8XkAHGfAPS2rA==
    - 2gua.rainbow-brackets@0.0.6:Tbu8dTz0i+/bgcKQTQ5b8g==
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@ -3,8 +3,5 @@
    // for the documentation about the extensions.json format
    "recommendations": [
        "platformio.platformio-ide"
    ],
    "unwantedRecommendations": [
        "ms-vscode.cpptools-extension-pack"
    ]
 }
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,384 +1,6 @@
 ## WLED changelog
-#### Build 2310010, build 2310130
+### Builds after release 0.12.0
 -   Release of WLED version 0.14.0 "Hoshi"
 -   Bugfixes for #3400, #3403, #3405
 -   minor HTML optimizations
 -   audioreactive: bugfix for UDP sound sync (partly initialized packets)
 #### Build 2309240
 -   Release of WLED beta version 0.14.0-b6 "Hoshi"
 -   Effect bugfixes and improvements (Meteor, Meteor Smooth, Scrolling Text)
 -   audioreactive: bugfixes for ES8388 and ES7243 init; minor improvements for analog inputs
 #### Build 2309100
 -   Release of WLED beta version 0.14.0-b5 "Hoshi"
 -   New standard esp32 build with audioreactive
 -   Effect blending bugfixes, and minor optimizations
 #### Build 2309050
 -   Effect blending (#3311) (finally effect transitions!)
    *WARNING*: May not work well with ESP8266, with plenty of segments or usermods (low RAM condition)!!!
 -   Added receive and send sync groups to JSON API (#3317) (you can change sync groups using preset)
 -   Internal temperature usermod (#3246)
 -   MQTT server and topic length overrides (#3354) (new build flags)
 -   Animated Staircase usermod enhancement (#3348) (on/off toggle/relay control)
 -   Added local time info to Info page (#3351)
 -   New effect: Rolling Balls (a.k.a. linear bounce) (#1039)
 -   Various bug fixes and enhancements.
 #### Build 2308110
 -   Release of WLED beta version 0.14.0-b4 "Hoshi"
 -   Reset effect data immediately upon mode change
 #### Build 2308030
 -   Improved random palette handling and blending
 -   Soap bugfix
 -   Fix ESP-NOW crash with AP mode Always
 #### Build 2307180
 -   Bus-level global buffering (#3280)
 -   Removed per-segment LED buffer (SEGMENT.leds)
 -   various fixes and improvements (ESP variants platform 5.3.0, effect optimizations, /json/cfg pin allocation)
 #### Build 2307130
 -   larger `oappend()` stack buffer (3.5k) for ESP32
 -   Preset cycle bugfix (#3262)
 -   Rotary encoder ALT fix for large LED count (#3276)
 -   effect updates (2D Plasmaball), `blur()` speedup
 -   On/Off toggle from nodes view (may show unknown device type on older versions) (#3291)
 -   various fixes and improvements (ABL, crashes when changing presets with different segments)
 #### Build 2306270
 -   ESP-NOW remote support (#3237)
 -   Pixel Magic tool (display pixel art) (#3249)
 -   Websocket (peek) fallback when connection cannot be established, WS retries (#3267)
 -   Add WiFi network scan RPC command to Improv Serial (#3271)
 -   Longer (custom option available) segment name for ESP32
 -   various fixes and improvements
 #### Build 2306210
 -   0.14.0-b3 release
 -   respect global I2C in all usermods (no local initialization of I2C bus)
 -   Multi relay usermod compile-time enabled option (-D MULTI_RELAY_ENABLED=true|false)
 #### Build 2306180
 -   Added client-side option for applying effect defaults from metadata
 -   Improved ESP8266 stability by reducing WebSocket response resends
 -   Updated ESP8266 core to 3.1.2
 #### Build 2306141
 -   Lissajous improvements
 -   Scrolling Text improvements (leading 0)
 #### Build 2306140
 -   Add settings PIN (un)locking to JSON post API
 #### Build 2306130
 -   Bumped version to 0.14-b3 (beta 3)
 -   added pin dropdowns in LED preferences (not for LED pins) and usermods
 -   introduced (unused ATM) NeoGammaWLEDMethod class
 -   Reverse proxy support
 -   PCF8754 support for Rotary encoder (requires wiring INT pin to ESP GPIO)
 -   Rely on global I2C pins for usermods (breaking change)
 -   various fixes and enhancements
 #### Build 2306020
 -   Support for segment sets (PR #3171)
 -   Reduce sound simulation modes to 2 to facilitate segment sets
 -   Trigger button immediately on press if all configured presets are the same (PR #3226)
 -   Changes for allowing Alexa to change light color to White when auto-calculating from RGB (PR #3211)
 #### Build 2305280
 -   DDP protocol update (#3193)
 -   added PCF8574 I2C port expander support for Multi relay usermod
 -   MQTT multipacket (fragmented) message fix
 -   added option to retain MQTT brightness and color messages
 -   new ethernet board: @srg74 Ethernet Shield
 -   new 2D effects: Soap (#3184) & Octopus & Waving cell (credit @St3P40 https://github.com/80Stepko08)
 -   various fixes and enhancements
 #### Build 2305090
 -   new ethernet board: @Wladi ABC! WLED Eth
 -   Battery usermod voltage calculation (#3116)
 -   custom palette editor (#3164)
 -   improvements in Dancing Shadows and Tartan effects
 -   UCS389x support
 -   switched to NeoPixelBus 2.7.5 (replaced NeoPixelBrightnessBus with NeoPixelBusLg)
 -   SPI bus clock selection (for LEDs) (#3173)
 -   DMX mode preset fix (#3134)
 -   iOS fix for scroll (#3182)
 -   Wordclock "Norddeutsch" fix (#3161)
 -   various fixes and enhancements
 #### Build 2304090
 -   updated Arduino ESP8266 core to 4.1.0 (newer compiler)
 -   updated NeoPixelBus to 2.7.3 (with support for UCS890x chipset)
 -   better support for ESP32-C3, ESP32-S2 and ESP32-S3 (Arduino ESP32 core 5.2.0)
 -   iPad/tablet with 1024 pixels width in landscape orientation PC mode support (#3153)
 -   fix for Pixel Art Converter (#3155)
 #### Build 2303240
 -   Peek scaling of large 2D matrices
 -   Added 0D (1 pixel) metadata for effects & enhance 0D (analog strip) UI handling
 -   Added ability to disable ADAlight (-D WLED_DISABLE_ADALIGHT)
 -   Fixed APA102 output on Ethernet enabled controllers
 -   Added ArtNet virtual/network output (#3121)
 -   Klipper usermod (#3106)
 -   Remove DST from CST timezone
 -   various fixes and enhancements
 #### Build 2302180
 -   Removed Blynk support (servers shut down on 31st Dec 2022)
 -   Added `ledgap.json` to complement ledmaps for 2D matrices
 -   Added support for white addressable strips (#3073)
 -   Ability to use SHT temperature usermod with PWM fan usermod
 -   Added `onStateChange()` callback to usermods (#3081)
 -   Refactored `bus_manager` [internal]
 -   Dual 1D & 2D mode (add 1D strip after the matrix)
 -   Removed 1D -> 2D mapping for individual pixel control
 -   effect tweak: Fireworks 1D
 -   various bugfixes
 #### Build 2301240
 -   Version bump to v0.14.0-b2 "Hoshi"
 -   PixelArt converter (convert any image to pixel art and display it on a matrix) (PR #3042)
 -   various effect updates and optimisations
    -   added Overlay option to some effects (allows overlapping segments)
    -   added gradient text on Scrolling Text
    -   added #DDMM, #MMDD & #HHMM date and time options for Scrolling Text effect (PR #2990)
    -   deprecated: Dynamic Smooth, Dissolve Rnd, Solid Glitter
    -   optimised & enhanced loading of default values
    -   new effect: Distortion Waves (2D)
    -   2D support for Ripple effect
    -   slower minimum speed for Railway effect
 -   DMX effect mode & segment controls (PR #2891)
 -   Optimisations for conditional compiles (further reduction of code size)
 -   better UX with effect sliders (PR #3012)
 -   enhanced support for ESP32 variants: C3, S2 & S3
 -   usermod enhancements (PIR, Temperature, Battery (PR #2975), Analog Clock (PR #2993))
 -   new usermod SHT (PR #2963)
 -   2D matrix set up with gaps or irregular panels (breaking change!) (PR #2892)
 -   palette blending/transitions
 -   random palette smooth changes
 -   hex color notations in custom palettes
 -   allow more virtual buses
 -   plethora of bugfixes
 ### WLED release 0.14.0-b1
 #### Build 2212222
 -   Version bump to v0.14.0-b1 "Hoshi"
 -   2D matrix support (including mapping 1D effects to 2D and 2D peek)
 -   [internal] completely rewritten Segment & WS2812FX handling code
 -   [internal] ability to add custom effects via usermods
 -   [internal] set of 2D drawing functions
 -   transitions on every segment (including ESP8266)
 -   enhanced old and new 2D effects (metadata: default values)
 -   custom palettes (up to 10; upload palette0.json, palette1.json, ...)
 -   custom effect sliders and options, quick filters
 -   global I2C and SPI GPIO allocation (for usermods)
 -   usermod settings page enhancements (dropdown & info)
 -   asynchronous preset loading (and added "pd" JSON API call for direct preset apply)
 -   new usermod Boblight (PR #2917)
 -   new usermod PWM Outputs (PR #2912)
 -   new usermod Audioreactive
 -   new usermod Word Clock Matrix (PR #2743)
 -   new usermod Ping Pong Clock (PR #2746)
 -   new usermod ADS1115 (PR #2752)
 -   new usermod Analog Clock (PR #2736)
 -   various usermod enhancements and updates
 -   allow disabling pull-up resistors on buttons
 -   SD card support (PR #2877)
 -   enhanced HTTP API to support custom effect sliders & options (X1, X2, X3, M1, M2, M3)
 -   multiple UDP sync message retries (PR #2830)
 -   network debug printer (PR #2870)
 -   automatic UI PC mode on large displays
 -   removed support for upgrading from pre-0.10 (EEPROM)
 -   support for setting GPIO level when LEDs are off (RMT idle level, ESP32 only) (PR #2478)
 -   Pakistan time-zone (PKT)
 -   ArtPoll support
 -   TM1829 LED support
 -   experimental support for ESP32 S2, S3 and C3
 -   general improvements and bugfixes
 ### WLED release 0.13.3
 -   Version bump to v0.13.3 "Toki"
 -   Disable ESP watchdog by default (fixes flickering and boot issues on a fresh install)
 -   Added support for LPD6803
 ### WLED release 0.13.2
 #### Build 2208140
 -   Version bump to v0.13.2 "Toki"
 -   Added option to receive live data on the main segment only (PR #2601)
 -   Enable ESP watchdog by default (PR #2657)
 -   Fixed race condition when saving bus config
 -   Better potentiometer filtering (PR #2693)
 -   More suitable DMX libraries (PR #2652)
 -   Fixed outgoing serial TPM2 message length (PR #2628)
 -   Fixed next universe overflow and Art-Net DMX start address (PR #2607)
 -   Fixed relative segment brightness (PR #2665)
 ### Builds between releases 0.13.1 and 0.13.2
 #### Build 2203191
 -   Fixed sunrise/set calculation (once again)
 #### Build 2203190
 -   Fixed `/json/cfg` unable to set busses (#2589)
 -   Fixed Peek with odd LED counts > 255 (#2586)
 #### Build 2203160
 -   Version bump to v0.13.2-a0 "Toki"
 -   Add ability to skip up to 255 LEDs
 -   Dependency version bumps
 ### WLED release 0.13.1
 #### Build 2203150
 -   Version bump to v0.13.1 "Toki"
 -   Fix persistent preset bug, preventing save of new presets
 ### WLED release 0.13.0
 #### Build 2203142
 -   Release of WLED v0.13.0 "Toki"
 -   Reduce APA102 hardware SPI frequency to 5Mhz
 -   Remove `persistent` parameter in `savePreset()`
 ### Builds between releases 0.12.0 and 0.13.0
 #### Build 2203140
 -   Added factory reset by pressing button 0 for >10 seconds
 -   Added ability to set presets from DMX Effect mode
 -   Simplified label hiding JS in user interface
 -   Fixed JSON `{"live":true}` indefinite realtime mode
 #### Build 2203080
 -   Disabled auto white mode in segments with no RGB bus
 -   Fixed hostname string not 0-terminated 
 -   Fixed Popcorn mode not lighting first LED on pop
 #### Build 2203060
 -   Dynamic hiding of unused color controls in UI (PR #2567)
 -   Removed native Cronixie support and added Cronixie usermod
 -   Fixed disabled timed preset expanding calendar
 -   Fixed Color Order setting shown for analog busses
 -   Fixed incorrect operator (#2566)
 #### Build 2203011
 -   IR rewrite (PR #2561), supports CCT
 -   Added locate button to Time settings
 -   CSS fixes and adjustments
 -   Consistent Tab indentation in index JS and CSS
 -   Added initial contribution style guideline
 #### Build 2202222
 -   Version bump to 0.13.0-b7 "Toki"
 -   Fixed HTTP API commands not applying to all selected segments in some conditions
 -   Blynk support is not compiled in by default on ESP32 builds
 #### Build 2202210
 -   Fixed HTTP API commands not applying to all selected segments if called from JSON
 -   Improved Stream effects, no longer rely on LED state and won't fade out at low brightness
 #### Build 2202200
 -   Added `info.leds.seglc` per-segment light capability info (PR #2552)
 -   Fixed `info.leds.rgbw` behavior
 -   Segment bounds sync (PR #2547)
 -   WebSockets auto reconnection and error handling
 -   Disable relay pin by default (PR #2531)
 -   Various fixes (ESP32 touch pin 33, floats, PR #2530, #2534, #2538)
 -   Deprecated `info.leds.cct`, `info.leds.wv` and `info.leds.rgbw`
 -   Deprecated `/url` endpoint
 #### Build 2202030
 -   Switched to binary format for WebSockets peek (PR #2516)
 -   Playlist bugfix
 -   Added `extractModeName()` utility function
 -   Added serial out (PR #2517)
 -   Added configurable baud rate
 #### Build 2201260
 -   Initial ESP32-C3 and ESP32-S2 support (PRs #2452, #2454, #2502)
 -   Full segment sync (PR #2427)
 -   Allow overriding of color order by ranges (PR #2463) 
 -   Added white channel to Peek
 #### Build 2112080
 -   Version bump to 0.13.0-b6 "Toki"
 -   Added "ESP02" (ESP8266 with 2M of flash) to PIO/release binaries
 #### Build 2112070
 -   Added new effect "Fairy", replacing "Police All"
 -   Added new effect "Fairytwinkle", replacing "Two Areas"
 -   Static single JSON buffer (performance and stability improvement) (PR #2336)
 #### Build 2112030
 -   Fixed ESP32 crash on Colortwinkles brightness change
 -   Fixed setting picker to black resetting hue and saturation
 -   Fixed auto white mode not saved to config
 #### Build 2111300
 -   Added CCT and white balance correction support (PR #2285)
 -   Unified UI slider style
 -   Added LED settings config template upload
 #### Build 2111220
 -   Fixed preset cycle not working from preset called by UI
 -   Reintroduced permanent min. and max. cycle bounds
 #### Build 2111190
 -   Changed default ESP32 LED pin from 16 to 2
 -   Renamed "Running 2" to "Chase 2"
 -   Renamed "Tri Chase" to "Chase 3"
 #### Build 2111170
 -   Version bump to 0.13.0-b5 "Toki"
 -   Improv Serial support (PR #2334)
 -   Button improvements (PR #2284)
 -   Added two time zones (PR #2264, 2311)
 -   JSON in/decrementing support for brightness and presets
 -   Fixed no gamma correction for JSON individual LED control
 -   Preset cycle bugfix
 -   Removed ledCount
 -   LED settings buffer bugfix
 -   Network pin conflict bugfix
 -   Changed default ESP32 partition layout to 4M, 1M FS
 #### Build 2110110
 -   Version bump to 0.13.0-b4 "Toki"
 -   Added option for bus refresh if off (PR #2259)
 -   New auto segment logic
 -   Fixed current calculations for virtual or non-linear configs (PR #2262)
 #### Build 2110060
@ -745,7 +367,6 @@
 -   Added support for WESP32 ethernet board (PR #1764)
 -   Added Caching for main UI (PR #1704)
 -   Added Tetrix mode (PR #1729)
 -   Removed Merry Christmas mode (use "Chase 2" - called Running 2 before 0.13.0)
 -   Added memory check on Bus creation
 #### Build 2102050
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -1,78 +0,0 @@
 ## Thank you for making WLED better!
 Here are a few suggestions to make it easier for you to contribute!
 ### Code style
 When in doubt, it is easiest to replicate the code style you find in the files you want to edit :)
 Below are the guidelines we use in the WLED repository.
 #### Indentation
 We use tabs for Indentation in Web files (.html/.css/.js) and spaces (2 per indentation level) for all other files.  
 You are all set if you have enabled `Editor: Detect Indentation` in VS Code.
 #### Blocks
 Whether the opening bracket of e.g. an `if` block is in the same line as the condition or in a separate line is up to your discretion. If there is only one statement, leaving out block braches is acceptable.
 Good:  
 ```cpp
 if (a == b) {
  doStuff(a);
 }
 ```
 ```cpp
 if (a == b)
 {
  doStuff(a);
 }
 ```
 ```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 paranthesis and variables.  
 Spaces between variables and operators are up to the authors discretion.
 There should be no space between function names and their argument parenthesis.
 Good:  
 ```cpp
 if (a == b) {
  doStuff(a);
 }
 ```
 Not good:  
 ```cpp
 if( a==b ){
  doStuff ( a);
 }
 ```
 #### Comments
 Comments should have a space between the delimiting characters (e.g. `//`) and the comment text.
 Note: This is a recent change, the majority of the codebase still has comments without spaces.
 Good:  
 ```
 // This is a comment.
 /* This is a CSS inline comment */
 /* 
 * This is a comment
 * wrapping over multiple lines,
 * used in WLED for file headers and function explanations
 */
 <!-- This is an HTML comment -->
 ```
 There is no set character limit for a comment within a line,
 though as a rule of thumb you should wrap your comment if it exceeds the width of your editor window.  
 Inline comments are OK if they describe that line only and are not exceedingly wide.
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "wled",
-  "version": "0.14.0",
+  "version": "0.13.0-b3",
  "description": "Tools for WLED project",
  "main": "tools/cdata.js",
  "directories": {
@ -25,7 +25,7 @@
    "clean-css": "^4.2.3",
    "html-minifier-terser": "^5.1.1",
    "inliner": "^1.13.1",
-    "nodemon": "^2.0.20",
+    "nodemon": "^2.0.4",
    "zlib": "^1.0.5"
  }
 }
--- a/platformio.ini
+++ b/platformio.ini
@ -6,23 +6,20 @@
 # ENVIRONMENTS
 #
 # Please uncomment one of the lines below to select your board(s)
 # (use `platformio_override.ini` when building for your own board; see `platformio_override.ini.sample` for an example)
 # ------------------------------------------------------------------------------
-# CI binaries
+# Travis CI binaries (use `platformio_override.ini` when building for your own board; see `platformio_override.ini.sample` for an example)
-; default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth # ESP32 variant builds are temporarily excluded from CI due to toolchain issues on the GitHub Actions Linux environment
+; default_envs = travis_esp8266, travis_esp32
 default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth, esp32dev_audioreactive, lolin_s2_mini, esp32c3dev, esp32s3dev_8MB, esp32s3dev_8MB_PSRAM_opi
 # Release binaries
-; default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth, lolin_s2_mini, esp32c3dev, esp32s3dev_8MB
+default_envs = nodemcuv2, esp01_1m_full, esp32dev, esp32_eth
 # Build everything
-; default_envs = esp32dev, esp8285_4CH_MagicHome, codm-controller-0_6-rev2, codm-controller-0_6, esp32s2_saola, d1_mini_5CH_Shojo_PCB, d1_mini, sp501e, nodemcuv2, esp32_eth, anavi_miracle_controller, esp07, esp01_1m_full, m5atom, h803wf, d1_mini_ota, heltec_wifi_kit_8, esp8285_H801, d1_mini_debug, wemos_shield_esp32, elekstube_ips
+; default_envs = esp32dev, esp8285_4CH_MagicHome, esp8285_4CH_H801, codm-controller-0.6-rev2, codm-controller-0.6, esp32s2_saola, d1_mini_5CH_Shojo_PCB, d1_mini, sp501e, travis_esp8266, travis_esp32, nodemcuv2, esp32_eth, anavi_miracle_controller, esp07, esp01_1m_full, m5atom, h803wf, d1_mini_ota, heltec_wifi_kit_8, esp8285_5CH_H801, d1_mini_debug, wemos_shield_esp32, elekstube_ips
 # Single binaries (uncomment your board)
 ; default_envs = elekstube_ips
 ; default_envs = nodemcuv2
 ; default_envs = esp8266_2m
 ; default_envs = esp01_1m_full
 ; default_envs = esp07
 ; default_envs = d1_mini
@ -32,16 +29,12 @@ default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth, esp32d
 ; default_envs = d1_mini_ota
 ; default_envs = esp32dev
 ; default_envs = esp8285_4CH_MagicHome
-; default_envs = esp8285_H801
+; default_envs = esp8285_4CH_H801
 ; default_envs = esp8285_5CH_H801
 ; default_envs = d1_mini_5CH_Shojo_PCB
 ; default_envs = wemos_shield_esp32
 ; default_envs = m5atom
 ; default_envs = esp32_eth
 ; default_envs = esp32dev_qio80
 ; default_envs = esp32_eth_ota1mapp
 ; default_envs = esp32s2_saola
 ; default_envs = esp32c3dev
 ; default_envs = lolin_s2_mini
 src_dir  = ./wled00
 data_dir = ./wled00/data
@ -60,45 +53,33 @@ extra_configs =
 arduino_core_2_6_3 = espressif8266@2.3.3
 arduino_core_2_7_4 = espressif8266@2.6.2
 arduino_core_3_0_0 = espressif8266@3.0.0
 arduino_core_3_2_0 = espressif8266@3.2.0
 arduino_core_4_1_0 = espressif8266@4.1.0
 arduino_core_3_1_2 = espressif8266@4.2.0
 # Development platforms
 arduino_core_develop = https://github.com/platformio/platform-espressif8266#develop
 arduino_core_git = https://github.com/platformio/platform-espressif8266#feature/stage
 # Platform to use for ESP8266
-platform_wled_default = ${common.arduino_core_3_1_2}
+platform_wled_default = ${common.arduino_core_2_7_4}
 # We use 2.7.4.7 for all, includes PWM flicker fix and Wstring optimization
-#platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
+platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
-platform_packages = platformio/framework-arduinoespressif8266
+                    platformio/toolchain-xtensa @ ~2.40802.200502
-                    platformio/toolchain-xtensa @ ~2.100300.220621 #2.40802.200502
+                    platformio/tool-esptool @ ~1.413.0
-                    platformio/tool-esptool #@ ~1.413.0
+                    platformio/tool-esptoolpy @ ~1.30000.0
                    platformio/tool-esptoolpy #@ ~1.30000.0
 ## previous platform for 8266, in case of problems with the new one
 ## you'll need  makuna/NeoPixelBus@ 2.6.9 for arduino_core_3_2_0, which does not support Ucs890x
 ;; platform_wled_default = ${common.arduino_core_3_2_0}
 ;; platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
 ;;                    platformio/toolchain-xtensa @ ~2.40802.200502
 ;;                    platformio/tool-esptool @ ~1.413.0
 ;;                    platformio/tool-esptoolpy @ ~1.30000.0
 # ------------------------------------------------------------------------------
 # FLAGS: DEBUG
-# esp8266 : see https://docs.platformio.org/en/latest/platforms/espressif8266.html#debug-level
+#
 # esp32   : see https://docs.platformio.org/en/latest/platforms/espressif32.html#debug-level
 # ------------------------------------------------------------------------------
-debug_flags = -D DEBUG=1 -D WLED_DEBUG
+debug_flags = -D DEBUG=1 -D WLED_DEBUG -DDEBUG_ESP_WIFI -DDEBUG_ESP_HTTP_CLIENT -DDEBUG_ESP_HTTP_UPDATE -DDEBUG_ESP_HTTP_SERVER -DDEBUG_ESP_UPDATER -DDEBUG_ESP_OTA -DDEBUG_TLS_MEM
  -DDEBUG_ESP_WIFI -DDEBUG_ESP_HTTP_CLIENT -DDEBUG_ESP_HTTP_UPDATE -DDEBUG_ESP_HTTP_SERVER -DDEBUG_ESP_UPDATER -DDEBUG_ESP_OTA -DDEBUG_TLS_MEM ;; for esp8266
 #if needed (for memleaks etc) also add; -DDEBUG_ESP_OOM -include "umm_malloc/umm_malloc_cfg.h"
 #-DDEBUG_ESP_CORE is not working right now
 # ------------------------------------------------------------------------------
 # FLAGS: ldscript (available ldscripts at https://github.com/esp8266/Arduino/tree/master/tools/sdk/ld)
 #    ldscript_1m0m (1024 KB) =  999 KB sketch, 4 KB eeprom,      no spiffs, 16 KB reserved
 #    ldscript_2m1m (2048 KB) = 1019 KB sketch, 4 KB eeprom, 1004 KB spiffs, 16 KB reserved
 #    ldscript_4m1m (4096 KB) = 1019 KB sketch, 4 KB eeprom, 1002 KB spiffs, 16 KB reserved, 2048 KB empty/ota?
 #    ldscript_4m3m (4096 KB) = 1019 KB sketch, 4 KB eeprom, 3040 KB spiffs, 16 KB reserved
 #
 # Available lwIP variants (macros):
 #    -DPIO_FRAMEWORK_ARDUINO_LWIP_HIGHER_BANDWIDTH  = v1.4 Higher Bandwidth (default)
@ -118,13 +99,11 @@ debug_flags = -D DEBUG=1 -D WLED_DEBUG
 #  This reduces the OTA size with ~45KB, so it's especially useful on low memory boards (512k/1m).
 # ------------------------------------------------------------------------------
 build_flags =
  -Wno-attributes
  -DMQTT_MAX_PACKET_SIZE=1024
  -DSECURE_CLIENT=SECURE_CLIENT_BEARSSL
  -DBEARSSL_SSL_BASIC
  -D CORE_DEBUG_LEVEL=0
  -D NDEBUG
  -Wno-attributes ;; silence warnings about unknown attribute 'maybe_unused' in NeoPixelBus
  #build_flags for the IRremoteESP8266 library (enabled decoders have to appear here)
  -D _IR_ENABLE_DEFAULT_=false
  -D DECODE_HASH=true
@ -132,17 +111,20 @@ build_flags =
  -D DECODE_SONY=true
  -D DECODE_SAMSUNG=true
  -D DECODE_LG=true
  ;-Dregister= # remove warnings in C++17 due to use of deprecated register keyword by the FastLED library ;; warning: this breaks framework code on ESP32-C3 and ESP32-S2
  -DWLED_USE_MY_CONFIG
  ; -D USERMOD_SENSORSTOMQTT
  #For ADS1115 sensor uncomment following
  ; -D USERMOD_ADS1115
 build_unflags =
 # enables all features for travis CI
 build_flags_all_features =
  -D WLED_ENABLE_ADALIGHT
  -D WLED_ENABLE_DMX
  -D WLED_ENABLE_MQTT
  -D WLED_ENABLE_WEBSOCKETS
 build_flags_esp8266 = ${common.build_flags}  ${esp8266.build_flags}
 build_flags_esp32   = ${common.build_flags}  ${esp32.build_flags}
 build_flags_esp32_V4= ${common.build_flags}  ${esp32_idf_V4.build_flags}
 ldscript_1m128k = eagle.flash.1m128.ld
 ldscript_2m512k = eagle.flash.2m512.ld
@ -172,29 +154,27 @@ upload_speed = 115200
 # LIBRARIES: required dependencies
 #   Please note that we don't always use the latest version of a library.
 #
-#   The following libraries have been included (and some of them changed) in the source:
+#   The following libraries have been included (and some of them changd) in the source:
-#     ArduinoJson@5.13.5, E131@1.0.0(changed), Time@1.5, Timezone@1.2.1
+#     ArduinoJson@5.13.5, Blynk@0.5.4(changed), E131@1.0.0(changed), Time@1.5, Timezone@1.2.1
 # ------------------------------------------------------------------------------
 lib_compat_mode = strict
 lib_deps =
-    fastled/FastLED @ 3.6.0
+    fastled/FastLED @ 3.4.0
-    IRremoteESP8266 @ 2.8.2
+    IRremoteESP8266 @ 2.7.18
-    makuna/NeoPixelBus @ 2.7.5
+    https://github.com/lorol/LITTLEFS.git
-    https://github.com/Aircoookie/ESPAsyncWebServer.git @ ~2.0.7
+    https://github.com/Aircoookie/ESPAsyncWebServer.git @ ~2.0.2
  #For use of the TTGO T-Display ESP32 Module with integrated TFT display uncomment the following line
    #TFT_eSPI
-  #For compatible OLED display uncomment following
+  #For use SSD1306 OLED display uncomment following
-    #U8g2 #@ ~2.33.15
+    #U8g2@~2.27.2
-  #For Dallas sensor uncomment following
+  #For Dallas sensor uncomment following 2 lines
-    #OneWire @ ~2.3.7
+    #OneWire@~2.3.5
    #milesburton/DallasTemperature@^3.9.0
  #For BME280 sensor uncomment following
    #BME280@~3.0.0
    ; adafruit/Adafruit BMP280 Library @ 2.1.0
    ; adafruit/Adafruit CCS811 Library @ 1.0.4
    ; adafruit/Adafruit Si7021 Library @ 1.4.0
  #For ADS1115 sensor uncomment following
    ; adafruit/Adafruit BusIO @ 1.13.2
    ; adafruit/Adafruit ADS1X15 @ 2.4.0
 extra_scripts             = ${scripts_defaults.extra_scripts}
@ -203,9 +183,7 @@ build_flags =
  -DESP8266
  -DFP_IN_IROM
  ;-Wno-deprecated-declarations
-  ;-Wno-register  ;; leaves some warnings when compiling C files: command-line option '-Wno-register' is valid for C++/ObjC++ but not for C
+  ;-Wno-register
  ;-Dregister= # remove warnings in C++17 due to use of deprecated register keyword by the FastLED library ;; warning: this can be dangerous
  -Wno-misleading-indentation
 ; NONOSDK22x_190703 = 2.2.2-dev(38a443e)
  -DPIO_FRAMEWORK_ARDUINO_ESPRESSIF_SDK22x_190703
 ; lwIP 2 - Higher Bandwidth no Features
@ -216,111 +194,37 @@ build_flags =
  -DVTABLES_IN_FLASH
 ; restrict to minimal mime-types
  -DMIMETYPE_MINIMAL
  ; other special-purpose framework flags (see https://docs.platformio.org/en/latest/platforms/espressif8266.html)
  ; -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
 lib_deps = 
  #https://github.com/lorol/LITTLEFS.git
  ESPAsyncTCP @ 1.2.2
  ESPAsyncUDP
  ${env.lib_deps}
  # ESPAsyncTCP @ 1.2.0
  ESPAsyncUDP
  makuna/NeoPixelBus @ 2.6.7 # 2.6.5/2.6.6 and newer do not compile on ESP core < 3.0.0
 [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_flags = -g
  -DARDUINO_ARCH_ESP32
-  #-DCONFIG_LITTLEFS_FOR_IDF_3_2
+  -DCONFIG_LITTLEFS_FOR_IDF_3_2
  -D CONFIG_ASYNC_TCP_USE_WDT=0
  #use LITTLEFS library by lorol in ESP32 core 1.x.x instead of built-in in 2.x.x
  -D LOROL_LITTLEFS
  ; -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
 default_partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
 lib_deps =
  https://github.com/lorol/LITTLEFS.git
  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
  ${env.lib_deps}
 # additional build flags for audioreactive
 AR_build_flags = -D USERMOD_AUDIOREACTIVE -D UM_AUDIOREACTIVE_USE_NEW_FFT
 AR_lib_deps = https://github.com/kosme/arduinoFFT#develop @ ^1.9.2
 [esp32_idf_V4]
 ;; experimental build environment for ESP32 using ESP-IDF 4.4.x / arduino-esp32 v2.0.5
 ;; very similar to the normal ESP32 flags, but omitting Lorol LittleFS, as littlefs is included in the new framework already.
 ;;
 ;; please note that you can NOT update existing ESP32 installs with a "V4" build. Also updating by OTA will not work properly.
 ;; You need to completely erase your device (esptool erase_flash) first, then install the "V4" build from VSCode+platformio.
 platform = espressif32@5.3.0
 platform_packages =
 build_flags = -g
  -Wshadow=compatible-local ;; emit warning in case a local variable "shadows" another local one
  -DARDUINO_ARCH_ESP32 -DESP32
  #-DCONFIG_LITTLEFS_FOR_IDF_3_2
  -D CONFIG_ASYNC_TCP_USE_WDT=0
  -DARDUINO_USB_CDC_ON_BOOT=0 ;; this flag is mandatory for "classic ESP32" when building with arduino-esp32 >=2.0.3
 default_partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
 lib_deps =
  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
  ${env.lib_deps}
  makuna/NeoPixelBus @ 2.6.7
  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
 [esp32s2]
 ;; generic definitions for all ESP32-S2 boards
 platform = espressif32@5.3.0
 platform_packages =
 build_flags = -g
  -DARDUINO_ARCH_ESP32
  -DCONFIG_LITTLEFS_FOR_IDF_3_2
  -DARDUINO_ARCH_ESP32S2
-  -DCONFIG_IDF_TARGET_ESP32S2=1
+  -DCONFIG_IDF_TARGET_ESP32S2
  -D CONFIG_ASYNC_TCP_USE_WDT=0
  -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_USB_DFU_ON_BOOT=0
  -DCO
  -DARDUINO_USB_MODE=0 ;; this flag is mandatory for ESP32-S2 !
  ;; please make sure that the following flags are properly set (to 0 or 1) by your board.json, or included in your custom platformio_override.ini entry:
  ;; ARDUINO_USB_CDC_ON_BOOT
 lib_deps =
  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
  ${env.lib_deps}
 [esp32c3]
 ;; generic definitions for all ESP32-C3 boards
 platform = espressif32@5.3.0
 platform_packages =
 build_flags = -g
  -DARDUINO_ARCH_ESP32
  -DARDUINO_ARCH_ESP32C3
  -DCONFIG_IDF_TARGET_ESP32C3=1
  -D CONFIG_ASYNC_TCP_USE_WDT=0
  -DCO
  -DARDUINO_USB_MODE=1 ;; this flag is mandatory for ESP32-C3
  ;; please make sure that the following flags are properly set (to 0 or 1) by your board.json, or included in your custom platformio_override.ini entry:
  ;; ARDUINO_USB_CDC_ON_BOOT
 lib_deps =
  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
  ${env.lib_deps}
-
+  makuna/NeoPixelBus @ 2.6.7
 [esp32s3]
 ;; generic definitions for all ESP32-S3 boards
 platform = espressif32@5.3.0
 platform_packages =
 build_flags = -g
  -DESP32
  -DARDUINO_ARCH_ESP32
  -DARDUINO_ARCH_ESP32S3
  -DCONFIG_IDF_TARGET_ESP32S3=1
  -D CONFIG_ASYNC_TCP_USE_WDT=0
  -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_DFU_ON_BOOT=0
  -DCO
  ;; please make sure that the following flags are properly set (to 0 or 1) by your board.json, or included in your custom platformio_override.ini entry:
  ;; ARDUINO_USB_MODE, ARDUINO_USB_CDC_ON_BOOT
 lib_deps =
  https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
  ${env.lib_deps}
 # ------------------------------------------------------------------------------
 # WLED BUILDS
@ -332,17 +236,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} -D WLED_RELEASE_NAME=ESP8266 #-DWLED_DISABLE_2D
+build_flags = ${common.build_flags_esp8266} -D WLED_RELEASE_NAME=ESP8266
 lib_deps = ${esp8266.lib_deps}
 monitor_filters = esp8266_exception_decoder
 [env:esp8266_2m]
 board = esp_wroom_02
 platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D WLED_RELEASE_NAME=ESP02
 lib_deps = ${esp8266.lib_deps}
 [env:esp01_1m_full]
@ -352,7 +246,6 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_1m128k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D WLED_RELEASE_NAME=ESP01 -D WLED_DISABLE_OTA
  ; -D WLED_USE_UNREAL_MATH ;; may cause wrong sunset/sunrise times, but saves 7064 bytes FLASH and 975 bytes RAM
 lib_deps = ${esp8266.lib_deps}
 [env:esp07]
@ -395,142 +288,32 @@ lib_deps = ${esp8266.lib_deps}
 [env:esp32dev]
 board = esp32dev
-platform = ${esp32.platform}
+platform = espressif32@2.0
 platform_packages = ${esp32.platform_packages}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32 #-D WLED_DISABLE_BROWNOUT_DET
 lib_deps = ${esp32.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.default_partitions}
 [env:esp32dev_audioreactive]
 board = esp32dev
 platform = ${esp32.platform}
 platform_packages = ${esp32.platform_packages}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32_audioreactive #-D WLED_DISABLE_BROWNOUT_DET
  ${esp32.AR_build_flags}
 lib_deps = ${esp32.lib_deps}
  ${esp32.AR_lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.default_partitions}
 ; board_build.f_flash = 80000000L
 ; board_build.flash_mode = dio
 [env:esp32dev_qio80]
 board = esp32dev
 platform = ${esp32.platform}
 platform_packages = ${esp32.platform_packages}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32_qio80 #-D WLED_DISABLE_BROWNOUT_DET
 lib_deps = ${esp32.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32.default_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 [env:esp32dev_V4_dio80]
 ;; experimental ESP32 env using ESP-IDF V4.4.x
 ;; Warning: this build environment is not stable!!
 ;; please erase your device before installing.
 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_qio80 #-D WLED_DISABLE_BROWNOUT_DET
 lib_deps = ${esp32_idf_V4.lib_deps}
 monitor_filters = esp32_exception_decoder
 board_build.partitions = ${esp32_idf_V4.default_partitions}
 board_build.f_flash = 80000000L
 board_build.flash_mode = dio
 [env:esp32_eth]
 board = esp32-poe
-platform = ${esp32.platform}
+platform = espressif32@2.0
 platform_packages = ${esp32.platform_packages}
 upload_speed = 921600
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32_Ethernet -D RLYPIN=-1 -D WLED_USE_ETHERNET -D BTNPIN=-1
  -D WLED_DISABLE_ESPNOW ;; ESP-NOW requires wifi, may crash with ethernet only
 lib_deps = ${esp32.lib_deps}
 board_build.partitions = ${esp32.default_partitions}
 [env:esp32s2_saola]
-board = esp32-s2-saola-1
+board = esp32dev
-platform = https://github.com/tasmota/platform-espressif32/releases/download/v2.0.2.2/platform-tasmota-espressif32-2.0.2.zip
+board_build.mcu = esp32s2
 platform = espressif32
 platform_packages =
    toolchain-xtensa32s2
    framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#2.0.0-alpha1
 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} #-D WLED_RELEASE_NAME=S2_saola
  ;-DLOLIN_WIFI_FIX ;; try this in case Wifi does not work
  -DARDUINO_USB_CDC_ON_BOOT=1
 lib_deps = ${esp32s2.lib_deps}
 [env:esp32c3dev]
 extends = esp32c3
 platform = ${esp32c3.platform}
 platform_packages = ${esp32c3.platform_packages}
 framework = arduino
 board = esp32-c3-devkitm-1
 board_build.partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
 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
  ;-DARDUINO_USB_CDC_ON_BOOT=0   ;; for serial-to-USB chip
 upload_speed = 460800
 build_unflags = ${common.build_unflags}
 lib_deps = ${esp32c3.lib_deps}
 [env:esp32s3dev_8MB]
 ;; ESP32-S3-DevKitC-1 development board, with 8MB FLASH, no PSRAM (flash_mode: qio)
 board = esp32-s3-devkitc-1
 platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600 ; or  460800
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s3.build_flags} -D WLED_RELEASE_NAME=ESP32-S3_8MB
  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
  -D ARDUINO_USB_CDC_ON_BOOT=0  ;; -D ARDUINO_USB_MODE=1 ;; for boards with serial-to-USB chip
  ;-D ARDUINO_USB_CDC_ON_BOOT=1 ;; -D ARDUINO_USB_MODE=1 ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
  ;-D WLED_DEBUG
 lib_deps = ${esp32s3.lib_deps}
 board_build.partitions = tools/WLED_ESP32_8MB.csv
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 ; board_build.flash_mode = dio   ;; try this if you have problems at startup
 monitor_filters = esp32_exception_decoder
 [env:esp32s3dev_8MB_PSRAM_opi]
 ;; ESP32-S3 development board, with 8MB FLASH and >= 8MB PSRAM (memory_type: qio_opi)
 board = esp32-s3-devkitc-1 ;; generic dev board; the next line adds PSRAM support
 board_build.arduino.memory_type = qio_opi     ;; use with PSRAM: 8MB or 16MB
 platform = ${esp32s3.platform}
 platform_packages = ${esp32s3.platform_packages}
 upload_speed = 921600
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32s3.build_flags}
  -D CONFIG_LITTLEFS_FOR_IDF_3_2 -D WLED_WATCHDOG_TIMEOUT=0
  ;-D ARDUINO_USB_CDC_ON_BOOT=0  ;; -D ARDUINO_USB_MODE=1 ;; for boards with serial-to-USB chip
  -D ARDUINO_USB_CDC_ON_BOOT=1 -D ARDUINO_USB_MODE=1      ;; for boards with USB-OTG connector only (USBCDC or "TinyUSB")
  ; -D WLED_RELEASE_NAME=ESP32-S3_PSRAM
  -D WLED_USE_PSRAM -DBOARD_HAS_PSRAM ; tells WLED that PSRAM shall be used
 lib_deps = ${esp32s3.lib_deps}
 board_build.partitions = tools/WLED_ESP32_8MB.csv
 board_build.f_flash = 80000000L
 board_build.flash_mode = qio
 monitor_filters = esp32_exception_decoder
 [env:esp32s3dev_8MB_PSRAM_qspi]
 ;; ESP32-TinyS3 development board, with 8MB FLASH and PSRAM (memory_type: qio_qspi)
 extends = env:esp32s3dev_8MB_PSRAM_opi
 ;board = um_tinys3 ;    -> needs workaround from https://github.com/Aircoookie/WLED/pull/2905#issuecomment-1328049860
 board = esp32-s3-devkitc-1 ;; generic dev board; the next line adds PSRAM support
 board_build.arduino.memory_type = qio_qspi ;; use with PSRAM: 2MB or  4MB
 [env:esp8285_4CH_MagicHome]
 board = esp8285
 platform = ${common.platform_wled_default}
@ -540,7 +323,16 @@ build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D WLED_DISABLE_OTA
 lib_deps = ${esp8266.lib_deps}
-[env:esp8285_H801]
+[env:esp8285_4CH_H801]
 board = esp8285
 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} -D WLED_DISABLE_OTA
 lib_deps = ${esp8266.lib_deps}
 [env:esp8285_5CH_H801]
 board = esp8285
 platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
@ -593,60 +385,13 @@ build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D LEDPIN=12 -D IRPIN=-1 -D RLYPIN=2
 lib_deps = ${esp8266.lib_deps}
 [env:lolin_s2_mini]
 platform = ${esp32s2.platform}
 platform_packages = ${esp32s2.platform_packages}
 board = lolin_s2_mini
 board_build.partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
 build_unflags = ${common.build_unflags} #-DARDUINO_USB_CDC_ON_BOOT=1
 build_flags = ${common.build_flags} ${esp32s2.build_flags} -D WLED_RELEASE_NAME=ESP32-S2
  -DBOARD_HAS_PSRAM
  -DARDUINO_USB_CDC_ON_BOOT=1 # try disabling and enabling unflag above in case of board-specific issues, will disable Serial
  -DARDUINO_USB_MSC_ON_BOOT=0
  -DARDUINO_USB_DFU_ON_BOOT=0
  -DLOLIN_WIFI_FIX ; seems to work much better with this
  -D WLED_USE_PSRAM
  ; -D WLED_USE_UNREAL_MATH ;; may cause wrong sunset/sunrise times, but saves 6792 bytes FLASH
  -D WLED_WATCHDOG_TIMEOUT=0
  -D CONFIG_ASYNC_TCP_USE_WDT=0
  -D LEDPIN=16
  -D BTNPIN=18
  -D RLYPIN=9
  -D IRPIN=7
  -D HW_PIN_SCL=35
  -D HW_PIN_SDA=33
  -D HW_PIN_CLOCKSPI=7
  -D HW_PIN_DATASPI=11
  -D HW_PIN_MISOSPI=9
 ;  -D STATUSLED=15
 lib_deps = ${esp32s2.lib_deps}
 # ------------------------------------------------------------------------------
 # custom board configurations
 # ------------------------------------------------------------------------------
 [env:esp32c3dev_2MB]
 ;; for ESP32-C3 boards with 2MB flash (instead of 4MB).
 ;; this board need a specific partition file. OTA not possible.
 extends = esp32c3
 platform = ${esp32c3.platform}
 platform_packages = ${esp32c3.platform_packages}
 board = esp32-c3-devkitm-1
 build_flags = ${common.build_flags} ${esp32c3.build_flags} #-D WLED_RELEASE_NAME=ESP32-C3
  -D WLED_WATCHDOG_TIMEOUT=0
  -D WLED_DISABLE_OTA
  ; -DARDUINO_USB_CDC_ON_BOOT=1 ;; for virtual CDC USB
  -DARDUINO_USB_CDC_ON_BOOT=0   ;; for serial-to-USB chip
 build_unflags = ${common.build_unflags}
 upload_speed = 115200
 lib_deps = ${esp32c3.lib_deps}
 board_build.partitions = tools/WLED_ESP32_2MB_noOTA.csv
 board_build.flash_mode = dio
 [env:wemos_shield_esp32]
 board = esp32dev
-platform = ${esp32.platform}
+platform = espressif32@3.2
 platform_packages = ${esp32.platform_packages}
 upload_speed = 460800
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32}
@ -658,22 +403,16 @@ build_flags = ${common.build_flags_esp32}
  -D USERMOD_DALLASTEMPERATURE
  -D USERMOD_FOUR_LINE_DISPLAY
  -D TEMPERATURE_PIN=23
  -D USE_ALT_DISPlAY ; new versions of USERMOD_FOUR_LINE_DISPLAY and USERMOD_ROTARY_ENCODER_UI
  -D USERMOD_AUDIOREACTIVE
 lib_deps = ${esp32.lib_deps}
  OneWire@~2.3.5
  olikraus/U8g2 @ ^2.28.8
  https://github.com/blazoncek/arduinoFFT.git
 board_build.partitions = ${esp32.default_partitions}
 [env:m5atom]
 board = esp32dev
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32} -D LEDPIN=27 -D BTNPIN=39
 lib_deps = ${esp32.lib_deps}
-platform = ${esp32.platform}
+platform = espressif32@3.2
 platform_packages = ${esp32.platform_packages}
 board_build.partitions = ${esp32.default_partitions}
 [env:sp501e]
 board = esp_wroom_02
@ -689,73 +428,28 @@ board_build.ldscript = ${common.ldscript_2m512k}
 build_flags = ${common.build_flags_esp8266} -D LEDPIN=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
+# ------------------------------------------------------------------------------
-board = esp8285
+# travis test board configurations
-platform = ${common.platform_wled_default}
+# ------------------------------------------------------------------------------
-platform_packages = ${common.platform_packages}
+
-board_build.ldscript = ${common.ldscript_2m512k}
+[env:travis_esp8266]
 extends = env:d1_mini
 build_type = debug
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp8266} -D WLED_RELEASE_NAME=ESP8266 -D BTNPIN=-1 -D RLYPIN=-1 -D DATA_PINS=4,12,14,13,5
+build_flags = ${common.build_flags_esp8266} ${common.debug_flags} ${common.build_flags_all_features}
                                            -D DEFAULT_LED_TYPE=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0
 lib_deps = ${esp8266.lib_deps}
-
+[env:travis_esp32]
-[env:Athom_15w_RGBCW]        ;15w bulb
+extends = env:esp32dev
-board = esp8285
+; build_type = debug
 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} -D WLED_RELEASE_NAME=ESP8266 -D BTNPIN=-1 -D RLYPIN=-1 -D DATA_PINS=4,12,14,5,13
+build_flags = ${common.build_flags_esp32} ${common.debug_flags} ${common.build_flags_all_features}
                                            -D DEFAULT_LED_TYPE=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0 -D WLED_USE_IC_CCT
 lib_deps = ${esp8266.lib_deps}
 [env:Athom_3Pin_Controller]        ;small controller with only data
 board = esp8285
 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} -D WLED_RELEASE_NAME=ESP8266 -D BTNPIN=0 -D RLYPIN=-1 -D LEDPIN=1 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 [env:Athom_4Pin_Controller]       ; With clock and data interface
 board = esp8285
 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} -D WLED_RELEASE_NAME=ESP8266 -D BTNPIN=0 -D RLYPIN=12 -D LEDPIN=1 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 [env:Athom_5Pin_Controller]      ;Analog light strip controller
 board = esp8285
 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} -D WLED_RELEASE_NAME=ESP8266 -D BTNPIN=0 -D RLYPIN=-1 DATA_PINS=4,12,14,13 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 [env:MY9291]
 board = esp01_1m
 platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_1m128k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D WLED_RELEASE_NAME=ESP01 -D WLED_DISABLE_OTA -D USERMOD_MY9291
 lib_deps = ${esp8266.lib_deps}
 # ------------------------------------------------------------------------------
 # codm pixel controller board configurations
-# codm-controller-0_6 can also be used for the TYWE3S controller
+# codm-controller-0.6 can also be used for the TYWE3S controller
 # ------------------------------------------------------------------------------
-[env:codm-controller-0_6]
+[env:codm-controller-0.6]
 board = esp_wroom_02
 platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
@ -764,7 +458,7 @@ build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
 lib_deps = ${esp8266.lib_deps}
-[env:codm-controller-0_6-rev2]
+[env:codm-controller-0.6-rev2]
 board = esp_wroom_02
 platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
@ -778,8 +472,7 @@ lib_deps = ${esp8266.lib_deps}
 # ------------------------------------------------------------------------------
 [env:elekstube_ips]
 board = esp32dev
-platform = ${esp32.platform}
+platform = espressif32@3.2
 platform_packages = ${esp32.platform_packages}
 upload_speed = 921600
 build_flags = ${common.build_flags_esp32} -D WLED_DISABLE_BROWNOUT_DET -D WLED_DISABLE_INFRARED
  -D USERMOD_RTC
@ -787,6 +480,7 @@ build_flags = ${common.build_flags_esp32} -D WLED_DISABLE_BROWNOUT_DET -D WLED_D
  -D LEDPIN=12
  -D RLYPIN=27
  -D BTNPIN=34
  -D WLED_DISABLE_INFRARED
  -D DEFAULT_LED_COUNT=6
  # Display config
  -D ST7789_DRIVER
@ -804,4 +498,3 @@ monitor_filters = esp32_exception_decoder
 lib_deps =
  ${esp32.lib_deps}
  TFT_eSPI @ ^2.3.70
 board_build.partitions = ${esp32.default_partitions}
--- a/platformio_override.ini.sample
+++ b/platformio_override.ini.sample
@ -19,13 +19,10 @@ build_flags = ${common.build_flags_esp8266}
 ; *** Use custom settings from file my_config.h
   -DWLED_USE_MY_CONFIG
 ; *********************************************************************
 ;
 ;
 ; *** To use the below defines/overrides, copy and paste each onto it's own line just below build_flags in the section above.
 ; 
 ; disable specific features
 ;  -D WLED_DISABLE_OTA
 ;  -D WLED_DISABLE_ALEXA
 ;  -D WLED_DISABLE_BLYNK
 ;  -D WLED_DISABLE_CRONIXIE
 ;  -D WLED_DISABLE_HUESYNC
 ;  -D WLED_DISABLE_INFRARED
 ;  -D WLED_DISABLE_WEBSOCKETS
@ -48,18 +45,3 @@ build_flags = ${common.build_flags_esp8266}
 ;   for the Magic Home LED Controller use PWM pins 5,12,13,15
 ;   for the H801 controller use PINs 15,13,12,14 (W2 = 04)
 ;   for the BW-LT11 controller use PINs 12,4,14,5
 ;   
 ; 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
 ;   
 ; set milliampere limit when using ESP pin to power leds
 ;   -D ABL_MILLIAMPS_DEFAULT=850
 ;
 ; 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
--- a/readme.md
+++ b/readme.md
@ -3,7 +3,7 @@
  <a href="https://github.com/Aircoookie/WLED/releases"><img src="https://img.shields.io/github/release/Aircoookie/WLED.svg?style=flat-square"></a>
  <a href="https://raw.githubusercontent.com/Aircoookie/WLED/master/LICENSE"><img src="https://img.shields.io/github/license/Aircoookie/wled?color=blue&style=flat-square"></a>
  <a href="https://wled.discourse.group"><img src="https://img.shields.io/discourse/topics?colorB=blue&label=forum&server=https%3A%2F%2Fwled.discourse.group%2F&style=flat-square"></a>
-  <a href="https://discord.gg/QAh7wJHrRM"><img src="https://img.shields.io/discord/473448917040758787.svg?colorB=blue&label=discord&style=flat-square"></a>
+  <a href="https://discord.gg/KuqP7NE"><img src="https://img.shields.io/discord/473448917040758787.svg?colorB=blue&label=discord&style=flat-square"></a>
  <a href="https://kno.wled.ge"><img src="https://img.shields.io/badge/quick_start-wiki-blue.svg?style=flat-square"></a>
  <a href="https://github.com/Aircoookie/WLED-App"><img src="https://img.shields.io/badge/app-wled-blue.svg?style=flat-square"></a>
  <a href="https://gitpod.io/#https://github.com/Aircoookie/WLED"><img src="https://img.shields.io/badge/Gitpod-ready--to--code-blue?style=flat-square&logo=gitpod"></a>
@ -15,11 +15,11 @@
 A fast and feature-rich implementation of an ESP8266/ESP32 webserver to control NeoPixel (WS2812B, WS2811, SK6812) LEDs or also SPI based chipsets like the WS2801 and APA102!
 ## ⚙️ Features
- WS2812FX library with more than 100 special effects  
+- WS2812FX library integrated for over 100 special effects  
 - FastLED noise effects and 50 palettes  
 - Modern UI with color, effect and segment controls  
- Segments to set different effects and colors to user defined parts of the LED string  
+- Segments to set different effects and colors to parts of the LEDs  
- Settings page - configuration via the network  
+- Settings page - configuration over network  
 - Access Point and station mode - automatic failsafe AP  
 - Up to 10 LED outputs per instance
 - Support for RGBW strips  
@ -27,14 +27,15 @@ A fast and feature-rich implementation of an ESP8266/ESP32 webserver to control
 - Presets can be used to automatically execute API calls  
 - Nightlight function (gradually dims down)  
 - Full OTA software updatability (HTTP + ArduinoOTA), password protectable  
- Configurable analog clock (Cronixie, 7-segment and EleksTube IPS clock support via usermods) 
+- Configurable analog clock + support for the Cronixie kit by Diamex  
- Configurable Auto Brightness limit for safe operation  
+- Configurable Auto Brightness limit for safer operation  
 - Filesystem-based config for easier backup of presets and settings  
 ## 💡 Supported light control interfaces
 - WLED app for [Android](https://play.google.com/store/apps/details?id=com.aircoookie.WLED) and [iOS](https://apps.apple.com/us/app/wled/id1475695033)
 - JSON and HTTP request APIs  
 - MQTT  
 - Blynk IoT  
 - E1.31, Art-Net, DDP and TPM2.net
 - [diyHue](https://github.com/diyhue/diyHue) (Wled is supported by diyHue, including Hue Sync Entertainment under udp. Thanks to [Gregory Mallios](https://github.com/gmallios))
 - [Hyperion](https://github.com/hyperion-project/hyperion.ng)
@ -50,35 +51,52 @@ A fast and feature-rich implementation of an ESP8266/ESP32 webserver to control
 See the [documentation on our official site](https://kno.wled.ge)!
-[On this page](https://kno.wled.ge/basics/tutorials/) you can find excellent tutorials and tools to help you get your new project up and running!
+[On this page](https://github.com/Aircoookie/WLED/wiki/Learning-the-ropes) you can find excellent tutorials made by the community and helpful tools to help you get your new lamp up and running!
-## 🖼️ User interface
+## 🖼️ Images
-<img src="images/macbook-pro-space-gray-on-the-wooden-table.jpg" width="50%"><img src="images/walking-with-iphone-x.jpg" width="50%">
+<img src="/images/macbook-pro-space-gray-on-the-wooden-table.jpg" width="50%"><img src="/images/walking-with-iphone-x.jpg" width="50%">
-## 💾 Compatible hardware
+## 💾 Compatible LED Strips
 Type | Voltage | Comments
 |---|---|---|
 WS2812B | 5v |
 WS2813 | 5v | 
 SK6812 | 5v | RGBW
 APA102 | 5v | C/D
 WS2801 | 5v | C/D
 LPD8806 | 5v | C/D
 TM1814 | 12v | RGBW
 WS2811 | 12v | 3-LED segments
 WS2815 | 12v | 
 GS8208 | 12v |
 Analog/non-addressable | any | Requires additional circuitry
 ## 🧊 Compatible PC RGB Fans and ARGB accessories
 Brand | Model | Comments
 |---|---|---|
 Corsair | HD120 Fan | Uses WS2812B, data-in only
 PCCOOLER | Moonlight 5-pack Fans | Uses WS2812B, includes Data-out connector to keep each fan uniquely addressable if wired in series like traditional LED strips
 Any | 5v 3-pin ARGB for PC | Any PC RGB device that supports the 5v 3-pin ARGB motherboard header should work fine with WLED. All the major motherboard vendors support the Corsair HD120 and PCCOOLER fans listed, so we can safely assume any device that supports motherboard ARGB 5V 3-Pin standard will work with WLED.
 See [here](https://kno.wled.ge/basics/compatible-hardware)!
 ## ✌️ Other
 Licensed under the MIT license  
-Credits [here](https://kno.wled.ge/about/contributors/)!
+Credits [here](https://github.com/Aircoookie/WLED/wiki/Contributors-&-About)!
 Uses Linearicons by Perxis!
 Join the Discord server to discuss everything about WLED!
-<a href="https://discord.gg/QAh7wJHrRM"><img src="https://discordapp.com/api/guilds/473448917040758787/widget.png?style=banner2" width="25%"></a>
+<a href="https://discord.gg/KuqP7NE"><img src="https://discordapp.com/api/guilds/473448917040758787/widget.png?style=banner2" width="25%"></a>
 Check out the WLED [Discourse forum](https://wled.discourse.group)!  
-
+You can also send me mails to [dev.aircoookie@gmail.com](mailto:dev.aircoookie@gmail.com), but please only do so if you want to talk to me privately.  
-You can also send me mails to [dev.aircoookie@gmail.com](mailto:dev.aircoookie@gmail.com), but please, only do so if you want to talk to me privately.  
+If WLED really brightens up your every day, you can [![](https://img.shields.io/badge/send%20me%20a%20small%20gift-paypal-blue.svg?style=flat-square)](https://paypal.me/aircoookie)
 If WLED really brightens up your day, you can [![](https://img.shields.io/badge/send%20me%20a%20small%20gift-paypal-blue.svg?style=flat-square)](https://paypal.me/aircoookie)
 *Disclaimer:*   
-
+If you are sensitive to photosensitive epilepsy it is not recommended that you use this software.  
-If you are prone to photosensitive epilepsy, we recommended you do **not** use this software.  
+In case you still want to try, don't use strobe, lighting or noise modes or high effect speed settings.
 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.  
--- a/requirements.txt
+++ b/requirements.txt
@ -1,58 +1,54 @@
 #
-# This file is autogenerated by pip-compile with python 3.8
+# This file is autogenerated by pip-compile
 # To update, run:
 #
 #    pip-compile
 #
-aiofiles==22.1.0
+aiofiles==0.6.0
    # via platformio
-ajsonrpc==1.2.0
+ajsonrpc==1.1.0
    # via platformio
-anyio==3.6.2
+bottle==0.12.19
    # via starlette
 bottle==0.12.25
    # via platformio
-certifi==2023.7.22
+certifi==2020.12.5
    # via requests
-charset-normalizer==3.1.0
+chardet==4.0.0
    # via requests
-click==8.1.3
+click==7.1.2
    # via
    #   platformio
    #   uvicorn
-colorama==0.4.6
+colorama==0.4.4
    # via platformio
-h11==0.14.0
+h11==0.12.0
    # via
    #   uvicorn
    #   wsproto
-idna==3.4
+idna==2.10
-    # via
+    # via requests
-    #   anyio
+ifaddr==0.1.7
-    #   requests
+    # via zeroconf
-marshmallow==3.19.0
+marshmallow==3.11.1
    # via platformio
-packaging==23.1
+platformio==5.1.1
    # via marshmallow
 platformio==6.1.6
    # via -r requirements.in
-pyelftools==0.29
+pyelftools==0.27
    # via platformio
 pyserial==3.5
    # via platformio
-requests==2.31.0
+requests==2.25.1
    # via platformio
-semantic-version==2.10.0
+semantic-version==2.8.5
    # via platformio
-sniffio==1.3.0
+starlette==0.14.2
    # via anyio
 starlette==0.23.1
    # via platformio
-tabulate==0.9.0
+tabulate==0.8.9
    # via platformio
-urllib3==1.26.15
+urllib3==1.26.5
    # via requests
-uvicorn==0.20.0
+uvicorn==0.13.4
    # via platformio
-wsproto==1.2.0
+wsproto==1.0.0
    # via platformio
 zeroconf==0.28.8
    # via platformio
--- a/tools/WLED_ESP32-wrover_4MB.csv
+++ b/tools/WLED_ESP32-wrover_4MB.csv
@ -1,6 +0,0 @@
 # Name,   Type, SubType, Offset,  Size, Flags
 nvs,      data, nvs,     0x9000,  0x5000,
 otadata,  data, ota,     0xe000,  0x2000,
 app0,     app,  ota_0,   0x10000, 0x180000,
 app1,     app,  ota_1,   0x190000,0x180000,
 spiffs,   data, spiffs,  0x310000,0xF0000,
--- a/tools/WLED_ESP32_16MB_9MB_FS.csv
+++ b/tools/WLED_ESP32_16MB_9MB_FS.csv
@ -1,8 +0,0 @@
 # Name,   Type, SubType, Offset,  Size, Flags
 nvs,      data, nvs,     0x9000,  0x5000,
 otadata,  data, ota,     0xe000,  0x2000,
 app0,     app,  ota_0,   0x10000, 0x300000,
 app1,     app,  ota_1,   0x310000,0x300000,
 spiffs,   data, spiffs,  0x610000,0x9E0000,
 coredump, data, coredump,,64K
 # to create/use ffat, see https://github.com/marcmerlin/esp32_fatfsimage
--- a/tools/WLED_ESP32_2MB_noOTA.csv
+++ b/tools/WLED_ESP32_2MB_noOTA.csv
@ -1,5 +0,0 @@
 # Name,   Type, SubType, Offset,  Size, Flags
 nvs,      data, nvs,     0x9000,    20K,
 otadata,  data, ota,     0xe000,    8K,
 app0,     app,  ota_0,   0x10000,   1536K,
 spiffs,   data, spiffs,  0x190000,  384K,
--- a/tools/WLED_ESP32_8MB.csv
+++ b/tools/WLED_ESP32_8MB.csv
@ -3,5 +3,4 @@ nvs,      data, nvs,     0x9000,  0x5000,
 otadata,  data, ota,     0xe000,  0x2000,
 app0,     app,  ota_0,   0x10000, 0x200000,
 app1,     app,  ota_1,   0x210000,0x200000,
-spiffs,   data, spiffs,  0x410000,0x3E0000,
+spiffs,   data, spiffs,  0x410000,0x3F0000,
 coredump, data, coredump,,64K
--- a/tools/cdata.js
+++ b/tools/cdata.js
@ -16,32 +16,21 @@
 */
 const fs = require("fs");
 const inliner = require("inliner");
 const zlib = require("zlib");
 const CleanCSS = require("clean-css");
 const MinifyHTML = require("html-minifier-terser").minify;
 const packageJson = require("../package.json");
 /**
 *
 */
-function hexdump(buffer,isHex=false) {
+function hexdump(buffer) {
  let lines = [];
-  for (let i = 0; i < buffer.length; i +=(isHex?32:16)) {
+  for (let i = 0; i < buffer.length; i += 16) {
-    var block;
+    let block = buffer.slice(i, i + 16); // cut buffer into blocks of 16
    let hexArray = [];
-    if (isHex) {
+
      block = buffer.slice(i, i + 32)
      for (let j = 0; j < block.length; j +=2 ) {
        hexArray.push("0x" + block.slice(j,j+2))
      }
    } else {
      block = buffer.slice(i, i + 16); // cut buffer into blocks of 16
    for (let value of block) {
      hexArray.push("0x" + value.toString(16).padStart(2, "0"));
    }
    }
    let hexString = hexArray.join(", ");
    let line = `  ${hexString}`;
@ -51,6 +40,9 @@ function hexdump(buffer,isHex=false) {
  return lines.join(",\n");
 }
 const inliner = require("inliner");
 const zlib = require("zlib");
 function strReplace(str, search, replacement) {
  return str.split(search).join(replacement);
 }
@ -64,52 +56,16 @@ function adoptVersionAndRepo(html) {
    html = strReplace(html, "https://github.com/atuline/WLED", repoUrl);
    html = strReplace(html, "https://github.com/Aircoookie/WLED", repoUrl);
  }
  let version = packageJson.version;
  if (version) {
    html = strReplace(html, "##VERSION##", version);
  }
  return html;
 }
-function filter(str, type) {
+function writeHtmlGzipped(sourceFile, resultFile) {
  str = adoptVersionAndRepo(str);
  if (type === undefined) {
    return str;
  } else if (type == "css-minify") {
    return new CleanCSS({}).minify(str).styles;
  } else if (type == "js-minify") {
    return MinifyHTML('<script>' + str + '</script>', {
      collapseWhitespace: true,
      minifyJS: true, 
      continueOnParseError: false,
      removeComments: true,
    }).replace(/<[\/]*script>/g,'');
  } else if (type == "html-minify") {
    return MinifyHTML(str, {
      collapseWhitespace: true,
      maxLineLength: 80,
      minifyCSS: true,
      minifyJS: true, 
      continueOnParseError: false,
      removeComments: true,
    });
  } else if (type == "html-minify-ui") {
    return MinifyHTML(str, {
      collapseWhitespace: true,
      conservativeCollapse: true,
      maxLineLength: 80,
      minifyCSS: true,
      minifyJS: true, 
      continueOnParseError: false,
      removeComments: true,
    });
  } else {
    console.warn("Unknown filter: " + type);
    return str;
  }
 }
 function writeHtmlGzipped(sourceFile, resultFile, page) {
  console.info("Reading " + sourceFile);
  new inliner(sourceFile, function (error, html) {
    console.info("Inlined " + html.length + " characters");
@ -139,8 +95,8 @@ function writeHtmlGzipped(sourceFile, resultFile, page) {
 */
 // Autogenerated from ${sourceFile}, do not edit!!
-const uint16_t PAGE_${page}_L = ${result.length};
+const uint16_t PAGE_index_L = ${result.length};
-const uint8_t PAGE_${page}[] PROGMEM = {
+const uint8_t PAGE_index[] PROGMEM = {
 ${array}
 };
 `;
@ -150,6 +106,41 @@ ${array}
  });
 }
 const CleanCSS = require("clean-css");
 const MinifyHTML = require("html-minifier-terser").minify;
 function filter(str, type) {
  str = adoptVersionAndRepo(str);
  if (type === undefined) {
    return str;
  } else if (type == "css-minify") {
    return new CleanCSS({}).minify(str).styles;
  } else if (type == "html-minify") {
    return MinifyHTML(str, {
      collapseWhitespace: true,
      maxLineLength: 80,
      minifyCSS: true,
      minifyJS: true, 
      continueOnParseError: false,
      removeComments: true,
    });
  } else if (type == "html-minify-ui") {
    return MinifyHTML(str, {
      collapseWhitespace: true,
      conservativeCollapse: true,
      maxLineLength: 80,
      minifyCSS: true,
      minifyJS: true, 
      continueOnParseError: false,
      removeComments: true,
    });
  } else {
    console.warn("Unknown filter: " + type);
    return str;
  }
 }
 function specToChunk(srcDir, s) {
  if (s.method == "plaintext") {
    const buf = fs.readFileSync(srcDir + "/" + s.file);
@ -162,21 +153,6 @@ const char ${s.name}[] PROGMEM = R"${s.prepend || ""}${filter(str, s.filter)}${
 `;
    return s.mangle ? s.mangle(chunk) : chunk;
  } else if (s.method == "gzip") {
    const buf = fs.readFileSync(srcDir + "/" + s.file);
    var str = buf.toString('utf-8');
    if (s.mangle) str = s.mangle(str);
    const zip = zlib.gzipSync(filter(str, s.filter), { level: zlib.constants.Z_BEST_COMPRESSION });
    const result = hexdump(zip.toString('hex'), true);
    const chunk = `
 // Autogenerated from ${srcDir}/${s.file}, do not edit!!
 const uint16_t ${s.name}_length = ${zip.length};
 const uint8_t ${s.name}[] PROGMEM = {
 ${result}
 };
 `;
    return chunk;
  } else if (s.method == "binary") {
    const buf = fs.readFileSync(srcDir + "/" + s.file);
    const result = hexdump(buf);
@ -188,7 +164,7 @@ ${result}
 };
 `;
-    return chunk;
+    return s.mangle ? s.mangle(chunk) : chunk;
  } else {
    console.warn("Unknown method: " + s.method);
    return undefined;
@ -218,114 +194,160 @@ function writeChunks(srcDir, specs, resultFile) {
  fs.writeFileSync(resultFile, src);
 }
-writeHtmlGzipped("wled00/data/index.htm", "wled00/html_ui.h", 'index');
+writeHtmlGzipped("wled00/data/index.htm", "wled00/html_ui.h");
-writeHtmlGzipped("wled00/data/simple.htm", "wled00/html_simple.h", 'simple');
+
 writeHtmlGzipped("wled00/data/pixart/pixart.htm", "wled00/html_pixart.h", 'pixart');
 writeHtmlGzipped("wled00/data/cpal/cpal.htm", "wled00/html_cpal.h", 'cpal');
 writeHtmlGzipped("wled00/data/pxmagic/pxmagic.htm", "wled00/html_pxmagic.h", 'pxmagic');
 /*
 writeChunks(
  "wled00/data",
  [
    {
      file: "simple.css",
      name: "PAGE_simpleCss",
      method: "gzip",
      filter: "css-minify",
    },
    {
      file: "simple.js",
      name: "PAGE_simpleJs",
      method: "gzip",
      filter: "js-minify",
    },
    {
      file: "simple.htm",
      name: "PAGE_simple",
      method: "gzip",
      filter: "html-minify-ui",
    }
  ],
  "wled00/html_simplex.h"
 );
 */
 writeChunks(
  "wled00/data",
  [
    {
      file: "style.css",
      name: "PAGE_settingsCss",
-      method: "gzip",
+      prepend: "=====(<style>",
      append: "</style>)=====",
      method: "plaintext",
      filter: "css-minify",
      mangle: (str) =>
        str
          .replace("%%","%")
    },
    {
      file: "settings.htm",
      name: "PAGE_settings",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace("%", "%%")
          .replace(/User Interface\<\/button\>\<\/form\>/gms, "User Interface\<\/button\>\<\/form\>%DMXMENU%"),
    },
    {
      file: "settings_wifi.htm",
      name: "PAGE_settings_wifi",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace(/\<link rel="stylesheet".*\>/gms, "")
          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
          .replace(
            /function GetV().*\<\/script\>/gms,
            "function GetV() {var d=document;\n"
          ),
    },
    {
      file: "settings_leds.htm",
      name: "PAGE_settings_leds",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace(/\<link rel="stylesheet".*\>/gms, "")
          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
          .replace(
            /function GetV().*\<\/script\>/gms,
            "function GetV() {var d=document;\n"
          ),
    },
    {
      file: "settings_dmx.htm",
      name: "PAGE_settings_dmx",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) => {
        const nocss = str
          .replace(/\<link rel="stylesheet".*\>/gms, "")
          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
          .replace(
            /function GetV().*\<\/script\>/gms,
            "function GetV() {var d=document;\n"
          );
        return `
 #ifdef WLED_ENABLE_DMX
 ${nocss}
 #else
 const char PAGE_settings_dmx[] PROGMEM = R"=====()=====";
 #endif
 `;
      },
    },
    {
      file: "settings_ui.htm",
      name: "PAGE_settings_ui",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace(/\<link rel="stylesheet".*\>/gms, "")
          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
          .replace(
            /function GetV().*\<\/script\>/gms,
            "function GetV() {var d=document;\n"
          ),
    },
    {
      file: "settings_sync.htm",
      name: "PAGE_settings_sync",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace(/\<link rel="stylesheet".*\>/gms, "")
          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
          .replace(/function GetV().*\<\/script\>/gms, "function GetV() {\n"),
    },
    {
      file: "settings_time.htm",
      name: "PAGE_settings_time",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace(/\<link rel="stylesheet".*\>/gms, "")
          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
          .replace(/function GetV().*\<\/script\>/gms, "function GetV() {\n"),
    },
    {
      file: "settings_sec.htm",
      name: "PAGE_settings_sec",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace(/\<link rel="stylesheet".*\>/gms, "")
          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
          .replace(
            /function GetV().*\<\/script\>/gms,
            "function GetV() {var d=document;\n"
          ),
    },
    {
      file: "settings_um.htm",
      name: "PAGE_settings_um",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
-    },
+      mangle: (str) =>
-    {
+        str
-      file: "settings_2D.htm",
+          .replace(/\<link rel="stylesheet".*\>/gms, "")
-      name: "PAGE_settings_2D",
+          .replace(/\<style\>.*\<\/style\>/gms, "%CSS%%SCSS%")
-      method: "gzip",
+          .replace(
-      filter: "html-minify",
+            /function GetV().*\<\/script\>/gms,
-    },
+            "function GetV() {var d=document;\n"
-    {
+          ),
      file: "settings_pin.htm",
      name: "PAGE_settings_pin",
      method: "gzip",
      filter: "html-minify"
    }
  ],
  "wled00/html_settings.h"
@ -337,7 +359,9 @@ writeChunks(
    {
      file: "usermod.htm",
      name: "PAGE_usermod",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str.replace(/fetch\("http\:\/\/.*\/win/gms, 'fetch("/win'),
@ -369,37 +393,41 @@ const char PAGE_dmxmap[] PROGMEM = R"=====()=====";
    {
      file: "update.htm",
      name: "PAGE_update",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
      mangle: (str) =>
        str
          .replace(
            /function GetV().*\<\/script\>/gms,
            "</script><script src=\"/settings/s.js?p=9\"></script>"
          )
    },
    {
      file: "welcome.htm",
      name: "PAGE_welcome",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
    },
    {
      file: "liveview.htm",
      name: "PAGE_liveview",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
    },
    {
-      file: "liveviewws2D.htm",
+      file: "liveviewws.htm",
-      name: "PAGE_liveviewws2D",
+      name: "PAGE_liveviewws",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
    },
    {
      file: "404.htm",
      name: "PAGE_404",
-      method: "gzip",
+      prepend: "=====(",
      append: ")=====",
      method: "plaintext",
      filter: "html-minify",
    },
    {
@ -407,16 +435,6 @@ const char PAGE_dmxmap[] PROGMEM = R"=====()=====";
      name: "favicon",
      method: "binary",
    },
    {
      file: "iro.js",
      name: "iroJs",
      method: "gzip"
    },
    {
      file: "rangetouch.js",
      name: "rangetouchJs",
      method: "gzip"
    }
  ],
  "wled00/html_other.h"
 );
--- a/usermods/ADS1115_v2/ChannelSettings.h
+++ b/usermods/ADS1115_v2/ChannelSettings.h
@ -1,15 +0,0 @@
 #include "wled.h"
 namespace ADS1115
 {
  struct ChannelSettings {
    const String settingName;
    bool isEnabled;
    String name;
    String units;
    const uint16_t mux;
    float multiplier;
    float offset;
    uint8_t decimals;
  };
 }
--- a/usermods/ADS1115_v2/readme.md
+++ b/usermods/ADS1115_v2/readme.md
@ -1,10 +0,0 @@
 # ADS1115 16-Bit ADC with four inputs
 This usermod will read from an ADS1115 ADC. The voltages are displayed in the Info section of the web UI.
 Configuration is performed via the Usermod menu. There are no parameters to set in code!
 ## Installation 
 Add the build flag `-D USERMOD_ADS1115` to your platformio environment.
 Uncomment libraries with comment `#For ADS1115 sensor uncomment following`
--- a/usermods/ADS1115_v2/usermod_ads1115.h
+++ b/usermods/ADS1115_v2/usermod_ads1115.h
@ -1,255 +0,0 @@
 #pragma once
 #include "wled.h"
 #include <Adafruit_ADS1X15.h>
 #include <math.h>
 #include "ChannelSettings.h"
 using namespace ADS1115;
 class ADS1115Usermod : public Usermod {
  public:
    void setup() {
      ads.setGain(GAIN_ONE);        // 1x gain   +/- 4.096V
      if (!ads.begin()) {
        Serial.println("Failed to initialize ADS");
        return;
      }
      if (!initChannel()) {
        isInitialized = true;
        return;
      }
      startReading();
      isEnabled = true;
      isInitialized = true;
    }
    void loop() {
      if (isEnabled && millis() - lastTime > loopInterval) {
        lastTime = millis();
        // If we don't have new data, skip this iteration.
        if (!ads.conversionComplete()) {
          return;
        }
        updateResult();
        moveToNextChannel();
        startReading();
      }
    }
    void addToJsonInfo(JsonObject& root)
    {
      if (!isEnabled) {
        return;
      }
      JsonObject user = root[F("u")];
      if (user.isNull()) user = root.createNestedObject(F("u"));
      for (uint8_t i = 0; i < channelsCount; i++) {
        ChannelSettings* settingsPtr = &(channelSettings[i]);
        if (!settingsPtr->isEnabled) {
          continue;
        }
        JsonArray lightArr = user.createNestedArray(settingsPtr->name); //name
        float value = round((readings[i] + settingsPtr->offset) * settingsPtr->multiplier, settingsPtr->decimals);
        lightArr.add(value); //value
        lightArr.add(" " + settingsPtr->units); //unit
      }
    }
    void addToConfig(JsonObject& root)
    {
      JsonObject top = root.createNestedObject(F("ADC ADS1115"));
      for (uint8_t i = 0; i < channelsCount; i++) {
        ChannelSettings* settingsPtr = &(channelSettings[i]);
        JsonObject channel = top.createNestedObject(settingsPtr->settingName);
        channel[F("Enabled")] = settingsPtr->isEnabled;
        channel[F("Name")] = settingsPtr->name;
        channel[F("Units")] = settingsPtr->units;
        channel[F("Multiplier")] = settingsPtr->multiplier;
        channel[F("Offset")] = settingsPtr->offset;
        channel[F("Decimals")] = settingsPtr->decimals;
      }
      top[F("Loop Interval")] = loopInterval;
    }
    bool readFromConfig(JsonObject& root)
    {
      JsonObject top = root[F("ADC ADS1115")];
      bool configComplete = !top.isNull();
      bool hasEnabledChannels = false;
      for (uint8_t i = 0; i < channelsCount && configComplete; i++) {
        ChannelSettings* settingsPtr = &(channelSettings[i]);
        JsonObject channel = top[settingsPtr->settingName];
        configComplete &= !channel.isNull();
        configComplete &= getJsonValue(channel[F("Enabled")], settingsPtr->isEnabled);
        configComplete &= getJsonValue(channel[F("Name")], settingsPtr->name);
        configComplete &= getJsonValue(channel[F("Units")], settingsPtr->units);
        configComplete &= getJsonValue(channel[F("Multiplier")], settingsPtr->multiplier);
        configComplete &= getJsonValue(channel[F("Offset")], settingsPtr->offset);
        configComplete &= getJsonValue(channel[F("Decimals")], settingsPtr->decimals);
        hasEnabledChannels |= settingsPtr->isEnabled;
      }
      configComplete &= getJsonValue(top[F("Loop Interval")], loopInterval);
      isEnabled = isInitialized && configComplete && hasEnabledChannels;
      return configComplete;
    }
    uint16_t getId()
    {
      return USERMOD_ID_ADS1115;
    }
  private:
    static const uint8_t channelsCount = 8;
    ChannelSettings channelSettings[channelsCount] = {
      {
        "Differential reading from AIN0 (P) and AIN1 (N)",
        false,
        "Differential AIN0 AIN1",
        "V",
        ADS1X15_REG_CONFIG_MUX_DIFF_0_1,
        1,
        0,
        3
      },
      {
        "Differential reading from AIN0 (P) and AIN3 (N)",
        false,
        "Differential AIN0 AIN3",
        "V",
        ADS1X15_REG_CONFIG_MUX_DIFF_0_3,
        1,
        0,
        3
      },
      {
        "Differential reading from AIN1 (P) and AIN3 (N)",
        false,
        "Differential AIN1 AIN3",
        "V",
        ADS1X15_REG_CONFIG_MUX_DIFF_1_3,
        1,
        0,
        3
      },
      {
        "Differential reading from AIN2 (P) and AIN3 (N)",
        false,
        "Differential AIN2 AIN3",
        "V",
        ADS1X15_REG_CONFIG_MUX_DIFF_2_3,
        1,
        0,
        3
      },
      {
        "Single-ended reading from AIN0",
        false,
        "Single-ended AIN0",
        "V",
        ADS1X15_REG_CONFIG_MUX_SINGLE_0,
        1,
        0,
        3
      },
      {
        "Single-ended reading from AIN1",
        false,
        "Single-ended AIN1",
        "V",
        ADS1X15_REG_CONFIG_MUX_SINGLE_1,
        1,
        0,
        3
      },
      {
        "Single-ended reading from AIN2",
        false,
        "Single-ended AIN2",
        "V",
        ADS1X15_REG_CONFIG_MUX_SINGLE_2,
        1,
        0,
        3
      },
      {
        "Single-ended reading from AIN3",
        false,
        "Single-ended AIN3",
        "V",
        ADS1X15_REG_CONFIG_MUX_SINGLE_3,
        1,
        0,
        3
      },
    };
    float readings[channelsCount] = {0, 0, 0, 0, 0, 0, 0, 0};
    unsigned long loopInterval = 1000;
    unsigned long lastTime = 0;
    Adafruit_ADS1115 ads;
    uint8_t activeChannel;
    bool isEnabled = false;
    bool isInitialized = false;
    static float round(float value, uint8_t decimals) {
      return roundf(value * powf(10, decimals)) / powf(10, decimals);
    }
    bool initChannel() {
      for (uint8_t i = 0; i < channelsCount; i++) {
        if (channelSettings[i].isEnabled) {
          activeChannel = i;
          return true;
        }
      }
      activeChannel = 0;
      return false;
    }
    void moveToNextChannel() {
      uint8_t oldActiveChannel = activeChannel;
      do
      {
        if (++activeChannel >= channelsCount){
          activeChannel = 0;
        }
      }
      while (!channelSettings[activeChannel].isEnabled && oldActiveChannel != activeChannel);
    }
    void startReading() {
      ads.startADCReading(channelSettings[activeChannel].mux, /*continuous=*/false);
    }
    void updateResult() {
        int16_t results = ads.getLastConversionResults();
        readings[activeChannel] = ads.computeVolts(results);
    }
 };
--- a/usermods/Analog_Clock/Analog_Clock.h
+++ b/usermods/Analog_Clock/Analog_Clock.h
@ -1,256 +0,0 @@
 #pragma once
 #include "wled.h"
 /*
 * Usermod for analog clock
 */
 extern Timezone* tz;
 class AnalogClockUsermod : public Usermod {
 private:
    static constexpr uint32_t refreshRate = 50; // per second
    static constexpr uint32_t refreshDelay = 1000 / refreshRate;
    struct Segment {
        // config
        int16_t firstLed  = 0;
        int16_t lastLed   = 59;
        int16_t centerLed = 0;
        // runtime
        int16_t size;
        Segment() {
            update();
        }
        void validateAndUpdate() {
            if (firstLed < 0 || firstLed >= strip.getLengthTotal() ||
                    lastLed < firstLed || lastLed >= strip.getLengthTotal()) {
                *this = {};
                return;
            }
            if (centerLed < firstLed || centerLed > lastLed) {
                centerLed = firstLed;
            }
            update();
        }
        void update() {
            size = lastLed - firstLed + 1;
        }
    };
    // configuration (available in API and stored in flash)
    bool     enabled          = false;
    Segment  mainSegment;
    bool     hourMarksEnabled = true;
    uint32_t hourMarkColor    = 0xFF0000;
    uint32_t hourColor        = 0x0000FF;
    uint32_t minuteColor      = 0x00FF00;
    bool     secondsEnabled   = true;
    Segment  secondsSegment;
    uint32_t secondColor      = 0xFF0000;
    bool     blendColors      = true;
    uint16_t secondsEffect    = 0;
    // runtime
    bool     initDone         = false;
    uint32_t lastOverlayDraw  = 0;
    void validateAndUpdate() {
        mainSegment.validateAndUpdate();
        secondsSegment.validateAndUpdate();
        if (secondsEffect < 0 || secondsEffect > 1) {
            secondsEffect = 0;
        }
    }
    int16_t adjustToSegment(double progress, Segment const& segment) {
        int16_t led = segment.centerLed + progress * segment.size;
        return led > segment.lastLed
                ? segment.firstLed + led - segment.lastLed - 1
                : led;
    }
    void setPixelColor(uint16_t n, uint32_t c) {
        if (!blendColors) {
            strip.setPixelColor(n, c);
        } else {
            uint32_t oldC = strip.getPixelColor(n);
            strip.setPixelColor(n, qadd32(oldC, c));
        }
    }
    String colorToHexString(uint32_t c) {
        char buffer[9];
        sprintf(buffer, "%06X", c);
        return buffer;
    }
    bool hexStringToColor(String const& s, uint32_t& c, uint32_t def) {
        char *ep;
        unsigned long long r = strtoull(s.c_str(), &ep, 16);
        if (*ep == 0) {
            c = r;
            return true;
        } else {
            c = def;
            return false;
        }
    }
    void secondsEffectSineFade(int16_t secondLed, Toki::Time const& time) {
        uint32_t ms = time.ms % 1000;
        uint8_t b0 = (cos8(ms * 64 / 1000) - 128) * 2;
        setPixelColor(secondLed, gamma32(scale32(secondColor, b0)));
        uint8_t b1 = (sin8(ms * 64 / 1000) - 128) * 2;
        setPixelColor(inc(secondLed, 1, secondsSegment), gamma32(scale32(secondColor, b1)));
    }
    static inline uint32_t qadd32(uint32_t c1, uint32_t c2) {
        return RGBW32(
            qadd8(R(c1), R(c2)),
            qadd8(G(c1), G(c2)),
            qadd8(B(c1), B(c2)),
            qadd8(W(c1), W(c2))
        );
    }
    static inline uint32_t scale32(uint32_t c, fract8 scale) {
        return RGBW32(
            scale8(R(c), scale),
            scale8(G(c), scale),
            scale8(B(c), scale),
            scale8(W(c), scale)
        );
    }
    static inline int16_t dec(int16_t n, int16_t i, Segment const& seg) {
        return n - seg.firstLed >= i
                ? n - i
                : seg.lastLed - seg.firstLed - i + n + 1;
    }
    static inline int16_t inc(int16_t n, int16_t i, Segment const& seg) {
        int16_t r = n + i;
        if (r > seg.lastLed) {
            return seg.firstLed + n - seg.lastLed;
        }
        return r;
    }
 public:
    AnalogClockUsermod() {
    }
    void setup() override {
        initDone = true;
        validateAndUpdate();
    }
    void loop() override {
        if (millis() - lastOverlayDraw > refreshDelay) {
            strip.trigger();
        }
    }
    void handleOverlayDraw() override {
        if (!enabled) {
            return;
        }
        lastOverlayDraw = millis();
        auto time = toki.getTime();
        double secondP = second(localTime) / 60.0;
        double minuteP = minute(localTime) / 60.0;
        double hourP = (hour(localTime) % 12) / 12.0 + minuteP / 12.0;
        if (hourMarksEnabled)         {
            for (int Led = 0; Led <= 55; Led = Led + 5)
            {
                int16_t hourmarkled = adjustToSegment(Led / 60.0, mainSegment);
                setPixelColor(hourmarkled, hourMarkColor);
            }
        }
        if (secondsEnabled) {
            int16_t secondLed = adjustToSegment(secondP, secondsSegment);
            switch (secondsEffect) {
                case 0: // no effect
                    setPixelColor(secondLed, secondColor);
                    break;
                case 1: // fading seconds
                    secondsEffectSineFade(secondLed, time);
                    break;
            }
            // TODO: move to secondsTrailEffect
            // for (uint16_t i = 1; i < secondsTrail + 1; ++i) {
            //     uint16_t trailLed = dec(secondLed, i, secondsSegment);
            //     uint8_t trailBright = 255 / (secondsTrail + 1) * (secondsTrail - i + 1);
            //     setPixelColor(trailLed, gamma32(scale32(secondColor, trailBright)));
            // }
        }
        setPixelColor(adjustToSegment(minuteP, mainSegment), minuteColor);
        setPixelColor(adjustToSegment(hourP, mainSegment), hourColor);
    }
    void addToConfig(JsonObject& root) override {
        validateAndUpdate();
        JsonObject top = root.createNestedObject(F("Analog Clock"));
        top[F("Overlay Enabled")]               = enabled;
        top[F("First LED (Main Ring)")]         = mainSegment.firstLed;
        top[F("Last LED (Main Ring)")]          = mainSegment.lastLed;
        top[F("Center/12h LED (Main Ring)")]    = mainSegment.centerLed;
        top[F("Hour Marks Enabled")]            = hourMarksEnabled;
        top[F("Hour Mark Color (RRGGBB)")]      = colorToHexString(hourMarkColor);
        top[F("Hour Color (RRGGBB)")]           = colorToHexString(hourColor);
        top[F("Minute Color (RRGGBB)")]         = colorToHexString(minuteColor);
        top[F("Show Seconds")]                  = secondsEnabled;
        top[F("First LED (Seconds Ring)")]      = secondsSegment.firstLed;
        top[F("Last LED (Seconds Ring)")]       = secondsSegment.lastLed;
        top[F("Center/12h LED (Seconds Ring)")] = secondsSegment.centerLed;
        top[F("Second Color (RRGGBB)")]         = colorToHexString(secondColor);
        top[F("Seconds Effect (0-1)")]          = secondsEffect;
        top[F("Blend Colors")]                  = blendColors;
    }
    bool readFromConfig(JsonObject& root) override {
        JsonObject top = root[F("Analog Clock")];
        bool configComplete = !top.isNull();
        String color;
        configComplete &= getJsonValue(top[F("Overlay Enabled")], enabled, false);
        configComplete &= getJsonValue(top[F("First LED (Main Ring)")], mainSegment.firstLed, 0);
        configComplete &= getJsonValue(top[F("Last LED (Main Ring)")], mainSegment.lastLed, 59);
        configComplete &= getJsonValue(top[F("Center/12h LED (Main Ring)")], mainSegment.centerLed, 0);
        configComplete &= getJsonValue(top[F("Hour Marks Enabled")], hourMarksEnabled, false);
        configComplete &= getJsonValue(top[F("Hour Mark Color (RRGGBB)")], color, F("161616")) && hexStringToColor(color, hourMarkColor, 0x161616);
        configComplete &= getJsonValue(top[F("Hour Color (RRGGBB)")], color, F("0000FF")) && hexStringToColor(color, hourColor, 0x0000FF);
        configComplete &= getJsonValue(top[F("Minute Color (RRGGBB)")], color, F("00FF00")) && hexStringToColor(color, minuteColor, 0x00FF00);
        configComplete &= getJsonValue(top[F("Show Seconds")], secondsEnabled, true);
        configComplete &= getJsonValue(top[F("First LED (Seconds Ring)")], secondsSegment.firstLed, 0);
        configComplete &= getJsonValue(top[F("Last LED (Seconds Ring)")], secondsSegment.lastLed, 59);
        configComplete &= getJsonValue(top[F("Center/12h LED (Seconds Ring)")], secondsSegment.centerLed, 0);
        configComplete &= getJsonValue(top[F("Second Color (RRGGBB)")], color, F("FF0000")) && hexStringToColor(color, secondColor, 0xFF0000);
        configComplete &= getJsonValue(top[F("Seconds Effect (0-1)")], secondsEffect, 0);
        configComplete &= getJsonValue(top[F("Blend Colors")], blendColors, true);
        if (initDone) {
            validateAndUpdate();
        }
        return configComplete;
    }
    uint16_t getId() override {
        return USERMOD_ID_ANALOG_CLOCK;
    }
 };
--- a/usermods/Animated_Staircase/Animated_Staircase.h
+++ b/usermods/Animated_Staircase/Animated_Staircase.h
@ -25,7 +25,6 @@ class Animated_Staircase : public Usermod {
    bool useUSSensorBottom         = false; // using PIR or UltraSound sensor?
    unsigned int topMaxDist        = 50;    // default maximum measured distance in cm, top
    unsigned int bottomMaxDist     = 50;    // default maximum measured distance in cm, bottom
    bool togglePower               = false; // toggle power on/off with staircase on/off
    /* runtime variables */
    bool initDone = false;
@ -66,7 +65,7 @@ class Animated_Staircase : public Usermod {
    // The maximum number of configured segments.
    // Dynamically updated based on user configuration.
    byte maxSegmentId = 1;
-    byte minSegmentId = 0;
+    byte mainSegmentId = 0;
    // These values are used by the API to read the
    // last sensor state, or trigger a sensor
@ -91,37 +90,39 @@ class Animated_Staircase : public Usermod {
    static const char _bottomEcho_pin[];
    static const char _topEchoCm[];
    static const char _bottomEchoCm[];
    static const char _togglePower[];
-    void publishMqtt(bool bottom, const char* state) {
+    void publishMqtt(bool bottom, const char* state)
-#ifndef WLED_DISABLE_MQTT
+    {
      //Check if MQTT Connected, otherwise it will crash the 8266
      if (WLED_MQTT_CONNECTED){
        char subuf[64];
        sprintf_P(subuf, PSTR("%s/motion/%d"), mqttDeviceTopic, (int)bottom);
        mqtt->publish(subuf, 0, false, state);
      }
 #endif
    }
    void updateSegments() {
-      for (int i = minSegmentId; i < maxSegmentId; i++) {
+      mainSegmentId = strip.getMainSegmentId();
-        Segment &seg = strip.getSegment(i);
+      WS2812FX::Segment* segments = strip.getSegments();
-        if (!seg.isActive()) continue; // skip gaps
+      for (int i = 0; i < MAX_NUM_SEGMENTS; i++, segments++) {
        if (!segments->isActive()) {
          maxSegmentId = i - 1;
          break;
        }
        if (i >= onIndex && i < offIndex) {
-          seg.setOption(SEG_OPTION_ON, true);
+          segments->setOption(SEG_OPTION_ON, 1, 1);
          // We may need to copy mode and colors from segment 0 to make sure
          // changes are propagated even when the config is changed during a wipe
-          // seg.setMode(mainsegment.mode);
+          // segments->mode = mainsegment.mode;
-          // seg.setColor(0, mainsegment.colors[0]);
+          // segments->colors[0] = mainsegment.colors[0];
        } else {
-          seg.setOption(SEG_OPTION_ON, false);
+          segments->setOption(SEG_OPTION_ON, 0, 1);
        }
        // Always mark segments as "transitional", we are animating the staircase
-        //seg.setOption(SEG_OPTION_TRANSITIONAL, true); // not needed anymore as setOption() does it
+        segments->setOption(SEG_OPTION_TRANSITIONAL, 1, 1);
      }
      strip.trigger();  // force strip refresh
      stateChanged = true;  // inform external devices/UI of change
      colorUpdated(CALL_MODE_DIRECT_CHANGE);
    }
@ -198,7 +199,6 @@ class Animated_Staircase : public Usermod {
          if (on) {
            lastSensor = topSensorRead;
          } else {
            if (togglePower && onIndex == offIndex && offMode) toggleOnOff(); // toggle power on if off
            // If the bottom sensor triggered, we need to swipe up, ON
            swipe = bottomSensorRead;
@ -208,9 +208,9 @@ class Animated_Staircase : public Usermod {
            if (onIndex == offIndex) {
              // Position the indices for a correct on-swipe
              if (swipe == SWIPE_UP) {
-                onIndex = minSegmentId;
+                onIndex = mainSegmentId;
              } else {
-                onIndex = maxSegmentId;
+                onIndex = maxSegmentId+1;
              }
              offIndex = onIndex;
            }
@ -222,7 +222,7 @@ class Animated_Staircase : public Usermod {
    }
    void autoPowerOff() {
-      if ((millis() - lastSwitchTime) > on_time_ms) {
+      if (on && ((millis() - lastSwitchTime) > on_time_ms)) {
        // if sensors are still on, do nothing
        if (bottomSensorState || topSensorState) return;
@ -239,12 +239,10 @@ class Animated_Staircase : public Usermod {
      if ((millis() - lastTime) > segment_delay_ms) {
        lastTime = millis();
        byte oldOn  = onIndex;
        byte oldOff = offIndex;
        if (on) {
          // Turn on all segments
-          onIndex  = MAX(minSegmentId, onIndex - 1);
+          onIndex = MAX(mainSegmentId, onIndex - 1);
-          offIndex = MIN(maxSegmentId, offIndex + 1);
+          offIndex = MIN(maxSegmentId + 1, offIndex + 1);
        } else {
          if (swipe == SWIPE_UP) {
            onIndex = MIN(offIndex, onIndex + 1);
@ -252,10 +250,7 @@ class Animated_Staircase : public Usermod {
            offIndex = MAX(onIndex, offIndex - 1);
          }
        }
-        if (oldOn != onIndex || oldOff != offIndex) {
+        updateSegments();
          updateSegments(); // reduce the number of updates to necessary ones
          if (togglePower && onIndex == offIndex && !offMode && !on) toggleOnOff();  // toggle power off for all segments off
        }
      }
    }
@ -293,23 +288,16 @@ class Animated_Staircase : public Usermod {
          pinMode(topPIRorTriggerPin, OUTPUT);
          pinMode(topEchoPin, INPUT);
        }
        onIndex  = minSegmentId = strip.getMainSegmentId(); // it may not be the best idea to start with main segment as it may not be the first one
        offIndex = maxSegmentId = strip.getLastActiveSegmentId() + 1;
        // shorten the strip transition time to be equal or shorter than segment delay
        transitionDelayTemp = transitionDelay = segment_delay_ms;
        strip.setTransition(segment_delay_ms/100);
        strip.trigger();
      } else {
        if (togglePower && !on && offMode) toggleOnOff(); // toggle power on if off
        // Restore segment options
-        for (int i = 0; i <= strip.getLastActiveSegmentId(); i++) {
+        WS2812FX::Segment* segments = strip.getSegments();
-          Segment &seg = strip.getSegment(i);
+        for (int i = 0; i < MAX_NUM_SEGMENTS; i++, segments++) {
-          if (!seg.isActive()) continue; // skip vector gaps
+          if (!segments->isActive()) {
-          seg.setOption(SEG_OPTION_ON, true);
+            maxSegmentId = i - 1;
            break;
          }
          segments->setOption(SEG_OPTION_ON, 1, 1);
        }
        strip.trigger();  // force strip update
        stateChanged = true;  // inform external dvices/UI of change
        colorUpdated(CALL_MODE_DIRECT_CHANGE);
        DEBUG_PRINTLN(F("Animated Staircase disabled."));
      }
@ -345,16 +333,13 @@ class Animated_Staircase : public Usermod {
    void loop() {
      if (!enabled || strip.isUpdating()) return;
      minSegmentId = strip.getMainSegmentId();  // it may not be the best idea to start with main segment as it may not be the first one
      maxSegmentId = strip.getLastActiveSegmentId() + 1;
      checkSensors();
-      if (on) autoPowerOff();
+      autoPowerOff();
      updateSwipe();
    }
    uint16_t getId() { return USERMOD_ID_ANIMATED_STAIRCASE; }
 #ifndef WLED_DISABLE_MQTT
    /**
     * handling of MQTT message
     * topic only contains stripped topic (part after /wled/MAC)
@ -392,7 +377,6 @@ class Animated_Staircase : public Usermod {
        mqtt->subscribe(subuf, 0);
      }
    }
 #endif
    void addToJsonState(JsonObject& root) {
      JsonObject staircase = root[FPSTR(_name)];
@ -409,29 +393,19 @@ class Animated_Staircase : public Usermod {
    */
    void readFromJsonState(JsonObject& root) {
      if (!initDone) return;  // prevent crash on boot applyPreset()
      bool en = enabled;
      JsonObject staircase = root[FPSTR(_name)];
      if (!staircase.isNull()) {
        if (staircase[FPSTR(_enabled)].is<bool>()) {
-          en = staircase[FPSTR(_enabled)].as<bool>();
+          enabled   = staircase[FPSTR(_enabled)].as<bool>();
        } else {
          String str = staircase[FPSTR(_enabled)]; // checkbox -> off or on
-          en = (bool)(str!="off"); // off is guaranteed to be present
+          enabled = (bool)(str!="off"); // off is guaranteed to be present
        }
        if (en != enabled) enable(en);
        readSensorsFromJson(staircase);
        DEBUG_PRINTLN(F("Staircase sensor state read from API."));
      }
    }
    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
    }
    /*
    * Writes the configuration to internal flash memory.
    */
@ -451,7 +425,6 @@ class Animated_Staircase : public Usermod {
      staircase[FPSTR(_bottomEcho_pin)]            = useUSSensorBottom ? bottomEchoPin : -1;
      staircase[FPSTR(_topEchoCm)]                 = topMaxDist;
      staircase[FPSTR(_bottomEchoCm)]              = bottomMaxDist;
      staircase[FPSTR(_togglePower)]               = togglePower;
      DEBUG_PRINTLN(F("Staircase config saved."));
    }
@ -496,8 +469,6 @@ class Animated_Staircase : public Usermod {
      bottomMaxDist = top[FPSTR(_bottomEchoCm)] | bottomMaxDist;
      bottomMaxDist = min(150,max(30,(int)bottomMaxDist));  // max distance ~1.5m (a lag of 9ms may be expected)
      togglePower = top[FPSTR(_togglePower)] | togglePower;  // staircase toggles power on/off
      DEBUG_PRINT(FPSTR(_name));
      if (!initDone) {
        // first run: reading from cfg.json
@ -521,7 +492,7 @@ class Animated_Staircase : public Usermod {
        if (changed) setup();
      }
      // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-      return !top[FPSTR(_togglePower)].isNull();
+      return true;
    }
    /*
@ -529,22 +500,22 @@ class Animated_Staircase : public Usermod {
    * tab of the web-UI.
    */
    void addToJsonInfo(JsonObject& root) {
-      JsonObject user = root["u"];
+      JsonObject staircase = root["u"];
-      if (user.isNull()) {
+      if (staircase.isNull()) {
-        user = root.createNestedObject("u");
+        staircase = root.createNestedObject("u");
      }
-      JsonArray infoArr = user.createNestedArray(FPSTR(_name));  // name
+      JsonArray usermodEnabled = staircase.createNestedArray(F("Staircase"));  // name
-
+      String btn = F("<button class=\"btn infobtn\" onclick=\"requestJson({staircase:{enabled:");
-      String uiDomString = F("<button class=\"btn btn-xs\" onclick=\"requestJson({");
+      if (enabled) {
-      uiDomString += FPSTR(_name);
+        btn += F("false}},false,false);loadInfo();\">");
-      uiDomString += F(":{");
+        btn += F("enabled");
-      uiDomString += FPSTR(_enabled);
+      } else {
-      uiDomString += enabled ? F(":false}});\">") : F(":true}});\">");
+        btn += F("true}},false,false);loadInfo();\">");
-      uiDomString += F("<i class=\"icons ");
+        btn += F("disabled");
-      uiDomString += enabled ? "on" : "off";
+      }
-      uiDomString += F("\">&#xe08f;</i></button>");
+      btn += F("</button>");
-      infoArr.add(uiDomString);
+      usermodEnabled.add(btn);                             // value
    }
 };
@ -561,4 +532,3 @@ const char Animated_Staircase::_bottomPIRorTrigger_pin[]    PROGMEM = "bottomPIR
 const char Animated_Staircase::_bottomEcho_pin[]            PROGMEM = "bottomEcho_pin";
 const char Animated_Staircase::_topEchoCm[]                 PROGMEM = "top-dist-cm";
 const char Animated_Staircase::_bottomEchoCm[]              PROGMEM = "bottom-dist-cm";
 const char Animated_Staircase::_togglePower[]               PROGMEM = "toggle-on-off";
--- a/usermods/Animated_Staircase/README.md
+++ b/usermods/Animated_Staircase/README.md
@ -1,14 +1,14 @@
 # Usermod Animated Staircase
-This usermod makes your staircase look cool by illuminating it with an animation. It uses
+This usermod makes your staircase look cool by switching it on with an animation. It uses
 PIR or ultrasonic sensors at the top and bottom of your stairs to:
- Light up the steps in the direction you're walking.
+- Light up the steps in your walking direction, leading the way.
 - Switch off the steps after you, in the direction of the last detected movement.
 - Always switch on when one of the sensors detects movement, even if an effect
-  is still running. It can gracefully handle multiple people on the stairs.
+  is still running. It can therewith handle multiple people on the stairs gracefully.
 The Animated Staircase can be controlled by the WLED API. Change settings such as
-speed, on/off time and distance by sending an HTTP request, see below.
+speed, on/off time and distance settings by sending an HTTP request, see below.
 ## WLED integration
 To include this usermod in your WLED setup, you have to be able to [compile WLED from source](https://github.com/Aircoookie/WLED/wiki/Compiling-WLED).
@ -20,16 +20,17 @@ Edit `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.
-You can configure usermod using the Usermods settings page.
+You can configure usermod using Usermods settings page.
-Please enter GPIO pins for PIR or ultrasonic sensors (trigger and echo).
+Please enter GPIO pins for PIR sensors or ultrasonic sensor (trigger and echo).
 If you use PIR sensor enter -1 for echo pin.
-Maximum distance for ultrasonic sensor can be configured as the time needed for an echo (see below).
+Maximum distance for ultrasonic sensor can be configured as a time needed for echo (see below).
 ## Hardware installation
-1. Attach the LED strip to each step of the stairs.
+1. Stick the LED strip under each step of the stairs.
-2. Connect the ESP8266 pin D4 or ESP32 pin D2 to the first LED data pin at the bottom step.
+2. Connect the ESP8266 pin D4 or ESP32 pin D2 to the first LED data pin at the bottom step
   of your stairs.
 3. Connect the data-out pin at the end of each strip per step to the data-in pin on the 
-   next step, creating one large virtual LED strip.
+   other end of the next step, creating one large virtual LED strip.
 4. Mount sensors of choice at the bottom and top of the stairs and connect them to the ESP.
 5. To make sure all LEDs get enough power and have your staircase lighted evenly, power each
   step from one side, using at least AWG14 or 2.5mm^2 cable. Don't connect them serial as you
@ -61,7 +62,7 @@ or remove them and put everything on one line.
 To read the current settings, open a browser to `http://xxx.xxx.xxx.xxx/json/state` (use your WLED 
 device IP address). The device will respond with a json object containing all WLED settings. 
-The staircase settings and sensor states are inside the WLED "state" element:
+The staircase settings and sensor states are inside the WLED status element:
 ```json
 {
@ -69,14 +70,14 @@ The staircase settings and sensor states are inside the WLED "state" element:
        "staircase": {
            "enabled": true,
            "bottom-sensor": false,
-            "top-sensor": false
+            "tops-ensor": false
        },
 }
 ```
 ### Enable/disable the usermod
 By disabling the usermod you will be able to keep the LED's on, independent from the sensor
-activity. This enables you to play with the lights without the usermod switching them on or off.
+activity. This enables to play with the lights without the usermod switching them on or off.
 To disable the usermod:
@ -91,17 +92,17 @@ To enable the usermod again, use `"enabled":true`.
 Alternatively you can use _Usermod_ Settings page where you can change other parameters as well.
 ### Changing animation parameters and detection range of the ultrasonic HC-SR04 sensor
-Using _Usermod_ Settings page you can define different usermod parameters, includng sensor pins, delay between segment activation etc.
+Using _Usermod_ Settings page you can define different usermod parameters, includng sensor pins, delay between segment activation and so on.
 When an ultrasonic sensor is enabled you can enter maximum detection distance in centimeters separately for top and bottom sensors.
-**Please note:** using an HC-SR04 sensor, particularly when detecting echos at longer
+**Please note:** that using an HC-SR04 sensor, particularly when detecting echos at longer
-distances creates delays in the WLED software, _might_ introduce timing hiccups in your animation or
+distances creates delays in the WLED software, and _might_ introduce timing hickups in your animations or
 a less responsive web interface. It is therefore advised to keep the detection distance as short as possible.
 ### Animation triggering through the API
-In addition to activation by one of the stair sensors, you can also trigger the animation manually
+Instead of stairs activation by one of the sensors, you can also trigger the animation through
-via the API. To simulate triggering the bottom sensor, use:
+the API. To simulate triggering the bottom sensor, use:
 ```bash
 curl -X POST -H "Content-Type: application/json" \
@ -109,7 +110,7 @@ curl -X POST -H "Content-Type: application/json" \
     xxx.xxx.xxx.xxx/json/state
 ```
-Likewise, to trigger the top sensor:
+Likewise, to trigger the top sensor, use:
 ```bash
 curl -X POST -H "Content-Type: application/json" \
@ -118,7 +119,7 @@ curl -X POST -H "Content-Type: application/json" \
 ```
 **MQTT**
 You can publish a message with either `up` or `down` on topic `/swipe` to trigger animation.
-You can also use `on` or `off` for enabling or disabling the usermod.
+You can also use `on` or `off` for enabling or disabling usermod.
 Have fun with this usermod.<br/>
 www.rolfje.com
--- a/usermods/Artemis_reciever/usermod.cpp
+++ b/usermods/Artemis_reciever/usermod.cpp
@ -24,7 +24,7 @@ void RGBNET_readValues() {
    int channel = UDP.read();
    //channel data is not used we only supports one channel
-    int len = UDP.read(RGBNET_packet, strip.getLengthTotal()*3);
+    int len = UDP.read(RGBNET_packet, ledCount*3);
    if(len==0){
      return;
    }
@ -50,7 +50,7 @@ void handleConfig(AsyncWebServerRequest *request)
  \"channels\": [\
    {\
      \"channel\": 1,\
-      \"leds\": " + strip.getLengthTotal() + "\
+      \"leds\": " + ledCount + "\
    },\
    {\
      \"channel\": 2,\
--- a/usermods/BH1750_v2/readme.md
+++ b/usermods/BH1750_v2/readme.md
@ -1,49 +0,0 @@
 # BH1750 usermod
 This usermod will read from an ambient light sensor like the BH1750.
 The luminance is displayed in both the Info section of the web UI, as well as published to the `/luminance` MQTT topic if enabled.
 ## Dependencies
 - Libraries
  - `claws/BH1750 @^1.2.0`
  - This must be added under `lib_deps` in your `platformio.ini` (or `platformio_override.ini`).
 - Data is published over MQTT - make sure you've enabled the MQTT sync interface.
 ## Compiliation
 To enable, compile with `USERMOD_BH1750` defined  (e.g. in `platformio_override.ini`)
 ```ini
 [env:usermod_BH1750_d1_mini]
 extends = env:d1_mini
 build_flags =
    ${common.build_flags_esp8266}
    -D USERMOD_BH1750
 lib_deps = 
    ${esp8266.lib_deps}
    claws/BH1750 @ ^1.2.0
 ```
 ### Configuration Options
 The following settings can be set at compile-time but are configurable on the usermod menu (except First Measurement time):
 *   `USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL` - the max number of milliseconds between measurements, defaults to 10000ms
 *   `USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL` - the min number of milliseconds between measurements, defaults to 500ms
 *   `USERMOD_BH1750_OFFSET_VALUE` - the offset value to report on, defaults to 1
 *   `USERMOD_BH1750_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 10000 ms
 In addition, the Usermod screen allows you to:
 - enable/disable the usermod
 - Enable Home Assistant Discovery of usermod
 - Configure the SCL/SDA pins
 ## API
 The following method is available to interact with the usermod from other code modules:
 - `getIlluminance` read the brightness from the sensor
 ## Change Log
 Jul 2022
 - Added Home Assistant Discovery
 - Implemented PinManager to register pins
 - Made pins configurable in usermod menu
 - Added API call to read luminance from other modules
 - Enhanced info-screen outputs
 - Updated `readme.md`
--- a/usermods/BH1750_v2/usermod_bh1750.h
+++ b/usermods/BH1750_v2/usermod_bh1750.h
@ -1,252 +0,0 @@
 // force the compiler to show a warning to confirm that this file is included
 #warning **** Included USERMOD_BH1750 ****
 #ifndef WLED_ENABLE_MQTT
 #error "This user mod requires MQTT to be enabled."
 #endif
 #pragma once
 #include "wled.h"
 #include <BH1750.h>
 // the max frequency to check photoresistor, 10 seconds
 #ifndef USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL
 #define USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL 10000
 #endif
 // the min frequency to check photoresistor, 500 ms
 #ifndef USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL
 #define USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL 500
 #endif
 // how many seconds after boot to take first measurement, 10 seconds
 #ifndef USERMOD_BH1750_FIRST_MEASUREMENT_AT
 #define USERMOD_BH1750_FIRST_MEASUREMENT_AT 10000
 #endif
 // only report if differance grater than offset value
 #ifndef USERMOD_BH1750_OFFSET_VALUE
 #define USERMOD_BH1750_OFFSET_VALUE 1
 #endif
 class Usermod_BH1750 : public Usermod
 {
 private:
  int8_t offset = USERMOD_BH1750_OFFSET_VALUE;
  unsigned long maxReadingInterval = USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL;
  unsigned long minReadingInterval = USERMOD_BH1750_MIN_MEASUREMENT_INTERVAL;
  unsigned long lastMeasurement = UINT32_MAX - (USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL - USERMOD_BH1750_FIRST_MEASUREMENT_AT);
  unsigned long lastSend = UINT32_MAX - (USERMOD_BH1750_MAX_MEASUREMENT_INTERVAL - USERMOD_BH1750_FIRST_MEASUREMENT_AT);
  // flag to indicate we have finished the first readLightLevel call
  // allows this library to report to the user how long until the first
  // measurement
  bool getLuminanceComplete = false;
  // flag set at startup
  bool enabled = true;
  // strings to reduce flash memory usage (used more than twice)
  static const char _name[];
  static const char _enabled[];
  static const char _maxReadInterval[];
  static const char _minReadInterval[];
  static const char _offset[];
  static const char _HomeAssistantDiscovery[];
  bool initDone = false;
  bool sensorFound = false;
  // Home Assistant and MQTT  
  String mqttLuminanceTopic = F("");
  bool mqttInitialized = false;
  bool HomeAssistantDiscovery = true; // Publish Home Assistant Discovery messages
  BH1750 lightMeter;
  float lastLux = -1000;
  bool checkBoundSensor(float newValue, float prevValue, float maxDiff)
  {
    return isnan(prevValue) || newValue <= prevValue - maxDiff || newValue >= prevValue + maxDiff || (newValue == 0.0 && prevValue > 0.0);
  }
  // set up Home Assistant discovery entries
  void _mqttInitialize()
  {
    mqttLuminanceTopic = String(mqttDeviceTopic) + F("/brightness");
    if (HomeAssistantDiscovery) _createMqttSensor(F("Brightness"), mqttLuminanceTopic, F("Illuminance"), F(" lx"));
  }
  // Create an MQTT Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
  void _createMqttSensor(const String &name, const String &topic, const String &deviceClass, const String &unitOfMeasurement)
  {
    String t = String(F("homeassistant/sensor/")) + mqttClientID + F("/") + name + F("/config");
    StaticJsonDocument<600> doc;
    doc[F("name")] = String(serverDescription) + F(" ") + name;
    doc[F("state_topic")] = topic;
    doc[F("unique_id")] = String(mqttClientID) + name;
    if (unitOfMeasurement != "")
      doc[F("unit_of_measurement")] = unitOfMeasurement;
    if (deviceClass != "")
      doc[F("device_class")] = deviceClass;
    doc[F("expire_after")] = 1800;
    JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device
    device[F("name")] = serverDescription;
    device[F("identifiers")] = "wled-sensor-" + String(mqttClientID);
    device[F("manufacturer")] = F("WLED");
    device[F("model")] = F("FOSS");
    device[F("sw_version")] = versionString;
    String temp;
    serializeJson(doc, temp);
    DEBUG_PRINTLN(t);
    DEBUG_PRINTLN(temp);
    mqtt->publish(t.c_str(), 0, true, temp.c_str());
  }
 public:
  void setup()
  {
    if (i2c_scl<0 || i2c_sda<0) { enabled = false; return; }
    sensorFound = lightMeter.begin();
    initDone = true;
  }
  void loop()
  {
    if ((!enabled) || strip.isUpdating())
      return;
    unsigned long now = millis();
    // check to see if we are due for taking a measurement
    // lastMeasurement will not be updated until the conversion
    // is complete the the reading is finished
    if (now - lastMeasurement < minReadingInterval)
    {
      return;
    }
    bool shouldUpdate = now - lastSend > maxReadingInterval;
    float lux = lightMeter.readLightLevel();
    lastMeasurement = millis();
    getLuminanceComplete = true;
    if (shouldUpdate || checkBoundSensor(lux, lastLux, offset))
    {
      lastLux = lux;
      lastSend = millis();
 #ifndef WLED_DISABLE_MQTT
      if (WLED_MQTT_CONNECTED)
      {
        if (!mqttInitialized)
          {
            _mqttInitialize();
            mqttInitialized = true;
          }
        mqtt->publish(mqttLuminanceTopic.c_str(), 0, true, String(lux).c_str());
        DEBUG_PRINTLN(F("Brightness: ") + String(lux) + F("lx"));
      }
      else
      {
        DEBUG_PRINTLN(F("Missing MQTT connection. Not publishing data"));
      }
 #endif
    }
  }
  inline float getIlluminance() {
    return (float)lastLux;
  }
  void addToJsonInfo(JsonObject &root)
  {
    JsonObject user = root[F("u")];
    if (user.isNull())
      user = root.createNestedObject(F("u"));
    JsonArray lux_json = user.createNestedArray(F("Luminance"));
    if (!enabled) {
      lux_json.add(F("disabled"));
    } else if (!sensorFound) {
        // if no sensor 
        lux_json.add(F("BH1750 "));
        lux_json.add(F("Not Found"));
    } else if (!getLuminanceComplete) {
      // if we haven't read the sensor yet, let the user know
        // that we are still waiting for the first measurement
        lux_json.add((USERMOD_BH1750_FIRST_MEASUREMENT_AT - millis()) / 1000);
        lux_json.add(F(" sec until read"));
        return;
    } else {
      lux_json.add(lastLux);
      lux_json.add(F(" lx"));
    }
  }
  // (called from set.cpp) stores persistent properties to cfg.json
  void addToConfig(JsonObject &root)
  {
    // we add JSON object.
    JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
    top[FPSTR(_enabled)] = enabled;
    top[FPSTR(_maxReadInterval)] = maxReadingInterval;
    top[FPSTR(_minReadInterval)] = minReadingInterval;
    top[FPSTR(_HomeAssistantDiscovery)] = HomeAssistantDiscovery;
    top[FPSTR(_offset)] = offset;
    DEBUG_PRINTLN(F("BH1750 config saved."));
  }
  // called before setup() to populate properties from values stored in cfg.json
  bool readFromConfig(JsonObject &root)
  {
    // we look for JSON object.
    JsonObject top = root[FPSTR(_name)];
    if (top.isNull())
    {
      DEBUG_PRINT(FPSTR(_name));
      DEBUG_PRINT(F("BH1750"));
      DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
      return false;
    }
    bool configComplete = !top.isNull();
    configComplete &= getJsonValue(top[FPSTR(_enabled)], enabled, false);
    configComplete &= getJsonValue(top[FPSTR(_maxReadInterval)], maxReadingInterval, 10000); //ms
    configComplete &= getJsonValue(top[FPSTR(_minReadInterval)], minReadingInterval, 500); //ms
    configComplete &= getJsonValue(top[FPSTR(_HomeAssistantDiscovery)], HomeAssistantDiscovery, false);
    configComplete &= getJsonValue(top[FPSTR(_offset)], offset, 1);
    DEBUG_PRINT(FPSTR(_name));
    if (!initDone) {
      DEBUG_PRINTLN(F(" config loaded."));
    } else {
      DEBUG_PRINTLN(F(" config (re)loaded."));
    }
    return configComplete;
  }
  uint16_t getId()
  {
    return USERMOD_ID_BH1750;
  }
 };
 // strings to reduce flash memory usage (used more than twice)
 const char Usermod_BH1750::_name[] PROGMEM = "BH1750";
 const char Usermod_BH1750::_enabled[] PROGMEM = "enabled";
 const char Usermod_BH1750::_maxReadInterval[] PROGMEM = "max-read-interval-ms";
 const char Usermod_BH1750::_minReadInterval[] PROGMEM = "min-read-interval-ms";
 const char Usermod_BH1750::_HomeAssistantDiscovery[] PROGMEM = "HomeAssistantDiscoveryLux";
 const char Usermod_BH1750::_offset[] PROGMEM = "offset-lx";
--- a/usermods/BME280_v2/README.md
+++ b/usermods/BME280_v2/README.md
@ -1,60 +1,36 @@
-# Usermod BME280
+Hello! I have written a v2 usermod for the BME280/BMP280 sensor based on the [existing v1 usermod](https://github.com/Aircoookie/WLED/blob/master/usermods/Wemos_D1_mini%2BWemos32_mini_shield/usermod_bme280.cpp). It is not just a refactor, there are many changes which I made to fit my use case, and I hope they will fit the use cases of others as well! Most notably, this usermod is *just* for the BME280 and does not control a display like in the v1 usermod designed for the WeMos shield. 
 This Usermod is designed to read a `BME280` or `BMP280` sensor and output the following:
 - Temperature
 - Humidity (`BME280` only)
 - Pressure
 - Heat Index (`BME280` only)
 - Dew Point (`BME280` only)
-Configuration is performed via the Usermod menu.  There are no parameters to set in code!  The following settings can be configured in the Usermod Menu:
+- Requires libraries `BME280@~3.0.0` (by [finitespace](https://github.com/finitespace/BME280)) and `Wire`. Please add these under `lib_deps` in your `platform.ini` (or `platform_override.ini`).
- Temperature Decimals (number of decimal places to output)
+- Data is published over MQTT so make sure you've enabled the MQTT sync interface.
- Humidity Decimals
+- This usermod also writes to serial (GPIO1 on ESP8266). Please make sure nothing else listening on the serial TX pin of your board will get confused by log messages!
 - Pressure Decimals
 - Temperature Interval (how many seconds between temperature and humidity measurements)
 - Pressure Interval
 - Publish Always (turn off to only publish changes, on to publish whether or not value changed)
 - Use Celsius (turn off to use Fahrenheit)
 - Home Assistant Discovery (turn on to sent MQTT Discovery entries for Home Assistant)
 - SCL/SDA GPIO Pins
-Dependencies
+To enable, compile with `USERMOD_BME280` defined (i.e. `platformio_override.ini`)
 - Libraries
  - `BME280@~3.0.0` (by [finitespace](https://github.com/finitespace/BME280))
  - `Wire`
  - These must be added under `lib_deps` in your `platform.ini` (or `platform_override.ini`).
 - Data is published over MQTT - make sure you've enabled the MQTT sync interface.
 - This usermod also writes to serial (GPIO1 on ESP8266). Please make sure nothing else is listening to the serial TX pin or your board will get confused by log messages!
 In addition to outputting via MQTT, you can read the values from the Info Screen on the dashboard page of the device's web interface.
 Methods also exist to read the read/calculated values from other WLED modules through code.
 - `getTemperatureC()`
 - `getTemperatureF()`
 - `getHumidity()`
 - `getPressure()`
 - `getDewPointC()`
 - `getDewPointF()`
 - `getHeatIndexC()`
 - `getHeatIndexF()`
 # Compiling
 To enable, compile with `USERMOD_BME280` defined  (e.g. in `platformio_override.ini`)
 ```ini
 [env:usermod_bme280_d1_mini]
 extends = env:d1_mini
 build_flags =
  ${common.build_flags_esp8266}
  -D USERMOD_BME280
-lib_deps = 
+```
-  ${esp8266.lib_deps}
+or define `USERMOD_BME280` in `my_config.h`
-  BME280@~3.0.0
+```c++
-  Wire
+#define USERMOD_BME280
 ```
 Changes include:
 - Adjustable measure intervals
  - Temperature and pressure have separate intervals due to pressure not frequently changing at any constant altitude
 - Adjustment of number of decimal places in published sensor values
  - Separate adjustment for temperature, humidity and pressure values
  - Values are rounded to the specified number of decimal places
 - Pressure measured in units of hPa instead of Pa
 - Calculation of heat index (apparent temperature) and dew point
  - These, along with humidity measurements, are disabled if the sensor is a BMP280
 - 16x oversampling of sensor during measurement
 - Values are only published if they are different from the previous value
 - Values are published on startup (continually until the MQTT broker acknowledges a successful publication)
-# MQTT
+Adjustments are made through preprocessor definitions at the start of the class definition.
-MQTT topics are as follows (`<deviceTopic>` is set in MQTT section of Sync Setup menu):
+
 MQTT topics are as follows:
 Measurement type | MQTT topic
 --- | ---
 Temperature | `<deviceTopic>/temperature`
@ -62,29 +38,3 @@ Humidity | `<deviceTopic>/humidity`
 Pressure | `<deviceTopic>/pressure`
 Heat index | `<deviceTopic>/heat_index`
 Dew point | `<deviceTopic>/dew_point`
 If you are using Home Assistant, and `Home Assistant Discovery` is turned on, Home Assistant should automatically detect a new device, provided you have the MQTT integration installed.  The device is separate from the main WLED device and will contain sensors for Pressure, Humidity, Temperature, Dew Point and Heat Index.
 # Revision History
 Jul 2022
 - Added Home Assistant Discovery
 - Added API interface to output data
 - Removed compile-time variables
 - Added usermod menu interface
 - Added value outputs to info screen
 - Updated `readme.md`
 - Registered usermod
 - Implemented PinManager for usermod
 - Implemented reallocation of pins without reboot
 Apr 2021
 - Added `Publish Always` option
 Dec 2020
 - Ported to V2 Usermod format
 - Customizable `measure intervals`
 - Customizable number of `decimal places` in published sensor values
 - Pressure measured in units of hPa instead of Pa
 - Calculation of heat index (apparent temperature) and dew point
 - `16x oversampling` of sensor during measurement
 - Values only published if they are different from the previous value
--- a/usermods/BME280_v2/usermod_bme280.h
+++ b/usermods/BME280_v2/usermod_bme280.h
@ -1,39 +1,51 @@
 // force the compiler to show a warning to confirm that this file is included
 #warning **** Included USERMOD_BME280 version 2.0 ****
 #ifndef WLED_ENABLE_MQTT
 #error "This user mod requires MQTT to be enabled."
 #endif
 #pragma once
 #include "wled.h"
 #include <Arduino.h>
 #include <Wire.h>
 #include <BME280I2C.h>               // BME280 sensor
 #include <EnvironmentCalculations.h> // BME280 extended measurements
 class UsermodBME280 : public Usermod
 {
 private:
 // User-defined configuration
 #define Celsius               // Show temperature mesaurement in Celcius. Comment out for Fahrenheit
 #define TemperatureDecimals 1 // Number of decimal places in published temperaure values
 #define HumidityDecimals 2    // Number of decimal places in published humidity values
 #define PressureDecimals 2    // Number of decimal places in published pressure values
 #define TemperatureInterval 5 // Interval to measure temperature (and humidity, dew point if available) in seconds
 #define PressureInterval 300  // Interval to measure pressure in seconds
 #define PublishAlways 0       // Publish values even when they have not changed
-  // NOTE: Do not implement any compile-time variables, anything the user needs to configure
+// Sanity checks
-  // should be configurable from the Usermod menu using the methods below
+#if !defined(TemperatureDecimals) || TemperatureDecimals < 0
-  // key settings set via usermod menu
+  #define TemperatureDecimals 0
-  uint8_t  TemperatureDecimals = 0;  // Number of decimal places in published temperaure values
+#endif
-  uint8_t  HumidityDecimals = 0;    // Number of decimal places in published humidity values
+#if !defined(HumidityDecimals) || HumidityDecimals < 0
-  uint8_t  PressureDecimals = 0;    // Number of decimal places in published pressure values
+  #define HumidityDecimals 0
-  uint16_t TemperatureInterval = 5; // Interval to measure temperature (and humidity, dew point if available) in seconds
+#endif
-  uint16_t PressureInterval = 300;  // Interval to measure pressure in seconds
+#if !defined(PressureDecimals) || PressureDecimals < 0
-  bool PublishAlways = false;             // Publish values even when they have not changed
+  #define PressureDecimals 0
-  bool UseCelsius = true;                 // Use Celsius for Reporting
+#endif
-  bool HomeAssistantDiscovery = false;    // Publish Home Assistant Device Information
+#if !defined(TemperatureInterval) || TemperatureInterval < 0
-  bool enabled = true;
+  #define TemperatureInterval 1
 #endif
 #if !defined(PressureInterval) || PressureInterval < 0
  #define PressureInterval TemperatureInterval
 #endif
 #if !defined(PublishAlways)
  #define PublishAlways 0
 #endif
-  // set the default pins based on the architecture, these get overridden by Usermod menu settings
+#ifdef ARDUINO_ARCH_ESP32 // ESP32 boards
-  #ifdef ESP8266
+  uint8_t SCL_PIN = 22;
  uint8_t SDA_PIN = 21;
 #else // ESP8266 boards
  uint8_t SCL_PIN = 5;
  uint8_t SDA_PIN = 4;
  //uint8_t RST_PIN = 16; // Uncoment for Heltec WiFi-Kit-8
 #endif
  bool initDone = false;
  // BME280 sensor settings
  BME280I2C::Settings settings{
@ -63,7 +75,6 @@ private:
  float sensorHeatIndex;
  float sensorDewPoint;
  float sensorPressure;
  String tempScale;
  // Track previous sensor values
  float lastTemperature;
  float lastHumidity;
@ -71,37 +82,20 @@ private:
  float lastDewPoint;
  float lastPressure;
-  // MQTT topic strings for publishing Home Assistant discovery topics
+  // Store packet IDs of MQTT publications
-  bool mqttInitialized = false;
+  uint16_t mqttTemperaturePub = 0;
  uint16_t mqttPressurePub = 0;
  // strings to reduce flash memory usage (used more than twice)
  static const char _name[];
  static const char _enabled[];
  // Read the BME280/BMP280 Sensor (which one runs depends on whether Celsius or Farenheit being set in Usermod Menu)
  void UpdateBME280Data(int SensorType)
  {
    float _temperature, _humidity, _pressure;
-
+    #ifdef Celsius
    if (UseCelsius) {
      BME280::TempUnit tempUnit(BME280::TempUnit_Celsius);
      EnvironmentCalculations::TempUnit envTempUnit(EnvironmentCalculations::TempUnit_Celsius);
-      BME280::PresUnit presUnit(BME280::PresUnit_hPa);
+    #else
      bme.read(_pressure, _temperature, _humidity, tempUnit, presUnit);
      sensorTemperature = _temperature;
      sensorHumidity = _humidity;
      sensorPressure = _pressure;
      tempScale = F("°C");
      if (sensorType == 1)
      {
        sensorHeatIndex = EnvironmentCalculations::HeatIndex(_temperature, _humidity, envTempUnit);
        sensorDewPoint = EnvironmentCalculations::DewPoint(_temperature, _humidity, envTempUnit);
      }
    } else {
      BME280::TempUnit tempUnit(BME280::TempUnit_Fahrenheit);
      EnvironmentCalculations::TempUnit envTempUnit(EnvironmentCalculations::TempUnit_Fahrenheit);
    #endif
    BME280::PresUnit presUnit(BME280::PresUnit_hPa);
    bme.read(_pressure, _temperature, _humidity, tempUnit, presUnit);
@ -109,87 +103,22 @@ private:
    sensorTemperature = _temperature;
    sensorHumidity = _humidity;
    sensorPressure = _pressure;
      tempScale = F("°F");
    if (sensorType == 1)
    {
      sensorHeatIndex = EnvironmentCalculations::HeatIndex(_temperature, _humidity, envTempUnit);
      sensorDewPoint = EnvironmentCalculations::DewPoint(_temperature, _humidity, envTempUnit);
    }
  }
  }
  // Procedure to define all MQTT discovery Topics 
  void _mqttInitialize()
  {
    char mqttTemperatureTopic[128];
    char mqttHumidityTopic[128];
    char mqttPressureTopic[128];
    char mqttHeatIndexTopic[128];
    char mqttDewPointTopic[128];
    snprintf_P(mqttTemperatureTopic, 127, PSTR("%s/temperature"), mqttDeviceTopic);
    snprintf_P(mqttPressureTopic, 127, PSTR("%s/pressure"), mqttDeviceTopic);
    snprintf_P(mqttHumidityTopic, 127, PSTR("%s/humidity"), mqttDeviceTopic);
    snprintf_P(mqttHeatIndexTopic, 127, PSTR("%s/heat_index"), mqttDeviceTopic);
    snprintf_P(mqttDewPointTopic, 127, PSTR("%s/dew_point"), mqttDeviceTopic);
    if (HomeAssistantDiscovery) {
      _createMqttSensor(F("Temperature"), mqttTemperatureTopic, "temperature", tempScale);
      _createMqttSensor(F("Pressure"), mqttPressureTopic, "pressure", F("hPa"));
      _createMqttSensor(F("Humidity"), mqttHumidityTopic, "humidity", F("%"));
      _createMqttSensor(F("HeatIndex"), mqttHeatIndexTopic, "temperature", tempScale);
      _createMqttSensor(F("DewPoint"), mqttDewPointTopic, "temperature", tempScale);
    }
  }
  // Create an MQTT Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
  void _createMqttSensor(const String &name, const String &topic, const String &deviceClass, const String &unitOfMeasurement)
  {
    String t = String(F("homeassistant/sensor/")) + mqttClientID + F("/") + name + F("/config");
    StaticJsonDocument<600> doc;
    doc[F("name")] = String(serverDescription) + " " + name;
    doc[F("state_topic")] = topic;
    doc[F("unique_id")] = String(mqttClientID) + name;
    if (unitOfMeasurement != "")
      doc[F("unit_of_measurement")] = unitOfMeasurement;
    if (deviceClass != "")
      doc[F("device_class")] = deviceClass;
    doc[F("expire_after")] = 1800;
    JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device
    device[F("name")] = serverDescription;
    device[F("identifiers")] = "wled-sensor-" + String(mqttClientID);
    device[F("manufacturer")] = F("WLED");
    device[F("model")] = F("FOSS");
    device[F("sw_version")] = versionString;
    String temp;
    serializeJson(doc, temp);
    DEBUG_PRINTLN(t);
    DEBUG_PRINTLN(temp);
    mqtt->publish(t.c_str(), 0, true, temp.c_str());
  }
    void publishMqtt(const char *topic, const char* state) {
      //Check if MQTT Connected, otherwise it will crash the 8266
      if (WLED_MQTT_CONNECTED){
        char subuf[128];
        snprintf_P(subuf, 127, PSTR("%s/%s"), mqttDeviceTopic, topic);
        mqtt->publish(subuf, 0, false, state);
      }
    }
 public:
  void setup()
  {
-    if (i2c_scl<0 || i2c_sda<0) { enabled = false; sensorType = 0; return; }
+    Wire.begin(SDA_PIN, SCL_PIN);
    if (!bme.begin())
    {
      sensorType = 0;
-      DEBUG_PRINTLN(F("Could not find BME280 I2C sensor!"));
+      Serial.println("Could not find BME280I2C sensor!");
    }
    else
    {
@ -197,68 +126,69 @@ public:
      {
      case BME280::ChipModel_BME280:
        sensorType = 1;
-        DEBUG_PRINTLN(F("Found BME280 sensor! Success."));
+        Serial.println("Found BME280 sensor! Success.");
        break;
      case BME280::ChipModel_BMP280:
        sensorType = 2;
-        DEBUG_PRINTLN(F("Found BMP280 sensor! No Humidity available."));
+        Serial.println("Found BMP280 sensor! No Humidity available.");
        break;
      default:
        sensorType = 0;
-        DEBUG_PRINTLN(F("Found UNKNOWN sensor! Error!"));
+        Serial.println("Found UNKNOWN sensor! Error!");
      }
    }
    initDone=true;
  }
  void loop()
  {
    if (!enabled || strip.isUpdating()) return;
    // BME280 sensor MQTT publishing
-    // Check if sensor present and Connected, otherwise it will crash the MCU
+    // Check if sensor present and MQTT Connected, otherwise it will crash the MCU
-    if (sensorType != 0)
+    if (sensorType != 0 && mqtt != nullptr)
    {
      // Timer to fetch new temperature, humidity and pressure data at intervals
      timer = millis();
-      if (timer - lastTemperatureMeasure >= TemperatureInterval * 1000)
+      if (timer - lastTemperatureMeasure >= TemperatureInterval * 1000 || mqttTemperaturePub == 0)
      {
        lastTemperatureMeasure = timer;
        UpdateBME280Data(sensorType);
-        float temperature = roundf(sensorTemperature * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
+        float temperature = roundf(sensorTemperature * pow(10, TemperatureDecimals)) / pow(10, TemperatureDecimals);
        float humidity, heatIndex, dewPoint;
        // If temperature has changed since last measure, create string populated with device topic
        // from the UI and values read from sensor, then publish to broker
        if (temperature != lastTemperature || PublishAlways)
        {
-          publishMqtt("temperature", String(temperature, TemperatureDecimals).c_str());
+          String topic = String(mqttDeviceTopic) + "/temperature";
          mqttTemperaturePub = mqtt->publish(topic.c_str(), 0, false, String(temperature, TemperatureDecimals).c_str());
        }
        lastTemperature = temperature; // Update last sensor temperature for next loop
        if (sensorType == 1) // Only if sensor is a BME280
        {
-          humidity = roundf(sensorHumidity * powf(10, HumidityDecimals)) / powf(10, HumidityDecimals);
+          humidity = roundf(sensorHumidity * pow(10, HumidityDecimals)) / pow(10, HumidityDecimals);
-          heatIndex = roundf(sensorHeatIndex * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
+          heatIndex = roundf(sensorHeatIndex * pow(10, TemperatureDecimals)) / pow(10, TemperatureDecimals);
-          dewPoint = roundf(sensorDewPoint * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
+          dewPoint = roundf(sensorDewPoint * pow(10, TemperatureDecimals)) / pow(10, TemperatureDecimals);
          if (humidity != lastHumidity || PublishAlways)
          {
-            publishMqtt("humidity", String(humidity, HumidityDecimals).c_str());
+            String topic = String(mqttDeviceTopic) + "/humidity";
            mqtt->publish(topic.c_str(), 0, false, String(humidity, HumidityDecimals).c_str());
          }
          if (heatIndex != lastHeatIndex || PublishAlways)
          {
-            publishMqtt("heat_index", String(heatIndex, TemperatureDecimals).c_str());
+            String topic = String(mqttDeviceTopic) + "/heat_index";
            mqtt->publish(topic.c_str(), 0, false, String(heatIndex, TemperatureDecimals).c_str());
          }
          if (dewPoint != lastDewPoint || PublishAlways)
          {
-            publishMqtt("dew_point", String(dewPoint, TemperatureDecimals).c_str());
+            String topic = String(mqttDeviceTopic) + "/dew_point";
            mqtt->publish(topic.c_str(), 0, false, String(dewPoint, TemperatureDecimals).c_str());
          }
          lastHumidity = humidity;
@ -267,190 +197,20 @@ public:
        }
      }
-      if (timer - lastPressureMeasure >= PressureInterval * 1000)
+      if (timer - lastPressureMeasure >= PressureInterval * 1000 || mqttPressurePub == 0)
      {
        lastPressureMeasure = timer;
-        float pressure = roundf(sensorPressure * powf(10, PressureDecimals)) / powf(10, PressureDecimals);
+        float pressure = roundf(sensorPressure * pow(10, PressureDecimals)) / pow(10, PressureDecimals);
        if (pressure != lastPressure || PublishAlways)
        {
-          publishMqtt("pressure", String(pressure, PressureDecimals).c_str());
+          String topic = String(mqttDeviceTopic) + "/pressure";
          mqttPressurePub = mqtt->publish(topic.c_str(), 0, true, String(pressure, PressureDecimals).c_str());
        }
        lastPressure = pressure;
      }
    }
  }
  void onMqttConnect(bool sessionPresent)
  {
    if (WLED_MQTT_CONNECTED && !mqttInitialized)
    {
      _mqttInitialize();
      mqttInitialized = true;
    }
  }
    /*
     * API calls te enable data exchange between WLED modules
     */
    inline float getTemperatureC() {
      if (UseCelsius) {
        return (float)roundf(sensorTemperature * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
      } else {
        return (float)roundf(sensorTemperature * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals) * 1.8f + 32;
      }      
    }
    inline float getTemperatureF() {
      if (UseCelsius) {
        return ((float)roundf(sensorTemperature * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals) -32) * 0.56f;
      } else {
        return (float)roundf(sensorTemperature * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
      }
    }
    inline float getHumidity() {
      return (float)roundf(sensorHumidity * powf(10, HumidityDecimals));
    }
    inline float getPressure() {
      return (float)roundf(sensorPressure * powf(10, PressureDecimals));
    }
    inline float getDewPointC() {
      if (UseCelsius) {
        return (float)roundf(sensorDewPoint * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
      } else {
        return (float)roundf(sensorDewPoint * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals) * 1.8f + 32;
      }
    }
    inline float getDewPointF() {
      if (UseCelsius) {
        return ((float)roundf(sensorDewPoint * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals) -32) * 0.56f;
      } else {
        return (float)roundf(sensorDewPoint * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
      }
    }
    inline float getHeatIndexC() {
      if (UseCelsius) {
        return (float)roundf(sensorHeatIndex * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
      } else {
        return (float)roundf(sensorHeatIndex * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals) * 1.8f + 32;
      }
    }
    inline float getHeatIndexF() {
      if (UseCelsius) {
        return ((float)roundf(sensorHeatIndex * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals) -32) * 0.56f;
      } else {
        return (float)roundf(sensorHeatIndex * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
      }
    }
  // Publish Sensor Information to Info Page
  void addToJsonInfo(JsonObject &root)
  {
    JsonObject user = root[F("u")];
    if (user.isNull()) user = root.createNestedObject(F("u"));
    if (sensorType==0) //No Sensor
    {
      // if we sensor not detected, let the user know
      JsonArray temperature_json = user.createNestedArray(F("BME/BMP280 Sensor"));
      temperature_json.add(F("Not Found"));
    }
    else if (sensorType==2) //BMP280
    {
      JsonArray temperature_json = user.createNestedArray(F("Temperature"));
      JsonArray pressure_json = user.createNestedArray(F("Pressure"));
      temperature_json.add(roundf(sensorTemperature * powf(10, TemperatureDecimals)));
      temperature_json.add(tempScale);
      pressure_json.add(roundf(sensorPressure * powf(10, PressureDecimals)));
      pressure_json.add(F("hPa"));
    }
    else if (sensorType==1) //BME280
    {
      JsonArray temperature_json = user.createNestedArray(F("Temperature"));
      JsonArray humidity_json = user.createNestedArray(F("Humidity"));
      JsonArray pressure_json = user.createNestedArray(F("Pressure"));
      JsonArray heatindex_json = user.createNestedArray(F("Heat Index"));
      JsonArray dewpoint_json = user.createNestedArray(F("Dew Point"));
      temperature_json.add(roundf(sensorTemperature * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals));
      temperature_json.add(tempScale);
      humidity_json.add(roundf(sensorHumidity * powf(10, HumidityDecimals)));
      humidity_json.add(F("%"));
      pressure_json.add(roundf(sensorPressure * powf(10, PressureDecimals)));
      pressure_json.add(F("hPa"));
      heatindex_json.add(roundf(sensorHeatIndex * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals));
      heatindex_json.add(tempScale);
      dewpoint_json.add(roundf(sensorDewPoint * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals));
      dewpoint_json.add(tempScale);
    }
      return;
  }
  // Save Usermod Config Settings
  void addToConfig(JsonObject& root)
  {
    JsonObject top = root.createNestedObject(FPSTR(_name));
    top[FPSTR(_enabled)] = enabled;
    top[F("TemperatureDecimals")] = TemperatureDecimals;
    top[F("HumidityDecimals")] = HumidityDecimals;
    top[F("PressureDecimals")] = PressureDecimals;
    top[F("TemperatureInterval")] = TemperatureInterval;
    top[F("PressureInterval")] = PressureInterval;
    top[F("PublishAlways")] = PublishAlways;
    top[F("UseCelsius")] = UseCelsius;
    top[F("HomeAssistantDiscovery")] = HomeAssistantDiscovery;
    DEBUG_PRINTLN(F("BME280 config saved."));
  }
  // Read Usermod Config Settings
  bool readFromConfig(JsonObject& root)
  {
    // default settings values could be set here (or below using the 3-argument getJsonValue()) instead of in the class definition or constructor
    // setting them inside readFromConfig() is slightly more robust, handling the rare but plausible use case of single value being missing after boot (e.g. if the cfg.json was manually edited and a value was removed)
    JsonObject top = root[FPSTR(_name)];
    if (top.isNull()) {
      DEBUG_PRINT(F(_name));
      DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
      return false;
    }
    bool configComplete = !top.isNull();
    configComplete &= getJsonValue(top[FPSTR(_enabled)], enabled);
    // A 3-argument getJsonValue() assigns the 3rd argument as a default value if the Json value is missing
    configComplete &= getJsonValue(top[F("TemperatureDecimals")], TemperatureDecimals, 1);
    configComplete &= getJsonValue(top[F("HumidityDecimals")], HumidityDecimals, 0);
    configComplete &= getJsonValue(top[F("PressureDecimals")], PressureDecimals, 0);
    configComplete &= getJsonValue(top[F("TemperatureInterval")], TemperatureInterval, 30);
    configComplete &= getJsonValue(top[F("PressureInterval")], PressureInterval, 30);
    configComplete &= getJsonValue(top[F("PublishAlways")], PublishAlways, false);
    configComplete &= getJsonValue(top[F("UseCelsius")], UseCelsius, true);
    configComplete &= getJsonValue(top[F("HomeAssistantDiscovery")], HomeAssistantDiscovery, false);
    DEBUG_PRINT(FPSTR(_name));
    if (!initDone) {
      // first run: reading from cfg.json
      DEBUG_PRINTLN(F(" config loaded."));
    } else {
      DEBUG_PRINTLN(F(" config (re)loaded."));
      // changing parameters from settings page
    }
    return configComplete;
  }
  uint16_t getId() {
    return USERMOD_ID_BME280;
  }
 };
 const char UsermodBME280::_name[]                      PROGMEM = "BME280/BMP280";
 const char UsermodBME280::_enabled[]                   PROGMEM = "enabled";
--- a/usermods/Battery/assets/battery_info_screen.png
+++ b/usermods/Battery/assets/battery_info_screen.png
--- a/usermods/Battery/assets/battery_usermod_logo.png
+++ b/usermods/Battery/assets/battery_usermod_logo.png
--- a/usermods/Battery/battery_defaults.h
+++ b/usermods/Battery/battery_defaults.h
@ -1,81 +0,0 @@
 // pin defaults
 // for the esp32 it is best to use the ADC1: GPIO32 - GPIO39
 // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/adc.html
 #ifndef USERMOD_BATTERY_MEASUREMENT_PIN
  #ifdef ARDUINO_ARCH_ESP32
    #define USERMOD_BATTERY_MEASUREMENT_PIN 35
  #else //ESP8266 boards
    #define USERMOD_BATTERY_MEASUREMENT_PIN A0
  #endif
 #endif
 // the frequency to check the battery, 30 sec
 #ifndef USERMOD_BATTERY_MEASUREMENT_INTERVAL
  #define USERMOD_BATTERY_MEASUREMENT_INTERVAL 30000
 #endif
 // default for 18650 battery
 // https://batterybro.com/blogs/18650-wholesale-battery-reviews/18852515-when-to-recycle-18650-batteries-and-how-to-start-a-collection-center-in-your-vape-shop
 // Discharge voltage: 2.5 volt + .1 for personal safety
 #ifndef USERMOD_BATTERY_MIN_VOLTAGE
  #ifdef USERMOD_BATTERY_USE_LIPO
    // LiPo "1S" Batteries should not be dischared below 3V !!
    #define USERMOD_BATTERY_MIN_VOLTAGE 3.2f
  #else
    #define USERMOD_BATTERY_MIN_VOLTAGE 2.6f
  #endif
 #endif
 //the default ratio for the voltage divider
 #ifndef USERMOD_BATTERY_VOLTAGE_MULTIPLIER
  #ifdef ARDUINO_ARCH_ESP32
    #define USERMOD_BATTERY_VOLTAGE_MULTIPLIER 2.0f
  #else //ESP8266 boards
    #define USERMOD_BATTERY_VOLTAGE_MULTIPLIER 4.2f
  #endif
 #endif
 #ifndef USERMOD_BATTERY_MAX_VOLTAGE
  #define USERMOD_BATTERY_MAX_VOLTAGE 4.2f
 #endif
 // a common capacity for single 18650 battery cells is between 2500 and 3600 mAh
 #ifndef USERMOD_BATTERY_TOTAL_CAPACITY
  #define USERMOD_BATTERY_TOTAL_CAPACITY 3100
 #endif
 // offset or calibration value to fine tune the calculated voltage
 #ifndef USERMOD_BATTERY_CALIBRATION
  #define USERMOD_BATTERY_CALIBRATION 0
 #endif
 // calculate remaining time / the time that is left before the battery runs out of power
 // #ifndef USERMOD_BATTERY_CALCULATE_TIME_LEFT_ENABLED
 //   #define USERMOD_BATTERY_CALCULATE_TIME_LEFT_ENABLED false
 // #endif
 // auto-off feature
 #ifndef USERMOD_BATTERY_AUTO_OFF_ENABLED
  #define USERMOD_BATTERY_AUTO_OFF_ENABLED true
 #endif
 #ifndef USERMOD_BATTERY_AUTO_OFF_THRESHOLD
  #define USERMOD_BATTERY_AUTO_OFF_THRESHOLD 10
 #endif
 // low power indication feature
 #ifndef USERMOD_BATTERY_LOW_POWER_INDICATOR_ENABLED
  #define USERMOD_BATTERY_LOW_POWER_INDICATOR_ENABLED true
 #endif
 #ifndef USERMOD_BATTERY_LOW_POWER_INDICATOR_PRESET
  #define USERMOD_BATTERY_LOW_POWER_INDICATOR_PRESET 0
 #endif
 #ifndef USERMOD_BATTERY_LOW_POWER_INDICATOR_THRESHOLD
  #define USERMOD_BATTERY_LOW_POWER_INDICATOR_THRESHOLD 20
 #endif
 #ifndef USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION
  #define USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION 5
 #endif
--- a/usermods/Battery/readme.md
+++ b/usermods/Battery/readme.md
@ -1,112 +0,0 @@
 <p align="center">
  <img width="700" src="assets/battery_usermod_logo.png">
 </p>
 # Welcome to the battery usermod! 🔋
 Enables battery level monitoring of your project.
 For this to work, the positive side of the (18650) battery must be connected to pin `A0` of the d1 mini/esp8266 with a 100k Ohm resistor (see [Useful Links](#useful-links)).
 If you have an ESP32 board, connect the positive side of the battery to ADC1 (GPIO32 - GPIO39)
 <p align="center">
  <img width="500" src="assets/battery_info_screen.png">
 </p>
 ## ⚙️ Features
 - 💯 Displays current battery voltage 
 - 🚥 Displays battery level
 - 🚫 Auto-off with configurable Threshold
 - 🚨 Low power indicator with many configuration posibilities
 ## 🎈 Installation
 define `USERMOD_BATTERY` in `wled00/my_config.h`
 ### Example wiring
 <p align="center">
  <img width="300" src="assets/battery_connection_schematic_01.png">
 </p>
 ### Define Your Options
 | Name                                            | Unit        | Description                                                                           |
 | ----------------------------------------------- | ----------- |-------------------------------------------------------------------------------------- |
 | `USERMOD_BATTERY`                               |             | define this (in `my_config.h`) to have this usermod included wled00\usermods_list.cpp |
 | `USERMOD_BATTERY_USE_LIPO`                      |             | define this (in `my_config.h`) if you use LiPo rechargeables (1S)                     |
 | `USERMOD_BATTERY_MEASUREMENT_PIN`               |             | defaults to A0 on ESP8266 and GPIO35 on ESP32                                         |
 | `USERMOD_BATTERY_MEASUREMENT_INTERVAL`          | ms          | battery check interval. defaults to 30 seconds                                        |
 | `USERMOD_BATTERY_MIN_VOLTAGE`                   | v           | minimum battery voltage. default is 2.6 (18650 battery standard)                      |
 | `USERMOD_BATTERY_MAX_VOLTAGE`                   | v           | maximum battery voltage. default is 4.2 (18650 battery standard)                      |
 | `USERMOD_BATTERY_TOTAL_CAPACITY`                | mAh         | the capacity of all cells in parralel sumed up                                        |
 | `USERMOD_BATTERY_CALIBRATION`                   |             | offset / calibration number, fine tune the measured voltage by the microcontroller    |
 | Auto-Off                                        | ---         | ---                                                                                   |
 | `USERMOD_BATTERY_AUTO_OFF_ENABLED`              | true/false  | enables auto-off                                                                      |
 | `USERMOD_BATTERY_AUTO_OFF_THRESHOLD`            | % (0-100)   | when this threshold is reached master power turns off                                 |
 | Low-Power-Indicator                             | ---         | ---                                                                                   |
 | `USERMOD_BATTERY_LOW_POWER_INDICATOR_ENABLED`   | true/false  | enables low power indication                                                          |
 | `USERMOD_BATTERY_LOW_POWER_INDICATOR_PRESET`    | preset id   | when low power is detected then use this preset to indicate low power                 |
 | `USERMOD_BATTERY_LOW_POWER_INDICATOR_THRESHOLD` | % (0-100)   | when this threshold is reached low power gets indicated                               |
 | `USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION`  | seconds     | for this long the configured preset is played                                         |
 All parameters can be configured at runtime via the Usermods settings page.
 ## ⚠️ Important
 - Make sure you know your battery specifications! All batteries are **NOT** the same!
 - Example:
 | Your battery specification table  |                 | Options you can define        | 
 | :-------------------------------- |:--------------- | :---------------------------- |
 | Capacity                          | 3500mAh 12,5 Wh |                               |
 | Minimum capacity                  | 3350mAh 11,9 Wh |                               |
 | Rated voltage                     | 3.6V - 3.7V     |                               |
 | **Charging end voltage**          | **4,2V ± 0,05** | `USERMOD_BATTERY_MAX_VOLTAGE` |
 | **Discharge voltage**             | **2,5V**        | `USERMOD_BATTERY_MIN_VOLTAGE` |
 | Max. discharge current (constant) | 10A (10000mA)   |                               |
 | max. charging current             | 1.7A (1700mA)   |                               |
 | ...                               | ...             | ...                           |
 | ..                                | ..              | ..                            |
 Specification from:  [Molicel INR18650-M35A, 3500mAh 10A Lithium-ion battery, 3.6V - 3.7V](https://www.akkuteile.de/lithium-ionen-akkus/18650/molicel/molicel-inr18650-m35a-3500mah-10a-lithium-ionen-akku-3-6v-3-7v_100833)
 ## 🌐 Useful Links
 - https://lazyzero.de/elektronik/esp8266/wemos_d1_mini_a0/start
 - https://arduinodiy.wordpress.com/2016/12/25/monitoring-lipo-battery-voltage-with-wemos-d1-minibattery-shield-and-thingspeak/
 ## 📝 Change Log
 2023-01-04
 - basic support for LiPo rechargeable batteries ( `-D USERMOD_BATTERY_USE_LIPO`)
 - improved support for esp32 (read calibrated voltage)
 - corrected config saving (measurement pin, and battery min/max were lost)
 - various bugfixes
 2022-12-25
 - added "auto-off" feature
 - added "low-power-indication" feature
 - added "calibration/offset" field to configuration page
 - added getter and setter, so that user usermods could interact with this one
 - update readme (added new options, made it markdownlint compliant)
 2021-09-02
 - added "Battery voltage" to info
 - added circuit diagram to readme
 - added MQTT support, sending battery voltage
 - minor fixes
 2021-08-15
 - changed `USERMOD_BATTERY_MIN_VOLTAGE` to 2.6 volt as default for 18650 batteries
 - Updated readme, added specification table
 2021-08-10
 - Created
--- a/usermods/Battery/usermod_v2_Battery.h
+++ b/usermods/Battery/usermod_v2_Battery.h
@ -1,787 +0,0 @@
 #pragma once
 #include "wled.h"
 #include "battery_defaults.h"
 /*
 * Usermod by Maximilian Mewes
 * Mail: mewes.maximilian@gmx.de
 * GitHub: itCarl
 * Date: 25.12.2022
 * If you have any questions, please feel free to contact me.
 */
 class UsermodBattery : public Usermod 
 {
  private:
    // battery pin can be defined in my_config.h
    int8_t batteryPin = USERMOD_BATTERY_MEASUREMENT_PIN;
    // how often to read the battery voltage
    unsigned long readingInterval = USERMOD_BATTERY_MEASUREMENT_INTERVAL;
    unsigned long nextReadTime = 0;
    unsigned long lastReadTime = 0;
    // battery min. voltage
    float minBatteryVoltage = USERMOD_BATTERY_MIN_VOLTAGE;
    // battery max. voltage
    float maxBatteryVoltage = USERMOD_BATTERY_MAX_VOLTAGE;
    // all battery cells summed up
    unsigned int totalBatteryCapacity = USERMOD_BATTERY_TOTAL_CAPACITY;
    // raw analog reading 
    float rawValue = 0.0f;
    // calculated voltage            
    float voltage = maxBatteryVoltage;
    // between 0 and 1, to control strength of voltage smoothing filter
    float alpha = 0.05f;
    // multiplier for the voltage divider that is in place between ADC pin and battery, default will be 2 but might be adapted to readout voltages over ~5v ESP32 or ~6.6v ESP8266
    float voltageMultiplier = USERMOD_BATTERY_VOLTAGE_MULTIPLIER;
    // mapped battery level based on voltage
    int8_t batteryLevel = 100;
    // offset or calibration value to fine tune the calculated voltage
    float calibration = USERMOD_BATTERY_CALIBRATION;
    // time left estimation feature
    // bool calculateTimeLeftEnabled = USERMOD_BATTERY_CALCULATE_TIME_LEFT_ENABLED;
    // float estimatedTimeLeft = 0.0;
    // auto shutdown/shutoff/master off feature
    bool autoOffEnabled = USERMOD_BATTERY_AUTO_OFF_ENABLED;
    int8_t autoOffThreshold = USERMOD_BATTERY_AUTO_OFF_THRESHOLD;
    // low power indicator feature
    bool lowPowerIndicatorEnabled = USERMOD_BATTERY_LOW_POWER_INDICATOR_ENABLED;
    int8_t lowPowerIndicatorPreset = USERMOD_BATTERY_LOW_POWER_INDICATOR_PRESET;
    int8_t lowPowerIndicatorThreshold = USERMOD_BATTERY_LOW_POWER_INDICATOR_THRESHOLD;
    int8_t lowPowerIndicatorReactivationThreshold = lowPowerIndicatorThreshold+10;
    int8_t lowPowerIndicatorDuration = USERMOD_BATTERY_LOW_POWER_INDICATOR_DURATION;
    bool lowPowerIndicationDone = false;
    unsigned long lowPowerActivationTime = 0; // used temporary during active time
    int8_t lastPreset = 0;
    bool initDone = false;
    bool initializing = true;
    // strings to reduce flash memory usage (used more than twice)
    static const char _name[];
    static const char _readInterval[];
    static const char _enabled[];
    static const char _threshold[];
    static const char _preset[];
    static const char _duration[];
    static const char _init[];
    // custom map function
    // https://forum.arduino.cc/t/floating-point-using-map-function/348113/2
    double mapf(double x, double in_min, double in_max, double out_min, double out_max) 
    {
      return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
    }
    float dot2round(float x) 
    {
      float nx = (int)(x * 100 + .5);
      return (float)(nx / 100);
    }
    /*
     * Turn off all leds
     */
    void turnOff()
    {
      bri = 0;
      stateUpdated(CALL_MODE_DIRECT_CHANGE);
    }
    /*
     * Indicate low power by activating a configured preset for a given time and then switching back to the preset that was selected previously
     */
    void lowPowerIndicator()
    {
      if (!lowPowerIndicatorEnabled) return;
      if (batteryPin < 0) return;  // no measurement
      if (lowPowerIndicationDone && lowPowerIndicatorReactivationThreshold <= batteryLevel) lowPowerIndicationDone = false;
      if (lowPowerIndicatorThreshold <= batteryLevel) return;
      if (lowPowerIndicationDone) return;
      if (lowPowerActivationTime <= 1) {
        lowPowerActivationTime = millis();
        lastPreset = currentPreset;
        applyPreset(lowPowerIndicatorPreset);
      }
      if (lowPowerActivationTime+(lowPowerIndicatorDuration*1000) <= millis()) {
        lowPowerIndicationDone = true;
        lowPowerActivationTime = 0;
        applyPreset(lastPreset);
      }      
    }
    float readVoltage()
    {
      #ifdef ARDUINO_ARCH_ESP32
        // use calibrated millivolts analogread on esp32 (150 mV ~ 2450 mV default attentuation) and divide by 1000 to get from milivolts to volts and multiply by voltage multiplier and apply calibration value
        return (analogReadMilliVolts(batteryPin) / 1000.0f) * voltageMultiplier  + calibration;
      #else
        // use analog read on esp8266 ( 0V ~ 1V no attenuation options) and divide by ADC precision 1023 and multiply by voltage multiplier and apply calibration value
        return (analogRead(batteryPin) / 1023.0f) * voltageMultiplier + calibration;
      #endif
    }
  public:
    //Functions called by WLED
    /*
     * setup() is called once at boot. WiFi is not yet connected at this point.
     * You can use it to initialize variables, sensors or similar.
     */
    void setup() 
    {
      #ifdef ARDUINO_ARCH_ESP32
        bool success = false;
        DEBUG_PRINTLN(F("Allocating battery pin..."));
        if (batteryPin >= 0 && digitalPinToAnalogChannel(batteryPin) >= 0) 
          if (pinManager.allocatePin(batteryPin, false, PinOwner::UM_Battery)) {
            DEBUG_PRINTLN(F("Battery pin allocation succeeded."));
            success = true;
            voltage = readVoltage();
          }
        if (!success) {
          DEBUG_PRINTLN(F("Battery pin allocation failed."));
          batteryPin = -1;  // allocation failed
        } else {
          pinMode(batteryPin, INPUT);
        }
      #else //ESP8266 boards have only one analog input pin A0
        pinMode(batteryPin, INPUT);
        voltage = readVoltage();
      #endif
      nextReadTime = millis() + readingInterval;
      lastReadTime = millis();
      initDone = true;
    }
    /*
     * connected() is called every time the WiFi is (re)connected
     * Use it to initialize network interfaces
     */
    void connected() 
    {
      //Serial.println("Connected to WiFi!");
    }
    /*
     * loop() is called continuously. Here you can check for events, read sensors, etc.
     * 
     */
    void loop() 
    {
      if(strip.isUpdating()) return;
      lowPowerIndicator();
      // check the battery level every USERMOD_BATTERY_MEASUREMENT_INTERVAL (ms)
      if (millis() < nextReadTime) return;
      nextReadTime = millis() + readingInterval;
      lastReadTime = millis();
      if (batteryPin < 0) return;  // nothing to read
      initializing = false;
      rawValue = readVoltage();
      // filter with exponential smoothing because ADC in esp32 is fluctuating too much for a good single readout
      voltage = voltage + alpha * (rawValue - voltage);
      // check if voltage is within specified voltage range, allow 10% over/under voltage - removed cause this just makes it hard for people to troubleshoot as the voltage in the web gui will say invalid instead of displaying a voltage
      //voltage = ((voltage < minBatteryVoltage * 0.85f) || (voltage > maxBatteryVoltage * 1.1f)) ? -1.0f : voltage;
      // translate battery voltage into percentage
      /*
        the standard "map" function doesn't work
        https://www.arduino.cc/reference/en/language/functions/math/map/  notes and warnings at the bottom
      */
      #ifdef USERMOD_BATTERY_USE_LIPO
        batteryLevel = mapf(voltage, minBatteryVoltage, maxBatteryVoltage, 0, 100); // basic mapping
        // LiPo batteries have a differnt dischargin curve, see 
        //  https://blog.ampow.com/lipo-voltage-chart/
        if (batteryLevel < 40.0f) 
          batteryLevel = mapf(batteryLevel, 0, 40, 0, 12);       // last 45% -> drops very quickly
        else {
          if (batteryLevel < 90.0f)
            batteryLevel = mapf(batteryLevel, 40, 90, 12, 95);   // 90% ... 40% -> almost linear drop
          else // level >  90%
            batteryLevel = mapf(batteryLevel, 90, 105, 95, 100); // highest 15% -> drop slowly
        }
      #else
        batteryLevel = mapf(voltage, minBatteryVoltage, maxBatteryVoltage, 0, 100);
      #endif
      if (voltage > -1.0f) batteryLevel = constrain(batteryLevel, 0.0f, 110.0f);
      // if (calculateTimeLeftEnabled) {
      //   float currentBatteryCapacity = totalBatteryCapacity;
      //   estimatedTimeLeft = (currentBatteryCapacity/strip.currentMilliamps)*60;
      // }
      // Auto off -- Master power off
      if (autoOffEnabled && (autoOffThreshold >= batteryLevel))
        turnOff();
 #ifndef WLED_DISABLE_MQTT
      // SmartHome stuff
      // still don't know much about MQTT and/or HA
      if (WLED_MQTT_CONNECTED) {
        char buf[64]; // buffer for snprintf()
        snprintf_P(buf, 63, PSTR("%s/voltage"), mqttDeviceTopic);
        mqtt->publish(buf, 0, false, String(voltage).c_str());
      }
 #endif
    }
    /*
     * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
     * Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
     * Below it is shown how this could be used for e.g. a light sensor
     */
    void addToJsonInfo(JsonObject& root)
    {
      JsonObject user = root["u"];
      if (user.isNull()) user = root.createNestedObject("u");
      if (batteryPin < 0) {
        JsonArray infoVoltage = user.createNestedArray(F("Battery voltage"));
        infoVoltage.add(F("n/a"));
        infoVoltage.add(F(" invalid GPIO"));
        return;  // no GPIO - nothing to report
      }
      // info modal display names
      JsonArray infoPercentage = user.createNestedArray(F("Battery level"));
      JsonArray infoVoltage = user.createNestedArray(F("Battery voltage"));
      // if (calculateTimeLeftEnabled)
      // {
      //   JsonArray infoEstimatedTimeLeft = user.createNestedArray(F("Estimated time left"));
      //   if (initializing) {
      //     infoEstimatedTimeLeft.add(FPSTR(_init));
      //   } else {
      //     infoEstimatedTimeLeft.add(estimatedTimeLeft);
      //     infoEstimatedTimeLeft.add(F(" min"));
      //   }
      // }
      JsonArray infoNextUpdate = user.createNestedArray(F("Next update"));
      infoNextUpdate.add((nextReadTime - millis()) / 1000);
      infoNextUpdate.add(F(" sec"));
      if (initializing) {
        infoPercentage.add(FPSTR(_init));
        infoVoltage.add(FPSTR(_init));
        return;
      }
      if (batteryLevel < 0) {
        infoPercentage.add(F("invalid"));
      } else {
        infoPercentage.add(batteryLevel);
      }
      infoPercentage.add(F(" %"));
      if (voltage < 0) {
        infoVoltage.add(F("invalid"));
      } else {
        infoVoltage.add(dot2round(voltage));
      }
      infoVoltage.add(F(" V"));
    }
    /*
     * 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)
    {
    }
    */
    /*
     * 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)
    {
    }
    */
    /*
     * addToConfig() can be used to add custom persistent settings to the cfg.json file in the "um" (usermod) object.
     * It will be called by WLED when settings are actually saved (for example, LED settings are saved)
     * If you want to force saving the current state, use serializeConfig() in your loop().
     * 
     * CAUTION: serializeConfig() will initiate a filesystem write operation.
     * It might cause the LEDs to stutter and will cause flash wear if called too often.
     * Use it sparingly and always in the loop, never in network callbacks!
     * 
     * addToConfig() will make your settings editable through the Usermod Settings page automatically.
     *
     * Usermod Settings Overview:
     * - Numeric values are treated as floats in the browser.
     *   - If the numeric value entered into the browser contains a decimal point, it will be parsed as a C float
     *     before being returned to the Usermod.  The float data type has only 6-7 decimal digits of precision, and
     *     doubles are not supported, numbers will be rounded to the nearest float value when being parsed.
     *     The range accepted by the input field is +/- 1.175494351e-38 to +/- 3.402823466e+38.
     *   - If the numeric value entered into the browser doesn't contain a decimal point, it will be parsed as a
     *     C int32_t (range: -2147483648 to 2147483647) before being returned to the usermod.
     *     Overflows or underflows are truncated to the max/min value for an int32_t, and again truncated to the type
     *     used in the Usermod when reading the value from ArduinoJson.
     * - Pin values can be treated differently from an integer value by using the key name "pin"
     *   - "pin" can contain a single or array of integer values
     *   - On the Usermod Settings page there is simple checking for pin conflicts and warnings for special pins
     *     - Red color indicates a conflict.  Yellow color indicates a pin with a warning (e.g. an input-only pin)
     *   - Tip: use int8_t to store the pin value in the Usermod, so a -1 value (pin not set) can be used
     *
     * See usermod_v2_auto_save.h for an example that saves Flash space by reusing ArduinoJson key name strings
     * 
     * If you need a dedicated settings page with custom layout for your Usermod, that takes a lot more work.  
     * You will have to add the setting to the HTML, xml.cpp and set.cpp manually.
     * See the WLED Soundreactive fork (code and wiki) for reference.  https://github.com/atuline/WLED
     * 
     * I highly recommend checking out the basics of ArduinoJson serialization and deserialization in order to use custom settings!
     */
    void addToConfig(JsonObject& root)
    {
      JsonObject battery = root.createNestedObject(FPSTR(_name));           // usermodname
      #ifdef ARDUINO_ARCH_ESP32
        battery[F("pin")] = batteryPin;
      #endif
      // battery[F("time-left")] = calculateTimeLeftEnabled;
      battery[F("min-voltage")] = minBatteryVoltage;
      battery[F("max-voltage")] = maxBatteryVoltage;
      battery[F("capacity")] = totalBatteryCapacity;
      battery[F("calibration")] = calibration;
      battery[F("voltage-multiplier")] = voltageMultiplier;
      battery[FPSTR(_readInterval)] = readingInterval;
      JsonObject ao = battery.createNestedObject(F("auto-off"));               // auto off section
      ao[FPSTR(_enabled)] = autoOffEnabled;
      ao[FPSTR(_threshold)] = autoOffThreshold;
      JsonObject lp = battery.createNestedObject(F("indicator"));    // low power section
      lp[FPSTR(_enabled)] = lowPowerIndicatorEnabled;
      lp[FPSTR(_preset)] = lowPowerIndicatorPreset; // dropdown trickery (String)lowPowerIndicatorPreset; 
      lp[FPSTR(_threshold)] = lowPowerIndicatorThreshold;
      lp[FPSTR(_duration)] = lowPowerIndicatorDuration;
      // read voltage in case calibration or voltage multiplier changed to see immediate effect
      voltage = readVoltage();
      DEBUG_PRINTLN(F("Battery config saved."));
    }
    void appendConfigData()
    {
      oappend(SET_F("addInfo('Battery:min-voltage', 1, 'v');"));
      oappend(SET_F("addInfo('Battery:max-voltage', 1, 'v');"));
      oappend(SET_F("addInfo('Battery:capacity', 1, 'mAh');"));
      oappend(SET_F("addInfo('Battery:interval', 1, 'ms');"));
      oappend(SET_F("addInfo('Battery:auto-off:threshold', 1, '%');"));
      oappend(SET_F("addInfo('Battery:indicator:threshold', 1, '%');"));
      oappend(SET_F("addInfo('Battery:indicator:duration', 1, 's');"));
      // cannot quite get this mf to work. its exeeding some buffer limit i think
      // what i wanted is 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);"));
      // for(int8_t i=1; i < 42; i++) {
      //   oappend(SET_F("addOption(bd, 'Preset#"));
      //   oappendi(i);
      //   oappend(SET_F("',"));
      //   oappendi(i);
      //   oappend(SET_F(");"));
      // }
    }
    /*
     * readFromConfig() can be used to read back the custom settings you added with addToConfig().
     * This is called by WLED when settings are loaded (currently this only happens immediately after boot, or after saving on the Usermod Settings page)
     * 
     * readFromConfig() is called BEFORE setup(). This means you can use your persistent values in setup() (e.g. pin assignments, buffer sizes),
     * but also that if you want to write persistent values to a dynamic buffer, you'd need to allocate it here instead of in setup.
     * If you don't know what that is, don't fret. It most likely doesn't affect your use case :)
     * 
     * Return true in case the config values returned from Usermod Settings were complete, or false if you'd like WLED to save your defaults to disk (so any missing values are editable in Usermod Settings)
     * 
     * getJsonValue() returns false if the value is missing, or copies the value into the variable provided and returns true if the value is present
     * The configComplete variable is true only if the "exampleUsermod" object and all values are present.  If any values are missing, WLED will know to call addToConfig() to save them
     * 
     * This function is guaranteed to be called on boot, but could also be called every time settings are updated
     */
    bool readFromConfig(JsonObject& root)
    {
      #ifdef ARDUINO_ARCH_ESP32
        int8_t newBatteryPin = batteryPin;
      #endif
      JsonObject battery = root[FPSTR(_name)];
      if (battery.isNull()) 
      {
        DEBUG_PRINT(FPSTR(_name));
        DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
        return false;
      }
      #ifdef ARDUINO_ARCH_ESP32
        newBatteryPin     = battery[F("pin")] | newBatteryPin;
      #endif
      // calculateTimeLeftEnabled = battery[F("time-left")] | calculateTimeLeftEnabled;
      setMinBatteryVoltage(battery[F("min-voltage")] | minBatteryVoltage);
      setMaxBatteryVoltage(battery[F("max-voltage")] | maxBatteryVoltage);
      setTotalBatteryCapacity(battery[F("capacity")] | totalBatteryCapacity);
      setCalibration(battery[F("calibration")] | calibration);
      setVoltageMultiplier(battery[F("voltage-multiplier")] | voltageMultiplier);
      setReadingInterval(battery[FPSTR(_readInterval)] | readingInterval);
      JsonObject ao = battery[F("auto-off")];
      setAutoOffEnabled(ao[FPSTR(_enabled)] | autoOffEnabled);
      setAutoOffThreshold(ao[FPSTR(_threshold)] | autoOffThreshold);
      JsonObject lp = battery[F("indicator")];
      setLowPowerIndicatorEnabled(lp[FPSTR(_enabled)] | lowPowerIndicatorEnabled);
      setLowPowerIndicatorPreset(lp[FPSTR(_preset)] | lowPowerIndicatorPreset); // dropdown trickery (int)lp["preset"]
      setLowPowerIndicatorThreshold(lp[FPSTR(_threshold)] | lowPowerIndicatorThreshold);
      lowPowerIndicatorReactivationThreshold = lowPowerIndicatorThreshold+10;
      setLowPowerIndicatorDuration(lp[FPSTR(_duration)] | lowPowerIndicatorDuration);
      DEBUG_PRINT(FPSTR(_name));
      #ifdef ARDUINO_ARCH_ESP32
        if (!initDone) 
        {
          // first run: reading from cfg.json
          batteryPin = newBatteryPin;
          DEBUG_PRINTLN(F(" config loaded."));
        } 
        else 
        {
          DEBUG_PRINTLN(F(" config (re)loaded."));
          // changing parameters from settings page
          if (newBatteryPin != batteryPin) 
          {
            // deallocate pin
            pinManager.deallocatePin(batteryPin, PinOwner::UM_Battery);
            batteryPin = newBatteryPin;
            // initialise
            setup();
          }
        }
      #endif
      return !battery[FPSTR(_readInterval)].isNull();
    }
    /*
     * Generate a preset sample for low power indication 
     */
    void generateExamplePreset()
    {
      // StaticJsonDocument<300> j;
      // JsonObject preset = j.createNestedObject();
      // preset["mainseg"] = 0;
      // JsonArray seg = preset.createNestedArray("seg");
      // JsonObject seg0 = seg.createNestedObject();
      // seg0["id"] = 0;
      // seg0["start"] = 0;
      // seg0["stop"] = 60;
      // seg0["grp"] = 0;
      // seg0["spc"] = 0;
      // seg0["on"] = true;
      // seg0["bri"] = 255;
      // JsonArray col0 = seg0.createNestedArray("col");
      // JsonArray col00 = col0.createNestedArray();
      // col00.add(255);
      // col00.add(0);
      // col00.add(0);
      // seg0["fx"] = 1;
      // seg0["sx"] = 128;
      // seg0["ix"] = 128;
      // savePreset(199, "Low power Indicator", preset);
    }
    /*
     *
     * Getter and Setter. Just in case some other usermod wants to interact with this in the future
     *
     */
    /*
     * getId() allows you to optionally give your V2 usermod an unique ID (please define it in const.h!).
     * This could be used in the future for the system to determine whether your usermod is installed.
     */
    uint16_t getId()
    {
      return USERMOD_ID_BATTERY;
    }
    unsigned long getReadingInterval()
    {
      return readingInterval;
    }
    /*
     * minimum repetition is 3000ms (3s) 
     */
    void setReadingInterval(unsigned long newReadingInterval)
    {
      readingInterval = max((unsigned long)3000, newReadingInterval);
    }
    /*
     * Get lowest configured battery voltage
     */
    float getMinBatteryVoltage()
    {
      return minBatteryVoltage;
    }
    /*
     * Set lowest battery voltage
     * can't be below 0 volt
     */
    void setMinBatteryVoltage(float voltage)
    {
      minBatteryVoltage = max(0.0f, voltage);
    }
    /*
     * Get highest configured battery voltage
     */
    float getMaxBatteryVoltage()
    {
      return maxBatteryVoltage;
    }
    /*
     * Set highest battery voltage
     * can't be below minBatteryVoltage
     */
    void setMaxBatteryVoltage(float voltage)
    {
      #ifdef USERMOD_BATTERY_USE_LIPO
        maxBatteryVoltage = max(getMinBatteryVoltage()+0.7f, voltage);
      #else
        maxBatteryVoltage = max(getMinBatteryVoltage()+1.0f, voltage);
      #endif
    }
    /*
     * Get the capacity of all cells in parralel sumed up
     * unit: mAh
     */
    unsigned int getTotalBatteryCapacity()
    {
      return totalBatteryCapacity;
    }
    void setTotalBatteryCapacity(unsigned int capacity)
    {
      totalBatteryCapacity = capacity;
    }
    /*
     * Get the calculated voltage
     * formula: (adc pin value / adc precision * max voltage) + calibration
     */
    float getVoltage()
    {
      return voltage;
    }
    /*
     * Get the mapped battery level (0 - 100) based on voltage
     * important: voltage can drop when a load is applied, so its only an estimate
     */
    int8_t getBatteryLevel()
    {
      return batteryLevel;
    }
    /*
     * Get the configured calibration value
     * a offset value to fine-tune the calculated voltage.
     */
    float getCalibration()
    {
      return calibration;
    }
    /*
     * Set the voltage calibration offset value
     * a offset value to fine-tune the calculated voltage.
     */
    void setCalibration(float offset)
    {
      calibration = offset;
    }
    /*
     * Set the voltage multiplier value
     * A multiplier that may need adjusting for different voltage divider setups
     */
    void setVoltageMultiplier(float multiplier)
    {
      voltageMultiplier = multiplier;
    }
    /*
     * Get the voltage multiplier value
     * A multiplier that may need adjusting for different voltage divider setups
     */
    float getVoltageMultiplier()
    {
      return voltageMultiplier;
    }
    /*
     * Get auto-off feature enabled status
     * is auto-off enabled, true/false
     */
    bool getAutoOffEnabled()
    {
      return autoOffEnabled;
    }
    /*
     * Set auto-off feature status 
     */
    void setAutoOffEnabled(bool enabled)
    {
      autoOffEnabled = enabled;
    }
    /*
     * Get auto-off threshold in percent (0-100)
     */
    int8_t getAutoOffThreshold()
    {
      return autoOffThreshold;
    }
    /*
     * Set auto-off threshold in percent (0-100) 
     */
    void setAutoOffThreshold(int8_t threshold)
    {
      autoOffThreshold = min((int8_t)100, max((int8_t)0, threshold));
      // when low power indicator is enabled the auto-off threshold cannot be above indicator threshold
      autoOffThreshold  = lowPowerIndicatorEnabled /*&& autoOffEnabled*/ ? min(lowPowerIndicatorThreshold-1, (int)autoOffThreshold) : autoOffThreshold;
    }
    /*
     * Get low-power-indicator feature enabled status
     * is the low-power-indicator enabled, true/false
     */
    bool getLowPowerIndicatorEnabled()
    {
      return lowPowerIndicatorEnabled;
    }
    /*
     * Set low-power-indicator feature status 
     */
    void setLowPowerIndicatorEnabled(bool enabled)
    {
      lowPowerIndicatorEnabled = enabled;
    }
    /*
     * Get low-power-indicator preset to activate when low power is detected
     */
    int8_t getLowPowerIndicatorPreset()
    {
      return lowPowerIndicatorPreset;
    }
    /* 
     * Set low-power-indicator preset to activate when low power is detected
     */
    void setLowPowerIndicatorPreset(int8_t presetId)
    {
      // String tmp = ""; For what ever reason this doesn't work :(
      // lowPowerIndicatorPreset = getPresetName(presetId, tmp) ? presetId : lowPowerIndicatorPreset;
      lowPowerIndicatorPreset = presetId;
    }
    /*
     * Get low-power-indicator threshold in percent (0-100)
     */
    int8_t getLowPowerIndicatorThreshold()
    {
      return lowPowerIndicatorThreshold;
    }
    /*
     * Set low-power-indicator threshold in percent (0-100)
     */
    void setLowPowerIndicatorThreshold(int8_t threshold)
    {
      lowPowerIndicatorThreshold = threshold;
      // when auto-off is enabled the indicator threshold cannot be below auto-off threshold
      lowPowerIndicatorThreshold  = autoOffEnabled /*&& lowPowerIndicatorEnabled*/ ? max(autoOffThreshold+1, (int)lowPowerIndicatorThreshold) : max(5, (int)lowPowerIndicatorThreshold);
    }
    /*
     * Get low-power-indicator duration in seconds
     */
    int8_t getLowPowerIndicatorDuration()
    {
      return lowPowerIndicatorDuration;
    }
    /*
     * Set low-power-indicator duration in seconds
     */
    void setLowPowerIndicatorDuration(int8_t duration)
    {
      lowPowerIndicatorDuration = duration;
    }
    /*
     * Get low-power-indicator status when the indication is done thsi returns true
     */
    bool getLowPowerIndicatorDone()
    {
      return lowPowerIndicationDone;
    }
 };
 // strings to reduce flash memory usage (used more than twice)
 const char UsermodBattery::_name[]          PROGMEM = "Battery";
 const char UsermodBattery::_readInterval[]  PROGMEM = "interval";
 const char UsermodBattery::_enabled[]       PROGMEM = "enabled";
 const char UsermodBattery::_threshold[]     PROGMEM = "threshold";
 const char UsermodBattery::_preset[]        PROGMEM = "preset";
 const char UsermodBattery::_duration[]      PROGMEM = "duration";
 const char UsermodBattery::_init[]          PROGMEM = "init";
--- a/usermods/Cronixie/readme.md
+++ b/usermods/Cronixie/readme.md
@ -1,8 +0,0 @@
 # Cronixie clock usermod
 This usermod supports driving the Cronixie M and L clock kits by Diamex.
 ## Installation 
 Compile and upload after adding `-D USERMOD_CRONIXIE` to `build_flags` of your PlatformIO environment.  
 Make sure the Auto Brightness Limiter is enabled at 420mA (!) and configure 60 WS281x LEDs.
--- a/usermods/Cronixie/usermod_cronixie.h
+++ b/usermods/Cronixie/usermod_cronixie.h
@ -1,302 +0,0 @@
 #pragma once
 #include "wled.h"
 class UsermodCronixie : public Usermod {
  private:
    unsigned long lastTime = 0;
    char cronixieDisplay[7] = "HHMMSS";
    byte _digitOut[6] = {10,10,10,10,10,10};
    byte dP[6] = {255, 255, 255, 255, 255, 255};
    // set your config variables to their boot default value (this can also be done in readFromConfig() or a constructor if you prefer)
    bool backlight = true;
  public:
    void initCronixie()
    {
      if (dP[0] == 255) // if dP[0] is 255, cronixie is not yet init'ed
      {
        setCronixie();
        strip.getSegment(0).grouping = 10; // 10 LEDs per digit
      }
    }
    void setup() {
    }
    void loop() {
      if (!toki.isTick()) return;
      initCronixie();
      _overlayCronixie();
      strip.trigger();
    }
    byte getSameCodeLength(char code, int index, char const cronixieDisplay[])
    {
      byte counter = 0;
      for (int i = index+1; i < 6; i++)
      {
        if (cronixieDisplay[i] == code)
        {
          counter++;
        } else {
          return counter;
        }
      }
      return counter;
    }
    void setCronixie()
    {
      /*
      * digit purpose index
      * 0-9 | 0-9 (incl. random)
      * 10 | blank
      * 11 | blank, bg off
      * 12 | test upw.
      * 13 | test dnw.
      * 14 | binary AM/PM
      * 15 | BB upper +50 for no trailing 0
      * 16 | BBB
      * 17 | BBBB
      * 18 | BBBBB
      * 19 | BBBBBB
      * 20 | H
      * 21 | HH
      * 22 | HHH
      * 23 | HHHH
      * 24 | M
      * 25 | MM
      * 26 | MMM
      * 27 | MMMM
      * 28 | MMMMM
      * 29 | MMMMMM
      * 30 | S
      * 31 | SS
      * 32 | SSS
      * 33 | SSSS
      * 34 | SSSSS
      * 35 | SSSSSS
      * 36 | Y
      * 37 | YY
      * 38 | YYYY
      * 39 | I
      * 40 | II
      * 41 | W
      * 42 | WW
      * 43 | D
      * 44 | DD
      * 45 | DDD
      * 46 | V
      * 47 | VV
      * 48 | VVV
      * 49 | VVVV
      * 50 | VVVVV
      * 51 | VVVVVV
      * 52 | v
      * 53 | vv
      * 54 | vvv
      * 55 | vvvv
      * 56 | vvvvv
      * 57 | vvvvvv
      */
      //H HourLower | HH - Hour 24. | AH - Hour 12. | HHH Hour of Month | HHHH Hour of Year
      //M MinuteUpper | MM Minute of Hour | MMM Minute of 12h | MMMM Minute of Day | MMMMM Minute of Month | MMMMMM Minute of Year
      //S SecondUpper | SS Second of Minute | SSS Second of 10 Minute | SSSS Second of Hour | SSSSS Second of Day | SSSSSS Second of Week
      //B AM/PM | BB 0-6/6-12/12-18/18-24 | BBB 0-3... | BBBB 0-1.5... | BBBBB 0-1 | BBBBBB 0-0.5
      //Y YearLower | YY - Year LU | YYYY - Std.
      //I MonthLower | II - Month of Year 
      //W Week of Month | WW Week of Year
      //D Day of Week | DD Day Of Month | DDD Day Of Year
      DEBUG_PRINT("cset ");
      DEBUG_PRINTLN(cronixieDisplay);
      for (int i = 0; i < 6; i++)
      {
        dP[i] = 10;
        switch (cronixieDisplay[i])
        {
          case '_': dP[i] = 10; break; 
          case '-': dP[i] = 11; break; 
          case 'r': dP[i] = random(1,7); break; //random btw. 1-6
          case 'R': dP[i] = random(0,10); break; //random btw. 0-9
          //case 't': break; //Test upw.
          //case 'T': break; //Test dnw.
          case 'b': dP[i] = 14 + getSameCodeLength('b',i,cronixieDisplay); i = i+dP[i]-14; break; 
          case 'B': dP[i] = 14 + getSameCodeLength('B',i,cronixieDisplay); i = i+dP[i]-14; break;
          case 'h': dP[i] = 70 + getSameCodeLength('h',i,cronixieDisplay); i = i+dP[i]-70; break;
          case 'H': dP[i] = 20 + getSameCodeLength('H',i,cronixieDisplay); i = i+dP[i]-20; break;
          case 'A': dP[i] = 108; i++; break;
          case 'a': dP[i] = 58; i++; break;
          case 'm': dP[i] = 74 + getSameCodeLength('m',i,cronixieDisplay); i = i+dP[i]-74; break;
          case 'M': dP[i] = 24 + getSameCodeLength('M',i,cronixieDisplay); i = i+dP[i]-24; break;
          case 's': dP[i] = 80 + getSameCodeLength('s',i,cronixieDisplay); i = i+dP[i]-80; break; //refresh more often bc. of secs
          case 'S': dP[i] = 30 + getSameCodeLength('S',i,cronixieDisplay); i = i+dP[i]-30; break;
          case 'Y': dP[i] = 36 + getSameCodeLength('Y',i,cronixieDisplay); i = i+dP[i]-36; break; 
          case 'y': dP[i] = 86 + getSameCodeLength('y',i,cronixieDisplay); i = i+dP[i]-86; break; 
          case 'I': dP[i] = 39 + getSameCodeLength('I',i,cronixieDisplay); i = i+dP[i]-39; break;  //Month. Don't ask me why month and minute both start with M.
          case 'i': dP[i] = 89 + getSameCodeLength('i',i,cronixieDisplay); i = i+dP[i]-89; break; 
          //case 'W': break;
          //case 'w': break;
          case 'D': dP[i] = 43 + getSameCodeLength('D',i,cronixieDisplay); i = i+dP[i]-43; break;
          case 'd': dP[i] = 93 + getSameCodeLength('d',i,cronixieDisplay); i = i+dP[i]-93; break;
          case '0': dP[i] = 0; break;
          case '1': dP[i] = 1; break;
          case '2': dP[i] = 2; break;
          case '3': dP[i] = 3; break;
          case '4': dP[i] = 4; break;
          case '5': dP[i] = 5; break;
          case '6': dP[i] = 6; break;
          case '7': dP[i] = 7; break;
          case '8': dP[i] = 8; break;
          case '9': dP[i] = 9; break;
          //case 'V': break; //user var0
          //case 'v': break; //user var1
        }
      }
      DEBUG_PRINT("result ");
      for (int i = 0; i < 5; i++)
      {
        DEBUG_PRINT((int)dP[i]);
        DEBUG_PRINT(" ");
      }
      DEBUG_PRINTLN((int)dP[5]);
      _overlayCronixie(); // refresh
    }
    void _overlayCronixie()
    {
      byte h = hour(localTime);
      byte h0 = h;
      byte m = minute(localTime);
      byte s = second(localTime);
      byte d = day(localTime);
      byte mi = month(localTime);
      int y = year(localTime);
      //this has to be changed in time for 22nd century
      y -= 2000; if (y<0) y += 30; //makes countdown work
      if (useAMPM && !countdownMode)
      {
        if (h>12) h-=12;
        else if (h==0) h+=12;
      }
      for (int i = 0; i < 6; i++)
      {
        if (dP[i] < 12) _digitOut[i] = dP[i];
        else {
          if (dP[i] < 65)
          {
            switch(dP[i])
            {
              case 21: _digitOut[i] = h/10; _digitOut[i+1] = h- _digitOut[i]*10; i++; break; //HH
              case 25: _digitOut[i] = m/10; _digitOut[i+1] = m- _digitOut[i]*10; i++; break; //MM
              case 31: _digitOut[i] = s/10; _digitOut[i+1] = s- _digitOut[i]*10; i++; break; //SS
              case 20: _digitOut[i] = h- (h/10)*10; break; //H
              case 24: _digitOut[i] = m/10; break; //M
              case 30: _digitOut[i] = s/10; break; //S
              case 43: _digitOut[i] = weekday(localTime); _digitOut[i]--; if (_digitOut[i]<1) _digitOut[i]= 7; break; //D
              case 44: _digitOut[i] = d/10; _digitOut[i+1] = d- _digitOut[i]*10; i++; break; //DD
              case 40: _digitOut[i] = mi/10; _digitOut[i+1] = mi- _digitOut[i]*10; i++; break; //II
              case 37: _digitOut[i] = y/10; _digitOut[i+1] = y- _digitOut[i]*10; i++; break; //YY
              case 39: _digitOut[i] = 2; _digitOut[i+1] = 0; _digitOut[i+2] = y/10; _digitOut[i+3] = y- _digitOut[i+2]*10; i+=3; break; //YYYY
              //case 16: _digitOut[i+2] = ((h0/3)&1)?1:0; i++; //BBB (BBBB NI)
              //case 15: _digitOut[i+1] = (h0>17 || (h0>5 && h0<12))?1:0; i++; //BB
              case 14: _digitOut[i] = (h0>11)?1:0; break; //B
            }
          } else
          {
            switch(dP[i])
            {
              case 71: _digitOut[i] = h/10; _digitOut[i+1] = h- _digitOut[i]*10; if(_digitOut[i] == 0) _digitOut[i]=10; i++; break; //hh
              case 75: _digitOut[i] = m/10; _digitOut[i+1] = m- _digitOut[i]*10; if(_digitOut[i] == 0) _digitOut[i]=10; i++; break; //mm
              case 81: _digitOut[i] = s/10; _digitOut[i+1] = s- _digitOut[i]*10; if(_digitOut[i] == 0) _digitOut[i]=10; i++; break; //ss
              //case 66: _digitOut[i+2] = ((h0/3)&1)?1:10; i++; //bbb (bbbb NI)
              //case 65: _digitOut[i+1] = (h0>17 || (h0>5 && h0<12))?1:10; i++; //bb
              case 64: _digitOut[i] = (h0>11)?1:10; break; //b
              case 93: _digitOut[i] = weekday(localTime); _digitOut[i]--; if (_digitOut[i]<1) _digitOut[i]= 7; break; //d
              case 94: _digitOut[i] = d/10; _digitOut[i+1] = d- _digitOut[i]*10; if(_digitOut[i] == 0) _digitOut[i]=10; i++; break; //dd
              case 90: _digitOut[i] = mi/10; _digitOut[i+1] = mi- _digitOut[i]*10; if(_digitOut[i] == 0) _digitOut[i]=10; i++; break; //ii
              case 87: _digitOut[i] = y/10; _digitOut[i+1] = y- _digitOut[i]*10; i++; break; //yy
              case 89: _digitOut[i] = 2; _digitOut[i+1] = 0; _digitOut[i+2] = y/10; _digitOut[i+3] = y- _digitOut[i+2]*10; i+=3; break; //yyyy
            }
          }
        }
      }
    }
    void handleOverlayDraw()
    {
      byte offsets[] = {5, 0, 6, 1, 7, 2, 8, 3, 9, 4};
      for (uint16_t i = 0; i < 6; i++)
      {
        byte o = 10*i;
        byte excl = 10;
        if(_digitOut[i] < 10) excl = offsets[_digitOut[i]];
        excl += o;
        if (backlight && _digitOut[i] <11)
        {
          uint32_t col = gamma32(strip.getSegment(0).colors[1]);
          for (uint16_t j=o; j< o+10; j++) {
            if (j != excl) strip.setPixelColor(j, col);
          }
        } else
        {
          for (uint16_t j=o; j< o+10; j++) {
            if (j != excl) strip.setPixelColor(j, 0);
          }
        }
      }
    }
    void addToJsonState(JsonObject& root)
    {
      root["nx"] = cronixieDisplay;
    }
    void readFromJsonState(JsonObject& root)
    {
      if (root["nx"].is<const char*>()) {
        strncpy(cronixieDisplay, root["nx"], 6);
        setCronixie();
      }
    }
    void addToConfig(JsonObject& root)
    {
      JsonObject top = root.createNestedObject(F("Cronixie"));
      top["backlight"] = backlight;
    }
    bool readFromConfig(JsonObject& root)
    {
      // default settings values could be set here (or below using the 3-argument getJsonValue()) instead of in the class definition or constructor
      // setting them inside readFromConfig() is slightly more robust, handling the rare but plausible use case of single value being missing after boot (e.g. if the cfg.json was manually edited and a value was removed)
      JsonObject top = root[F("Cronixie")];
      bool configComplete = !top.isNull();
      configComplete &= getJsonValue(top["backlight"], backlight);
      return configComplete;
    }
    uint16_t getId()
    {
      return USERMOD_ID_CRONIXIE;
    }
 };
--- a/usermods/DHT/platformio_override.ini
+++ b/usermods/DHT/platformio_override.ini
@ -6,13 +6,12 @@
 ; USERMOD_DHT_CELSIUS              - define this to report temperatures in degrees celsious, otherwise fahrenheit will be reported
 ; USERMOD_DHT_MEASUREMENT_INTERVAL - the number of milliseconds between measurements, defaults to 60 seconds
 ; USERMOD_DHT_FIRST_MEASUREMENT_AT - the number of milliseconds after boot to take first measurement, defaults to 90 seconds
 ; USERMOD_DHT_MQTT                 - publish measurements to the MQTT broker
 ; USERMOD_DHT_STATS                - For debug, report delay stats
 [env:d1_mini_usermod_dht_C]
 extends = env:d1_mini
 build_flags = ${env:d1_mini.build_flags} -D USERMOD_DHT -D USERMOD_DHT_CELSIUS
-lib_deps = ${env:d1_mini.lib_deps}
+lib_deps = ${env.lib_deps}
    https://github.com/alwynallan/DHT_nonblocking
 [env:custom32_LEDPIN_16_usermod_dht_C]
--- a/usermods/DHT/readme.md
+++ b/usermods/DHT/readme.md
@ -1,13 +1,9 @@
 # DHT Temperature/Humidity sensor usermod
 This usermod will read from an attached DHT22 or DHT11 humidity and temperature sensor.
-The sensor readings are displayed in the Info section of the web UI (and optionally sent to an MQTT broker).
+The sensor readings are displayed in the Info section of the web UI.
-If sensor is not detected after 10 update intervals, the usermod will be disabled.
+If sensor is not detected after a while (10 update intervals), this usermod will be disabled.
 If enabled, measured temperature and humidity will be published to the following MQTT topics
 * `{devceTopic}/dht/temperature`
 * `{devceTopic}/dht/humidity`
 ## Installation
@ -15,13 +11,12 @@ Copy the example `platformio_override.ini` to the root directory.  This file sho
 ### Define Your Options
-* `USERMOD_DHT`                      - define this to include this user mod wled00\usermods_list.cpp
+* `USERMOD_DHT`                      - define this to have this user mod included wled00\usermods_list.cpp
 * `USERMOD_DHT_DHTTYPE`              - DHT model: 11, 21, 22 for DHT11, DHT21, or DHT22, defaults to 22/DHT22
 * `USERMOD_DHT_PIN`                  - pin to which DTH is connected, defaults to Q2 pin on QuinLed Dig-Uno's board
-* `USERMOD_DHT_CELSIUS`              - define this to report temperatures in degrees Celsius, otherwise Fahrenheit will be reported
+* `USERMOD_DHT_CELSIUS`              - define this to report temperatures in degrees celsious, otherwise fahrenheit will be reported
-* `USERMOD_DHT_MEASUREMENT_INTERVAL` - the number of milliseconds between measurements, defaults to 60000 ms
+* `USERMOD_DHT_MEASUREMENT_INTERVAL` - the number of milliseconds between measurements, defaults to 60 seconds
-* `USERMOD_DHT_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 90000 ms
+* `USERMOD_DHT_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 90 seconds
 * `USERMOD_DHT_MQTT`                 - publish measurements to an MQTT broker
 * `USERMOD_DHT_STATS`                - For debug, report delay stats
 ## Project link
@ -34,12 +29,10 @@ If you are using `platformio_override.ini`, you should be able to refresh the ta
 ## Change Log
-2022-10-15
+
 * Add ability to publish sensor readings to an MQTT broker
 * fix compilation error for sample [env:d1_mini_usermod_dht_C] task
 2020-02-04
 * Change default QuinLed pin to Q2
-* Instead of trying to keep updates at constant cadence, space out readings by measurement interval. Hopefully, this helps eliminate occasional bursts of readings with errors
+* Instead of trying to keep updates at constant cadence, space readings out by measurement interval; hope this helps to avoid occasional bursts of readings with errors
 * Add some more (optional) stats
 2020-02-03
 * Due to poor readouts on ESP32 with previous DHT library, rewrote to use https://github.com/alwynallan/DHT_nonblocking
--- a/usermods/DHT/usermod_dht.h
+++ b/usermods/DHT/usermod_dht.h
@ -1,10 +1,6 @@
 #pragma once
 #include "wled.h"
 #ifndef WLED_ENABLE_MQTT
 #error "This user mod requires MQTT to be enabled."
 #endif
 #include <dht_nonblocking.h>
@ -66,10 +62,6 @@ class UsermodDHT : public Usermod {
    float humidity, temperature = 0;
    bool initializing = true;
    bool disabled = false;
    #ifdef USERMOD_DHT_MQTT
    char dhtMqttTopic[64];
    size_t dhtMqttTopicLen;
    #endif
    #ifdef USERMOD_DHT_STATS
    unsigned long nextResetStatsTime = 0;
    uint16_t updates = 0;
@ -84,10 +76,6 @@ class UsermodDHT : public Usermod {
    void setup() {
      nextReadTime = millis() + USERMOD_DHT_FIRST_MEASUREMENT_AT;
      lastReadTime = millis();
      #ifdef USERMOD_DHT_MQTT
      sprintf(dhtMqttTopic, "%s/dht", mqttDeviceTopic);
      dhtMqttTopicLen = strlen(dhtMqttTopic);
      #endif
      #ifdef USERMOD_DHT_STATS
      nextResetStatsTime = millis() + 60*60*1000;
      #endif
@ -122,25 +110,6 @@ class UsermodDHT : public Usermod {
        temperature = tempC * 9 / 5 + 32;
        #endif
        #ifdef USERMOD_DHT_MQTT
        // 10^n where n is number of decimal places to display in mqtt message. Please adjust buff size together with this constant
        #define FLOAT_PREC 100
        if (WLED_MQTT_CONNECTED) {
          char buff[10];
          strcpy(dhtMqttTopic + dhtMqttTopicLen, "/temperature");
          sprintf(buff, "%d.%d", (int)temperature, ((int)(temperature * FLOAT_PREC)) % FLOAT_PREC);
          mqtt->publish(dhtMqttTopic, 0, false, buff);
          sprintf(buff, "%d.%d", (int)humidity, ((int)(humidity * FLOAT_PREC)) % FLOAT_PREC);
          strcpy(dhtMqttTopic + dhtMqttTopicLen, "/humidity");
          mqtt->publish(dhtMqttTopic, 0, false, buff);
          dhtMqttTopic[dhtMqttTopicLen] = '\0';
        }
        #undef FLOAT_PREC
        #endif
        nextReadTime = millis() + USERMOD_DHT_MEASUREMENT_INTERVAL;
        lastReadTime = millis();
        initializing = false;
--- a/usermods/ESP32_TouchBrightnessControl/readme.md
+++ b/usermods/ESP32_TouchBrightnessControl/readme.md
@ -0,0 +1,19 @@
 # ESP32 Touch Brightness Control
 Toggle On/Off with a long press (800ms)
 Switch through 5 brightness levels (defined in usermod_touchbrightness.h, values 0-255) with a short (100ms) touch
 ## Installation 
 Copy 'usermod_touchbrightness.h' to the wled00 directory.  
 in 'usermod_list.cpp' add this:
 > #include "usermod_touchbrightness.h"
 above "void registerUsermods()"
 and
 > usermods.add(new TouchBrightnessControl());
 inside the "registerUsermods()" function
--- a/usermods/ESP32_TouchBrightnessControl/usermod_touchbrightness.h
+++ b/usermods/ESP32_TouchBrightnessControl/usermod_touchbrightness.h
@ -0,0 +1,89 @@
 //
 //  usermod_touchbrightness.h
 //  github.com/aircoookie/WLED
 //
 //  Created by Justin Kühner on 14.09.2020.
 //  Copyright © 2020 NeariX. All rights reserved.
 //  https://github.com/NeariX67/
 //  Discord: @NeariX#4799
 #pragma once
 #include "wled.h"
 #define threshold 40                    //Increase value if touches falsely accur. Decrease value if actual touches are not recognized
 #define touchPin T0                     //T0 = D4 / GPIO4
 //Define the 5 brightness levels
 //Long press to turn off / on
 #define brightness1 51
 #define brightness2 102
 #define brightness3 153
 #define brightness4 204
 #define brightness5 255
 #ifdef ESP32
 class TouchBrightnessControl : public Usermod {
  private:
    unsigned long lastTime = 0;         //Interval
    unsigned long lastTouch = 0;        //Timestamp of last Touch
    unsigned long lastRelease = 0;      //Timestamp of last Touch release
    boolean released = true;            //current Touch state (touched/released)
    uint16_t touchReading = 0;          //sensor reading, maybe use uint8_t???
    uint16_t touchDuration = 0;         //duration of last touch
  public:
    void setup() {
      lastTouch = millis();
      lastRelease = millis();
      lastTime = millis();
    }
    void loop() {
      if (millis() - lastTime >= 50) {                           //Check every 50ms if a touch occurs
        lastTime = millis();
        touchReading = touchRead(touchPin);                      //Read touch sensor on pin T0 (GPIO4 / D4)
        if(touchReading < threshold && released) {               //Touch started
          released = false;
          lastTouch = millis();
        }
        else if(touchReading >= threshold && !released) {        //Touch released
          released = true;
          lastRelease = millis();
          touchDuration = lastRelease - lastTouch;               //Calculate duration
        }
        //Serial.println(touchDuration);
        if(touchDuration >= 800 && released) {                   //Toggle power if button press is longer than 800ms
          touchDuration = 0;                                     //Reset touch duration to avoid multiple actions on same touch
          toggleOnOff();
          colorUpdated(2);                                       //Refresh values
        }
        else if(touchDuration >= 100 && released) {              //Switch to next brightness if touch is between 100 and 800ms
          touchDuration = 0;                                     //Reset touch duration to avoid multiple actions on same touch
          if(bri < brightness1) {
            bri = brightness1;
          } else if(bri >= brightness1 && bri < brightness2) {
            bri = brightness2;
          } else if(bri >= brightness2 && bri < brightness3) {
            bri = brightness3;
          } else if(bri >= brightness3 && bri < brightness4) {
            bri = brightness4;
          } else if(bri >= brightness4 && bri < brightness5) {
            bri = brightness5;
          } else if(bri >= brightness5) {
            bri = brightness1;
          }
          colorUpdated(2);                                       //Refresh values
        }
      }
    }
 };
 #endif
--- a/usermods/EXAMPLE_v2/usermod_v2_example.h
+++ b/usermods/EXAMPLE_v2/usermod_v2_example.h
@ -22,12 +22,8 @@
 //class name. Use something descriptive and leave the ": public Usermod" part :)
 class MyExampleUsermod : public Usermod {
  private:
    //Private class members. You can declare variables and functions only accessible to your usermod here
    bool enabled = false;
    bool initDone = false;
    unsigned long lastTime = 0;
    // set your config variables to their boot default value (this can also be done in readFromConfig() or a constructor if you prefer)
@ -41,56 +37,15 @@ class MyExampleUsermod : public Usermod {
    long testLong;
    int8_t testPins[2];
    // string that are used multiple time (this will save some flash memory)
    static const char _name[];
    static const char _enabled[];
    // any private methods should go here (non-inline methosd should be defined out of class)
    void publishMqtt(const char* state, bool retain = false); // example for publishing MQTT message
  public:
-
+    //Functions called by WLED
    // non WLED related methods, may be used for data exchange between usermods (non-inline methods should be defined out of class)
    /**
     * Enable/Disable the usermod
     */
    inline void enable(bool enable) { enabled = enable; }
    /**
     * Get usermod enabled/disabled state
     */
    inline bool isEnabled() { return enabled; }
    // in such case add the following to another usermod:
    //  in private vars:
    //   #ifdef USERMOD_EXAMPLE
    //   MyExampleUsermod* UM;
    //   #endif
    //  in setup()
    //   #ifdef USERMOD_EXAMPLE
    //   UM = (MyExampleUsermod*) usermods.lookup(USERMOD_ID_EXAMPLE);
    //   #endif
    //  somewhere in loop() or other member method
    //   #ifdef USERMOD_EXAMPLE
    //   if (UM != nullptr) isExampleEnabled = UM->isEnabled();
    //   if (!isExampleEnabled) UM->enable(true);
    //   #endif
    // methods called by WLED (can be inlined as they are called only once but if you call them explicitly define them out of class)
    /*
     * setup() is called once at boot. WiFi is not yet connected at this point.
     * readFromConfig() is called prior to setup()
     * You can use it to initialize variables, sensors or similar.
     */
    void setup() {
      // do your set-up here
      //Serial.println("Hello from my usermod!");
      initDone = true;
    }
@ -114,11 +69,6 @@ class MyExampleUsermod : public Usermod {
     *    Instead, use a timer check as shown here.
     */
    void loop() {
      // if usermod is disabled or called during strip updating just exit
      // NOTE: on very long strips strip.isUpdating() may always return true so update accordingly
      if (!enabled || strip.isUpdating()) return;
      // do your magic here
      if (millis() - lastTime > 1000) {
        //Serial.println("I'm alive!");
        lastTime = millis();
@ -131,25 +81,19 @@ class MyExampleUsermod : public Usermod {
     * Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
     * Below it is shown how this could be used for e.g. a light sensor
     */
    /*
    void addToJsonInfo(JsonObject& root)
    {
-      // if "u" object does not exist yet wee need to create it
+      int reading = 20;
      //this code adds "u":{"Light":[20," lux"]} to the info object
      JsonObject user = root["u"];
      if (user.isNull()) user = root.createNestedObject("u");
-      //this code adds "u":{"ExampleUsermod":[20," lux"]} to the info object
+      JsonArray lightArr = user.createNestedArray("Light"); //name
-      //int reading = 20;
+      lightArr.add(reading); //value
-      //JsonArray lightArr = user.createNestedArray(FPSTR(_name))); //name
+      lightArr.add(" lux"); //unit
      //lightArr.add(reading); //value
      //lightArr.add(F(" lux")); //unit
      // if you are implementing a sensor usermod, you may publish sensor data
      //JsonObject sensor = root[F("sensor")];
      //if (sensor.isNull()) sensor = root.createNestedObject(F("sensor"));
      //temp = sensor.createNestedArray(F("light"));
      //temp.add(reading);
      //temp.add(F("lux"));
    }
    */
    /*
@ -158,12 +102,7 @@ class MyExampleUsermod : public Usermod {
     */
    void addToJsonState(JsonObject& root)
    {
-      if (!initDone || !enabled) return;  // prevent crash on boot applyPreset()
+      //root["user0"] = userVar0;
      JsonObject usermod = root[FPSTR(_name)];
      if (usermod.isNull()) usermod = root.createNestedObject(FPSTR(_name));
      //usermod["user0"] = userVar0;
    }
@ -173,14 +112,7 @@ class MyExampleUsermod : public Usermod {
     */
    void readFromJsonState(JsonObject& root)
    {
-      if (!initDone) return;  // prevent crash on boot applyPreset()
+      userVar0 = root["user0"] | userVar0; //if "user0" key exists in JSON, update, else keep old value
      JsonObject usermod = root[FPSTR(_name)];
      if (!usermod.isNull()) {
        // expect JSON usermod data in usermod name object: {"ExampleUsermod:{"user0":10}"}
        userVar0 = usermod["user0"] | userVar0; //if "user0" key exists in JSON, update, else keep old value
      }
      // you can as well check WLED state JSON keys
      //if (root["bri"] == 255) Serial.println(F("Don't burn down your garage!"));
    }
@ -222,10 +154,8 @@ class MyExampleUsermod : public Usermod {
     */
    void addToConfig(JsonObject& root)
    {
-      JsonObject top = root.createNestedObject(FPSTR(_name));
+      JsonObject top = root.createNestedObject("exampleUsermod");
-      top[FPSTR(_enabled)] = enabled;
+      top["great"] = userVar0; //save these vars persistently whenever settings are saved
      //save these vars persistently whenever settings are saved
      top["great"] = userVar0;
      top["testBool"] = testBool;
      top["testInt"] = testInt;
      top["testLong"] = testLong;
@ -258,7 +188,7 @@ class MyExampleUsermod : public Usermod {
      // default settings values could be set here (or below using the 3-argument getJsonValue()) instead of in the class definition or constructor
      // setting them inside readFromConfig() is slightly more robust, handling the rare but plausible use case of single value being missing after boot (e.g. if the cfg.json was manually edited and a value was removed)
-      JsonObject top = root[FPSTR(_name)];
+      JsonObject top = root["exampleUsermod"];
      bool configComplete = !top.isNull();
@ -271,8 +201,6 @@ class MyExampleUsermod : public Usermod {
      // A 3-argument getJsonValue() assigns the 3rd argument as a default value if the Json value is missing
      configComplete &= getJsonValue(top["testInt"], testInt, 42);  
      configComplete &= getJsonValue(top["testLong"], testLong, -42424242);
      // "pin" fields have special handling in settings page (or some_pin as well)
      configComplete &= getJsonValue(top["pin"][0], testPins[0], -1);
      configComplete &= getJsonValue(top["pin"][1], testPins[1], -1);
@ -280,97 +208,6 @@ class MyExampleUsermod : public Usermod {
    }
    /*
     * appendConfigData() is called when user enters usermod settings page
     * it may add additional metadata for certain entry fields (adding drop down is possible)
     * be careful not to add too much as oappend() buffer is limited to 3k
     */
    void appendConfigData()
    {
      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);"));
    }
    /*
     * 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()
    {
      //strip.setPixelColor(0, RGBW32(0,0,0,0)) // set the first pixel to black
    }
    /**
     * handleButton() can be used to override default button behaviour. Returning true
     * will prevent button working in a default way.
     * Replicating button.cpp
     */
    bool handleButton(uint8_t b) {
      yield();
      // ignore certain button types as they may have other consequences
      if (!enabled
       || buttonType[b] == BTN_TYPE_NONE
       || buttonType[b] == BTN_TYPE_RESERVED
       || buttonType[b] == BTN_TYPE_PIR_SENSOR
       || buttonType[b] == BTN_TYPE_ANALOG
       || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) {
        return false;
      }
      bool handled = false;
      // do your button handling here
      return handled;
    }
 #ifndef WLED_DISABLE_MQTT
    /**
     * handling of MQTT message
     * topic only contains stripped topic (part after /wled/MAC)
     */
    bool onMqttMessage(char* topic, char* payload) {
      // check if we received a command
      //if (strlen(topic) == 8 && strncmp_P(topic, PSTR("/command"), 8) == 0) {
      //  String action = payload;
      //  if (action == "on") {
      //    enabled = true;
      //    return true;
      //  } else if (action == "off") {
      //    enabled = false;
      //    return true;
      //  } else if (action == "toggle") {
      //    enabled = !enabled;
      //    return true;
      //  }
      //}
      return false;
    }
    /**
     * onMqttConnect() is called when MQTT connection is established
     */
    void onMqttConnect(bool sessionPresent) {
      // do any MQTT related initialisation here
      //publishMqtt("I am alive!");
    }
 #endif
    /**
     * onStateChanged() is used to detect WLED state change
     * @mode parameter is CALL_MODE_... parameter used for notifications
     */
    void onStateChange(uint8_t mode) {
      // do something if WLED state changed (color, brightness, effect, preset, etc)
    }
    /*
     * getId() allows you to optionally give your V2 usermod an unique ID (please define it in const.h!).
     * This could be used in the future for the system to determine whether your usermod is installed.
@ -383,24 +220,3 @@ class MyExampleUsermod : public Usermod {
   //More methods can be added in the future, this example will then be extended.
   //Your usermod will remain compatible as it does not need to implement all methods from the Usermod base class!
 };
 // add more strings here to reduce flash memory usage
 const char MyExampleUsermod::_name[]    PROGMEM = "ExampleUsermod";
 const char MyExampleUsermod::_enabled[] PROGMEM = "enabled";
 // implementation of non-inline member methods
 void MyExampleUsermod::publishMqtt(const char* state, bool retain)
 {
 #ifndef WLED_DISABLE_MQTT
  //Check if MQTT Connected, otherwise it will crash the 8266
  if (WLED_MQTT_CONNECTED) {
    char subuf[64];
    strcpy(subuf, mqttDeviceTopic);
    strcat_P(subuf, PSTR("/example"));
    mqtt->publish(subuf, 0, retain, state);
  }
 #endif
 }
--- a/usermods/EleksTube_IPS/TFTs.h
+++ b/usermods/EleksTube_IPS/TFTs.h
@ -12,7 +12,6 @@ class TFTs : public TFT_eSPI {
 private:
  uint8_t digits[NUM_DIGITS];
  // These read 16- and 32-bit types from the SD card file.
  // BMP data is stored little-endian, Arduino is little-endian too.
  // May need to reverse subscript order if porting elsewhere.
@ -34,16 +33,7 @@ private:
  }
  uint16_t output_buffer[TFT_HEIGHT][TFT_WIDTH];
  int16_t w = 135, h = 240, x = 0, y = 0, bufferedDigit = 255;
  uint16_t digitR, digitG, digitB, dimming = 255;
  uint32_t digitColor = 0;
  void drawBuffer() {
    bool oldSwapBytes = getSwapBytes();
    setSwapBytes(true);
    pushImage(x, y, w, h, (uint16_t *)output_buffer);
    setSwapBytes(oldSwapBytes);
  }
  // These BMP functions are stolen directly from the TFT_SPIFFS_BMP example in the TFT_eSPI library.
  // Unfortunately, they aren't part of the library itself, so I had to copy them.
@ -51,69 +41,44 @@ private:
  //// BEGIN STOLEN CODE
-  // Draw directly from file stored in RGB565 format. Fastest
+  // Draw directly from file stored in RGB565 format
  bool drawBin(const char *filename) {
    fs::File bmpFS;
    // Open requested file on SD card
    bmpFS = WLED_FS.open(filename, "r");
-    size_t sz = bmpFS.size();
+    if (!bmpFS)
-    if (sz > 64800) {
+    {
-      bmpFS.close();
+      Serial.print(F("File not found: "));
-      return false;
+      Serial.println(filename);
      return(false);
    }
-    uint16_t r, g, b, dimming = 255;
+    size_t sz = bmpFS.size();
-    int16_t row, col;
+    if (sz <= 64800)
    {
      bool oldSwapBytes = getSwapBytes();
      setSwapBytes(true);
      int16_t h = sz / (135 * 2);
      //draw img that is shorter than 240pix into the center
-    w = 135;
+      int16_t y = (height() - h) /2;
    h = sz / (w * 2);
    x = 0;
    y = (height() - h) /2;
-    uint8_t lineBuffer[w * 2];
+      bmpFS.read((uint8_t *) output_buffer,sz);
-    if (!realtimeMode || realtimeOverride || (realtimeMode && useMainSegmentOnly)) strip.service();
+      if (!realtimeMode || realtimeOverride) strip.service();
-    // 0,0 coordinates are top left
+      pushImage(0, y, 135, h, (uint16_t *)output_buffer);
    for (row = 0; row < h; row++) {
-      bmpFS.read(lineBuffer, sizeof(lineBuffer));
+      setSwapBytes(oldSwapBytes);
      uint8_t PixM, PixL;
      // Colors are already in 16-bit R5, G6, B5 format
      for (col = 0; col < w; col++)
      {
        if (dimming == 255 && !digitColor) { // not needed, copy directly
          output_buffer[row][col] = (lineBuffer[col*2+1] << 8) | (lineBuffer[col*2]);
        } else {
          // 16 BPP pixel format: R5, G6, B5 ; bin: RRRR RGGG GGGB BBBB
          PixM = lineBuffer[col*2+1];
          PixL = lineBuffer[col*2];
          // align to 8-bit value (MSB left aligned)
          r = (PixM) & 0xF8;
          g = ((PixM << 5) | (PixL >> 3)) & 0xFC;
          b = (PixL << 3) & 0xF8;
          r *= dimming; g *= dimming; b *= dimming;
          r  = r  >> 8; g  = g  >> 8; b  = b  >> 8;
          if (digitColor) { // grayscale pixel coloring
            uint8_t l = (r > g) ? ((r > b) ? r:b) : ((g > b) ? g:b);
            r = g = b = l;
            r *= digitR; g *= digitG; b *= digitB;
            r  = r >> 8; g  = g >> 8; b  = b >> 8;
    }
          output_buffer[row][col] = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
        }
      }
    }
    drawBuffer();
    bmpFS.close();
-    return true;
+    return(true);
  }
  bool drawBmp(const char *filename) {
@ -122,175 +87,78 @@ private:
    // Open requested file on SD card
    bmpFS = WLED_FS.open(filename, "r");
-    uint32_t seekOffset, headerSize, paletteSize = 0;
+    if (!bmpFS)
-    int16_t row;
+    {
-    uint16_t r, g, b, dimming = 255, bitDepth;
+      Serial.print(F("File not found: "));
      Serial.println(filename);
      return(false);
    }
    uint32_t seekOffset;
    int16_t w, h, row;
    uint8_t  r, g, b;
    uint16_t magic = read16(bmpFS);
-    if (magic != ('B' | ('M' << 8))) { // File not found or not a BMP
+    if (magic == 0xFFFF) {
      Serial.println(F("BMP not found!"));
      bmpFS.close();
-      return false;
+      return(false);
    }
-    (void) read32(bmpFS); // filesize in bytes
+    if (magic != 0x4D42) {
-    (void) read32(bmpFS); // reserved
+      Serial.print(F("File not a BMP. Magic: "));
-    seekOffset = read32(bmpFS); // start of bitmap
+      Serial.println(magic);
-    headerSize = read32(bmpFS); // header size
+      bmpFS.close();
-    w = read32(bmpFS); // width
+      return(false);
-    h = read32(bmpFS); // height
+    }
    (void) read16(bmpFS); // color planes (must be 1)
    bitDepth = read16(bmpFS);
-    if (read32(bmpFS) != 0 || (bitDepth != 24 && bitDepth != 1 && bitDepth != 4 && bitDepth != 8)) {
+    read32(bmpFS);
    read32(bmpFS);
    seekOffset = read32(bmpFS);
    read32(bmpFS);
    w = read32(bmpFS);
    h = read32(bmpFS);
    if ((read16(bmpFS) != 1) || (read16(bmpFS) != 24) || (read32(bmpFS) != 0)) {
      Serial.println(F("BMP format not recognized."));
      bmpFS.close();
-      return false;
+      return(false);
    }
    uint32_t palette[256];
    if (bitDepth <= 8) // 1,4,8 bit bitmap: read color palette
    {
      (void) read32(bmpFS); (void) read32(bmpFS); (void) read32(bmpFS); // size, w resolution, h resolution
      paletteSize = read32(bmpFS);
      if (paletteSize == 0) paletteSize = 1 << bitDepth; //if 0, size is 2^bitDepth
      bmpFS.seek(14 + headerSize); // start of color palette
      for (uint16_t i = 0; i < paletteSize; i++) {
        palette[i] = read32(bmpFS);
      }
    }
    //draw img that is shorter than 240pix into the center
-    x = (width() - w) /2;
+    int16_t y = (height() - h) /2;
    y = (height() - h) /2;
    bool oldSwapBytes = getSwapBytes();
    setSwapBytes(true);
    bmpFS.seek(seekOffset);
-    uint32_t lineSize = ((bitDepth * w +31) >> 5) * 4;
+    uint16_t padding = (4 - ((w * 3) & 3)) & 3;
-    uint8_t lineBuffer[lineSize];
+    uint8_t lineBuffer[w * 3 + padding];
-    uint8_t serviceStrip = (!realtimeMode || realtimeOverride || (realtimeMode && useMainSegmentOnly)) ? 7 : 0;
+    uint8_t serviceStrip = (!realtimeMode || realtimeOverride) ? 7 : 0;
    // row is decremented as the BMP image is drawn bottom up
    for (row = h-1; row >= 0; row--) {
      if ((row & 0b00000111) == serviceStrip) strip.service(); //still refresh backlight to mitigate stutter every few rows
      bmpFS.read(lineBuffer, sizeof(lineBuffer));
      uint8_t*  bptr = lineBuffer;
-      // Convert 24 to 16 bit colors while copying to output buffer.
+      // Convert 24 to 16 bit colours while copying to output buffer.
      for (uint16_t col = 0; col < w; col++)
      {
        if (bitDepth == 24) {
        b = *bptr++;
        g = *bptr++;
        r = *bptr++;
-        } else {
+        output_buffer[row][col] = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
          uint32_t c = 0;
          if (bitDepth == 8) {
            c = palette[*bptr++];
          }
          else if (bitDepth == 4) {
            c = palette[(*bptr >> ((col & 0x01)?0:4)) & 0x0F];
            if (col & 0x01) bptr++;
          }
          else { // bitDepth == 1
            c = palette[(*bptr >> (7 - (col & 0x07))) & 0x01];
            if ((col & 0x07) == 0x07) bptr++;
          }
          b = c; g = c >> 8; r = c >> 16;
        }
        if (dimming != 255) { // only dim when needed
          r *= dimming; g *= dimming; b *= dimming;
          r  = r  >> 8; g  = g  >> 8; b  = b  >> 8;
        }
        if (digitColor) { // grayscale pixel coloring
          uint8_t l = (r > g) ? ((r > b) ? r:b) : ((g > b) ? g:b);
          r = g = b = l;
          r *= digitR; g *= digitG; b *= digitB;
          r  = r >> 8; g  = g >> 8; b  = b >> 8;
        }
        output_buffer[row][col] = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xFF) >> 3);
      }
    }
-    drawBuffer();
+    pushImage(0, y, w, h, (uint16_t *)output_buffer);
    setSwapBytes(oldSwapBytes);
    bmpFS.close();
-    return true;
+    return(true);
  }
  bool drawClk(const char *filename) {
    fs::File bmpFS;
    // Open requested file on SD card
    bmpFS = WLED_FS.open(filename, "r");
    if (!bmpFS)
    {
      Serial.print("File not found: ");
      Serial.println(filename);
      return false;
    }
    uint16_t r, g, b, dimming = 255, magic;
    int16_t row, col;
    magic = read16(bmpFS);
    if (magic != 0x4B43) { // look for "CK" header
      Serial.print(F("File not a CLK. Magic: "));
      Serial.println(magic);
      bmpFS.close();
      return false;
    }
    w = read16(bmpFS);
    h = read16(bmpFS);
    x = (width() - w) / 2;
    y = (height() - h) / 2;
    uint8_t lineBuffer[w * 2];
    if (!realtimeMode || realtimeOverride || (realtimeMode && useMainSegmentOnly)) strip.service();
    // 0,0 coordinates are top left
    for (row = 0; row < h; row++) {
      bmpFS.read(lineBuffer, sizeof(lineBuffer));
      uint8_t PixM, PixL;
      // Colors are already in 16-bit R5, G6, B5 format
      for (col = 0; col < w; col++)
      {
        if (dimming == 255 && !digitColor) { // not needed, copy directly
          output_buffer[row][col+x] = (lineBuffer[col*2+1] << 8) | (lineBuffer[col*2]);
        } else {
          // 16 BPP pixel format: R5, G6, B5 ; bin: RRRR RGGG GGGB BBBB
          PixM = lineBuffer[col*2+1];
          PixL = lineBuffer[col*2];
          // align to 8-bit value (MSB left aligned)
          r = (PixM) & 0xF8;
          g = ((PixM << 5) | (PixL >> 3)) & 0xFC;
          b = (PixL << 3) & 0xF8;
          r *= dimming; g *= dimming; b *= dimming;
          r  = r  >> 8; g  = g  >> 8; b  = b  >> 8;
          if (digitColor) { // grayscale pixel coloring
            uint8_t l = (r > g) ? ((r > b) ? r:b) : ((g > b) ? g:b);
            r = g = b = l;
            r *= digitR; g *= digitG; b *= digitB;
            r  = r >> 8; g  = g >> 8; b  = b >> 8;
          }
          output_buffer[row][col+x] = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
        }
      }
    }
    drawBuffer();
    bmpFS.close();
    return true;
  }
 public:
  TFTs() : TFT_eSPI(), chip_select()
    { for (uint8_t digit=0; digit < NUM_DIGITS; digit++) digits[digit] = 0; }
@ -300,9 +168,6 @@ public:
  // A digit of 0xFF means blank the screen.
  const static uint8_t blanked = 255;
  uint8_t tubeSegment = 1;
  uint8_t digitOffset = 0;
  void begin() {
    pinMode(TFT_ENABLE_PIN, OUTPUT);
    digitalWrite(TFT_ENABLE_PIN, HIGH); //enable displays on boot
@ -317,53 +182,27 @@ public:
  void showDigit(uint8_t digit) {
    chip_select.setDigit(digit);
    uint8_t digitToDraw = digits[digit];
    if (digitToDraw < 10) digitToDraw += digitOffset;
-    if (digitToDraw == blanked) {
+    if (digits[digit] == blanked) {
-      fillScreen(TFT_BLACK); return;
+      fillScreen(TFT_BLACK);
    }
-
+    else {
-    // if last digit was the same, skip loading from FS to buffer
+      // Filenames are no bigger than "255.bmp\0"
    if (!digitColor && digitToDraw == bufferedDigit) drawBuffer();
    digitR = R(digitColor); digitG = G(digitColor); digitB = B(digitColor);
    // Filenames are no bigger than "254.bmp\0"
      char file_name[10];
-    // Fastest, raw RGB565
+      sprintf(file_name, "/%d.bmp", digits[digit]);
    sprintf(file_name, "/%d.bin", digitToDraw);
      if (WLED_FS.exists(file_name)) {
-      if (drawBin(file_name)) bufferedDigit = digitToDraw;
+        drawBmp(file_name);
-      return;
+      } else {
        sprintf(file_name, "/%d.bin", digits[digit]);
        drawBin(file_name);
      }
    // Fast, raw RGB565, see https://github.com/aly-fly/EleksTubeHAX on how to create this clk format
    sprintf(file_name, "/%d.clk", digitToDraw);
    if (WLED_FS.exists(file_name)) {
      if (drawClk(file_name)) bufferedDigit = digitToDraw;
      return;
    }
    // Slow, regular RGB888 or 1,4,8 bit palette BMP
    sprintf(file_name, "/%d.bmp", digitToDraw);
    if (drawBmp(file_name)) bufferedDigit = digitToDraw;
    return;
  }
  void setDigit(uint8_t digit, uint8_t value, show_t show=yes) {
    uint8_t old_value = digits[digit];
    digits[digit] = value;
    // Color in grayscale bitmaps if Segment 1 exists
    // TODO If secondary and tertiary are black, color all in primary,
    // else color first three from Seg 1 color slots and last three from Seg 2 color slots
    Segment& seg1 = strip.getSegment(tubeSegment);
    if (seg1.isActive()) {
      digitColor = strip.getPixelColor(seg1.start + digit);
      dimming = seg1.opacity;
    } else {
      digitColor = 0;
      dimming = 255;
    }
    if (show != no && (old_value != value || show == force)) {
      showDigit(digit);
    }
--- a/usermods/EleksTube_IPS/readme.md
+++ b/usermods/EleksTube_IPS/readme.md
@ -5,17 +5,16 @@ It enables running all WLED effects on the background SK6812 lighting, while dis
 Code is largely based on https://github.com/SmittyHalibut/EleksTubeHAX by Mark Smith!
 Supported:
- Display with custom bitmaps (.bmp) or raw RGB565 images (.bin) from filesystem
+- Display with custom bitmaps or raw RGB565 images (.bin) from filesystem
 - Background lighting
- All 4 hardware buttons
+- Power button
 - RTC (with RTC usermod)
 - Standard WLED time features (NTP, DST, timezones)
 Not supported:
- On-device setup with buttons (WiFi setup only)
+- 3 navigation buttons, on-device setup
-Your images must be 1-135 pixels wide and 1-240 pixels high.
+Your images must be exactly 135 pixels wide and 1-240 pixels high.
 BMP 1, 4, 8, and 24 bits per pixel formats are supported.
 ## Installation 
@ -26,20 +25,7 @@ Use LED pin 12, relay pin 27 and button pin 34.
 ## Use of RGB565 images
-Binary 16-bit per pixel RGB565 format `.bin` and `.clk` images are now supported. This has the benefit of using only 2/3rds of the file space a 24 BPP `.bmp` occupies.
+Binary 16-bit per pixel RGB565 format `.bin` images are now supported. This has the benefit of only using 2/3rds of the file size a `.bmp` has.
-The drawback is this format cannot be handled by common image programs and an extra conversion step is needed.
+The drawback is that this format cannot be handled by common image programs and that an extra conversion step is needed.
-You can use https://lvgl.io/tools/imageconverter to convert your .bmp to a .bin file (settings `True color` and `Binary RGB565`).  
+You can use https://lvgl.io/tools/imageconverter to convert your .bmp to a .bin file (settings `True color` and `Binary RGB565`)
-Thank you to @RedNax67 for adding .bin and .clk support.  
+Thank you to @RedNax67 for adding .bin support.
 For most clockface designs, using 4 or 8 BPP BMP format will reduce file size even more:
 | Bits per pixel | File size in kB (for 135x240 img) | % of 24 BPP BMP | Max unique colors
 | --- | --- | --- | --- |
 24 | 98 | 100% | 16M (66K)
 16 (.clk) | 64.8 | 66% | 66K
 8 | 33.7 | 34% | 256
 4 | 16.4 | 17% | 16
 1 | 4.9 | 5% | 2
 Comparison 1 vs. 4 vs. 8 vs. 24 BPP. With this clockface on the actual clock, 4 bit looks good, and 8 bit is almost indistinguishable from 24 bit.
 ![comparison](https://user-images.githubusercontent.com/21045690/156899667-5b55ed9f-6e03-4066-b2aa-1260e9570369.png)
--- a/usermods/EleksTube_IPS/usermod_elekstube_ips.h
+++ b/usermods/EleksTube_IPS/usermod_elekstube_ips.h
@ -6,13 +6,6 @@
 class ElekstubeIPSUsermod : public Usermod {
  private:
    // strings to reduce flash memory usage (used more than twice)
    static const char _name[];
    static const char _tubeSeg[];
    static const char _digitOffset[];
    char cronixieDisplay[7] = "HHMMSS";
    TFTs tfts;
    void updateClockDisplay(TFTs::show_t show=TFTs::yes) {
      bool set[6] = {false}; 
@ -28,8 +21,6 @@ class ElekstubeIPSUsermod : public Usermod {
          set[i] = false; //display HHMMSS time
        }
      }
      uint8_t hr = hour(localTime);
      uint8_t hrTens = hr/10;
      uint8_t mi = minute(localTime);
@ -46,10 +37,6 @@ class ElekstubeIPSUsermod : public Usermod {
    unsigned long lastTime = 0;
  public:
    uint8_t lastBri;
    uint32_t lastCols[6];
    TFTs::show_t fshow=TFTs::yes;
    void setup() {
      tfts.begin();
      tfts.fillScreen(TFT_BLACK);
@ -60,90 +47,10 @@ class ElekstubeIPSUsermod : public Usermod {
    }
    void loop() {
-      if (!toki.isTick()) return;
+      if (toki.isTick()) {
        updateLocalTime();
-
+        updateClockDisplay();
      Segment& seg1 = strip.getSegment(tfts.tubeSegment);
      if (seg1.isActive()) {
        bool update = false;
        if (seg1.opacity != lastBri) update = true;
        lastBri = seg1.opacity;
        for (uint8_t i = 0; i < 6; i++) {
          uint32_t c = strip.getPixelColor(seg1.start + i);
          if (c != lastCols[i]) update = true;
          lastCols[i] = c;
      }
        if (update) fshow=TFTs::force;
      } else if (lastCols[0] != 0) { // Segment 1 deleted
        fshow=TFTs::force;
        lastCols[0] = 0;
      }
      updateClockDisplay(fshow);
      fshow=TFTs::yes;
    }
    /**
     * addToConfig() (called from set.cpp) stores persistent properties to cfg.json
     */
    void addToConfig(JsonObject &root) {
      // we add JSON object: {"EleksTubeIPS": {"tubeSegment": 1, "digitOffset": 0}}
      JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
      top[FPSTR(_tubeSeg)] = tfts.tubeSegment;
      top[FPSTR(_digitOffset)] = tfts.digitOffset;
      DEBUG_PRINTLN(F("EleksTube config saved."));
    }
    /**
     * readFromConfig() is called before setup() to populate properties from values stored in cfg.json
     *
     * The function should return true if configuration was successfully loaded or false if there was no configuration.
     */
    bool readFromConfig(JsonObject &root) {
      // we look for JSON object: {"EleksTubeIPS": {"tubeSegment": 1, "digitOffset": 0}}
      DEBUG_PRINT(FPSTR(_name));
      JsonObject top = root[FPSTR(_name)];
      if (top.isNull()) {
        DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
        return false;
      }
      tfts.tubeSegment = top[FPSTR(_tubeSeg)] | tfts.tubeSegment;
      uint8_t digitOffsetPrev = tfts.digitOffset;
      tfts.digitOffset = top[FPSTR(_digitOffset)] | tfts.digitOffset;
      if (tfts.digitOffset > 240) tfts.digitOffset = 240;
      if (tfts.digitOffset != digitOffsetPrev) fshow=TFTs::force;
      // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
      return !top[FPSTR(_digitOffset)].isNull();
    }
    /*
     * 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)
    {
      root["nx"] = cronixieDisplay;
      root[FPSTR(_digitOffset)] = tfts.digitOffset;
    }
    /*
     * 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)
    {
      if (root["nx"].is<const char*>()) {
        strncpy(cronixieDisplay, root["nx"], 6);
      }
      uint8_t digitOffsetPrev = tfts.digitOffset;
      tfts.digitOffset = root[FPSTR(_digitOffset)] | tfts.digitOffset;
      if (tfts.digitOffset > 240) tfts.digitOffset = 240;
      if (tfts.digitOffset != digitOffsetPrev) fshow=TFTs::force;
    }
    uint16_t getId()
@ -151,8 +58,3 @@ class ElekstubeIPSUsermod : public Usermod {
      return USERMOD_ID_ELEKSTUBE_IPS;
    }
 };
 // strings to reduce flash memory usage (used more than twice)
 const char ElekstubeIPSUsermod::_name[]         PROGMEM = "EleksTubeIPS";
 const char ElekstubeIPSUsermod::_tubeSeg[]      PROGMEM = "tubeSegment";
 const char ElekstubeIPSUsermod::_digitOffset[]  PROGMEM = "digitOffset";
--- a/usermods/Enclosure_with_OLED_temp_ESP07/readme.md
+++ b/usermods/Enclosure_with_OLED_temp_ESP07/readme.md
@ -10,7 +10,7 @@ For BME280 sensor use usermod_bme280.cpp. Copy to wled00 and rename to usermod.c
 ## Features
 -   SSD1306 128x32 and 128x64 I2C OLED display
 -   On screen IP address, SSID and controller status (e.g. ON or OFF, recent effect)
-   Auto display shutoff for extending display lifetime
+-   Auto display shutoff for saving display lifetime
 -   Dallas temperature sensor
 -   Reporting temperature to MQTT broker
@ -39,15 +39,15 @@ default_envs = esp07
 ...
 lib_deps_external =
  ...
-  #To use the SSD1306 OLED display, uncomment following
+  #For use SSD1306 OLED display uncomment following
  U8g2@~2.27.3
-  #For Dallas sensor, uncomment the following 2 lines
+  #For Dallas sensor uncomment following 2 lines
  DallasTemperature@~3.8.0
  OneWire@~2.3.5
 ...
 ```
-For BME280 sensor, uncomment `U8g2@~2.27.3`,`BME280@~3.0.0 under` `[common]` section in `platformio.ini`:
+For BME280 sensor uncomment `U8g2@~2.27.3`,`BME280@~3.0.0 under` `[common]` section in `platformio.ini`:
 ```ini
 # platformio.ini
 ...
@ -60,7 +60,7 @@ default_envs = esp07
 ...
 lib_deps_external =
  ...
-  #To use the SSD1306 OLED display, uncomment following
+  #For use SSD1306 OLED display uncomment following
  U8g2@~2.27.3
  #For BME280 sensor uncomment following
  BME280@~3.0.0
--- a/usermods/Enclosure_with_OLED_temp_ESP07/usermod.cpp
+++ b/usermods/Enclosure_with_OLED_temp_ESP07/usermod.cpp
@ -1,7 +1,3 @@
 #ifndef WLED_ENABLE_MQTT
 #error "This user mod requires MQTT to be enabled."
 #endif
 #include "wled.h"
 #include <Arduino.h>
 #include <U8x8lib.h> // from https://github.com/olikraus/u8g2/
@ -104,9 +100,9 @@ void userLoop() {
    needRedraw = true;
  } else if (knownBrightness != bri) {
    needRedraw = true;
-  } else if (knownMode != strip.getMainSegment().mode) {
+  } else if (knownMode != strip.getMode()) {
    needRedraw = true;
-  } else if (knownPalette != strip.getMainSegment().palette) {
+  } else if (knownPalette != strip.getSegment(0).palette) {
    needRedraw = true;
  }
@ -130,8 +126,8 @@ void userLoop() {
  #endif
  knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
  knownBrightness = bri;
-  knownMode = strip.getMainSegment().mode;
+  knownMode = strip.getMode();
-  knownPalette = strip.getMainSegment().palette;
+  knownPalette = strip.getSegment(0).palette;
  u8x8.clear();
  u8x8.setFont(u8x8_font_chroma48medium8_r);
@ -152,14 +148,58 @@ void userLoop() {
  // Third row with mode name
  u8x8.setCursor(2, 2);
-  char lineBuffer[17];
+  uint8_t qComma = 0;
-  extractModeName(knownMode, JSON_mode_names, lineBuffer, 16);
+  bool insideQuotes = false;
-  u8x8.print(lineBuffer);
+  uint8_t printedChars = 0;
  char singleJsonSymbol;
  // Find the mode name in JSON
  for (size_t i = 0; i < strlen_P(JSON_mode_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_mode_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownMode))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  // Fourth row with palette name
  u8x8.setCursor(2, 3);
-  extractModeName(knownPalette, JSON_palette_names, lineBuffer, 16);
+  qComma = 0;
-  u8x8.print(lineBuffer);
+  insideQuotes = false;
  printedChars = 0;
  // Looking for palette name in JSON.
  for (size_t i = 0; i < strlen_P(JSON_palette_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_palette_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownPalette))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  u8x8.setFont(u8x8_font_open_iconic_embedded_1x1);
  u8x8.drawGlyph(0, 0, 80); // wifi icon
--- a/usermods/Enclosure_with_OLED_temp_ESP07/usermod_bme280.cpp
+++ b/usermods/Enclosure_with_OLED_temp_ESP07/usermod_bme280.cpp
@ -1,7 +1,3 @@
 #ifndef WLED_ENABLE_MQTT
 #error "This user mod requires MQTT to be enabled."
 #endif
 #include "wled.h"
 #include <Arduino.h>
 #include <U8x8lib.h> // from https://github.com/olikraus/u8g2/
@ -147,9 +143,9 @@ void userLoop() {
    needRedraw = true;
  } else if (knownBrightness != bri) {
    needRedraw = true;
-  } else if (knownMode != strip.getMainSegment().mode) {
+  } else if (knownMode != strip.getMode()) {
    needRedraw = true;
-  } else if (knownPalette != strip.getMainSegment().palette) {
+  } else if (knownPalette != strip.getSegment(0).palette) {
    needRedraw = true;
  }
@ -173,8 +169,8 @@ void userLoop() {
  #endif
  knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
  knownBrightness = bri;
-  knownMode = strip.getMainSegment().mode;
+  knownMode = strip.getMode();
-  knownPalette = strip.getMainSegment().palette;
+  knownPalette = strip.getSegment(0).palette;
  u8x8.clear();
  u8x8.setFont(u8x8_font_chroma48medium8_r);
@ -195,14 +191,58 @@ void userLoop() {
  // Third row with mode name
  u8x8.setCursor(2, 2);
-  char lineBuffer[17];
+  uint8_t qComma = 0;
-  extractModeName(knownMode, JSON_mode_names, lineBuffer, 16);
+  bool insideQuotes = false;
-  u8x8.print(lineBuffer);
+  uint8_t printedChars = 0;
  char singleJsonSymbol;
  // Find the mode name in JSON
  for (size_t i = 0; i < strlen_P(JSON_mode_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_mode_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownMode))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  // Fourth row with palette name
  u8x8.setCursor(2, 3);
-  extractModeName(knownPalette, JSON_palette_names, lineBuffer, 16);
+  qComma = 0;
-  u8x8.print(lineBuffer);
+  insideQuotes = false;
  printedChars = 0;
  // Looking for palette name in JSON.
  for (size_t i = 0; i < strlen_P(JSON_palette_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_palette_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownPalette))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  u8x8.setFont(u8x8_font_open_iconic_embedded_1x1);
  u8x8.drawGlyph(0, 0, 80); // wifi icon
--- a/usermods/Fix_unreachable_netservices_v2/readme.md
+++ b/usermods/Fix_unreachable_netservices_v2/readme.md
@ -2,16 +2,15 @@
 **Attention: This usermod compiles only for ESP8266**
-This usermod-v2 modification performs a ping request to a local IP address every 60 seconds. This ensures WLED net services remain accessible in some problematic WLAN environments.
+This usermod-v2 modification performs a ping request to the local IP address every 60 seconds. By this procedure the net services of WLED remains accessible in some problematic WLAN environments.
 The modification works with static or DHCP IP address configuration.
 _Story:_
-Unfortunately, with many ESP projects where a web server or other network services are running, after some time, the connecton to the web server is lost.
+Unfortunately, with all ESP projects where a web server or other network services are running, I have the problem that after some time the web server is no longer accessible.  Now I found out that the connection is at least reestablished when a ping request is executed by the device.
 The connection can be reestablished with a ping request from the device.
-With this modification, in the worst case, the network functions are not available until the next ping request. (60 seconds)
+With this modification, in the worst case, the network functions are not available for 60 seconds until the next ping request.
 ## Webinterface
--- a/usermods/Internal_Temperature_v2/readme.md
+++ b/usermods/Internal_Temperature_v2/readme.md
@ -1,17 +0,0 @@
 # Internal Temperature Usermod
 This usermod adds the temperature readout to the Info tab and also publishes that over the topic `mcutemp` topic.
 ## Important
 A shown temp of 53,33°C might indicate that the internal temp is not supported.
 ESP8266 does not have a internal temp sensor
 ESP32S2 seems to crash on reading the sensor -> disabled
 ## Installation
 Add a build flag `-D USERMOD_INTERNAL_TEMPERATURE` to your `platformio.ini` (or `platformio_override.ini`).
 ## Authors
 Soeren Willrodt [@lost-hope](https://github.com/lost-hope)
 Dimitry Zhemkov [@dima-zhemkov](https://github.com/dima-zhemkov)
--- a/usermods/Internal_Temperature_v2/usermod_internal_temperature.h
+++ b/usermods/Internal_Temperature_v2/usermod_internal_temperature.h
@ -1,117 +0,0 @@
 #pragma once
 #include "wled.h"
 class InternalTemperatureUsermod : public Usermod
 {
 private:
  unsigned long loopInterval = 10000;
  unsigned long lastTime = 0;
  bool isEnabled = false;
  float temperature = 0;
  static const char _name[];
  static const char _enabled[];
  static const char _loopInterval[];
  // any private methods should go here (non-inline methosd should be defined out of class)
  void publishMqtt(const char *state, bool retain = false); // example for publishing MQTT message
 public:
  void setup()
  {
  }
  void loop()
  {
    // if usermod is disabled or called during strip updating just exit
    // NOTE: on very long strips strip.isUpdating() may always return true so update accordingly
    if (!isEnabled || strip.isUpdating() || millis() - lastTime <= loopInterval)
      return;
    lastTime = millis();
 #ifdef ESP8266 // ESP8266
    // does not seem possible
    temperature = -1;
 #elif defined(CONFIG_IDF_TARGET_ESP32S2) // ESP32S2
    temperature = -1;
 #else                                    // ESP32 ESP32S3 and ESP32C3
    temperature = roundf(temperatureRead() * 10) / 10;
 #endif
 #ifndef WLED_DISABLE_MQTT
    if (WLED_MQTT_CONNECTED)
    {
      char array[10];
      snprintf(array, sizeof(array), "%f", temperature);
      publishMqtt(array);
    }
 #endif
  }
  void addToJsonInfo(JsonObject &root)
  {
    if (!isEnabled)
      return;
    // if "u" object does not exist yet wee need to create it
    JsonObject user = root["u"];
    if (user.isNull())
      user = root.createNestedObject("u");
    JsonArray userTempArr = user.createNestedArray(FPSTR(_name));
    userTempArr.add(temperature);
    userTempArr.add(F(" °C"));
    // if "sensor" object does not exist yet wee need to create it
    JsonObject sensor = root[F("sensor")];
    if (sensor.isNull())
      sensor = root.createNestedObject(F("sensor"));
    JsonArray sensorTempArr = sensor.createNestedArray(FPSTR(_name));
    sensorTempArr.add(temperature);
    sensorTempArr.add(F("°C"));
  }
  void addToConfig(JsonObject &root)
  {
    JsonObject top = root.createNestedObject(FPSTR(_name));
    top[FPSTR(_enabled)] = isEnabled;
    top[FPSTR(_loopInterval)] = loopInterval;
  }
  bool readFromConfig(JsonObject &root)
  {
    JsonObject top = root[FPSTR(_name)];
    bool configComplete = !top.isNull();
    configComplete &= getJsonValue(top[FPSTR(_enabled)], isEnabled);
    configComplete &= getJsonValue(top[FPSTR(_loopInterval)], loopInterval);
    return configComplete;
  }
  uint16_t getId()
  {
    return USERMOD_ID_INTERNAL_TEMPERATURE;
  }
 };
 const char InternalTemperatureUsermod::_name[] PROGMEM = "Internal Temperature";
 const char InternalTemperatureUsermod::_enabled[] PROGMEM = "Enabled";
 const char InternalTemperatureUsermod::_loopInterval[] PROGMEM = "Loop Interval";
 void InternalTemperatureUsermod::publishMqtt(const char *state, bool retain)
 {
 #ifndef WLED_DISABLE_MQTT
  // Check if MQTT Connected, otherwise it will crash the 8266
  if (WLED_MQTT_CONNECTED)
  {
    char subuf[64];
    strcpy(subuf, mqttDeviceTopic);
    strcat_P(subuf, PSTR("/mcutemp"));
    mqtt->publish(subuf, 0, retain, state);
  }
 #endif
 }
--- a/usermods/JSON_IR_remote/readme.md
+++ b/usermods/JSON_IR_remote/readme.md
@ -2,8 +2,8 @@
 ## Purpose 
-The JSON IR remote enables users to customize IR remote behavior without writing custom code and compiling. 
+The JSON IR remote allows users to customize IR remote behavior without writing custom code and compiling. 
-It also allows using any remote compatible with your IR receiver. Using the JSON IR remote, you can
+It also enables using any remote that is compatible with your IR receiver. Using the JSON IR remote, you can
 map buttons from any remote to any HTTP request API or JSON API command.  
 ## Usage
--- a/usermods/MY9291/MY92xx.h
+++ b/usermods/MY9291/MY92xx.h
@ -1,321 +0,0 @@
 /*
 MY92XX LED Driver for Arduino
 Based on the C driver by MaiKe Labs
 Copyright (c) 2016 - 2026 MaiKe Labs
 Copyright (C) 2017 - 2018 Xose Pérez for the Arduino compatible library
 This program 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.
 This program 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/>.
 */
 #ifndef _my92xx_h
 #define _my92xx_h
 #include <Arduino.h>
 #ifdef DEBUG_MY92XX
 #if ARDUINO_ARCH_ESP8266
 #define DEBUG_MSG_MY92XX(...) DEBUG_MY92XX.printf( __VA_ARGS__ )
 #elif ARDUINO_ARCH_AVR
 #define DEBUG_MSG_MY92XX(...) { char buffer[80]; snprintf(buffer, sizeof(buffer),  __VA_ARGS__ ); DEBUG_MY92XX.print(buffer); }
 #endif
 #else
 #define DEBUG_MSG_MY92XX(...)
 #endif
 typedef enum my92xx_model_t {
    MY92XX_MODEL_MY9291 = 0X00,
    MY92XX_MODEL_MY9231 = 0X01,
 } my92xx_model_t;
 typedef enum my92xx_cmd_one_shot_t {
    MY92XX_CMD_ONE_SHOT_DISABLE = 0X00,
    MY92XX_CMD_ONE_SHOT_ENFORCE = 0X01,
 } my92xx_cmd_one_shot_t;
 typedef enum my92xx_cmd_reaction_t {
    MY92XX_CMD_REACTION_FAST = 0X00,
    MY92XX_CMD_REACTION_SLOW = 0X01,
 } my92xx_cmd_reaction_t;
 typedef enum my92xx_cmd_bit_width_t {
    MY92XX_CMD_BIT_WIDTH_16 = 0X00,
    MY92XX_CMD_BIT_WIDTH_14 = 0X01,
    MY92XX_CMD_BIT_WIDTH_12 = 0X02,
    MY92XX_CMD_BIT_WIDTH_8 = 0X03,
 } my92xx_cmd_bit_width_t;
 typedef enum my92xx_cmd_frequency_t {
    MY92XX_CMD_FREQUENCY_DIVIDE_1 = 0X00,
    MY92XX_CMD_FREQUENCY_DIVIDE_4 = 0X01,
    MY92XX_CMD_FREQUENCY_DIVIDE_16 = 0X02,
    MY92XX_CMD_FREQUENCY_DIVIDE_64 = 0X03,
 } my92xx_cmd_frequency_t;
 typedef enum my92xx_cmd_scatter_t {
    MY92XX_CMD_SCATTER_APDM = 0X00,
    MY92XX_CMD_SCATTER_PWM = 0X01,
 } my92xx_cmd_scatter_t;
 typedef struct {
    my92xx_cmd_scatter_t scatter : 1;
    my92xx_cmd_frequency_t frequency : 2;
    my92xx_cmd_bit_width_t bit_width : 2;
    my92xx_cmd_reaction_t reaction : 1;
    my92xx_cmd_one_shot_t one_shot : 1;
    unsigned char resv : 1;
 } __attribute__((aligned(1), packed)) my92xx_cmd_t;
 #define MY92XX_COMMAND_DEFAULT { \
    .scatter = MY92XX_CMD_SCATTER_APDM, \
    .frequency = MY92XX_CMD_FREQUENCY_DIVIDE_1, \
    .bit_width = MY92XX_CMD_BIT_WIDTH_8, \
    .reaction = MY92XX_CMD_REACTION_FAST, \
    .one_shot = MY92XX_CMD_ONE_SHOT_DISABLE, \
    .resv = 0 \
 }
 class my92xx {
 public:
    my92xx(my92xx_model_t model, unsigned char chips, unsigned char di, unsigned char dcki, my92xx_cmd_t command);
    unsigned char getChannels();
    void setChannel(unsigned char channel, unsigned int value);
    unsigned int getChannel(unsigned char channel);
    void setState(bool state);
    bool getState();
    void update();
 private:
    void _di_pulse(unsigned int times);
    void _dcki_pulse(unsigned int times);
    void _set_cmd(my92xx_cmd_t command);
    void _send();
    void _write(unsigned int data, unsigned char bit_length);
    my92xx_cmd_t _command;
    my92xx_model_t _model = MY92XX_MODEL_MY9291;
    unsigned char _chips = 1;
    unsigned char _channels;
    uint16_t* _value;
    bool _state = false;
    unsigned char _pin_di;
    unsigned char _pin_dcki;
 };
 #if ARDUINO_ARCH_ESP8266
 extern "C" {
    void os_delay_us(unsigned int);
 }
 #elif ARDUINO_ARCH_AVR
 #define os_delay_us delayMicroseconds
 #endif
 void my92xx::_di_pulse(unsigned int times) {
    for (unsigned int i = 0; i < times; i++) {
        digitalWrite(_pin_di, HIGH);
        digitalWrite(_pin_di, LOW);
    }
 }
 void my92xx::_dcki_pulse(unsigned int times) {
    for (unsigned int i = 0; i < times; i++) {
        digitalWrite(_pin_dcki, HIGH);
        digitalWrite(_pin_dcki, LOW);
    }
 }
 void my92xx::_write(unsigned int data, unsigned char bit_length) {
    unsigned int mask = (0x01 << (bit_length - 1));
    for (unsigned int i = 0; i < bit_length / 2; i++) {
        digitalWrite(_pin_dcki, LOW);
        digitalWrite(_pin_di, (data & mask) ? HIGH : LOW);
        digitalWrite(_pin_dcki, HIGH);
        data = data << 1;
        digitalWrite(_pin_di, (data & mask) ? HIGH : LOW);
        digitalWrite(_pin_dcki, LOW);
        digitalWrite(_pin_di, LOW);
        data = data << 1;
    }
 }
 void my92xx::_set_cmd(my92xx_cmd_t command) {
    // ets_intr_lock();
    // TStop > 12us.
    os_delay_us(12);
    // Send 12 DI pulse, after 6 pulse's falling edge store duty data, and 12
    // pulse's rising edge convert to command mode.
    _di_pulse(12);
    // Delay >12us, begin send CMD data
    os_delay_us(12);
    // Send CMD data
    unsigned char command_data = *(unsigned char*)(&command);
    for (unsigned char i = 0; i < _chips; i++) {
        _write(command_data, 8);
    }
    // TStart > 12us. Delay 12 us.
    os_delay_us(12);
    // Send 16 DI pulse，at 14 pulse's falling edge store CMD data, and
    // at 16 pulse's falling edge convert to duty mode.
    _di_pulse(16);
    // TStop > 12us.
    os_delay_us(12);
    // ets_intr_unlock();
 }
 void my92xx::_send() {
 #ifdef DEBUG_MY92XX
    DEBUG_MSG_MY92XX("[MY92XX] Refresh: %s (", _state ? "ON" : "OFF");
    for (unsigned char channel = 0; channel < _channels; channel++) {
        DEBUG_MSG_MY92XX(" %d", _value[channel]);
    }
    DEBUG_MSG_MY92XX(" )\n");
 #endif
    unsigned char bit_length = 8;
    switch (_command.bit_width) {
    case MY92XX_CMD_BIT_WIDTH_16:
        bit_length = 16;
        break;
    case MY92XX_CMD_BIT_WIDTH_14:
        bit_length = 14;
        break;
    case MY92XX_CMD_BIT_WIDTH_12:
        bit_length = 12;
        break;
    case MY92XX_CMD_BIT_WIDTH_8:
        bit_length = 8;
        break;
    default:
        bit_length = 8;
        break;
    }
    // ets_intr_lock();
    // TStop > 12us.
    os_delay_us(12);
    // Send color data
    for (unsigned char channel = 0; channel < _channels; channel++) {
        _write(_state ? _value[channel] : 0, bit_length);
    }
    // TStart > 12us. Ready for send DI pulse.
    os_delay_us(12);
    // Send 8 DI pulse. After 8 pulse falling edge, store old data.
    _di_pulse(8);
    // TStop > 12us.
    os_delay_us(12);
    // ets_intr_unlock();
 }
 // -----------------------------------------------------------------------------
 unsigned char my92xx::getChannels() {
    return _channels;
 }
 void my92xx::setChannel(unsigned char channel, unsigned int value) {
    if (channel < _channels) {
        _value[channel] = value;
    }
 }
 unsigned int my92xx::getChannel(unsigned char channel) {
    if (channel < _channels) {
        return _value[channel];
    }
    return 0;
 }
 bool my92xx::getState() {
    return _state;
 }
 void my92xx::setState(bool state) {
    _state = state;
 }
 void my92xx::update() {
    _send();
 }
 // -----------------------------------------------------------------------------
 my92xx::my92xx(my92xx_model_t model, unsigned char chips, unsigned char di, unsigned char dcki, my92xx_cmd_t command) : _command(command) {
    _model = model;
    _chips = chips;
    _pin_di = di;
    _pin_dcki = dcki;
    // Init channels
    if (_model == MY92XX_MODEL_MY9291) {
        _channels = 4 * _chips;
    }
    else if (_model == MY92XX_MODEL_MY9231) {
        _channels = 3 * _chips;
    }
    _value = new uint16_t[_channels];
    for (unsigned char i = 0; i < _channels; i++) {
        _value[i] = 0;
    }
    // Init GPIO
    pinMode(_pin_di, OUTPUT);
    pinMode(_pin_dcki, OUTPUT);
    digitalWrite(_pin_di, LOW);
    digitalWrite(_pin_dcki, LOW);
    // Clear all duty register
    _dcki_pulse(32 * _chips);
    // Send init command
    _set_cmd(command);
    DEBUG_MSG_MY92XX("[MY92XX] Initialized\n");
 }
 #endif
--- a/usermods/MY9291/usermode_MY9291.h
+++ b/usermods/MY9291/usermode_MY9291.h
@ -1,45 +0,0 @@
 #pragma once
 #include "wled.h"
 #include "MY92xx.h"
 #define MY92XX_MODEL        MY92XX_MODEL_MY9291
 #define MY92XX_CHIPS        1
 #define MY92XX_DI_PIN       13
 #define MY92XX_DCKI_PIN     15
 #define MY92XX_RED          0
 #define MY92XX_GREEN        1
 #define MY92XX_BLUE         2
 #define MY92XX_WHITE        3
 class MY9291Usermod : public Usermod {
  private:
    my92xx _my92xx = my92xx(MY92XX_MODEL, MY92XX_CHIPS, MY92XX_DI_PIN, MY92XX_DCKI_PIN, MY92XX_COMMAND_DEFAULT);
  public:
    void setup() {
      _my92xx.setState(true);
    }
    void connected() {
    }
    void loop() {
      uint32_t c = strip.getPixelColor(0);
      int w = ((c >> 24) & 0xff) * bri / 255.0;
      int r = ((c >> 16) & 0xff) * bri / 255.0;
      int g = ((c >> 8) & 0xff) * bri / 255.0;
      int b = (c & 0xff) * bri / 255.0;
      _my92xx.setChannel(MY92XX_RED, r);
      _my92xx.setChannel(MY92XX_GREEN, g);
      _my92xx.setChannel(MY92XX_BLUE, b);
      _my92xx.setChannel(MY92XX_WHITE, w);
      _my92xx.update();
    }
    uint16_t getId() {
      return USERMOD_ID_MY9291;
    }
 };
--- a/usermods/PIR_sensor_mqtt_v1/README.md
+++ b/usermods/PIR_sensor_mqtt_v1/README.md
@ -0,0 +1,9 @@
 # PIR sensor with MQTT
 This simple usermod allows attaching a PIR sensor like the AM312 and publish the readings over MQTT. A message is sent when motion is detected as well as when motion has stopped.
 This usermod has only been tested with the AM312 sensor though should work for any other PIR sensor. Note that this does not control the LED strip directly, it only publishes MQTT readings for use with other integrations like Home Assistant.
 ## Installation
 Copy and replace the file `usermod.cpp` in wled00 directory.
--- a/usermods/PIR_sensor_mqtt_v1/usermod.cpp
+++ b/usermods/PIR_sensor_mqtt_v1/usermod.cpp
@ -0,0 +1,55 @@
 #include "wled.h"
 /*
 * This v1 usermod file allows you to add own functionality to WLED more easily
 * See: https://github.com/Aircoookie/WLED/wiki/Add-own-functionality
 * EEPROM bytes 2750+ are reserved for your custom use case. (if you extend #define EEPSIZE in const.h)
 * If you just need 8 bytes, use 2551-2559 (you do not need to increase EEPSIZE)
 * 
 * Consider the v2 usermod API if you need a more advanced feature set!
 */
 //Use userVar0 and userVar1 (API calls &U0=,&U1=, uint16_t)
 // PIR sensor pin
 const int MOTION_PIN = 16;
 // MQTT topic for sensor values
 const char MQTT_TOPIC[] = "/motion";
 int prevState = LOW;
 //gets called once at boot. Do all initialization that doesn't depend on network here
 void userSetup()
 {
  pinMode(MOTION_PIN, INPUT);
 }
 //gets called every time WiFi is (re-)connected. Initialize own network interfaces here
 void userConnected()
 {
 }
 void publishMqtt(String state)
 {
  //Check if MQTT Connected, otherwise it will crash the 8266
  if (mqtt != nullptr){
    char subuf[38];
    strcpy(subuf, mqttDeviceTopic);
    strcat(subuf, MQTT_TOPIC);
    mqtt->publish(subuf, 0, true, state.c_str());
  }
 }
 //loop. You can use "if (WLED_CONNECTED)" to check for successful connection
 void userLoop()
 {
  if (digitalRead(MOTION_PIN) == HIGH && prevState == LOW) { // Motion detected
    publishMqtt("ON");
    prevState = HIGH;
  } 
  if (digitalRead(MOTION_PIN) == LOW && prevState == HIGH) {  // Motion stopped
    publishMqtt("OFF");
    prevState = LOW;
  }
 }
--- a/usermods/PIR_sensor_switch/PIR_Highlight_Standby
+++ b/usermods/PIR_sensor_switch/PIR_Highlight_Standby
@ -61,7 +61,7 @@ class PIRsensorSwitch : public Usermod {
  private:
    // PIR sensor pin
    const uint8_t PIRsensorPin = 13; // D7 on D1 mini
-    // notification mode for stateUpdated()
+    // notification mode for colorUpdated()
    const byte NotifyUpdateMode = CALL_MODE_NO_NOTIFY; // CALL_MODE_DIRECT_CHANGE
    // 1 min delay before switch off after the sensor state goes LOW
    uint32_t m_switchOffDelay = 60000;
@ -127,7 +127,7 @@ class PIRsensorSwitch : public Usermod {
        if (bri != briHighlight) { 
          bri = briHighlight; // set current highlight brightness to last set highlight brightness
        }
-        stateUpdated(NotifyUpdateMode);
+        colorUpdated(NotifyUpdateMode);
        highlightActive = true; // flag highlight is on
      }    
      else { // **pir timer has elapsed**
@ -157,7 +157,7 @@ class PIRsensorSwitch : public Usermod {
          }
          applyMacro(macroLongPress); // apply standby lighting without brightness
        }
-        stateUpdated(NotifyUpdateMode);
+        colorUpdated(NotifyUpdateMode);
        highlightActive = false; // flag highlight is off
      }
    }
--- a/usermods/PIR_sensor_switch/readme.md
+++ b/usermods/PIR_sensor_switch/readme.md
@ -9,33 +9,66 @@ The LED strip is switched [using a relay](https://github.com/Aircoookie/WLED/wik
 ## Webinterface
-The info page in the web interface shows the remaining time of the off timer. Usermod can also be temporarily disbled/enabled from the info page by clicking PIR button.
+The info page in the web interface shows the remaining time of the off timer. 
 ## Sensor connection
-My setup uses an HC-SR501 or HC-SR602 sensor, an HC-SR505 should also work.
+My setup uses an HC-SR501 sensor, a HC-SR505 should also work.
-The usermod uses GPIO13 (D1 mini pin D7) by default for the sensor signal, but can be changed in the Usermod settings page.
+The usermod uses GPIO13 (D1 mini pin D7) by default for the sensor signal but can be changed in the Usermod settings page.
 [This example page](http://www.esp8266learning.com/wemos-mini-pir-sensor-example.php) describes how to connect the sensor.
-Use the potentiometers on the sensor to set the time delay to the minimum and the sensitivity to about half, or slightly above.
+Use the potentiometers on the sensor to set the time-delay to the minimum and the sensitivity to about half, or slightly above.
 You can also use usermod's off timer instead of sensor's. In such case rotate the potentiometer to its shortest time possible (or use SR602 which lacks such potentiometer).
 ## Usermod installation
-**NOTE:** Usermod has been included in master branch of WLED so it can be compiled in directly just by defining `-D USERMOD_PIRSWITCH` and optionaly `-D PIR_SENSOR_PIN=16` to override default pin. You can also change the default off time by adding `-D PIR_SENSOR_OFF_SEC=30`.
+1. Copy the file `usermod_PIR_sensor_switch.h` to the `wled00` directory.
 2. Register the usermod by adding `#include "usermod_PIR_sensor_switch.h"` in the top and `registerUsermod(new PIRsensorSwitch());` in the bottom of `usermods_list.cpp`.
-## API to enable/disable the PIR sensor from outside. For example from another usermod:
+Example **usermods_list.cpp**:
 ```cpp
 #include "wled.h"
 /*
 * Register your v2 usermods here!
 *   (for v1 usermods using just usermod.cpp, you can ignore this file)
 */
 /*
 * Add/uncomment your usermod filename here (and once more below)
 * || || ||
 * \/ \/ \/
 */
 //#include "usermod_v2_example.h"
 //#include "usermod_temperature.h"
 //#include "usermod_v2_empty.h"
 #include "usermod_PIR_sensor_switch.h"
 void registerUsermods()
 {
  /*
   * Add your usermod class name here
   * || || ||
   * \/ \/ \/
   */
  //usermods.add(new MyExampleUsermod());
  //usermods.add(new UsermodTemperature());
  //usermods.add(new UsermodRenameMe());
  usermods.add(new PIRsensorSwitch());
 }
 ```
 ## API to enable/disable the PIR sensor from outside. For example from another usermod.
 To query or change the PIR sensor state the methods `bool PIRsensorEnabled()` and `void EnablePIRsensor(bool enable)` are available.
 When the PIR sensor state changes an MQTT message is broadcasted with topic `wled/deviceMAC/motion` and message `on` or `off`.
-Usermod can also be configured to send just the MQTT message but not change WLED state using settings page as well as responding to motion only at night
+Usermod can also be configured to just send MQTT message and not change WLED state using settings page as well as responding to motion only during nighttime (assuming NTP and lattitude/longitude are set to determine sunrise/sunset times).
 (assuming NTP and lattitude/longitude are set to determine sunrise/sunset times).
 ### There are two options to get access to the usermod instance:
-1. Include `usermod_PIR_sensor_switch.h` **before** you include other usermods in `usermods_list.cpp'
+1. Include `usermod_PIR_sensor_switch.h` **before** you include the other usermod in `usermods_list.cpp'
 or
@ -62,32 +95,8 @@ class MyUsermod : public Usermod {
 };
 ```
-### Configuration options
+Have fun - @gegu
 Usermod can be configured via the Usermods settings page.
 * `PIRenabled` - enable/disable usermod
 * `pin` - dynamically change GPIO pin where PIR sensor is attached to ESP
 * `PIRoffSec` - number of seconds after PIR sensor deactivates when usermod triggers Off preset (or turns WLED off)
 * `on-preset` - preset triggered when PIR activates (if this is 0 it will just turn WLED on)
 * `off-preset` - preset triggered when PIR deactivates (if this is 0 it will just turn WLED off)
 * `nighttime-only` - enable triggering only between sunset and sunrise (you will need to set up _NTP_, _Lat_ & _Lon_ in Time & Macro settings)
 * `mqtt-only` - send only MQTT messages, do not interact with WLED
 * `off-only` - only trigger presets or turn WLED on/off if WLED is not already on (displaying effect)
 * `notifications` - enable or disable sending notifications to other WLED instances using Sync button
 Have fun - @gegu & @blazoncek
 ## Change log
 2021-04
 * Adaptation for runtime configuration.
 2021-11
 * Added information about dynamic configuration options
 * Added option to temporary enable/disble usermod from WLED UI (Info dialog)
 2022-11
 * Added compile time option for off timer.
 * Added Home Assistant autodiscovery MQTT broadcast.
 * Updated info on compiling.
--- a/usermods/PIR_sensor_switch/usermod_PIR_sensor_switch.h
+++ b/usermods/PIR_sensor_switch/usermod_PIR_sensor_switch.h
@ -11,65 +11,76 @@
  #endif
 #endif
 #ifndef PIR_SENSOR_OFF_SEC
  #define PIR_SENSOR_OFF_SEC 600
 #endif
 /*
 * This usermod handles PIR sensor states.
 * The strip will be switched on and the off timer will be resetted when the sensor goes HIGH. 
 * When the sensor state goes LOW, the off timer is started and when it expires, the strip is switched off. 
- * Maintained by: @blazoncek
+ * 
 * 
 * Usermods allow you to add own functionality to WLED more easily
 * See: https://github.com/Aircoookie/WLED/wiki/Add-own-functionality
 * 
 * v2 usermods are class inheritance based and can (but don't have to) implement more functions, each of them is shown in this example.
 * Multiple v2 usermods can be added to one compilation easily.
 * 
 * Creating a usermod:
 * This file serves as an example. If you want to create a usermod, it is recommended to use usermod_v2_empty.h from the usermods folder as a template.
 * Please remember to rename the class and file to a descriptive name.
 * You may also use multiple .h and .cpp files.
 * 
 * Using a usermod:
 * 1. Copy the usermod into the sketch folder (same folder as wled00.ino)
 * 2. Register the usermod by adding #include "usermod_filename.h" in the top and registerUsermod(new MyUsermodClass()) in the bottom of usermods_list.cpp
 */
 class PIRsensorSwitch : public Usermod
 {
 public:
-  // constructor
+  /**
   * constructor
   */
  PIRsensorSwitch() {}
-  // destructor
+  /**
   * desctructor
   */
  ~PIRsensorSwitch() {}
-  //Enable/Disable the PIR sensor
+  /**
-  inline void EnablePIRsensor(bool en) { enabled = en; }
+   * Enable/Disable the PIR sensor
-  
+   */
-  // Get PIR sensor enabled/disabled state
+  void EnablePIRsensor(bool en) { enabled = en; }
-  inline bool PIRsensorEnabled() { return enabled; }
+  /**
   * Get PIR sensor enabled/disabled state
   */
  bool PIRsensorEnabled() { return enabled; }
 private:
-
+  // PIR sensor pin
-  byte prevPreset   = 0;
+  int8_t PIRsensorPin = PIR_SENSOR_PIN;
-  byte prevPlaylist = 0;
+  // notification mode for colorUpdated()
-
+  const byte NotifyUpdateMode = CALL_MODE_NO_NOTIFY; // CALL_MODE_DIRECT_CHANGE
-  volatile unsigned long offTimerStart = 0;     // off timer start time
+  // delay before switch off after the sensor state goes LOW
-  volatile bool PIRtriggered           = false; // did PIR trigger?
+  uint32_t m_switchOffDelay = 600000; // 10min
-  byte NotifyUpdateMode  = CALL_MODE_NO_NOTIFY; // notification mode for stateUpdated(): CALL_MODE_NO_NOTIFY or CALL_MODE_DIRECT_CHANGE
+  // off timer start time
-  byte sensorPinState    = LOW;                 // current PIR sensor pin state
+  uint32_t m_offTimerStart = 0;
-  bool initDone          = false;               // status of initialization
+  // current PIR sensor pin state
-  unsigned long lastLoop = 0;
+  byte sensorPinState = LOW;
-
+  // PIR sensor enabled
-  // configurable parameters
+  bool enabled = true;
-  bool enabled              = true;           // PIR sensor enabled
+  // status of initialisation
-  int8_t PIRsensorPin       = PIR_SENSOR_PIN; // PIR sensor pin
+  bool initDone = false;
-  uint32_t m_switchOffDelay = PIR_SENSOR_OFF_SEC*1000;  // delay before switch off after the sensor state goes LOW (10min)
+  // on and off presets
-  uint8_t m_onPreset        = 0;              // on preset
+  uint8_t m_onPreset = 0;
-  uint8_t m_offPreset       = 0;              // off preset
+  uint8_t m_offPreset = 0;
-  bool m_nightTimeOnly      = false;          // flag to indicate that PIR sensor should activate WLED during nighttime only
+  // flag to indicate that PIR sensor should activate WLED during nighttime only
-  bool m_mqttOnly           = false;          // flag to send MQTT message only (assuming it is enabled)
+  bool m_nightTimeOnly = false;
  // flag to send MQTT message only (assuming it is enabled)
  bool m_mqttOnly = false;
  // flag to enable triggering only if WLED is initially off (LEDs are not on, preventing running effect being overwritten by PIR)
  bool m_offOnly = false;
-  bool m_offMode            = offMode;
+  bool PIRtriggered = false;
  bool m_override           = false;
-  // Home Assistant
+  unsigned long lastLoop = 0;
  bool HomeAssistantDiscovery = false;        // is HA discovery turned on
  // strings to reduce flash memory usage (used more than twice)
  static const char _name[];
@ -80,35 +91,104 @@ private:
  static const char _nightTime[];
  static const char _mqttOnly[];
  static const char _offOnly[];
  static const char _haDiscovery[];
  static const char _notify[];
  static const char _override[];
  /**
   * check if it is daytime
   * if sunrise/sunset is not defined (no NTP or lat/lon) default to nighttime
   */
-  static bool isDayTime();
+  bool isDayTime() {
    bool isDayTime = false;
    updateLocalTime();
    uint8_t hr = hour(localTime);
    uint8_t mi = minute(localTime);
    if (sunrise && sunset) {
      if (hour(sunrise)<hr && hour(sunset)>hr) {
        isDayTime = true;
      } else {
        if (hour(sunrise)==hr && minute(sunrise)<mi) {
          isDayTime = true;
        }
        if (hour(sunset)==hr && minute(sunset)>mi) {
          isDayTime = true;
        }
      }
    }
    return isDayTime;
  }
  /**
   * switch strip on/off
   */
-  void switchStrip(bool switchOn);
+  void switchStrip(bool switchOn)
-  void publishMqtt(const char* state);
+  {
    if (m_offOnly && bri && (switchOn || (!PIRtriggered && !switchOn))) return;
    PIRtriggered = switchOn;
    if (switchOn && m_onPreset) {
      applyPreset(m_onPreset);
    } else if (!switchOn && m_offPreset) {
      applyPreset(m_offPreset);
    } else if (switchOn && bri == 0) {
      bri = briLast;
      colorUpdated(NotifyUpdateMode);
    } else if (!switchOn && bri != 0) {
      briLast = bri;
      bri = 0;
      colorUpdated(NotifyUpdateMode);
    }
  }
-  // Create an MQTT Binary Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
+  void publishMqtt(const char* state)
-  void publishHomeAssistantAutodiscovery();
+  {
    //Check if MQTT Connected, otherwise it will crash the 8266
    if (WLED_MQTT_CONNECTED){
      char subuf[64];
      strcpy(subuf, mqttDeviceTopic);
      strcat_P(subuf, PSTR("/motion"));
      mqtt->publish(subuf, 0, false, state);
    }
  }
  /**
   * Read and update PIR sensor state.
   * Initilize/reset switch off timer
   */
-  bool updatePIRsensorState();
+  bool updatePIRsensorState()
  {
    bool pinState = digitalRead(PIRsensorPin);
    if (pinState != sensorPinState) {
      sensorPinState = pinState; // change previous state
      if (sensorPinState == HIGH) {
        m_offTimerStart = 0;
        if (!m_mqttOnly && (!m_nightTimeOnly || (m_nightTimeOnly && !isDayTime()))) switchStrip(true);
        publishMqtt("on");
      } else /*if (bri != 0)*/ {
        // start switch off timer
        m_offTimerStart = millis();
      }
      return true;
    }
    return false;
  }
  /**
   * switch off the strip if the delay has elapsed 
   */
-  bool handleOffTimer();
+  bool handleOffTimer()
  {
    if (m_offTimerStart > 0 && millis() - m_offTimerStart > m_switchOffDelay)
    {
      if (enabled == true)
      {
        if (!m_mqttOnly && (!m_nightTimeOnly || (m_nightTimeOnly && !isDayTime()))) switchStrip(false);
        publishMqtt("off");
      }
      m_offTimerStart = 0;
      return true;
    }
    return false;
  }
 public:
  //Functions called by WLED
@ -117,240 +197,7 @@ public:
   * setup() is called once at boot. WiFi is not yet connected at this point.
   * You can use it to initialize variables, sensors or similar.
   */
-  void setup();
+  void setup()
  /**
   * connected() is called every time the WiFi is (re)connected
   * Use it to initialize network interfaces
   */
  //void connected();
  /**
   * onMqttConnect() is called when MQTT connection is established
   */
  void onMqttConnect(bool sessionPresent);
  /**
   * loop() is called continuously. Here you can check for events, read sensors, etc.
   */
  void loop();
  /**
   * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
   * 
   * Add PIR sensor state and switch off timer duration to jsoninfo
   */
  void addToJsonInfo(JsonObject &root);
  /**
   * onStateChanged() is used to detect WLED state change
   */
  void onStateChange(uint8_t mode);
  /**
   * 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);
  /**
   * 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);
  /**
   * provide the changeable values
   */
  void addToConfig(JsonObject &root);
  /**
   * provide UI information and allow extending UI options
   */
  void appendConfigData();
  /**
   * restore the changeable values
   * readFromConfig() is called before setup() to populate properties from values stored in cfg.json
   *
   * The function should return true if configuration was successfully loaded or false if there was no configuration.
   */
  bool readFromConfig(JsonObject &root);
  /**
   * getId() allows you to optionally give your V2 usermod an unique ID (please define it in const.h!).
   * This could be used in the future for the system to determine whether your usermod is installed.
   */
  uint16_t getId() { return USERMOD_ID_PIRSWITCH; }
 };
 // strings to reduce flash memory usage (used more than twice)
 const char PIRsensorSwitch::_name[]           PROGMEM = "PIRsensorSwitch";
 const char PIRsensorSwitch::_enabled[]        PROGMEM = "PIRenabled";
 const char PIRsensorSwitch::_switchOffDelay[] PROGMEM = "PIRoffSec";
 const char PIRsensorSwitch::_onPreset[]       PROGMEM = "on-preset";
 const char PIRsensorSwitch::_offPreset[]      PROGMEM = "off-preset";
 const char PIRsensorSwitch::_nightTime[]      PROGMEM = "nighttime-only";
 const char PIRsensorSwitch::_mqttOnly[]       PROGMEM = "mqtt-only";
 const char PIRsensorSwitch::_offOnly[]        PROGMEM = "off-only";
 const char PIRsensorSwitch::_haDiscovery[]    PROGMEM = "HA-discovery";
 const char PIRsensorSwitch::_notify[]         PROGMEM = "notifications";
 const char PIRsensorSwitch::_override[]       PROGMEM = "override";
 bool PIRsensorSwitch::isDayTime() {
  updateLocalTime();
  uint8_t hr = hour(localTime);
  uint8_t mi = minute(localTime);
  if (sunrise && sunset) {
    if (hour(sunrise)<hr && hour(sunset)>hr) {
      return true;
    } else {
      if (hour(sunrise)==hr && minute(sunrise)<mi) {
        return true;
      }
      if (hour(sunset)==hr && minute(sunset)>mi) {
        return true;
      }
    }
  }
  return false;
 }
 void PIRsensorSwitch::switchStrip(bool switchOn)
 {
  if (m_offOnly && bri && (switchOn || (!PIRtriggered && !switchOn))) return; //if lights on and off only, do nothing
  if (PIRtriggered && switchOn) return; //if already on and triggered before, do nothing
  PIRtriggered = switchOn;
  DEBUG_PRINT(F("PIR: strip=")); DEBUG_PRINTLN(switchOn?"on":"off");
  if (switchOn) {
    if (m_onPreset) {
      if (currentPlaylist>0 && !offMode) {
        prevPlaylist = currentPlaylist;
        unloadPlaylist();
      } else if (currentPreset>0 && !offMode) {
        prevPreset   = currentPreset;
      } else {
        saveTemporaryPreset();
        prevPlaylist = 0;
        prevPreset   = 255;
      }
      applyPreset(m_onPreset, NotifyUpdateMode);
      return;
    }
    // preset not assigned
    if (bri == 0) {
      bri = briLast;
      stateUpdated(NotifyUpdateMode);
    }
  } else {
    if (m_offPreset) {
      applyPreset(m_offPreset, NotifyUpdateMode);
      return;
    } else if (prevPlaylist) {
      if (currentPreset==m_onPreset || currentPlaylist==m_onPreset) applyPreset(prevPlaylist, NotifyUpdateMode);
      prevPlaylist = 0;
      return;
    } else if (prevPreset) {
      if (prevPreset<255) { if (currentPreset==m_onPreset || currentPlaylist==m_onPreset) applyPreset(prevPreset, NotifyUpdateMode); }
      else                { if (currentPreset==m_onPreset || currentPlaylist==m_onPreset) applyTemporaryPreset(); }
      prevPreset = 0;
      return;
    }
    // preset not assigned
    if (bri != 0) {
      briLast = bri;
      bri = 0;
      stateUpdated(NotifyUpdateMode);
    }
  }
 }
 void PIRsensorSwitch::publishMqtt(const char* state)
 {
 #ifndef WLED_DISABLE_MQTT
  //Check if MQTT Connected, otherwise it will crash the 8266
  if (WLED_MQTT_CONNECTED) {
    char buf[64];
    sprintf_P(buf, PSTR("%s/motion"), mqttDeviceTopic);   //max length: 33 + 7 = 40
    mqtt->publish(buf, 0, false, state);
  }
 #endif
 }
 void PIRsensorSwitch::publishHomeAssistantAutodiscovery()
 {
 #ifndef WLED_DISABLE_MQTT
  if (WLED_MQTT_CONNECTED) {
    StaticJsonDocument<600> doc;
    char uid[24], json_str[1024], buf[128];
    sprintf_P(buf, PSTR("%s Motion"), serverDescription); //max length: 33 + 7 = 40
    doc[F("name")] = buf;
    sprintf_P(buf, PSTR("%s/motion"), mqttDeviceTopic);   //max length: 33 + 7 = 40
    doc[F("stat_t")] = buf;
    doc[F("pl_on")]  = "on";
    doc[F("pl_off")] = "off";
    sprintf_P(uid, PSTR("%s_motion"), escapedMac.c_str());
    doc[F("uniq_id")] = uid;
    doc[F("dev_cla")] = F("motion");
    doc[F("exp_aft")] = 1800;
    JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device
    device[F("name")] = serverDescription;
    device[F("ids")]  = String(F("wled-sensor-")) + mqttClientID;
    device[F("mf")]   = "WLED";
    device[F("mdl")]  = F("FOSS");
    device[F("sw")]   = versionString;
    sprintf_P(buf, PSTR("homeassistant/binary_sensor/%s/config"), uid);
    DEBUG_PRINTLN(buf);
    size_t payload_size = serializeJson(doc, json_str);
    DEBUG_PRINTLN(json_str);
    mqtt->publish(buf, 0, true, json_str, payload_size); // do we really need to retain?
  }
 #endif
 }
 bool PIRsensorSwitch::updatePIRsensorState()
 {
  bool pinState = digitalRead(PIRsensorPin);
  if (pinState != sensorPinState) {
    sensorPinState = pinState; // change previous state
    if (sensorPinState == HIGH) {
      offTimerStart = 0;
      if (!m_mqttOnly && (!m_nightTimeOnly || (m_nightTimeOnly && !isDayTime()))) switchStrip(true);
      else if (NotifyUpdateMode != CALL_MODE_NO_NOTIFY) updateInterfaces(CALL_MODE_WS_SEND);
      publishMqtt("on");
    } else {
      // start switch off timer
      offTimerStart = millis();
      if (NotifyUpdateMode != CALL_MODE_NO_NOTIFY) updateInterfaces(CALL_MODE_WS_SEND);
    }
    return true;
  }
  return false;
 }
 bool PIRsensorSwitch::handleOffTimer()
 {
  if (offTimerStart > 0 && millis() - offTimerStart > m_switchOffDelay) {
    offTimerStart = 0;
    if (enabled == true) {
      if (!m_mqttOnly && (!m_nightTimeOnly || (m_nightTimeOnly && !isDayTime()) || PIRtriggered)) switchStrip(false);
      else if (NotifyUpdateMode != CALL_MODE_NO_NOTIFY) updateInterfaces(CALL_MODE_WS_SEND);
      publishMqtt("off");
    }
    return true;
  }
  return false;
 }
 //Functions called by WLED
 void PIRsensorSwitch::setup()
  {
    if (enabled) {
      // pin retrieved from cfg.json (readFromConfig()) prior to running setup()
@ -369,14 +216,18 @@ void PIRsensorSwitch::setup()
    initDone = true;
  }
-void PIRsensorSwitch::onMqttConnect(bool sessionPresent)
+  /**
   * connected() is called every time the WiFi is (re)connected
   * Use it to initialize network interfaces
   */
  void connected()
  {
  if (HomeAssistantDiscovery) {
    publishHomeAssistantAutodiscovery();
  }
  }
-void PIRsensorSwitch::loop()
+  /**
   * loop() is called continuously. Here you can check for events, read sensors, etc.
   */
  void loop()
  {
    // only check sensors 4x/s
    if (!enabled || millis() - lastLoop < 250 || strip.isUpdating()) return;
@ -387,19 +238,25 @@ void PIRsensorSwitch::loop()
    }
  }
-void PIRsensorSwitch::addToJsonInfo(JsonObject &root)
+  /**
   * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
   * 
   * Add PIR sensor state and switch off timer duration to jsoninfo
   */
  void addToJsonInfo(JsonObject &root)
  {
    JsonObject user = root["u"];
    if (user.isNull()) user = root.createNestedObject("u");
-  JsonArray infoArr = user.createNestedArray(FPSTR(_name));
+    if (enabled)
-
+    {
-  String uiDomString;
+      // off timer
-  if (enabled) {
+      String uiDomString = F("PIR <i class=\"icons\">&#xe325;</i>");
-    if (offTimerStart > 0)
+      JsonArray infoArr = user.createNestedArray(uiDomString); // timer value
      if (m_offTimerStart > 0)
      {
        uiDomString = "";
-      unsigned int offSeconds = (m_switchOffDelay - (millis() - offTimerStart)) / 1000;
+        unsigned int offSeconds = (m_switchOffDelay - (millis() - m_offTimerStart)) / 1000;
        if (offSeconds >= 3600)
        {
          uiDomString += (offSeconds / 3600);
@ -425,51 +282,36 @@ void PIRsensorSwitch::addToJsonInfo(JsonObject &root)
        infoArr.add(sensorPinState ? F("sensor on") : F("inactive"));
      }
    } else {
      String uiDomString = F("PIR sensor");
      JsonArray infoArr = user.createNestedArray(uiDomString);
      infoArr.add(F("disabled"));
    }
  uiDomString  = F(" <button class=\"btn btn-xs\" onclick=\"requestJson({");
  uiDomString += FPSTR(_name);
  uiDomString += F(":{");
  uiDomString += FPSTR(_enabled);
  if (enabled) {
    uiDomString += F(":false}});\">");
    uiDomString += F("<i class=\"icons on\">&#xe325;</i>");
  } else {
    uiDomString += F(":true}});\">");
    uiDomString += F("<i class=\"icons off\">&#xe08f;</i>");
  }
  uiDomString += F("</button>");
  infoArr.add(uiDomString);
  JsonObject sensor = root[F("sensor")];
  if (sensor.isNull()) sensor = root.createNestedObject(F("sensor"));
  sensor[F("motion")] = sensorPinState || offTimerStart>0 ? true : false;
  }
-void PIRsensorSwitch::onStateChange(uint8_t mode) {
+  /**
-  if (!initDone) return;
+   * addToJsonState() can be used to add custom entries to the /json/state part of the JSON API (state object).
-  DEBUG_PRINT(F("PIR: offTimerStart=")); DEBUG_PRINTLN(offTimerStart);
+   * Values in the state object may be modified by connected clients
-  if (m_override && PIRtriggered && offTimerStart) { // debounce
+   */
-    // checking PIRtriggered and offTimerStart will prevent cancellation upon On trigger
+/*
-    DEBUG_PRINTLN(F("PIR: Canceled."));
+  void addToJsonState(JsonObject &root)
    offTimerStart = 0;
    PIRtriggered = false;
  }
 }
 void PIRsensorSwitch::readFromJsonState(JsonObject &root)
  {
  if (!initDone) return;  // prevent crash on boot applyPreset()
  JsonObject usermod = root[FPSTR(_name)];
  if (!usermod.isNull()) {
    if (usermod[FPSTR(_enabled)].is<bool>()) {
      enabled = usermod[FPSTR(_enabled)].as<bool>();
    }
  }
  }
 */
-void PIRsensorSwitch::addToConfig(JsonObject &root)
+  /**
   * 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)
  {
  }
 */
  /**
   * provide the changeable values
   */
  void addToConfig(JsonObject &root)
  {
    JsonObject top = root.createNestedObject(FPSTR(_name));
    top[FPSTR(_enabled)]   = enabled;
@ -480,27 +322,23 @@ void PIRsensorSwitch::addToConfig(JsonObject &root)
    top[FPSTR(_nightTime)] = m_nightTimeOnly;
    top[FPSTR(_mqttOnly)]  = m_mqttOnly;
    top[FPSTR(_offOnly)]   = m_offOnly;
  top[FPSTR(_override)]       = m_override;
  top[FPSTR(_haDiscovery)]    = HomeAssistantDiscovery;
  top[FPSTR(_notify)]         = (NotifyUpdateMode != CALL_MODE_NO_NOTIFY);
    DEBUG_PRINTLN(F("PIR config saved."));
  }
-void PIRsensorSwitch::appendConfigData()
+  /**
-{
+   * restore the changeable values
-  oappend(SET_F("addInfo('PIRsensorSwitch:HA-discovery',1,'HA=Home Assistant');"));     // 0 is field type, 1 is actual field
+   * readFromConfig() is called before setup() to populate properties from values stored in cfg.json
-  oappend(SET_F("addInfo('PIRsensorSwitch:notifications',1,'Periodic WS updates');"));  // 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
+   * The function should return true if configuration was successfully loaded or false if there was no configuration.
-}
+   */
-
+  bool readFromConfig(JsonObject &root)
 bool PIRsensorSwitch::readFromConfig(JsonObject &root)
  {
    bool oldEnabled = enabled;
    int8_t oldPin = PIRsensorPin;
  DEBUG_PRINT(FPSTR(_name));
    JsonObject top = root[FPSTR(_name)];
    if (top.isNull()) {
      DEBUG_PRINT(FPSTR(_name));
      DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
      return false;
    }
@ -513,17 +351,15 @@ bool PIRsensorSwitch::readFromConfig(JsonObject &root)
    m_onPreset = top[FPSTR(_onPreset)] | m_onPreset;
    m_onPreset = max(0,min(250,(int)m_onPreset));
    m_offPreset = top[FPSTR(_offPreset)] | m_offPreset;
    m_offPreset = max(0,min(250,(int)m_offPreset));
    m_nightTimeOnly = top[FPSTR(_nightTime)] | m_nightTimeOnly;
    m_mqttOnly      = top[FPSTR(_mqttOnly)] | m_mqttOnly;
    m_offOnly       = top[FPSTR(_offOnly)] | m_offOnly;
  m_override      = top[FPSTR(_override)] | m_override;
  HomeAssistantDiscovery = top[FPSTR(_haDiscovery)] | HomeAssistantDiscovery;
  NotifyUpdateMode = top[FPSTR(_notify)] ? CALL_MODE_DIRECT_CHANGE : CALL_MODE_NO_NOTIFY;
    DEBUG_PRINT(FPSTR(_name));
    if (!initDone) {
      // reading config prior to setup()
      DEBUG_PRINTLN(F(" config loaded."));
@ -549,5 +385,25 @@ bool PIRsensorSwitch::readFromConfig(JsonObject &root)
      DEBUG_PRINTLN(F(" config (re)loaded."));
    }
    // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-  return !top[FPSTR(_override)].isNull();
+    return !top[FPSTR(_offOnly)].isNull();
  }
  /**
   * getId() allows you to optionally give your V2 usermod an unique ID (please define it in const.h!).
   * This could be used in the future for the system to determine whether your usermod is installed.
   */
  uint16_t getId()
  {
    return USERMOD_ID_PIRSWITCH;
  }
 };
 // strings to reduce flash memory usage (used more than twice)
 const char PIRsensorSwitch::_name[]           PROGMEM = "PIRsensorSwitch";
 const char PIRsensorSwitch::_enabled[]        PROGMEM = "PIRenabled";
 const char PIRsensorSwitch::_switchOffDelay[] PROGMEM = "PIRoffSec";
 const char PIRsensorSwitch::_onPreset[]       PROGMEM = "on-preset";
 const char PIRsensorSwitch::_offPreset[]      PROGMEM = "off-preset";
 const char PIRsensorSwitch::_nightTime[]      PROGMEM = "nighttime-only";
 const char PIRsensorSwitch::_mqttOnly[]       PROGMEM = "mqtt-only";
 const char PIRsensorSwitch::_offOnly[]        PROGMEM = "off-only";
--- a/usermods/PWM_fan/readme.md
+++ b/usermods/PWM_fan/readme.md
@ -2,12 +2,12 @@
 v2 Usermod to to control PWM fan with RPM feedback and temperature control
-This usermod requires the Dallas Temperature usermod to obtain temperature information. If it's not available, the fan will run at 100% speed.
+This usermod requires Dallas Temperature usermod to obtain temperature information. If this is not available the fan will always run at 100% speed.
-If the fan does not have _tachometer_ (RPM) output you can set the _tachometer-pin_ to -1 to disable that feature.
+If the fan does not have _tacho_ (RPM) output you can set the _tacho-pin_ to -1 to not use that feature.
-You can also set the thershold temperature at which fan runs at lowest speed. If the measured temperature is 3°C greater than the threshold temperature, the fan will run at 100%.
+You can also set the thershold temperature at which fan runs at lowest speed. If the actual temperature measured will be 3°C greater than threshold temperature the fan will run at 100%.
-If the _tachometer_ is supported, the current speed (in RPM) will be displayed on the WLED Info page.
+If the _tacho_ is supported the current speed (in RPM) will be repored in WLED Info page.
 ## Installation
@ -19,8 +19,8 @@ You will also need `-D USERMOD_DALLASTEMPERATURE`.
 All of the parameters are configured during run-time using Usermods settings page.
 This includes:
-* PWM output pin (can be configured at compile time `-D PWM_PIN=xx`)
+* PWM output pin
-* tachometer input pin (can be configured at compile time `-D TACHO_PIN=xx`)
+* tacho input pin
 * sampling frequency in seconds
 * threshold temperature in degees C
@ -30,16 +30,7 @@ _NOTE:_ You may also need to tweak Dallas Temperature usermod sampling frequency
 No special requirements.
 ## Control PWM fan speed using JSON API
 e.g. you can use `{"PWM-fan":{"speed":30,"lock":true}}` to lock fan speed to 30 percent of maximum. (replace 30 with an arbitrary value between 0 and 100)
 If you include `speed` property you can set fan speed as a percentage (%) of maximum speed.
 If you include `lock` property you can lock (_true_) or unlock (_false_) the fan speed.
 If the fan speed is unlocked, it will revert to temperature controlled speed on the next update cycle. Once fan speed is locked it will remain so until it is unlocked by the next API call.
 ## Change Log
 2021-10
 * First public release
 2022-05
 * Added JSON API call to allow changing of speed
--- a/usermods/PWM_fan/usermod_PWM_fan.h
+++ b/usermods/PWM_fan/usermod_PWM_fan.h
@ -1,7 +1,7 @@
 #pragma once
-#if !defined(USERMOD_DALLASTEMPERATURE) && !defined(USERMOD_SHT)
+#ifndef USERMOD_DALLASTEMPERATURE
-#error The "PWM fan" usermod requires "Dallas Temeprature" or "SHT" usermod to function properly.
+#error The "PWM fan" usermod requires "Dallas Temeprature" usermod to function properly.
 #endif
 #include "wled.h"
@ -10,13 +10,6 @@
 // https://github.com/KlausMu/esp32-fan-controller/tree/main/src
 // adapted for WLED usermod by @blazoncek
 #ifndef TACHO_PIN
  #define TACHO_PIN -1
 #endif
 #ifndef PWM_PIN
  #define PWM_PIN -1
 #endif
 // tacho counter
 static volatile unsigned long counter_rpm = 0;
@ -38,22 +31,18 @@ class PWMFanUsermod : public Usermod {
    #ifdef ARDUINO_ARCH_ESP32
    uint8_t pwmChannel = 255;
    #endif
    bool lockFan = false;
    #ifdef USERMOD_DALLASTEMPERATURE
    UsermodTemperature* tempUM;
    #elif defined(USERMOD_SHT)
    ShtUsermod* tempUM;
    #endif
    // configurable parameters
-    int8_t  tachoPin          = TACHO_PIN;
+    int8_t  tachoPin          = -1;
-    int8_t  pwmPin            = PWM_PIN;
+    int8_t  pwmPin            = -1;
    uint8_t tachoUpdateSec    = 30;
-    float   targetTemperature = 35.0;
+    float   targetTemperature = 25.0;
-    uint8_t minPWMValuePct    = 0;
+    uint8_t minPWMValuePct    = 50;
    uint8_t numberOfInterrupsInOneSingleRotation = 2;     // Number of interrupts ESP32 sees on tacho signal on a single fan rotation. All the fans I've seen trigger two interrups.
    uint8_t pwmValuePct       = 0;
    // strings to reduce flash memory usage (used more than twice)
    static const char _name[];
@ -64,8 +53,6 @@ class PWMFanUsermod : public Usermod {
    static const char _tachoUpdateSec[];
    static const char _minPWMValuePct[];
    static const char _IRQperRotation[];
    static const char _speed[];
    static const char _lock[];
    void initTacho(void) {
      if (tachoPin < 0 || !pinManager.allocatePin(tachoPin, false, PinOwner::UM_Unspecified)){
@ -86,8 +73,6 @@ class PWMFanUsermod : public Usermod {
    }
    void updateTacho(void) {
      // store milliseconds when tacho was measured the last time
      msLastTachoMeasurement = millis();
      if (tachoPin < 0) return;
      // start of tacho measurement
@ -98,6 +83,8 @@ class PWMFanUsermod : public Usermod {
      last_rpm /= tachoUpdateSec;
      // reset counter
      counter_rpm = 0; 
      // store milliseconds when tacho was measured the last time
      msLastTachoMeasurement = millis();
      // attach interrupt again
      attachInterrupt(digitalPinToInterrupt(tachoPin), rpm_fan, FALLING);
    }
@ -105,7 +92,6 @@ class PWMFanUsermod : public Usermod {
    // https://randomnerdtutorials.com/esp32-pwm-arduino-ide/
    void initPWMfan(void) {
      if (pwmPin < 0 || !pinManager.allocatePin(pwmPin, true, PinOwner::UM_Unspecified)) {
        enabled = false;
        pwmPin = -1;
        return;
      }
@ -137,7 +123,7 @@ class PWMFanUsermod : public Usermod {
    }
    void updateFanSpeed(uint8_t pwmValue){
-      if (!enabled || pwmPin < 0) return;
+      if (pwmPin < 0) return;
      #ifdef ESP8266
      analogWrite(pwmPin, pwmValue);
@ -147,7 +133,7 @@ class PWMFanUsermod : public Usermod {
    }
    float getActualTemperature(void) {
-      #if defined(USERMOD_DALLASTEMPERATURE) || defined(USERMOD_SHT)
+      #ifdef USERMOD_DALLASTEMPERATURE
      if (tempUM != nullptr)
        return tempUM->getTemperatureC();
      #endif
@ -162,7 +148,7 @@ class PWMFanUsermod : public Usermod {
      int pwmStep = ((100 - minPWMValuePct) * newPWMvalue) / (7*100);
      int pwmMinimumValue = (minPWMValuePct * newPWMvalue) / 100;
-      if ((temp == NAN) || (temp <= -100.0)) {
+      if ((temp == NAN) || (temp <= 0.0)) {
        DEBUG_PRINTLN(F("WARNING: no temperature value available. Cannot do temperature control. Will set PWM fan to 255."));
      } else if (difftemp <= 0.0) {
        // Temperature is below target temperature. Run fan at minimum speed.
@ -191,8 +177,6 @@ class PWMFanUsermod : public Usermod {
      #ifdef USERMOD_DALLASTEMPERATURE   
      // This Usermod requires Temperature usermod
      tempUM = (UsermodTemperature*) usermods.lookup(USERMOD_ID_TEMPERATURE);
      #elif defined(USERMOD_SHT)
      tempUM = (ShtUsermod*) usermods.lookup(USERMOD_ID_SHT);
      #endif
      initTacho();
      initPWMfan();
@ -214,7 +198,7 @@ class PWMFanUsermod : public Usermod {
      if ((now - msLastTachoMeasurement) < (tachoUpdateSec * 1000)) return;
      updateTacho();
-      if (!lockFan) setFanPWMbasedOnTemperature();
+      setFanPWMbasedOnTemperature();
    }
    /*
@ -223,41 +207,12 @@ class PWMFanUsermod : public Usermod {
     * Below it is shown how this could be used for e.g. a light sensor
     */
    void addToJsonInfo(JsonObject& root) {
      if (tachoPin < 0) return;
      JsonObject user = root["u"];
      if (user.isNull()) user = root.createNestedObject("u");
-
+      JsonArray data = user.createNestedArray(FPSTR(_name));
      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 += F("':");
      uiDomString += enabled ? "false" : "true";
      uiDomString += F("}});\"><i class=\"icons ");
      uiDomString += enabled ? "on" : "off";
      uiDomString += F("\">&#xe08f;</i></button>");
      infoArr.add(uiDomString);
      if (enabled) {
        JsonArray infoArr = user.createNestedArray(F("Manual"));
        String uiDomString = F("<div class=\"slider\"><div class=\"sliderwrap il\"><input class=\"noslide\" onchange=\"requestJson({'");
        uiDomString += FPSTR(_name);
        uiDomString += F("':{'");
        uiDomString += FPSTR(_speed);
        uiDomString += F("':parseInt(this.value)}});\" oninput=\"updateTrail(this);\" max=100 min=0 type=\"range\" value=");
        uiDomString += pwmValuePct;
        uiDomString += F(" /><div class=\"sliderdisplay\"></div></div></div>"); //<output class=\"sliderbubble\"></output>
        infoArr.add(uiDomString);
        JsonArray data = user.createNestedArray(F("Speed"));
        if (tachoPin >= 0) {
      data.add(last_rpm);
      data.add(F("rpm"));
        } else {
          if (lockFan) data.add(F("locked"));
          else         data.add(F("auto"));
        }
      }
    }
    /*
@ -271,24 +226,9 @@ class PWMFanUsermod : public Usermod {
     * 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) {
+    //void readFromJsonState(JsonObject& root) {
-      if (!initDone) return;  // prevent crash on boot applyPreset()
+    //  if (!initDone) return;  // prevent crash on boot applyPreset()
-      JsonObject usermod = root[FPSTR(_name)];
+    //}
      if (!usermod.isNull()) {
        if (usermod[FPSTR(_enabled)].is<bool>()) {
          enabled = usermod[FPSTR(_enabled)].as<bool>();
          if (!enabled) updateFanSpeed(0);
        }
        if (enabled && !usermod[FPSTR(_speed)].isNull() && usermod[FPSTR(_speed)].is<int>()) {
          pwmValuePct = usermod[FPSTR(_speed)].as<int>();
          updateFanSpeed((constrain(pwmValuePct,0,100) * 255) / 100);
          if (pwmValuePct) lockFan = true;
        }
        if (enabled && !usermod[FPSTR(_lock)].isNull() && usermod[FPSTR(_lock)].is<bool>()) {
          lockFan = usermod[FPSTR(_lock)].as<bool>();
        }
      }
    }
    /*
     * addToConfig() can be used to add custom persistent settings to the cfg.json file in the "um" (usermod) object.
@ -390,5 +330,3 @@ const char PWMFanUsermod::_temperature[]    PROGMEM = "target-temp-C";
 const char PWMFanUsermod::_tachoUpdateSec[] PROGMEM = "tacho-update-s";
 const char PWMFanUsermod::_minPWMValuePct[] PROGMEM = "min-PWM-percent";
 const char PWMFanUsermod::_IRQperRotation[] PROGMEM = "IRQs-per-rotation";
 const char PWMFanUsermod::_speed[]          PROGMEM = "speed";
 const char PWMFanUsermod::_lock[]           PROGMEM = "lock";
--- a/usermods/QuinLED_Dig_Uno_Temp_MQTT/readme.md
+++ b/usermods/QuinLED_Dig_Uno_Temp_MQTT/readme.md
@ -0,0 +1,34 @@
 # QuinLED Dig Uno board
 These files allow WLED 0.9.1 to report the temp sensor on the Quinled board to MQTT. I use it to report the board temp to Home Assistant via MQTT, so it will send notifications if something happens and the board start to heat up.
 This code uses Aircookie's WLED software. It has a premade file for user modifications. I use it to publish the temperature from the dallas temperature sensor on the Quinled board. The entries for the top of the WLED00 file, initializes the required libraries, and variables for the sensor. The .ino file waits for 60 seconds, and checks to see if the MQTT server is connected (thanks Aircoookie). It then poles the sensor, and published it using the MQTT service already running, using the main topic programmed in the WLED UI.
 Installation of file: Copy and replace file in wled00 directory
 ## Project link
 * [QuinLED-Dig-Uno](https://quinled.info/2018/09/15/quinled-dig-uno/) - Project link
 ### Platformio requirements
 Uncomment `DallasTemperature@~3.8.0`,`OneWire@~2.3.5 under` `[common]` section in `platformio.ini`:
 ```ini
 # platformio.ini
 ...
 [platformio]
 ...
 ; default_envs = esp07
 default_envs = d1_mini
 ...
 [common]
 ...
 lib_deps_external =
  ...
  #For use SSD1306 OLED display uncomment following
  U8g2@~2.27.3
  #For Dallas sensor uncomment following 2 lines
  DallasTemperature@~3.8.0
  OneWire@~2.3.5
 ...
 ```
--- a/usermods/QuinLED_Dig_Uno_Temp_MQTT/usermod.cpp
+++ b/usermods/QuinLED_Dig_Uno_Temp_MQTT/usermod.cpp
@ -0,0 +1,54 @@
 #include <Arduino.h>
 #include "wled.h"
 //Intiating code for QuinLED Dig-Uno temp sensor
 //Uncomment Celsius if that is your prefered temperature scale
 #include <DallasTemperature.h> //Dallastemperature sensor
 #ifdef ARDUINO_ARCH_ESP32 //ESP32 boards
 OneWire oneWire(18);
 #else //ESP8266 boards
 OneWire oneWire(14);
 #endif
 DallasTemperature sensor(&oneWire);
 long temptimer = millis();
 long lastMeasure = 0;
 #define Celsius // Show temperature mesaurement in Celcius otherwise is in Fahrenheit
 void userSetup()
 {
 // Start the DS18B20 sensor
  sensor.begin();
 }
 //gets called every time WiFi is (re-)connected. Initialize own network interfaces here
 void userConnected()
 {
 }
 void userLoop()
 {
  temptimer = millis();
 // Timer to publishe new temperature every 60 seconds
  if (temptimer - lastMeasure > 60000) {
    lastMeasure = temptimer;
 //Check if MQTT Connected, otherwise it will crash the 8266
    if (mqtt != nullptr){
      sensor.requestTemperatures();
 //Gets prefered temperature scale based on selection in definitions section
      #ifdef Celsius
      float board_temperature = sensor.getTempCByIndex(0);
      #else
      float board_temperature = sensors.getTempFByIndex(0);
      #endif
 //Create character string populated with user defined device topic from the UI, and the read temperature. Then publish to MQTT server.
      char subuf[38];
      strcpy(subuf, mqttDeviceTopic);
      strcat(subuf, "/temperature");
      mqtt->publish(subuf, 0, true, String(board_temperature).c_str());
    return;}
  return;}
 return;
 }
--- a/usermods/RTC/readme.md
+++ b/usermods/RTC/readme.md
@ -1,6 +1,6 @@
 # DS1307/DS3231 Real time clock
-Gets the time from I2C RTC module on boot. This allows clock operation if WiFi is not available.
+Gets the time from I2C RTC module on boot. This allows clocks to operate e.g. if temporarily no WiFi is available.
 The stored time is updated each time NTP is synced. 
 ## Installation 
--- a/usermods/RTC/usermod_rtc.h
+++ b/usermods/RTC/usermod_rtc.h
@ -12,8 +12,6 @@ class RTCUsermod : public Usermod {
  public:
    void setup() {
      if (i2c_scl<0 || i2c_sda<0) { disabled = true; return; }
      RTC.begin();
      time_t rtcTime = RTC.get();
      if (rtcTime) {
        toki.setTime(rtcTime,TOKI_NO_MS_ACCURACY,TOKI_TS_RTC);
@ -24,26 +22,12 @@ class RTCUsermod : public Usermod {
    }
    void loop() {
-      if (disabled || strip.isUpdating()) return;
+      if (!disabled && toki.isTick()) {
      if (toki.isTick()) {
        time_t t = toki.second();
        if (t != RTC.get()) RTC.set(t); //set RTC to NTP/UI-provided value
      }
    }
    /*
     * addToConfig() can be used to add custom persistent settings to the cfg.json file in the "um" (usermod) object.
     * It will be called by WLED when settings are actually saved (for example, LED settings are saved)
     * I highly recommend checking out the basics of ArduinoJson serialization and deserialization in order to use custom settings!
     */
 //    void addToConfig(JsonObject& root)
 //    {
 //      JsonObject top = root.createNestedObject("RTC");
 //      JsonArray pins = top.createNestedArray("pin");
 //      pins.add(i2c_scl);
 //      pins.add(i2c_sda);
 //    }
    uint16_t getId()
    {
      return USERMOD_ID_RTC;
--- a/usermods/RelayBlinds/index.htm
+++ b/usermods/RelayBlinds/index.htm
@ -1,76 +0,0 @@
 <!DOCTYPE html>
 <html>
 <head><meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1">
  <meta charset="utf-8">
  <title>Blinds</title>
  <script>
      strA = "";
    function send()
    {
      nocache = "&nocache=" + Math.random() * 1000000;
      var request = new XMLHttpRequest();
      // send HTTP request
      request.open("GET", "win/" + strA +nocache, true);
      request.send(null);
      strA = "";
    }
    function up()
    {
      strA = "&U0=2";
      send();
    }
    function down()
    {
      strA = "&U0=1";
      send();
    }
    function OpenSettings()
    {
      window.open("/settings", "_self");
    }
  </script>
  <style>
    body {
      text-align: center;
      background: linear-gradient(45deg,#0ca,#0ac);
      height: 100%;
      margin: 0;
      background-repeat: no-repeat;
      background-attachment: fixed;
    }
    html {
      height: 100%;
    }
    svg {
      width: 30vw;
      padding: 2vh;
    }
    .tool_box {
      position: absolute;
      top: 50%;
      left: 50%;
      transform: translate(-50%, -50%);
    }
  </style>
 <style id="holderjs-style" type="text/css"></style></head>
 <body class=" __plain_text_READY__">
 <svg style="position: absolute; width: 0; height: 0; overflow: hidden;" version="1.1" xmlns="http://www.w3.org/2000/svg">
 <defs>
 <symbol id="icon-box-add" viewBox="0 0 32 32">
 <path d="M26 2h-20l-6 6v21c0 0.552 0.448 1 1 1h30c0.552 0 1-0.448 1-1v-21l-6-6zM16 26l-10-8h6v-6h8v6h6l-10 8zM4.828 6l2-2h18.343l2 2h-22.343z"></path>
 </symbol>
 <symbol id="icon-box-remove" viewBox="0 0 32 32">
 <path d="M26 2h-20l-6 6v21c0 0.552 0.448 1 1 1h30c0.552 0 1-0.448 1-1v-21l-6-6zM20 20v6h-8v-6h-6l10-8 10 8h-6zM4.828 6l2-2h18.343l2 2h-22.343z"></path>
 </symbol>
 <symbol id="icon-cog" viewBox="0 0 32 32">
 <path d="M29.181 19.070c-1.679-2.908-0.669-6.634 2.255-8.328l-3.145-5.447c-0.898 0.527-1.943 0.829-3.058 0.829-3.361 0-6.085-2.742-6.085-6.125h-6.289c0.008 1.044-0.252 2.103-0.811 3.070-1.679 2.908-5.411 3.897-8.339 2.211l-3.144 5.447c0.905 0.515 1.689 1.268 2.246 2.234 1.676 2.903 0.672 6.623-2.241 8.319l3.145 5.447c0.895-0.522 1.935-0.82 3.044-0.82 3.35 0 6.067 2.725 6.084 6.092h6.289c-0.003-1.034 0.259-2.080 0.811-3.038 1.676-2.903 5.399-3.894 8.325-2.219l3.145-5.447c-0.899-0.515-1.678-1.266-2.232-2.226zM16 22.479c-3.578 0-6.479-2.901-6.479-6.479s2.901-6.479 6.479-6.479c3.578 0 6.479 2.901 6.479 6.479s-2.901 6.479-6.479 6.479z"></path>
 </symbol>
 </defs>
 </svg>
  <div id="tbB" class="tool_box">
    <svg id="upb" onclick="up()"><use xlink:href="#icon-box-remove"></use></svg>
    <svg id="dnb" onclick="down()"><use xlink:href="#icon-box-add"></use></svg>
    <svg id="stb" onclick="OpenSettings()"><use xlink:href="#icon-cog"></use></svg>
  </div>
 </body>
 </html>
--- a/usermods/RelayBlinds/presets.json
+++ b/usermods/RelayBlinds/presets.json
@ -1 +0,0 @@
 {"0":{},"2":{"n":"▲","win":"U0=2"},"1":{"n":"▼","win":"U0=1"}}
--- a/usermods/RelayBlinds/readme.md
+++ b/usermods/RelayBlinds/readme.md
@ -1,8 +0,0 @@
 # RelayBlinds usermod
 This simple usermod toggles two relay pins momentarily (defaults to 500ms) when `userVar0` is set.  
 e.g. can be used to "push" the buttons of a window blinds motor controller.
 v1 usermod. Please replace usermod.cpp in the `wled00` directory with the one in this file.
 You may upload `index.htm` to `[WLED-IP]/edit` to replace the default lighting UI with a simple Up/Down button one.  
 A simple `presets.json` file is available. This makes the relay actions controllable via two presets to facilitate control e.g. the default UI or Alexa.
--- a/usermods/RelayBlinds/usermod.cpp
+++ b/usermods/RelayBlinds/usermod.cpp
@ -1,83 +0,0 @@
 #include "wled.h"
 //Use userVar0 and userVar1 (API calls &U0=,&U1=, uint16_t)
 //gets called once at boot. Do all initialization that doesn't depend on network here
 void userSetup()
 {
 }
 //gets called every time WiFi is (re-)connected. Initialize own network interfaces here
 void userConnected()
 {
 }
 /*
 * Physical IO
 */
 #define PIN_UP_RELAY 4
 #define PIN_DN_RELAY 5
 #define PIN_ON_TIME  500
 bool upActive = false, upActiveBefore = false, downActive = false, downActiveBefore = false;
 unsigned long upStartTime = 0, downStartTime = 0;
 void handleRelay()
 {
  //up and down relays
  if (userVar0) {
    upActive = true;
    if (userVar0 == 1) {
      upActive = false;
      downActive = true;
    }
    userVar0 = 0;
  }
  if (upActive)
  {
    if(!upActiveBefore)
    {
      pinMode(PIN_UP_RELAY, OUTPUT);
      digitalWrite(PIN_UP_RELAY, LOW);
      upActiveBefore = true;
      upStartTime = millis();
      DEBUG_PRINTLN("UPA");
    }
    if (millis()- upStartTime > PIN_ON_TIME)
    {
      upActive = false;
      DEBUG_PRINTLN("UPN");
    }
  } else if (upActiveBefore)
  {
    pinMode(PIN_UP_RELAY, INPUT);
    upActiveBefore = false;
  }
  if (downActive)
  {
    if(!downActiveBefore)
    {
      pinMode(PIN_DN_RELAY, OUTPUT);
      digitalWrite(PIN_DN_RELAY, LOW);
      downActiveBefore = true;
      downStartTime = millis();
    }
    if (millis()- downStartTime > PIN_ON_TIME)
    {
      downActive = false;
    }
  } else if (downActiveBefore)
  {
    pinMode(PIN_DN_RELAY, INPUT);
    downActiveBefore = false;
  }
 }
 //loop. You can use "if (WLED_CONNECTED)" to check for successful connection
 void userLoop()
 {
  handleRelay();
 }
--- a/usermods/SN_Photoresistor/readme.md
+++ b/usermods/SN_Photoresistor/readme.md
@ -1,7 +1,7 @@
 # SN_Photoresistor usermod
-This usermod will read from an attached photoresistor sensor like the KY-018.
+This usermod will read from an attached photoresistor sensor like the KY-018 sensor.
-The luminance is displayed in both the Info section of the web UI as well as published to the `/luminance` MQTT topic, if enabled.
+The luminance is displayed both in the Info section of the web UI as well as published to the `/luminance` MQTT topic if enabled.
 ## Installation
@ -9,15 +9,15 @@ Copy the example `platformio_override.ini` to the root directory.  This file sho
 ### Define Your Options
-* `USERMOD_SN_PHOTORESISTOR`                      - Enables this user mod. wled00\usermods_list.cpp
+* `USERMOD_SN_PHOTORESISTOR`                      - define this to have this user mod included wled00\usermods_list.cpp
-* `USERMOD_SN_PHOTORESISTOR_MEASUREMENT_INTERVAL` - Number of milliseconds between measurements. Defaults to 60000 ms
+* `USERMOD_SN_PHOTORESISTOR_MEASUREMENT_INTERVAL` - the number of milliseconds between measurements, defaults to 60 seconds
-* `USERMOD_SN_PHOTORESISTOR_FIRST_MEASUREMENT_AT` - Number of milliseconds after boot to take first measurement. Defaults to 20000 ms
+* `USERMOD_SN_PHOTORESISTOR_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 20 seconds
-* `USERMOD_SN_PHOTORESISTOR_REFERENCE_VOLTAGE`    - Voltage supplied to the sensor. Defaults to 5v
+* `USERMOD_SN_PHOTORESISTOR_REFERENCE_VOLTAGE`    - the voltage supplied to the sensor, defaults to 5v
-* `USERMOD_SN_PHOTORESISTOR_ADC_PRECISION`        - ADC precision. Defaults to 10 bits
+* `USERMOD_SN_PHOTORESISTOR_ADC_PRECISION`        - the ADC precision is the number of distinguishable ADC inputs, defaults to 1024.0 (10 bits)
-* `USERMOD_SN_PHOTORESISTOR_RESISTOR_VALUE`       - Resistor size, defaults to 10000.0 (10K Ohms)
+* `USERMOD_SN_PHOTORESISTOR_RESISTOR_VALUE`       - the resistor size, defaults to 10000.0 (10K hms)
-* `USERMOD_SN_PHOTORESISTOR_OFFSET_VALUE`         - Offset value to report on. Defaults to 25
+* `USERMOD_SN_PHOTORESISTOR_OFFSET_VALUE`         - the offset value to report on, defaults to 25
-All parameters can be configured at runtime via the Usermods settings page.
+All parameters can be configured at runtime using Usermods settings page.
 ## Project link
--- a/usermods/SN_Photoresistor/usermod_sn_photoresistor.h
+++ b/usermods/SN_Photoresistor/usermod_sn_photoresistor.h
@ -22,12 +22,12 @@
 // 10 bits
 #ifndef USERMOD_SN_PHOTORESISTOR_ADC_PRECISION
-#define USERMOD_SN_PHOTORESISTOR_ADC_PRECISION 1024.0f
+#define USERMOD_SN_PHOTORESISTOR_ADC_PRECISION 1024.0
 #endif
 // resistor size 10K hms
 #ifndef USERMOD_SN_PHOTORESISTOR_RESISTOR_VALUE
-#define USERMOD_SN_PHOTORESISTOR_RESISTOR_VALUE 10000.0f
+#define USERMOD_SN_PHOTORESISTOR_RESISTOR_VALUE 10000.0
 #endif
 // only report if differance grater than offset value
@ -109,7 +109,6 @@ public:
    {
      lastLDRValue = currentLDRValue;
 #ifndef WLED_DISABLE_MQTT
      if (WLED_MQTT_CONNECTED)
      {
        char subuf[45];
@ -122,12 +121,6 @@ public:
        DEBUG_PRINTLN("Missing MQTT connection. Not publishing data");
      }
    }
 #endif
  }
  uint16_t getLastLDRValue()
  {
    return lastLDRValue;
  }
  void addToJsonInfo(JsonObject &root)
--- a/usermods/ST7789_display/README.md
+++ b/usermods/ST7789_display/README.md
@ -1,21 +1,18 @@
-# Using the ST7789 TFT IPS 240x240 pixel color display with ESP32 boards
+# ST7789 TFT IPS Color display 240x240pxwith ESP32 boards
-This usermod enables display of the following:
+This usermod allow to use 240x240 display to display following:
 * Current date and time;
 * Network SSID;
 * IP address;
 * WiFi signal strength;
 * Brightness;
-* Selected effect;
+* Chosen effect;
-* Selected palette;
+* Chosen palette;
 * Effect speed and intensity;
 * Estimated current in mA;
 ## Hardware
 ***
-![Hardware](images/ST7789_Guide.jpg)
+![Hardware](images/ST7789_guide.jpg)
 ## Library used
@ -41,37 +38,35 @@ lib_deps =
 ...
 ```
-In the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
+Also, while in the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
-Add the following lines to section:
+Add lines to section:
 ```ini
 default_envs = esp32dev
 build_flags = ${common.build_flags_esp32}
  -D USERMOD_ST7789_DISPLAY
-    -DUSER_SETUP_LOADED=1
+
    -DST7789_DRIVER=1
    -DTFT_WIDTH=240
    -DTFT_HEIGHT=240
    -DCGRAM_OFFSET=1
    -DTFT_MOSI=21
    -DTFT_SCLK=22
    -DTFT_DC=27
    -DTFT_RST=26
    -DTFT_BL=14
    -DLOAD_GLCD=1
    ;optional for WROVER
    ;-DCONFIG_SPIRAM_SUPPORT=1
 ```
-Save the `platformio.ini` file.  Once saved, the required library files should be automatically downloaded for modifications in a later step.
+Save the `platformio.ini` file.  Once this is saved, the required library files should be automatically downloaded for modifications in a later step.
 ### TFT_eSPI Library Adjustments
-If you are not using PlatformIO, you need to modify a file in the `TFT_eSPI` library. If you followed the directions to modify and save the `platformio.ini` file above, the `Setup24_ST7789.h` file can be found in the `/.pio/libdeps/esp32dev/TFT_eSPI/User_Setups/` folder.
+We need to modify a file in the `TFT_eSPI` library. If you followed the directions to modify and save the `platformio.ini` file above, the `User_Setup_Select.h` file can be found in the `/.pio/libdeps/esp32dev/TFT_eSPI` folder.
-Edit `Setup_ST7789.h` file and uncomment and change GPIO pin numbers in lines containing `TFT_MOSI`, `TFT_SCLK`, `TFT_RST`, `TFT_DC`.
+Modify the  `User_Setup_Select.h` file as follows:
-Modify the `User_Setup_Select.h` by uncommenting the line containing `#include <User_Setups/Setup24_ST7789.h>` and commenting out the line containing `#include <User_Setup.h>`.
+* Comment out the following line (which is the 'default' setup file):
-If your display uses the backlight enable pin, add this definition: #define TFT_BL with backlight enable GPIO number.
+```ini
 //#include <User_Setup.h>           // Default setup is root library folder
 ```
 * Add following line:
 ```ini
 #include <User_Setups/Setup_ST7789_Display.h>    // Setup file for ESP32 ST7789V SPI bus TFT
 ```
 * Copy file `"Setup_ST7789_Display.h"` from usermod folder to `/.pio/libdeps/esp32dev/TFT_eSPI/User_Setups`
--- a/usermods/ST7789_display/ST7789_display.h
+++ b/usermods/ST7789_display/ST7789_display.h
@ -7,49 +7,33 @@
 #include <TFT_eSPI.h>
 #include <SPI.h>
-#ifndef USER_SETUP_LOADED
+#define USERMOD_ST7789_DISPLAY 97
-    #ifndef ST7789_DRIVER
+
-        #error Please define ST7789_DRIVER
+#ifndef TFT_DISPOFF
-    #endif
+#define TFT_DISPOFF 0x28
    #ifndef TFT_WIDTH
        #error Please define TFT_WIDTH
    #endif
    #ifndef TFT_HEIGHT
        #error Please define TFT_HEIGHT
    #endif
    #ifndef TFT_DC
        #error Please define TFT_DC
    #endif
    #ifndef TFT_RST
        #error Please define TFT_RST
    #endif
    #ifndef LOAD_GLCD
        #error Please define LOAD_GLCD
    #endif
 #endif
 #ifndef TFT_BL
    #define TFT_BL -1
 #endif
-#define USERMOD_ID_ST7789_DISPLAY 97
+#ifndef TFT_SLPIN
 #define TFT_SLPIN   0x10
 #endif
-TFT_eSPI tft = TFT_eSPI(TFT_WIDTH, TFT_HEIGHT); // Invoke custom library
+#define TFT_MOSI            21
 #define TFT_SCLK            22
 #define TFT_DC              18
 #define TFT_RST             5
 #define TFT_BL              26  // Display backlight control pin
-// Extra char (+1) for null
+TFT_eSPI tft = TFT_eSPI(240, 240); // Invoke custom library
 #define LINE_BUFFER_SIZE          20
 // How often we are redrawing screen
 #define USER_LOOP_REFRESH_RATE_MS 1000
 extern int getSignalQuality(int rssi);
 //class name. Use something descriptive and leave the ": public Usermod" part :)
 class St7789DisplayUsermod : public Usermod {
  private:
    //Private class members. You can declare variables and functions only accessible to your usermod here
    unsigned long lastTime = 0;
    bool enabled = true;
    bool displayTurnedOff = false;
    long lastRedraw = 0;
@ -61,70 +45,9 @@ class St7789DisplayUsermod : public Usermod {
    uint8_t knownBrightness = 0;
    uint8_t knownMode = 0;
    uint8_t knownPalette = 0;
-    uint8_t knownEffectSpeed = 0;
+    uint8_t tftcharwidth = 19;  // Number of chars that fit on screen with text size set to 2
    uint8_t knownEffectIntensity = 0;
    uint8_t knownMinute = 99;
    uint8_t knownHour = 99;
    const uint8_t tftcharwidth = 19;  // Number of chars that fit on screen with text size set to 2
    long lastUpdate = 0;
    void center(String &line, uint8_t width) {
      int len = line.length();
      if (len<width) for (byte i=(width-len)/2; i>0; i--) line = ' ' + line;
      for (byte i=line.length(); i<width; i++) line += ' ';
    }
    /**
     * Display the current date and time in large characters
     * on the middle rows. Based 24 or 12 hour depending on
     * the useAMPM configuration.
     */
    void showTime() {
        if (!ntpEnabled) return;
        char lineBuffer[LINE_BUFFER_SIZE];
        updateLocalTime();
        byte minuteCurrent = minute(localTime);
        byte hourCurrent   = hour(localTime);
        //byte secondCurrent = second(localTime);
        knownMinute = minuteCurrent;
        knownHour = hourCurrent;
        byte currentMonth = month(localTime);
        sprintf_P(lineBuffer, PSTR("%s %2d "), monthShortStr(currentMonth), day(localTime));
        tft.setTextColor(TFT_SILVER);
        tft.setCursor(84, 0);
        tft.setTextSize(2);
        tft.print(lineBuffer);
        byte showHour = hourCurrent;
        boolean isAM = false;
        if (useAMPM) {
            if (showHour == 0) {
                showHour = 12;
                isAM = true;
            } else if (showHour > 12) {
                showHour -= 12;
                isAM = false;
            } else {
                isAM = true;
            }
        }
        sprintf_P(lineBuffer, PSTR("%2d:%02d"), (useAMPM ? showHour : hourCurrent), minuteCurrent);
        tft.setTextColor(TFT_WHITE);
        tft.setTextSize(4);
        tft.setCursor(60, 24);
        tft.print(lineBuffer);
        tft.setTextSize(2);
        tft.setCursor(186, 24);
        //sprintf_P(lineBuffer, PSTR("%02d"), secondCurrent);
        if (useAMPM) tft.print(isAM ? "AM" : "PM");
        //else         tft.print(lineBuffer);
    }
  public:
    //Functions called by WLED
@ -134,15 +57,6 @@ class St7789DisplayUsermod : public Usermod {
     */
    void setup()
    {
        PinManagerPinType spiPins[] = { { spi_mosi, true }, { spi_miso, false}, { spi_sclk, true } };
        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);
            enabled = false;
            return;
        }
        tft.init();
        tft.setRotation(0);  //Rotation here is set up for the text to be readable with the port on the left. Use 1 to flip.
        tft.fillScreen(TFT_BLACK);
@ -151,8 +65,8 @@ class St7789DisplayUsermod : public Usermod {
        tft.setTextDatum(MC_DATUM);
        tft.setTextSize(2);
        tft.print("Loading...");
-        if (TFT_BL >= 0) 
+        if (TFT_BL > 0) 
-        {
+        { // TFT_BL has been set in the TFT_eSPI library
         pinMode(TFT_BL, OUTPUT); // Set backlight pin to output mode
         digitalWrite(TFT_BL, HIGH); // Turn backlight on.
        }
@ -177,8 +91,6 @@ class St7789DisplayUsermod : public Usermod {
     *    Instead, use a timer check as shown here.
     */
    void loop() {
        char buff[LINE_BUFFER_SIZE];
 // Check if we time interval for redrawing passes.
    if (millis() - lastUpdate < USER_LOOP_REFRESH_RATE_MS)
        {
@ -189,18 +101,28 @@ class St7789DisplayUsermod : public Usermod {
 // Turn off display after 5 minutes with no change.
    if(!displayTurnedOff && millis() - lastRedraw > 5*60*1000)
        {
-            if (TFT_BL >= 0) digitalWrite(TFT_BL, LOW); // Turn backlight off. 
+            digitalWrite(TFT_BL, LOW); // Turn backlight off. 
            displayTurnedOff = true;
        } 
 // Check if values which are shown on display changed from the last time.
-        if ((((apActive) ? String(apSSID) : WiFi.SSID()) != knownSsid) ||
+    if (((apActive) ? String(apSSID) : WiFi.SSID()) != knownSsid)
-            (knownIp != (apActive ? IPAddress(4, 3, 2, 1) : Network.localIP())) ||
+    {
-            (knownBrightness != bri) ||
+    needRedraw = true;
-            (knownEffectSpeed != strip.getMainSegment().speed) ||
+    }
-            (knownEffectIntensity != strip.getMainSegment().intensity) ||
+    else if (knownIp != (apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP()))
-            (knownMode != strip.getMainSegment().mode) ||
+    {
-            (knownPalette != strip.getMainSegment().palette))
+    needRedraw = true;
    }
    else if (knownBrightness != bri)
    {
    needRedraw = true;
    }
    else if (knownMode != strip.getMode())
    {
    needRedraw = true;
    }
    else if (knownPalette != strip.getSegment(0).palette)
    {
    needRedraw = true;
    }
@ -213,7 +135,7 @@ class St7789DisplayUsermod : public Usermod {
    if (displayTurnedOff)
    {
-            digitalWrite(TFT_BL, HIGH); // Turn backlight on.
+        digitalWrite(TFT_BL, TFT_BACKLIGHT_ON); // Turn backlight on.
        displayTurnedOff = false;
    }
    lastRedraw = millis();
@ -226,104 +148,135 @@ class St7789DisplayUsermod : public Usermod {
    #endif
    knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
    knownBrightness = bri;
-        knownMode = strip.getMainSegment().mode;
+    knownMode = strip.getMode();
-        knownPalette = strip.getMainSegment().palette;
+    knownPalette = strip.getSegment(0).palette;
        knownEffectSpeed = strip.getMainSegment().speed;
        knownEffectIntensity = strip.getMainSegment().intensity;
    tft.fillScreen(TFT_BLACK);
        showTime();
    tft.setTextSize(2);
 // First row with Wifi name
    tft.setTextColor(TFT_SILVER);
    tft.setCursor(3, 40);
    tft.print(knownSsid.substring(0, tftcharwidth > 1 ? tftcharwidth - 1 : 0));
 // Print `~` char to indicate that SSID is longer, than our dicplay
    if (knownSsid.length() > tftcharwidth)
        tft.print("~");
-        // Wifi name
+// Second row with AP IP and Password or IP
    tft.setTextColor(TFT_GREEN);
-        tft.setCursor(0, 60);
+    tft.setTextSize(2);
-        String line = knownSsid.substring(0, tftcharwidth-1);
+    tft.setCursor(3, 64);
        // Print `~` char to indicate that SSID is longer, than our display
        if (knownSsid.length() > tftcharwidth) line = line.substring(0, tftcharwidth-1) + '~';
        center(line, tftcharwidth);
        tft.print(line.c_str());
 // Print AP IP and password in AP mode or knownIP if AP not active.
    if (apActive)
    {
-            tft.setCursor(0, 84);
+    tft.setTextColor(TFT_YELLOW);
    tft.print("AP IP: ");
    tft.print(knownIp);
-            tft.setCursor(0,108);
+    tft.setCursor(3,86);
    tft.setTextColor(TFT_YELLOW);
    tft.print("AP Pass:");
    tft.print(apPass);
    }
    else
    {
-            tft.setCursor(0, 84);
+    tft.setTextColor(TFT_GREEN);
-            line = knownIp.toString();
+    tft.print("IP: ");
-            center(line, tftcharwidth);
+    tft.print(knownIp);
-            tft.print(line.c_str());
+    tft.setCursor(3,86);
-            // percent brightness
+    //tft.print("Signal Strength: ");
-            tft.setCursor(0, 120);
+    //tft.print(i.wifi.signal);
    tft.setTextColor(TFT_WHITE);
    tft.print("Bri: ");
-            tft.print((((int)bri*100)/255));
+    tft.print(((float(bri)/255)*100),0);
            tft.print("%");
            // signal quality
            tft.setCursor(124,120);
            tft.print("Sig: ");
            if (getSignalQuality(WiFi.RSSI()) < 10) {
                tft.setTextColor(TFT_RED);
            } else if (getSignalQuality(WiFi.RSSI()) < 25) {
                tft.setTextColor(TFT_ORANGE);
            } else {
                tft.setTextColor(TFT_GREEN);
            }
            tft.print(getSignalQuality(WiFi.RSSI()));
            tft.setTextColor(TFT_WHITE);
    tft.print("%");
    }
-        // mode name
+// Third row with mode name
-        tft.setTextColor(TFT_CYAN);
+    tft.setCursor(3, 108);
-        tft.setCursor(0, 144);
+    uint8_t qComma = 0;
-        char lineBuffer[tftcharwidth+1];
+    bool insideQuotes = false;
-        extractModeName(knownMode, JSON_mode_names, lineBuffer, tftcharwidth);
+    uint8_t printedChars = 0;
-        tft.print(lineBuffer);
+    char singleJsonSymbol;
-
+// Find the mode name in JSON
-        // palette name
+    for (size_t i = 0; i < strlen_P(JSON_mode_names); i++)
    {
        singleJsonSymbol = pgm_read_byte_near(JSON_mode_names + i);
        switch (singleJsonSymbol)
        {
            case '"':
            insideQuotes = !insideQuotes;
        break;
        case '[':
        case ']':
        break;
        case ',':
        qComma++;
        default:
            if (!insideQuotes || (qComma != knownMode))
            break;
        tft.setTextColor(TFT_MAGENTA);
        tft.print(singleJsonSymbol);
        printedChars++;
        }
    if ((qComma > knownMode) || (printedChars > tftcharwidth - 1))
      break;
    }
 // Fourth row with palette name
    tft.setTextColor(TFT_YELLOW);
-        tft.setCursor(0, 168);
+    tft.setCursor(3, 130);
-        extractModeName(knownPalette, JSON_palette_names, lineBuffer, tftcharwidth);
+    qComma = 0;
-        tft.print(lineBuffer);
+    insideQuotes = false;
-
+    printedChars = 0;
-        tft.setCursor(0, 192);
+// Looking for palette name in JSON.
-        tft.setTextColor(TFT_SILVER);
+    for (size_t i = 0; i < strlen_P(JSON_palette_names); i++)
-        sprintf_P(buff, PSTR("FX  Spd:%3d Int:%3d"), effectSpeed, effectIntensity);
+    {
-        tft.print(buff);
+    singleJsonSymbol = pgm_read_byte_near(JSON_palette_names + i);
-
+        switch (singleJsonSymbol)
        {
        case '"':
        insideQuotes = !insideQuotes;
        break;
        case '[':
        case ']':
        break;
        case ',':
        qComma++;
        default:
            if (!insideQuotes || (qComma != knownPalette))
            break;
        tft.print(singleJsonSymbol);
        printedChars++;
        }
 // The following is modified from the code from the u8g2/u8g8 based code (knownPalette was knownMode)
    if ((qComma > knownPalette) || (printedChars > tftcharwidth - 1))
      break;
    }
 // Fifth row with estimated mA usage
    tft.setTextColor(TFT_SILVER);
-        tft.setCursor(0, 216);
+    tft.setCursor(3, 152);
 // Print estimated milliamp usage (must specify the LED type in LED prefs for this to be a reasonable estimate).
    tft.print("Current: ");
        tft.setTextColor(TFT_ORANGE);
    tft.print(strip.currentMilliamps);
    tft.print("mA");
    }
    /*
     * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
     * Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
     * Below it is shown how this could be used for e.g. a light sensor
     */
    /*
    void addToJsonInfo(JsonObject& root)
    {
      int reading = 20;
      //this code adds "u":{"Light":[20," lux"]} to the info object
      JsonObject user = root["u"];
      if (user.isNull()) user = root.createNestedObject("u");
-      JsonArray lightArr = user.createNestedArray("ST7789"); //name
+      JsonArray lightArr = user.createNestedArray("Light"); //name
-      lightArr.add(enabled?F("installed"):F("disabled")); //unit
+      lightArr.add(reading); //value
      lightArr.add(" lux"); //unit
    }
    */
    /*
@ -342,7 +295,7 @@ class St7789DisplayUsermod : public Usermod {
     */
    void readFromJsonState(JsonObject& root)
    {
-      //userVar0 = root["user0"] | userVar0; //if "user0" key exists in JSON, update, else keep old value
+      userVar0 = root["user0"] | userVar0; //if "user0" key exists in JSON, update, else keep old value
      //if (root["bri"] == 255) Serial.println(F("Don't burn down your garage!"));
    }
@ -363,23 +316,11 @@ class St7789DisplayUsermod : public Usermod {
     */
    void addToConfig(JsonObject& root)
    {
-      JsonObject top = root.createNestedObject("ST7789");
+      JsonObject top = root.createNestedObject("exampleUsermod");
-      JsonArray pins = top.createNestedArray("pin");
+      top["great"] = userVar0; //save this var persistently whenever settings are saved
      pins.add(TFT_CS);
      pins.add(TFT_DC);
      pins.add(TFT_RST);
      pins.add(TFT_BL);
      //top["great"] = userVar0; //save this var persistently whenever settings are saved
    }
    void appendConfigData() {
      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[]',2,'','SPI BL');"));
    }
    /*
     * readFromConfig() can be used to read back the custom settings you added with addToConfig().
     * This is called by WLED when settings are loaded (currently this only happens once immediately after boot)
@ -388,11 +329,10 @@ class St7789DisplayUsermod : public Usermod {
     * but also that if you want to write persistent values to a dynamic buffer, you'd need to allocate it here instead of in setup.
     * If you don't know what that is, don't fret. It most likely doesn't affect your use case :)
     */
-    bool readFromConfig(JsonObject& root)
+    void readFromConfig(JsonObject& root)
    {
-      //JsonObject top = root["top"];
+      JsonObject top = root["top"];
-      //userVar0 = top["great"] | 42; //The value right of the pipe "|" is the default value in case your setting was not present in cfg.json (e.g. first boot)
+      userVar0 = top["great"] | 42; //The value right of the pipe "|" is the default value in case your setting was not present in cfg.json (e.g. first boot)
      return true;
    }
@ -402,7 +342,7 @@ class St7789DisplayUsermod : public Usermod {
     */
    uint16_t getId()
    {
-      return USERMOD_ID_ST7789_DISPLAY;
+      return USERMOD_ST7789_DISPLAY;
    }
   //More methods can be added in the future, this example will then be extended.
--- a/usermods/ST7789_display/Setup_ST7789_Display.h
+++ b/usermods/ST7789_display/Setup_ST7789_Display.h
@ -0,0 +1,39 @@
 // Setup for the ESP32 board with 1.5" 240x240 display
 // See SetupX_Template.h for all options available
 #define ST7789_DRIVER
 #define TFT_SDA_READ   // Display has a bidirectionsl SDA pin
 #define TFT_WIDTH  240
 #define TFT_HEIGHT 240
 #define CGRAM_OFFSET      // Library will add offsets required
 //#define TFT_MISO -1
 #define TFT_MOSI            21
 #define TFT_SCLK            22
 //#define TFT_CS              5
 #define TFT_DC              18
 #define TFT_RST             5
 #define TFT_BL          26  // Display backlight control pin
 #define TFT_BACKLIGHT_ON HIGH  // HIGH or LOW are options
 #define LOAD_GLCD
 #define LOAD_FONT2
 #define LOAD_FONT4
 #define LOAD_FONT6
 #define LOAD_FONT7
 #define LOAD_FONT8
 #define LOAD_GFXFF
 //#define SMOOTH_FONT
 //#define SPI_FREQUENCY  27000000
  #define SPI_FREQUENCY  40000000   // Maximum for ILI9341
 #define SPI_READ_FREQUENCY  6000000 // 6 MHz is the maximum SPI read speed for the ST7789V
--- a/usermods/Si7021_MQTT_HA/readme.md
+++ b/usermods/Si7021_MQTT_HA/readme.md
@ -1,69 +0,0 @@
 # Si7021 to MQTT (with Home Assistant Auto Discovery) usermod
 This usermod implements support for [Si7021 I²C temperature and humidity sensors](https://www.silabs.com/documents/public/data-sheets/Si7021-A20.pdf).
 As of this writing, the sensor data will *not* be shown on the WLED UI, but it _is_ published via MQTT to WLED's "built-in" MQTT device topic. 
 ```
 temperature: $mqttDeviceTopic/si7021_temperature
 humidity: $mqttDeviceTopic/si7021_humidity
 ```
 The following sensors can also be published:
 ```
 heat_index: $mqttDeviceTopic/si7021_heat_index
 dew_point: $mqttDeviceTopic/si7021_dew_point
 absolute_humidity: $mqttDeviceTopic/si7021_absolute_humidity
 ```
 Sensor data will be updated/sent every 60 seconds.
 This usermod also supports Home Assistant Auto Discovery.
 ## Settings via Usermod Setup
 - `enabled`: Enables this usermod
 - `Send Dew Point, Abs. Humidity and Heat Index`: Enables additional sensors
 - `Home Assistant MQTT Auto-Discovery`: Enables Home Assistant Auto Discovery
 # Installation
 ## Hardware
 Attach the Si7021 sensor to the I²C interface.
 Default PINs ESP32:
 ```
 SCL_PIN = 22;
 SDA_PIN = 21;
 ```
 Default PINs ESP8266:
 ```
 SCL_PIN = 5;
 SDA_PIN = 4;
 ```
 ## Software
 Add to `build_flags` in platformio.ini:
 ```
   -D USERMOD_SI7021_MQTT_HA
 ```
 Add to `lib_deps` in platformio.ini:
 ```
   adafruit/Adafruit Si7021 Library @ 1.4.0
   BME280@~3.0.0
 ```
 # Credits
 - Aircoookie for making WLED
 - Other usermod creators for example code (`sensors_to_mqtt` and `multi_relay` especially)
 - You, for reading this
--- a/usermods/Si7021_MQTT_HA/usermod_si7021_mqtt_ha.h
+++ b/usermods/Si7021_MQTT_HA/usermod_si7021_mqtt_ha.h
@ -1,231 +0,0 @@
 #ifndef WLED_ENABLE_MQTT
 #error "This user mod requires MQTT to be enabled."
 #endif
 #pragma once
 // this is remixed from usermod_v2_SensorsToMqtt.h (sensors_to_mqtt usermod)
 // and usermod_multi_relay.h (multi_relay usermod)
 #include "wled.h"
 #include <Adafruit_Si7021.h>
 #include <EnvironmentCalculations.h> // EnvironmentCalculations::HeatIndex(), ::DewPoint(), ::AbsoluteHumidity()
 Adafruit_Si7021 si7021;
 class Si7021_MQTT_HA : public Usermod
 {
  private:
    bool sensorInitialized = false;
    bool mqttInitialized = false;
    float sensorTemperature = 0;
    float sensorHumidity = 0;
    float sensorHeatIndex = 0;
    float sensorDewPoint = 0;
    float sensorAbsoluteHumidity= 0;
    String mqttTemperatureTopic = "";
    String mqttHumidityTopic = "";
    String mqttHeatIndexTopic = "";
    String mqttDewPointTopic = "";
    String mqttAbsoluteHumidityTopic = "";
    unsigned long nextMeasure = 0;
    bool enabled = false;
    bool haAutoDiscovery = true;
    bool sendAdditionalSensors = true;
    // strings to reduce flash memory usage (used more than twice)
    static const char _name[];
    static const char _enabled[];
    static const char _sendAdditionalSensors[];
    static const char _haAutoDiscovery[];
    void _initializeSensor()
    {
      sensorInitialized = si7021.begin();
      Serial.printf("Si7021_MQTT_HA: sensorInitialized = %d\n", sensorInitialized);
    }
    void _initializeMqtt()
    {
      mqttTemperatureTopic = String(mqttDeviceTopic) + "/si7021_temperature";
      mqttHumidityTopic = String(mqttDeviceTopic) + "/si7021_humidity";
      mqttHeatIndexTopic = String(mqttDeviceTopic) + "/si7021_heat_index";
      mqttDewPointTopic = String(mqttDeviceTopic) + "/si7021_dew_point";
      mqttAbsoluteHumidityTopic = String(mqttDeviceTopic) + "/si7021_absolute_humidity";
      // Update and publish sensor data
      _updateSensorData();
      _publishSensorData();
      if (haAutoDiscovery) {
        _publishHAMqttSensor("temperature", "Temperature", mqttTemperatureTopic, "temperature", "°C");
        _publishHAMqttSensor("humidity", "Humidity", mqttHumidityTopic, "humidity", "%");
        if (sendAdditionalSensors) {
          _publishHAMqttSensor("heat_index", "Heat Index", mqttHeatIndexTopic, "temperature", "°C");
          _publishHAMqttSensor("dew_point", "Dew Point", mqttDewPointTopic, "", "°C");
          _publishHAMqttSensor("absolute_humidity", "Absolute Humidity", mqttAbsoluteHumidityTopic, "", "g/m³");
        }
      }
      mqttInitialized = true;
    }
    void _publishHAMqttSensor(
      const String &name, 
      const String &friendly_name, 
      const String &state_topic, 
      const String &deviceClass, 
      const String &unitOfMeasurement)
    {
      if (WLED_MQTT_CONNECTED) {
        String topic = String("homeassistant/sensor/") + mqttClientID + "/" + name + "/config";
        StaticJsonDocument<300> doc;
        doc["name"] = String(serverDescription) + " " + friendly_name;
        doc["state_topic"] = state_topic;
        doc["unique_id"] = String(mqttClientID) + name;
        if (unitOfMeasurement != "")
          doc["unit_of_measurement"] = unitOfMeasurement;
        if (deviceClass != "")
          doc["device_class"] = deviceClass;
        doc["expire_after"] = 1800;
        JsonObject device = doc.createNestedObject("device"); // attach the sensor to the same device
        device["name"] = String(serverDescription);
        device["model"] = "WLED";
        device["manufacturer"] = "Aircoookie";
        device["identifiers"] = String("wled-") + String(serverDescription);
        device["sw_version"] = VERSION;
        String payload;
        serializeJson(doc, payload);
        mqtt->publish(topic.c_str(), 0, true, payload.c_str());
      }
    }
    void _updateSensorData()
    {
      sensorTemperature = si7021.readTemperature();
      sensorHumidity = si7021.readHumidity();
      // Serial.print("Si7021_MQTT_HA: Temperature: ");
      // Serial.print(sensorTemperature, 2);
      // Serial.print("\tHumidity: ");
      // Serial.print(sensorHumidity, 2);
      if (sendAdditionalSensors) {
        EnvironmentCalculations::TempUnit envTempUnit(EnvironmentCalculations::TempUnit_Celsius);
        sensorHeatIndex = EnvironmentCalculations::HeatIndex(sensorTemperature, sensorHumidity, envTempUnit);
        sensorDewPoint = EnvironmentCalculations::DewPoint(sensorTemperature, sensorHumidity, envTempUnit);
        sensorAbsoluteHumidity = EnvironmentCalculations::AbsoluteHumidity(sensorTemperature, sensorHumidity, envTempUnit);
        // Serial.print("\tHeat Index: ");
        // Serial.print(sensorHeatIndex, 2);
        // Serial.print("\tDew Point: ");
        // Serial.print(sensorDewPoint, 2);
        // Serial.print("\tAbsolute Humidity: ");
        // Serial.println(sensorAbsoluteHumidity, 2);
      }
      // else
      //   Serial.println("");
    }
    void _publishSensorData()
    {
      if (WLED_MQTT_CONNECTED) {
        mqtt->publish(mqttTemperatureTopic.c_str(), 0, false, String(sensorTemperature).c_str());
        mqtt->publish(mqttHumidityTopic.c_str(), 0, false, String(sensorHumidity).c_str());
        if (sendAdditionalSensors) {
          mqtt->publish(mqttHeatIndexTopic.c_str(), 0, false, String(sensorHeatIndex).c_str());
          mqtt->publish(mqttDewPointTopic.c_str(), 0, false, String(sensorDewPoint).c_str());
          mqtt->publish(mqttAbsoluteHumidityTopic.c_str(), 0, false, String(sensorAbsoluteHumidity).c_str());
        }
      }
    }
  public:
    void addToConfig(JsonObject& root)
    {
      JsonObject top = root.createNestedObject(FPSTR(_name));
      top[FPSTR(_enabled)] = enabled;
      top[FPSTR(_sendAdditionalSensors)] = sendAdditionalSensors;
      top[FPSTR(_haAutoDiscovery)] = haAutoDiscovery;
    }
    bool readFromConfig(JsonObject& root)
    {
      JsonObject top = root[FPSTR(_name)];
      bool configComplete = !top.isNull();
      configComplete &= getJsonValue(top[FPSTR(_enabled)], enabled);
      configComplete &= getJsonValue(top[FPSTR(_sendAdditionalSensors)], sendAdditionalSensors);
      configComplete &= getJsonValue(top[FPSTR(_haAutoDiscovery)], haAutoDiscovery);
      return configComplete;
    }
    void onMqttConnect(bool sessionPresent) {
      if (mqttDeviceTopic[0] != 0)
        _initializeMqtt();
    }
    void setup()
    {
      if (enabled) {
        Serial.println("Si7021_MQTT_HA: Starting!");
        Serial.println("Si7021_MQTT_HA: Initializing sensors.. ");
        _initializeSensor();
      }
    }
    // gets called every time WiFi is (re-)connected.
    void connected()
    {
      nextMeasure = millis() + 5000; // Schedule next measure in 5 seconds
    }
    void loop()
    {
      yield();
      if (!enabled || strip.isUpdating()) return; // !sensorFound || 
      unsigned long tempTimer = millis();
      if (tempTimer > nextMeasure) {
        nextMeasure = tempTimer + 60000; // Schedule next measure in 60 seconds
        if (!sensorInitialized) {
          Serial.println("Si7021_MQTT_HA: Error! Sensors not initialized in loop()!");
          _initializeSensor();
          return; // lets try again next loop
        }
        if (WLED_MQTT_CONNECTED) {
          if (!mqttInitialized)
            _initializeMqtt();
          // Update and publish sensor data
          _updateSensorData();
          _publishSensorData();
        }
        else {
          Serial.println("Si7021_MQTT_HA: Missing MQTT connection. Not publishing data");
          mqttInitialized = false;
        }
      }
    }
    uint16_t getId()
    {
      return USERMOD_ID_SI7021_MQTT_HA;
    }
 };
 // strings to reduce flash memory usage (used more than twice)
 const char Si7021_MQTT_HA::_name[]                   PROGMEM = "Si7021 MQTT (Home Assistant)";
 const char Si7021_MQTT_HA::_enabled[]                PROGMEM = "enabled";
 const char Si7021_MQTT_HA::_sendAdditionalSensors[]  PROGMEM = "Send Dew Point, Abs. Humidity and Heat Index";
 const char Si7021_MQTT_HA::_haAutoDiscovery[]        PROGMEM = "Home Assistant MQTT Auto-Discovery";
--- a/usermods/TTGO-T-Display/README.md
+++ b/usermods/TTGO-T-Display/README.md
@ -1,19 +1,19 @@
 # TTGO T-Display ESP32 with 240x135 TFT via SPI with TFT_eSPI
-This usermod enables use of the TTGO 240x135 T-Display ESP32 module
+This usermod allows use of the TTGO T-Display ESP32 module with integrated 240x135 display
 for controlling WLED and showing the following information: 
 * Current SSID
-* IP address, if obtained
+* IP address if obtained
-  * If connected to a network, current brightness percentage is shown 
+  * If connected to a network, current brightness % is shown 
-  * In AP mode, AP, IP and password are shown
+  * in AP mode AP IP and password are shown
 * Current effect
 * Current palette
-* Estimated current in mA (NOTE: for this to be a reasonable value, the correct LED type must be specified in the LED Prefs section)
+* Estimated current in mA is shown (NOTE: for this to be a reasonable value, the correct LED type must be specified in the LED Prefs section)
-Button pin is mapped to the onboard button adjacent to the reset button of the TTGO T-Display board.
+Button pin is mapped to the onboard button next to the side actuated reset button of the TTGO T-Display board.
-I have designed a 3D printed case around this board and an ["ElectroCookie"](https://amzn.to/2WCNeeA) project board, a [level shifter](https://amzn.to/3hbKu18), a [buck regulator](https://amzn.to/3mLMy0W), and a DC [power jack](https://amzn.to/3phj9NZ).  I use 12V WS2815 LED strips for my projects, and power them with 12V power supplies. The regulator supplies 5V for the ESP module and the level shifter.  If there is any interest in this case which elevates the board and display on custom extended standoffs to place the screen at the top of the enclosure (with accessible buttons), let me know, and I will post the STL files.  It is a bit tricky to get the height correct, so I also designed a one-time use 3D printed solder fixture to set the board in the right location and at the correct height for the housing.  (It is one-time use because it has to be cut off after soldering to be able to remove it).  I didn't think the effort to make it in multiple pieces was worthwhile.
+I have designed a 3D printed case around this board and an ["ElectroCookie"](https://amzn.to/2WCNeeA) project board, a [level shifter](https://amzn.to/3hbKu18), a [buck regulator](https://amzn.to/3mLMy0W), and a DC [power jack](https://amzn.to/3phj9NZ).  I use 12V WS2815 LED strips for my projects, and power them with 12V power supplies, so the regulator drops the voltage to the 5V level I need to power the ESP module and the level shifter.  If there is any interest in this case, which elevates the board and display on some custom extended headers to make place the screen at the top of the enclosure (with accessible buttons), let me know, and I could post the STL files.  It is a bit tricky to get the height correct, so I also designed a one-time use 3D printed solder fixture to set the board in the right location and at the correct height for the housing.  (It is one-time use because it has to be cut off after soldering to be able to remove it).  I didn't think the effort to make it in multiple pieces was worthwhile.
-Based on a rework of the ssd1306_i2c_oled_u8g2 usermod from the WLED repo.
+Usermod based on a rework of the ssd1306_i2c_oled_u8g2 usermod from the WLED repo.
 ## Hardware
 ![Hardware](assets/ttgo_hardware1.png)
@ -30,8 +30,8 @@ Based on a rework of the ssd1306_i2c_oled_u8g2 usermod from the WLED repo.
 Functionality checked with:
 * TTGO T-Display
 * PlatformIO
-* Group of 4 individual Neopixels from Adafruit and several full strings of 12v WS2815 LEDs.
+* Group of 4 individual Neopixels from Adafruit, and a several full strings of 12v WS2815 LEDs.
-* The hardware design shown above should be limited to shorter strings.  For larger strings, I use a different setup with a dedicated 12v power supply and power them directly from said supply (in addition to dropping the 12v to 5v with a buck regulator for the ESP module and level shifter).
+* The hardware design shown above should be limited to shorter strings.  For larger strings, I use a different setup with a dedicated 12v power supply and power them directly off the supply (in addition to dropping the 12v supply down to 5v with a buck regulator for the ESP module and level shifter).
 ## Setup Needed:
 * As with all usermods, copy the usermod.cpp file from the TTGO-T-Display usermod folder to the wled00 folder (replacing the default usermod.cpp file).
@ -51,24 +51,24 @@ lib_deps =
 ...
 ```
-In the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
+Also, while in the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
 Comment out the line described below:
 ```ini
-# Release binaries
+# Travis CI binaries (comment this out when building for single board)
-; default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth, esp32s2_saola, esp32c3
+; default_envs = travis_esp8266, esp01, esp01_1m_ota, travis_esp32
 ```
-and uncomment the following line in the 'Single binaries' section:
+and UNCOMMENT the following line in the 'Single binaries' section:
 ```ini
 default_envs = esp32dev
 ```
-Save the `platformio.ini` file.  Once saved, the required library files should be automatically downloaded for modifications in a later step.
+Save the `platformio.ini` file.  Once this is saved, the required library files should be automatically downloaded for modifications in a later step.
 ### Platformio_overrides.ini (added)
 Copy the `platformio_overrides.ini` file which is contained in the `usermods/TTGO-T-Display/` folder into the root of your project folder. This file contains an override that remaps the button pin of WLED to use the on-board button to the right of the USB-C connector (when viewed with the port oriented downward - see hardware photo).
 ### TFT_eSPI Library Adjustments (board selection)
-You need to modify a file in the `TFT_eSPI` library to select the correct board.  If you followed the directions to modify and save the `platformio.ini` file above, the `User_Setup_Select.h` file can be found in the `/.pio/libdeps/esp32dev/TFT_eSPI_ID1559` folder.
+We need to modify a file in the `TFT_eSPI` library to select the correct board.  If you followed the directions to modify and save the `platformio.ini` file above, the `User_Setup_Select.h` file can be found in the `/.pio/libdeps/esp32dev/TFT_eSPI_ID1559` folder.
 Modify the  `User_Setup_Select.h` file as follows:
 * Comment out the following line (which is the 'default' setup file):
@ -80,12 +80,12 @@ Modify the  `User_Setup_Select.h` file as follows:
 #include <User_Setups/Setup25_TTGO_T_Display.h>    // Setup file for ESP32 and TTGO T-Display ST7789V SPI bus TFT
 ```
-Build the file.  If you see a failure like this:
+Run the build and it should complete correctly.  If you see a failure like this:
 ```ini
 xtensa-esp32-elf-g++: error: wled00\wled00.ino.cpp: No such file or directory
 xtensa-esp32-elf-g++: fatal error: no input files
 ```
-try building again. Sometimes this happens on the first build attempt and subsequent attempts build correctly.
+Just try building again - I find that sometimes this happens on the first build attempt and subsequent attempts will build correctly.
 ## Arduino IDE
 - UNTESTED
--- a/usermods/TTGO-T-Display/usermod.cpp
+++ b/usermods/TTGO-T-Display/usermod.cpp
@ -110,9 +110,9 @@ void userLoop() {
    needRedraw = true;
  } else if (knownBrightness != bri) {
    needRedraw = true;
-  } else if (knownMode != strip.getMainSegment().mode) {
+  } else if (knownMode != strip.getMode()) {
    needRedraw = true;
-  } else if (knownPalette != strip.getMainSegment().palette) {
+  } else if (knownPalette != strip.getSegment(0).palette) {
    needRedraw = true;
  }
@ -136,8 +136,8 @@ void userLoop() {
  #endif
  knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
  knownBrightness = bri;
-  knownMode = strip.getMainSegment().mode;
+  knownMode = strip.getMode();
-  knownPalette = strip.getMainSegment().palette;
+  knownPalette = strip.getSegment(0).palette;
  tft.fillScreen(TFT_BLACK);
  tft.setTextSize(2);
@ -177,15 +177,58 @@ void userLoop() {
  // Third row with mode name
  tft.setCursor(1, 68);
-  char lineBuffer[tftcharwidth+1];
+  uint8_t qComma = 0;
-  extractModeName(knownMode, JSON_mode_names, lineBuffer, tftcharwidth);
+  bool insideQuotes = false;
-  tft.print(lineBuffer);
+  uint8_t printedChars = 0;
-
+  char singleJsonSymbol;
  // Find the mode name in JSON
  for (size_t i = 0; i < strlen_P(JSON_mode_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_mode_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownMode))
        break;
      tft.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > tftcharwidth - 1))
      break;
  }
  // Fourth row with palette name
  tft.setCursor(1, 90);
-  extractModeName(knownPalette, JSON_palette_names, lineBuffer, tftcharwidth);
+  qComma = 0;
-  tft.print(lineBuffer);
+  insideQuotes = false;
-
+  printedChars = 0;
  // Looking for palette name in JSON.
  for (size_t i = 0; i < strlen_P(JSON_palette_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_palette_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownPalette))
        break;
      tft.print(singleJsonSymbol);
      printedChars++;
    }
    // The following is modified from the code from the u8g2/u8g8 based code (knownPalette was knownMode)
    if ((qComma > knownPalette) || (printedChars > tftcharwidth - 1))
      break;
  }
  // Fifth row with estimated mA usage
  tft.setCursor(1, 112);
  // Print estimated milliamp usage (must specify the LED type in LED prefs for this to be a reasonable estimate).
--- a/usermods/Temperature/platformio_override.ini
+++ b/usermods/Temperature/platformio_override.ini
@ -1,12 +1,13 @@
 ; Options
 ; -------
 ; USERMOD_DALLASTEMPERATURE                      - define this to have this user mod included wled00\usermods_list.cpp
 ; USERMOD_DALLASTEMPERATURE_CELSIUS              - define this to report temperatures in degrees celsius, otherwise fahrenheit will be reported
 ; USERMOD_DALLASTEMPERATURE_MEASUREMENT_INTERVAL - the number of milliseconds between measurements, defaults to 60 seconds
 ; USERMOD_DALLASTEMPERATURE_FIRST_MEASUREMENT_AT - the number of milliseconds after boot to take first measurement, defaults to 20 seconds
 ;
 [env:d1_mini_usermod_dallas_temperature_C]
 extends = env:d1_mini
-build_flags = ${common.build_flags_esp8266} -D USERMOD_DALLASTEMPERATURE
+build_flags = ${common.build_flags_esp8266} -D USERMOD_DALLASTEMPERATURE -D USERMOD_DALLASTEMPERATURE_CELSIUS
 lib_deps = ${env.lib_deps}
-  paulstoffregen/OneWire@~2.3.7
+    milesburton/DallasTemperature@^3.9.0
-# you may want to use following with ESP32
+    OneWire@~2.3.5
 ;  https://github.com/blazoncek/OneWire.git # fixes Sensor error on ESP32
--- a/usermods/Temperature/readme.md
+++ b/usermods/Temperature/readme.md
@ -1,24 +1,22 @@
 # Temperature usermod
-Based on the excellent `QuinLED_Dig_Uno_Temp_MQTT` usermod by srg74 and 400killer!  
+Based on the excellent `QuinLED_Dig_Uno_Temp_MQTT` by srg74 and 400killer!  
-Reads an attached DS18B20 temperature sensor (as available on the QuinLED Dig-Uno)  
+This usermod will read from an attached DS18B20 temperature sensor (as available on the QuinLED Dig-Uno)  
-Temperature is displayed in both the Info section of the web UI as well as published to the `/temperature` MQTT topic, if enabled.  
+The temperature is displayed both in the Info section of the web UI as well as published to the `/temperature` MQTT topic if enabled.  
-May be expanded with support for different sensor types in the future.
+This usermod may be expanded with support for different sensor types in the future.
 If temperature sensor is not detected during boot, this usermod will be disabled.
 Maintained by @blazoncek
 ## Installation
 Copy the example `platformio_override.ini` to the root directory.  This file should be placed in the same directory as `platformio.ini`.
 ### Define Your Options
-* `USERMOD_DALLASTEMPERATURE`                      - enables this user mod wled00/usermods_list.cpp
+* `USERMOD_DALLASTEMPERATURE`                      - define this to have this user mod included wled00\usermods_list.cpp
-* `USERMOD_DALLASTEMPERATURE_MEASUREMENT_INTERVAL` - number of milliseconds between measurements, defaults to 60000 ms (60s)
+* `USERMOD_DALLASTEMPERATURE_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 20 seconds
-All parameters can be configured at runtime via the Usermods settings page, including pin, temperature in degrees Celsius or Farenheit and measurement interval.
+All parameters can be configured at runtime using Usermods settings page, including pin, selection to display temerature in degrees Celsius or Farenheit mand measurement interval.
 ## Project link
@ -29,6 +27,7 @@ All parameters can be configured at runtime via the Usermods settings page, incl
 If you are using `platformio_override.ini`, you should be able to refresh the task list and see your custom task, for example `env:d1_mini_usermod_dallas_temperature_C`.
 If you are not using `platformio_override.ini`, you might have to uncomment `OneWire@~2.3.5 under` `[common]` section in `platformio.ini`:
 ```ini
@ -44,20 +43,16 @@ default_envs = d1_mini
 lib_deps =
  ...
  #For Dallas sensor uncomment following line
-  OneWire@~2.3.7
+  OneWire@~2.3.5
-  # ... or you may want to use following with ESP32
+...
 ;  https://github.com/blazoncek/OneWire.git # fixes Sensor error on ESP32...
 ```
 ## Change Log
 2020-09-12 
-* Changed to use async non-blocking implementation
+* Changed to use async, non-blocking implementation
-* Do not report erroneous low temperatures to MQTT
+* Do not report low temperatures that indicate an error 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
--- a/usermods/Temperature/usermod_temperature.h
+++ b/usermods/Temperature/usermod_temperature.h
@ -29,7 +29,6 @@ class UsermodTemperature : public Usermod {
    bool degC = true;
    // using parasite power on the sensor
    bool parasite = false;
    int8_t parasitePin = -1;
    // how often do we read from sensor?
    unsigned long readingInterval = USERMOD_DALLASTEMPERATURE_MEASUREMENT_INTERVAL;
    // set last reading as "40 sec before boot", so first reading is taken after 20 sec
@ -38,112 +37,47 @@ class UsermodTemperature : public Usermod {
    // used to determine when we can read the sensors temperature
    // we have to wait at least 93.75 ms after requestTemperatures() is called
    unsigned long lastTemperaturesRequest;
-    float temperature;
+    float temperature = -100; // default to -100, DS18B20 only goes down to -50C
    // indicates requestTemperatures has been called but the sensor measurement is not complete
    bool waitingForConversion = false;
    // flag set at startup if DS18B20 sensor not found, avoids trying to keep getting
    // temperature if flashed to a board without a sensor attached
-    byte sensorFound;
+    bool sensorFound = false;
    bool enabled = true;
    bool HApublished = false;
    // strings to reduce flash memory usage (used more than twice)
    static const char _name[];
    static const char _enabled[];
    static const char _readInterval[];
    static const char _parasite[];
    static const char _parasitePin[];
    //Dallas sensor quick (& dirty) reading. Credit to - Author: Peter Scargill, August 17th, 2013
-    float readDallas();
+    float readDallas() {
-    void requestTemperatures();
+      byte i;
-    void readTemperature();
+      byte data[2];
    bool findSensor();
 #ifndef WLED_DISABLE_MQTT
    void publishHomeAssistantAutodiscovery();
 #endif
  public:
    /*
     * API calls te enable data exchange between WLED modules
     */
    inline float getTemperatureC() { return temperature; }
    inline float getTemperatureF() { return temperature * 1.8f + 32.0f; }
    float getTemperature();
    const char *getTemperatureUnit();
    uint16_t getId() { return USERMOD_ID_TEMPERATURE; }
    void setup();
    void loop();
    //void connected();
 #ifndef WLED_DISABLE_MQTT
    void onMqttConnect(bool sessionPresent);
 #endif
    //void onUpdateBegin(bool init);
    //bool handleButton(uint8_t b);
    //void handleOverlayDraw();
    void addToJsonInfo(JsonObject& root);
    //void addToJsonState(JsonObject &root);
    //void readFromJsonState(JsonObject &root);
    void addToConfig(JsonObject &root);
    bool readFromConfig(JsonObject &root);
    void appendConfigData();
 };
 //Dallas sensor quick (& dirty) reading. Credit to - Author: Peter Scargill, August 17th, 2013
 float UsermodTemperature::readDallas() {
  byte data[9];
      int16_t result;                         // raw data from sensor
-  float retVal = -127.0f;
+      if (!oneWire->reset()) return -127.0f;  // send reset command and fail fast
  if (oneWire->reset()) {                 // if reset() fails there are no OneWire devices
      oneWire->skip();                        // skip ROM
      oneWire->write(0xBE);                   // read (temperature) from EEPROM
-    oneWire->read_bytes(data, 9);         // first 2 bytes contain temperature
+      for (i=0; i < 2; i++) data[i] = oneWire->read();  // first 2 bytes contain temperature
-    #ifdef WLED_DEBUG
+      for (i=2; i < 8; i++) oneWire->read();  // read unused bytes  
    if (OneWire::crc8(data,8) != data[8]) {
      DEBUG_PRINTLN(F("CRC error reading temperature."));
      for (byte i=0; i < 9; i++) DEBUG_PRINTF("0x%02X ", data[i]);
      DEBUG_PRINT(F(" => "));
      DEBUG_PRINTF("0x%02X\n", OneWire::crc8(data,8));
    }
    #endif
    switch(sensorFound) {
      case 0x10:  // DS18S20 has 9-bit precision
        result = (data[1] << 8) | data[0];
        retVal = float(result) * 0.5f;
        break;
      case 0x22:  // DS18B20
      case 0x28:  // DS1822
      case 0x3B:  // DS1825
      case 0x42:  // DS28EA00
      result = (data[1]<<4) | (data[0]>>4);   // we only need whole part, we will add fraction when returning
-        if (data[1] & 0x80) result |= 0xF000;   // fix negative value
+      if (data[1]&0x80) result |= 0xFF00;     // fix negative value
        retVal = float(result) + ((data[0] & 0x08) ? 0.5f : 0.0f);
        break;
    }
  }
  for (byte i=1; i<9; i++) data[0] &= data[i];
  return data[0]==0xFF ? -127.0f : retVal;
 }
 void UsermodTemperature::requestTemperatures() {
  DEBUG_PRINTLN(F("Requesting temperature."));
      oneWire->reset();
      oneWire->skip();                        // skip ROM
-  oneWire->write(0x44,parasite);          // request new temperature reading
+      oneWire->write(0x44,parasite);          // request new temperature reading (without parasite power)
-  if (parasite && parasitePin >=0 ) digitalWrite(parasitePin, HIGH); // has to happen within 10us (open MOSFET)
+      return (float)result + ((data[0]&0x0008) ? 0.5f : 0.0f);
  lastTemperaturesRequest = millis();
  waitingForConversion = true;
    }
-void UsermodTemperature::readTemperature() {
+    void requestTemperatures() {
-  if (parasite && parasitePin >=0 ) digitalWrite(parasitePin, LOW); // deactivate power (close MOSFET)
+      readDallas();
      lastTemperaturesRequest = millis();
      waitingForConversion = true;
      DEBUG_PRINTLN(F("Requested temperature."));
    }
    void readTemperature() {
      temperature = readDallas();
      lastMeasurement = millis();
      waitingForConversion = false;
@ -152,7 +86,7 @@ void UsermodTemperature::readTemperature() {
      DEBUG_PRINTLN(temperature);
    }
-bool UsermodTemperature::findSensor() {
+    bool findSensor() {
      DEBUG_PRINTLN(F("Searching for sensor..."));
      uint8_t deviceAddress[8] = {0,0,0,0,0,0,0,0};
      // find out if we have DS18xxx sensor attached
@ -168,76 +102,45 @@ bool UsermodTemperature::findSensor() {
            case 0x3B:  // DS1825
            case 0x42:  // DS28EA00
              DEBUG_PRINTLN(F("Sensor found."));
          sensorFound = deviceAddress[0];
          DEBUG_PRINTF("0x%02X\n", sensorFound);
              return true;
          }
        }
      }
  DEBUG_PRINTLN(F("Sensor NOT found."));
      return false;
    }
-#ifndef WLED_DISABLE_MQTT
+  public:
 void UsermodTemperature::publishHomeAssistantAutodiscovery() {
  if (!WLED_MQTT_CONNECTED) return;
-  char json_str[1024], buf[128];
+    void setup() {
  size_t payload_size;
  StaticJsonDocument<1024> json;
  sprintf_P(buf, PSTR("%s Temperature"), serverDescription);
  json[F("name")] = buf;
  strcpy(buf, mqttDeviceTopic);
  strcat_P(buf, PSTR("/temperature"));
  json[F("state_topic")] = buf;
  json[F("device_class")] = F("temperature");
  json[F("unique_id")] = escapedMac.c_str();
  json[F("unit_of_measurement")] = F("°C");
  payload_size = serializeJson(json, json_str);
  sprintf_P(buf, PSTR("homeassistant/sensor/%s/config"), escapedMac.c_str());
  mqtt->publish(buf, 0, true, json_str, payload_size);
  HApublished = true;
 }
 #endif
 void UsermodTemperature::setup() {
      int retries = 10;
  sensorFound = 0;
  temperature = -127.0f; // default to -127, DS18B20 only goes down to -50C
      if (enabled) {
        // 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)) {
          oneWire = new OneWire(temperaturePin);
-      if (oneWire->reset()) {
+          if (!oneWire->reset()) {
-        while (!findSensor() && retries--) {
+            sensorFound = false;   // resetting 1-Wire bus yielded an error
          } else {
            while ((sensorFound=findSensor()) && retries--) {
              delay(25); // try to find sensor
            }
          }
      if (parasite && pinManager.allocatePin(parasitePin, true, PinOwner::UM_Temperature)) {
        pinMode(parasitePin, OUTPUT);
        digitalWrite(parasitePin, LOW); // deactivate power (close MOSFET)
      } else {
        parasitePin = -1;
      }
        } else {
          if (temperaturePin >= 0) {
            DEBUG_PRINTLN(F("Temperature pin allocation failed."));
          }
          temperaturePin = -1;  // allocation failed
          sensorFound = false;
        }
      }
      lastMeasurement = millis() - readingInterval + 10000;
      initDone = true;
    }
-void UsermodTemperature::loop() {
+    void loop() {
-  if (!enabled || !sensorFound || strip.isUpdating()) return;
+      if (!enabled || strip.isUpdating()) return;
  static uint8_t errorCount = 0;
      unsigned long now = millis();
      // check to see if we are due for taking a measurement
@ -253,60 +156,43 @@ void UsermodTemperature::loop() {
      }
      // we were waiting for a conversion to complete, have we waited log enough?
-  if (now - lastTemperaturesRequest >= 750 /* 93.75ms per the datasheet but can be up to 750ms */) {
+      if (now - lastTemperaturesRequest >= 100 /* 93.75ms per the datasheet but can be up to 750ms */) {
        readTemperature();
    if (getTemperatureC() < -100.0f) {
      if (++errorCount > 10) sensorFound = 0;
      lastMeasurement = now - readingInterval + 300; // force new measurement in 300ms
      return;
    }
    errorCount = 0;
 #ifndef WLED_DISABLE_MQTT
        if (WLED_MQTT_CONNECTED) {
          char subuf[64];
          strcpy(subuf, mqttDeviceTopic);
-      if (temperature > -100.0f) {
+          if (-100 <= temperature) {
            // dont publish super low temperature as the graph will get messed up
            // the DallasTemperature library returns -127C or -196.6F when problem
            // reading the sensor
            strcat_P(subuf, PSTR("/temperature"));
-        mqtt->publish(subuf, 0, false, String(getTemperatureC()).c_str());
+            mqtt->publish(subuf, 0, false, String(temperature).c_str());
            strcat_P(subuf, PSTR("_f"));
-        mqtt->publish(subuf, 0, false, String(getTemperatureF()).c_str());
+            mqtt->publish(subuf, 0, false, String((float)temperature * 1.8f + 32).c_str());
          } else {
            // publish something else to indicate status?
          }
        }
 #endif
      }
    }
-/**
+    /*
- * connected() is called every time the WiFi is (re)connected
+     * API calls te enable data exchange between WLED modules
 * Use it to initialize network interfaces
     */
-//void UsermodTemperature::connected() {}
+    inline float getTemperatureC() {
-
+      return (float)temperature;
 #ifndef WLED_DISABLE_MQTT
 /**
 * subscribe to MQTT topic if needed
 */
 void UsermodTemperature::onMqttConnect(bool sessionPresent) {
  //(re)subscribe to required topics
  //char subuf[64];
  if (mqttDeviceTopic[0] != 0) {
    publishHomeAssistantAutodiscovery();
    }
    inline float getTemperatureF() {
      return (float)temperature * 1.8f + 32;
    }
 #endif
    /*
     * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
     * Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
     * Below it is shown how this could be used for e.g. a light sensor
     */
-void UsermodTemperature::addToJsonInfo(JsonObject& root) {
+    void addToJsonInfo(JsonObject& root) {
      // dont add temperature to info if we are disabled
      if (!enabled) return;
@ -314,28 +200,24 @@ void UsermodTemperature::addToJsonInfo(JsonObject& root) {
      if (user.isNull()) user = root.createNestedObject("u");
      JsonArray temp = user.createNestedArray(FPSTR(_name));
      //temp.add(F("Loaded."));
-  if (temperature <= -100.0f) {
+      if (temperature <= -100.0 || (!sensorFound && temperature == -1.0)) {
        temp.add(0);
        temp.add(F(" Sensor Error!"));
        return;
      }
-  temp.add(getTemperature());
+      temp.add(degC ? temperature : (float)temperature * 1.8f + 32);
-  temp.add(getTemperatureUnit());
+      if (degC) temp.add(F("°C"));
-
+      else      temp.add(F("°F"));
  JsonObject sensor = root[F("sensor")];
  if (sensor.isNull()) sensor = root.createNestedObject(F("sensor"));
  temp = sensor.createNestedArray(F("temperature"));
  temp.add(getTemperature());
  temp.add(getTemperatureUnit());
    }
    /**
     * 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 UsermodTemperature::addToJsonState(JsonObject &root)
+    //void addToJsonState(JsonObject &root)
    //{
    //}
@ -344,14 +226,14 @@ void UsermodTemperature::addToJsonInfo(JsonObject& root) {
     * Values in the state object may be modified by connected clients
     * Read "<usermodname>_<usermodparam>" from json state and and change settings (i.e. GPIO pin) used.
     */
-//void UsermodTemperature::readFromJsonState(JsonObject &root) {
+    //void readFromJsonState(JsonObject &root) {
    //  if (!initDone) return;  // prevent crash on boot applyPreset()
    //}
    /**
     * addToConfig() (called from set.cpp) stores persistent properties to cfg.json
     */
-void UsermodTemperature::addToConfig(JsonObject &root) {
+    void addToConfig(JsonObject &root) {
      // we add JSON object: {"Temperature": {"pin": 0, "degC": true}}
      JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
      top[FPSTR(_enabled)] = enabled;
@ -359,7 +241,6 @@ void UsermodTemperature::addToConfig(JsonObject &root) {
      top["degC"] = degC;  // usermodparam
      top[FPSTR(_readInterval)] = readingInterval / 1000;
      top[FPSTR(_parasite)] = parasite;
  top[FPSTR(_parasitePin)] = parasitePin;
      DEBUG_PRINTLN(F("Temperature config saved."));
    }
@ -368,25 +249,26 @@ void UsermodTemperature::addToConfig(JsonObject &root) {
     *
     * The function should return true if configuration was successfully loaded or false if there was no configuration.
     */
-bool UsermodTemperature::readFromConfig(JsonObject &root) {
+    bool readFromConfig(JsonObject &root) {
      // we look for JSON object: {"Temperature": {"pin": 0, "degC": true}}
      int8_t newTemperaturePin = temperaturePin;
  DEBUG_PRINT(FPSTR(_name));
      JsonObject top = root[FPSTR(_name)];
      if (top.isNull()) {
        DEBUG_PRINT(FPSTR(_name));
        DEBUG_PRINTLN(F(": No config found. (Using defaults.)"));
        return false;
      }
      enabled           = top[FPSTR(_enabled)] | enabled;
      newTemperaturePin = top["pin"] | newTemperaturePin;
 //      newTemperaturePin = min(33,max(-1,(int)newTemperaturePin)); // bounds check
      degC              = top["degC"] | degC;
      readingInterval   = top[FPSTR(_readInterval)] | readingInterval/1000;
      readingInterval   = min(120,max(10,(int)readingInterval)) * 1000;  // convert to ms
      parasite          = top[FPSTR(_parasite)] | parasite;
  parasitePin       = top[FPSTR(_parasitePin)] | parasitePin;
      DEBUG_PRINT(FPSTR(_name));
      if (!initDone) {
        // first run: reading from cfg.json
        temperaturePin = newTemperaturePin;
@ -400,33 +282,22 @@ bool UsermodTemperature::readFromConfig(JsonObject &root) {
          delete oneWire;
          pinManager.deallocatePin(temperaturePin, PinOwner::UM_Temperature);
          temperaturePin = newTemperaturePin;
      pinManager.deallocatePin(parasitePin, PinOwner::UM_Temperature);
          // initialise
          setup();
        }
      }
      // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-  return !top[FPSTR(_parasitePin)].isNull();
+      return !top[FPSTR(_parasite)].isNull();
    }
-void UsermodTemperature::appendConfigData() {
+    uint16_t getId()
-  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
+      return USERMOD_ID_TEMPERATURE;
  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
 }
 float UsermodTemperature::getTemperature() {
  return degC ? getTemperatureC() : getTemperatureF();
 }
 const char *UsermodTemperature::getTemperatureUnit() {
  return degC ? "°C" : "°F";
    }
 };
 // strings to reduce flash memory usage (used more than twice)
 const char UsermodTemperature::_name[]         PROGMEM = "Temperature";
 const char UsermodTemperature::_enabled[]      PROGMEM = "enabled";
 const char UsermodTemperature::_readInterval[] PROGMEM = "read-interval-s";
 const char UsermodTemperature::_parasite[]     PROGMEM = "parasite-pwr";
 const char UsermodTemperature::_parasitePin[]  PROGMEM = "parasite-pwr-pin";
--- a/usermods/Temperature/usermods_list.cpp
+++ b/usermods/Temperature/usermods_list.cpp
@ -0,0 +1,31 @@
 #include "wled.h"
 /*
 * Register your v2 usermods here!
 */
 /*
 * Add/uncomment your usermod filename here (and once more below)
 * || || ||
 * \/ \/ \/
 */
 //#include "usermod_v2_example.h"
 #ifdef USERMOD_DALLASTEMPERATURE
 #include "../usermods/Temperature/usermod_temperature.h"
 #endif
 //#include "usermod_v2_empty.h"
 void registerUsermods()
 {
  /*
   * Add your usermod class name here
   * || || ||
   * \/ \/ \/
   */
  //usermods.add(new MyExampleUsermod());
 #ifdef USERMOD_DALLASTEMPERATURE
  usermods.add(new UsermodTemperature());
 #endif
  //usermods.add(new UsermodRenameMe());
 }
--- a/usermods/UserModv2_SunRiseAndSet/README.md
+++ b/usermods/UserModv2_SunRiseAndSet/README.md
@ -0,0 +1,15 @@
 WLED v2 UserMod for running macros at sunrise and sunset.
 At the time of this text, this user mod requires code to be changed to set certain variables:
    1. To reflect the user's graphical location (latitude/longitude) used for calculating apparent sunrise/sunset
    2. To specify which macros will be run at sunrise and/or sunset. (defaults to 15 at sunrise and 16 at sunset)
    3. To optionally provide an offset from sunrise/sunset, in minutes (max of +/- 2 hours), when the macro will be run.
 In addition, WLED must be configured to get time from NTP (and the time must be retrieved via NTP.)
 Please open the UserMod_SunRiseAndSet.h file for instructions on what needs to be changed, where to copy files, etc.
 If this usermod proves useful enough, the code might eventually be updated to allow prompting for the required information
 via the web interface and to store settings in EEPROM instead of hard-coding in the .h file.
 This usermod has only been tested on the esp32dev platform, but there's no reason it wouldn't work on other platforms.
--- a/usermods/UserModv2_SunRiseAndSet/UserMod_SunRiseAndSet.h
+++ b/usermods/UserModv2_SunRiseAndSet/UserMod_SunRiseAndSet.h
@ -0,0 +1,166 @@
 #pragma once
 #include "wled.h"
 #include <Dusk2Dawn.h>
 /*
 * 
 * REQUIREMENTS:
 *      The Dusk2Dawn library must be installed.  This can be found at https://github.com/dmkishi/Dusk2Dawn.  The 1.0.1 version of this library found via
 *      Arduino or platformio library managers is buggy and won't compile.  The latest version from github should be used.
 * 
 *      NTP must be enabled and functional.  It simply makes no sense to have events on sunrise/sunset when an accurate time isn't available.
 * 
 *      The user's geographical latitude and longitude must be configured (in decimal, not degrees/minutes/etc) using m_fLatitude and m_fLongitude
 * 
 *      if desired, an offset of up to +/- 2 hours can be specified for each of sunrise/sunset using m_sunriseOffset and m_sunsetOffset (defaults to 0)
 * 
 *      The specific macro to run at sunrise and/or sunset can be changed using m_sunriseMacro and m_sunsetMacro. (defaults to 15 and 16)
 * 
 *      From the Dusk2Dawn library:
 *          HINT: An easy way to find the longitude and latitude for any location is
 *          to find the spot in Google Maps, right click the place on the map, and
 *          select "What's here?". At the bottom, you’ll see a card with the
 *          coordinates.
 * 
 *      Once configured, copy UserMod_SunRiseAndSet.h to the sketch file (the same folder as wled00.ino exists), 
 *      and then edit "usermods_list.cpp":
 *          Add '#include "UserMod_SunRiseAndSet.h"' in the 'includes' area
 *          Add 'usermods.add(new UserMod_SunRiseAndSet());' in the registerUsermods() area
 * 
 */
 class UserMod_SunRiseAndSet : public Usermod 
 {
 private:    
    /**** USER SETTINGS ****/
    float m_fLatitude = 40.6;       // latitude where sunrise/set are calculated
    float m_fLongitude = -79.80;    // longitude where sunrise/set are calculated
    int8_t m_sunriseOffset = 0;     // offset from sunrise, in minutes, when macro should be run (negative for before sunrise, positive for after sunrise)
    int8_t m_sunsetOffset = 0;      // offset from sunset, in minutes, when macro should be run (negative for before sunset, positive for after sunset)
    uint8_t m_sunriseMacro = 15;    // macro number to run at sunrise
    uint8_t m_sunsetMacro = 16;     // macro number to run at sunset
    /**** END OF USER SETTINGS.  DO NOT EDIT BELOW THIS LINE! ****/
    Dusk2Dawn *m_pD2D = NULL;         // this must be dynamically allocated in order for parameters to be loaded from EEPROM
    int m_nUserSunrise = -1;        // time, in minutes from midnight, of sunrise    
    int m_nUserSunset = -1;         // time, in minutes from midnight, of sunset
    byte m_nLastRunMinute = -1;     // indicates what minute the userloop was last run - used so that the code only runs once per minute
 public:
    virtual void setup(void)
    {
        /* TODO:  From EEPROM, load the following variables:
        *
        *   int16_t latitude16 = 4060;      // user provided latitude, multiplied by 100 and rounded
        *   int16_t longitude16 = -7980;    // user provided longitude, multiplied by 100 and rounded.
        *   int8_t  sunrise_offset = 0;     // number of minutes to offset the sunrise macro trigger (positive for minutes after sunrise, negative for minutes before)
        *   int8_t  sunset_offset = 0;     // number of minutes to offset the sunset macro trigger (positive for minutes after sunset, negative for minutes before)
        * 
        *   then:
        *       m_fLatitude = (float)latitude / 100.0;
        *       m_fLongitude = (float)longitude / 100.0;
        *       m_sunriseOffset = sunrise_offset;
        *       m_sunsetOffset = sunset_offset;
        */
        if ((0.0 != m_fLatitude) || (0.0 != m_fLongitude))
        {
            m_pD2D = new Dusk2Dawn (m_fLatitude, m_fLongitude, 0 /* UTC */);
            // can't really check for failures.  if the alloc fails, the mod just doesn't work.
        }        
    }        
    void loop(void) 
    {
        // without NTP, or a configured lat/long, none of this stuff is going to work...  
        // As an alternative, need to figure out how to determine if the user has manually set the clock or not.
        if (m_pD2D && (999000000L != ntpLastSyncTime))
        {
            // to prevent needing to import all the timezone stuff from other modules, work completely in UTC
            time_t timeUTC = toki.second();
            tmElements_t tmNow;
            breakTime(timeUTC, tmNow);
            int nCurMinute = tmNow.Minute;
            if (m_nLastRunMinute != nCurMinute) //only check once a new minute begins
            {
                m_nLastRunMinute = nCurMinute;
                int numMinutes = (60 * tmNow.Hour) + m_nLastRunMinute; // how many minutes into the day are we?
                // check to see if sunrise/sunset should be re-determined.  Only do this if neither sunrise nor sunset 
                // are set.  That happens when the device has just stated, and after both sunrise/sunset have already run.
                if ((-1 == m_nUserSunrise) && (-1 == m_nUserSunset))
                {                
                    m_nUserSunrise = m_pD2D->sunrise(tmNow.Year + 1970, tmNow.Month, tmNow.Day, false) % 1440;
                    m_nUserSunset = m_pD2D->sunset(tmNow.Year + 1970, tmNow.Month, tmNow.Day, false) % 1440;
                    if (m_nUserSunrise > numMinutes) // has sunrise already passed?  if so, recompute for tomorrow
                    {
                        breakTime(timeUTC + (60*60*24), tmNow);
                        m_nUserSunrise = m_pD2D->sunrise(tmNow.Year + 1970, tmNow.Month, tmNow.Day, false) % 1440;
                        if (m_nUserSunset > numMinutes) // if sunset has also passed, recompute that as well
                        {
                            m_nUserSunset = m_pD2D->sunset(tmNow.Year + 1970, tmNow.Month, tmNow.Day, false) % 1440;
                        }                    
                    }
                    // offset by user provided values.  becuase the offsets are signed bytes, the max offset is just over 2 hours.
                    m_nUserSunrise += m_sunriseOffset;
                    m_nUserSunset += m_sunsetOffset;
                }
                if (numMinutes == m_nUserSunrise)     // Good Morning!
                {
                    if (m_sunriseMacro)
                        applyMacro(m_sunriseMacro); // run macro 15
                    m_nUserSunrise = -1;
                }
                else if (numMinutes == m_nUserSunset)  // Good Night!
                {
                    if (m_sunsetMacro)                    
                        applyMacro(m_sunsetMacro); // run macro 16
                    m_nUserSunset = -1;
                }
            } // if (m_nLastRunMinute != nCurMinute)
        }  // if (m_pD2D && (999000000L != ntpLastSyncTime))
    }
   void addToJsonState(JsonObject& root)
    {
        JsonObject user = root["SunRiseAndSet"];
        if (user.isNull()) user = root.createNestedObject("SunRiseAndSet");
        char buf[10];
        if (-1 != m_nUserSunrise)
        {
            snprintf(buf, 10, "%02d:%02d UTC", m_nUserSunrise / 60, m_nUserSunrise % 60);
            user["rise"] = buf;
        }
        if (-1 != m_nUserSunset)
        {
            snprintf(buf, 10, "%02d:%02d UTC", m_nUserSunset / 60, m_nUserSunset % 60);
            user["set"] = buf;
        }
        JsonObject vars = user.createNestedObject("vars");
        vars["lat"] = m_fLatitude;
        vars["long"] = m_fLongitude;
        vars["rise_mac"] = m_sunriseMacro;
        vars["set_mac"] = m_sunsetMacro;
        vars["rise_off"] = m_sunriseOffset;
        vars["set_off"] = m_sunsetOffset;
    }
    ~UserMod_SunRiseAndSet(void)
    {
        if (m_pD2D) delete m_pD2D;
    }
 };
--- a/usermods/VL53L0X_gestures/readme.md
+++ b/usermods/VL53L0X_gestures/readme.md
@ -1,16 +1,17 @@
 # Description
-Implements support of simple hand gestures via a VL53L0X sensor: on/off and brightness adjustment.
+That usermod implements support of simple hand gestures with VL53L0X sensor: on/off and brightness correction.
-Useful for controlling strips when you want to avoid touching anything.
+It can be useful for kitchen strips to avoid any touches.
- - on/off - swipe your hand below the sensor ("shortPressAction" is called. Can be customized via WLED macros)
+ - on/off - just swipe a hand below your sensor ("shortPressAction" is called and can be customized through WLED macros)
- - brightness adjustment - hold your hand below the sensor for 1 second to switch to "brightness" mode.
+ - brightness correction - keep your hand below sensor for 1 second to switch to "brightness" mode.
-                           adjust the brightness by changing the distance between your hand and the sensor (see parameters below for customization).
+                           Configure brightness by changing distance to the sensor (see parameters below for customization).
                           "macroLongPress" is also called here.
 ## Installation 
 1. Attach VL53L0X sensor to i2c pins according to default pins for your board.
 2. Add `-D USERMOD_VL53L0X_GESTURES` to your build flags at platformio.ini (plaformio_override.ini) for needed environment.
-In my case, for example: `build_flags = ${env.build_flags} -D USERMOD_VL53L0X_GESTURES`
+In my case, for example: `build_flags = ${common.build_flags_esp8266} -D RLYPIN=12 -D USERMOD_VL53L0X_GESTURES`
 3. Add "pololu/VL53L0X" dependency below to `lib_deps` like this:
 ```ini
 lib_deps = ${env.lib_deps}
@ -20,10 +21,15 @@ lib_deps = ${env.lib_deps}
 My entire `platformio_override.ini` for example (for nodemcu board):
 ```ini
 [platformio]
-default_envs = nodemcuv2
+default_envs = nodemcu
-[env:nodemcuv2]
+[env:nodemcu]
-build_flags = ${env.build_flags} -D USERMOD_VL53L0X_GESTURES
+board = nodemcu
 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} -D RLYPIN=12 -D USERMOD_VL53L0X_GESTURES
 lib_deps = ${env.lib_deps}
  pololu/VL53L0X @ ^1.3.0
 ```
--- a/usermods/VL53L0X_gestures/usermod_vl53l0x_gestures.h
+++ b/usermods/VL53L0X_gestures/usermod_vl53l0x_gestures.h
@ -3,13 +3,14 @@
 * It can be useful for kitchen strips to avoid any touches.
 * - on/off - just swipe a hand below your sensor ("shortPressAction" is called and can be customized through WLED macros)
 * - brightness correction - keep your hand below sensor for 1 second to switch to "brightness" mode.
-        Configure brightness by changing distance to the sensor (see parameters below for customization).
+ *                           Configure brightness by changing distance to the sensor (see parameters below for customization).
 *                           "macroLongPress" is also called here.
 *
- * Enabling this usermod:
+ * Enabling this mod usermod:
 * 1. Attach VL53L0X sensor to i2c pins according to default pins for your board.
- * 2. Add `-D USERMOD_VL53L0X_GESTURES` to your build flags at platformio.ini (plaformio_override.ini) for needed environment.
+ * 2. Add "-D USERMOD_VL53L0X_GESTURES" to your build flags at platformio.ini (plaformio_override.ini) for needed environment.
- * In my case, for example: `build_flags = ${env.build_flags} -D USERMOD_VL53L0X_GESTURES`
+ * In my case, for example: build_flags = ${common.build_flags_esp8266} -D RLYPIN=12 -D USERMOD_VL53L0X_GESTURES
- * 3. Add "pololu/VL53L0X" dependency below to `lib_deps` like this:
+ * 3. Add "pololu/VL53L0X" dependency to lib_deps like this:
 * lib_deps = ${env.lib_deps}
 *     pololu/VL53L0X @ ^1.3.0
 */
@ -21,11 +22,11 @@
 #include <VL53L0X.h>
 #ifndef VL53L0X_MAX_RANGE_MM
-#define VL53L0X_MAX_RANGE_MM 230 // max height in millimeters to react for motions
+#define VL53L0X_MAX_RANGE_MM 230 // max height in millimiters to react for motions
 #endif
 #ifndef VL53L0X_MIN_RANGE_OFFSET
-#define VL53L0X_MIN_RANGE_OFFSET 60 // minimal range in millimeters that sensor can detect. Used in long motions to correct brightness calculation.
+#define VL53L0X_MIN_RANGE_OFFSET 60 // minimal range in millimiters that sensor can detect. Used in long motions to correct brightnes calculation.
 #endif
 #ifndef VL53L0X_DELAY_MS
@ -33,7 +34,7 @@
 #endif
 #ifndef VL53L0X_LONG_MOTION_DELAY_MS
-#define VL53L0X_LONG_MOTION_DELAY_MS 1000 // switch onto "long motion" action after this delay
+#define VL53L0X_LONG_MOTION_DELAY_MS 1000 // how often to get data from sensor 
 #endif
 class UsermodVL53L0XGestures : public Usermod {
@ -41,7 +42,6 @@ class UsermodVL53L0XGestures : public Usermod {
    //Private class members. You can declare variables and functions only accessible to your usermod here
    unsigned long lastTime = 0;
    VL53L0X sensor;
    bool enabled = true;
    bool wasMotionBefore = false;
    bool isLongMotion = false;
@ -50,7 +50,7 @@ class UsermodVL53L0XGestures : public Usermod {
  public:
    void setup() {
-      if (i2c_scl<0 || i2c_sda<0) { enabled = false; return; }
+      Wire.begin();
      sensor.setTimeout(150);
      if (!sensor.init())
@ -63,40 +63,45 @@ class UsermodVL53L0XGestures : public Usermod {
    void loop() {
      if (!enabled || strip.isUpdating()) return;
      if (millis() - lastTime > VL53L0X_DELAY_MS)
      {
        lastTime = millis();
        int range = sensor.readRangeSingleMillimeters();
-        DEBUG_PRINTF("range: %d, brightness: %d\r\n", range, bri);
+        DEBUG_PRINTF(F("range: %d, brightness: %d"), range, bri);
        if (range < VL53L0X_MAX_RANGE_MM)
        {
          if (!wasMotionBefore)
          {
            motionStartTime = millis();
-            DEBUG_PRINTF("motionStartTime: %d\r\n", motionStartTime);
+            DEBUG_PRINTF(F("motionStartTime: %d"), motionStartTime);
          }
          wasMotionBefore = true;
          if (millis() - motionStartTime > VL53L0X_LONG_MOTION_DELAY_MS) //long motion
          {
-            DEBUG_PRINTF("long motion: %d\r\n", motionStartTime);
+            DEBUG_PRINTF(F("long motion: %d"), motionStartTime);
            if (!isLongMotion)
            {
              if (macroLongPress)
              {
                applyMacro(macroLongPress);
              }
              isLongMotion = true;
            }
            // set brightness according to range
            bri = (VL53L0X_MAX_RANGE_MM - max(range, VL53L0X_MIN_RANGE_OFFSET)) * 255 / (VL53L0X_MAX_RANGE_MM - VL53L0X_MIN_RANGE_OFFSET);
-            DEBUG_PRINTF("new brightness: %d", bri);
+            DEBUG_PRINTF(F("new brightness: %d"), bri);
-            stateUpdated(1);
+            colorUpdated(1);
          }
        } else if (wasMotionBefore) { //released
          long dur = millis() - motionStartTime;
          if (!isLongMotion)
          { //short press
-            DEBUG_PRINTLN(F("shortPressAction..."));
+            DEBUG_PRINTF(F("shortPressAction..."));
            shortPressAction();
          }
          wasMotionBefore = false;
@ -105,19 +110,6 @@ class UsermodVL53L0XGestures : public Usermod {
      }
    }
    /*
     * addToConfig() can be used to add custom persistent settings to the cfg.json file in the "um" (usermod) object.
     * It will be called by WLED when settings are actually saved (for example, LED settings are saved)
     * I highly recommend checking out the basics of ArduinoJson serialization and deserialization in order to use custom settings!
     */
 //    void addToConfig(JsonObject& root)
 //    {
 //      JsonObject top = root.createNestedObject("VL53L0x");
 //      JsonArray pins = top.createNestedArray("pin");
 //      pins.add(i2c_scl);
 //      pins.add(i2c_sda);
 //    }
    /*
     * getId() allows you to optionally give your V2 usermod an unique ID (please define it in const.h!).
     * This could be used in the future for the system to determine whether your usermod is installed.
--- a/usermods/Wemos_D1_mini+Wemos32_mini_shield/readme.md
+++ b/usermods/Wemos_D1_mini+Wemos32_mini_shield/readme.md
@ -9,10 +9,10 @@
 ## Features
 -   SSD1306 128x32 or 128x64 I2C OLED display
 -   On screen IP address, SSID and controller status (e.g. ON or OFF, recent effect)
-   Auto display shutoff for extending display lifetime
+-   Auto display shutoff for saving display lifetime
 -   Dallas temperature sensor
 -   Reporting temperature to MQTT broker
-   Relay for saving energy
+-   Relay for energy saving
 ## Hardware
 ![Shield](https://github.com/srg74/WLED-wemos-shield/blob/master/resources/Images/Assembly_8.jpg)
--- a/usermods/Wemos_D1_mini+Wemos32_mini_shield/usermod.cpp
+++ b/usermods/Wemos_D1_mini+Wemos32_mini_shield/usermod.cpp
@ -101,7 +101,6 @@ void userLoop() {
  if (temptimer - lastMeasure > 60000) 
  {
    lastMeasure = temptimer;    
 #ifndef WLED_DISABLE_MQTT
 //Check if MQTT Connected, otherwise it will crash the 8266
    if (mqtt != nullptr)
    {
@ -117,7 +116,6 @@ void userLoop() {
        t += "/temperature";
        mqtt->publish(t.c_str(), 0, true, String(board_temperature).c_str());
    }
  #endif
  }
  // Check if we time interval for redrawing passes.
@ -139,9 +137,9 @@ void userLoop() {
    needRedraw = true;
  } else if (knownBrightness != bri) {
    needRedraw = true;
-  } else if (knownMode != strip.getMainSegment().mode) {
+  } else if (knownMode != strip.getMode()) {
    needRedraw = true;
-  } else if (knownPalette != strip.getMainSegment().palette) {
+  } else if (knownPalette != strip.getSegment(0).palette) {
    needRedraw = true;
  }
@ -165,8 +163,8 @@ void userLoop() {
  #endif
  knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
  knownBrightness = bri;
-  knownMode = strip.getMainSegment().mode;
+  knownMode = strip.getMode();
-  knownPalette = strip.getMainSegment().palette;
+  knownPalette = strip.getSegment(0).palette;
  u8x8.clear();
  u8x8.setFont(u8x8_font_chroma48medium8_r);
@ -187,14 +185,58 @@ void userLoop() {
  // Third row with mode name
  u8x8.setCursor(2, 2);
-  char lineBuffer[17];
+  uint8_t qComma = 0;
-  extractModeName(knownMode, JSON_mode_names, lineBuffer, 16);
+  bool insideQuotes = false;
-  u8x8.print(lineBuffer);
+  uint8_t printedChars = 0;
  char singleJsonSymbol;
  // Find the mode name in JSON
  for (size_t i = 0; i < strlen_P(JSON_mode_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_mode_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownMode))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  // Fourth row with palette name
  u8x8.setCursor(2, 3);
-  extractModeName(knownPalette, JSON_palette_names, lineBuffer, 16);
+  qComma = 0;
-  u8x8.print(lineBuffer);
+  insideQuotes = false;
  printedChars = 0;
  // Looking for palette name in JSON.
  for (size_t i = 0; i < strlen_P(JSON_palette_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_palette_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownPalette))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  u8x8.setFont(u8x8_font_open_iconic_embedded_1x1);
  u8x8.drawGlyph(0, 0, 80); // wifi icon
--- a/usermods/Wemos_D1_mini+Wemos32_mini_shield/usermod_bme280.cpp
+++ b/usermods/Wemos_D1_mini+Wemos32_mini_shield/usermod_bme280.cpp
@ -103,7 +103,6 @@ void userLoop() {
  {
    lastMeasure = tempTimer;    
 #ifndef WLED_DISABLE_MQTT
 // Check if MQTT Connected, otherwise it will crash the 8266
    if (mqtt != nullptr)
    {
@ -123,7 +122,6 @@ void userLoop() {
      h += "/humidity";
      mqtt->publish(h.c_str(), 0, true, String(board_humidity).c_str());
    }
  #endif
  }
  // Check if we time interval for redrawing passes.
@ -145,9 +143,9 @@ void userLoop() {
    needRedraw = true;
  } else if (knownBrightness != bri) {
    needRedraw = true;
-  } else if (knownMode != strip.getMainSegment().mode) {
+  } else if (knownMode != strip.getMode()) {
    needRedraw = true;
-  } else if (knownPalette != strip.getMainSegment().palette) {
+  } else if (knownPalette != strip.getSegment(0).palette) {
    needRedraw = true;
  }
@ -171,8 +169,8 @@ void userLoop() {
  #endif
  knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
  knownBrightness = bri;
-  knownMode = strip.getMainSegment().mode;
+  knownMode = strip.getMode();
-  knownPalette = strip.getMainSegment().palette;
+  knownPalette = strip.getSegment(0).palette;
  u8x8.clear();
  u8x8.setFont(u8x8_font_chroma48medium8_r);
@ -193,14 +191,58 @@ void userLoop() {
  // Third row with mode name
  u8x8.setCursor(2, 2);
-  char lineBuffer[17];
+  uint8_t qComma = 0;
-  extractModeName(knownMode, JSON_mode_names, lineBuffer, 16);
+  bool insideQuotes = false;
-  u8x8.print(lineBuffer);
+  uint8_t printedChars = 0;
  char singleJsonSymbol;
  // Find the mode name in JSON
  for (size_t i = 0; i < strlen_P(JSON_mode_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_mode_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownMode))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  // Fourth row with palette name
  u8x8.setCursor(2, 3);
-  extractModeName(knownPalette, JSON_palette_names, lineBuffer, 16);
+  qComma = 0;
-  u8x8.print(lineBuffer);
+  insideQuotes = false;
  printedChars = 0;
  // Looking for palette name in JSON.
  for (size_t i = 0; i < strlen_P(JSON_palette_names); i++) {
    singleJsonSymbol = pgm_read_byte_near(JSON_palette_names + i);
    switch (singleJsonSymbol) {
    case '"':
      insideQuotes = !insideQuotes;
      break;
    case '[':
    case ']':
      break;
    case ',':
      qComma++;
    default:
      if (!insideQuotes || (qComma != knownPalette))
        break;
      u8x8.print(singleJsonSymbol);
      printedChars++;
    }
    if ((qComma > knownMode) || (printedChars > u8x8.getCols() - 2))
      break;
  }
  u8x8.setFont(u8x8_font_open_iconic_embedded_1x1);
  u8x8.drawGlyph(0, 0, 80); // wifi icon
--- a/usermods/audioreactive/audio_reactive.h
+++ b/usermods/audioreactive/audio_reactive.h
--- a/usermods/audioreactive/audio_source.h
+++ b/usermods/audioreactive/audio_source.h
@ -1,773 +0,0 @@
 #pragma once
 #ifdef ARDUINO_ARCH_ESP32
 #include "wled.h"
 #include <driver/i2s.h>
 #include <driver/adc.h>
 #include <soc/i2s_reg.h>  // needed for SPH0465 timing workaround (classic ESP32)
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
 #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32S3) && !defined(CONFIG_IDF_TARGET_ESP32C3)
 #include <driver/adc_deprecated.h>
 #include <driver/adc_types_deprecated.h>
 #endif
 // type of i2s_config_t.SampleRate was changed from "int" to "unsigned" in IDF 4.4.x
 #define SRate_t uint32_t
 #else
 #define SRate_t int
 #endif
 //#include <driver/i2s_std.h>
 //#include <driver/i2s_pdm.h>
 //#include <driver/i2s_tdm.h>
 //#include <driver/gpio.h>
 // see https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/hw-reference/chip-series-comparison.html#related-documents
 // and https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-reference/peripherals/i2s.html#overview-of-all-modes
 #if defined(CONFIG_IDF_TARGET_ESP32C2) || defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32H2) || defined(ESP8266) || defined(ESP8265)
  // there are two things in these MCUs that could lead to problems with audio processing:
  // * no floating point hardware (FPU) support - FFT uses float calculations. If done in software, a strong slow-down can be expected (between 8x and 20x)
  // * single core, so FFT task might slow down other things like LED updates
  #if !defined(SOC_I2S_NUM) || (SOC_I2S_NUM < 1)
  #error This audio reactive usermod does not support ESP32-C2 or ESP32-C3.
  #else
  #warning This audio reactive usermod does not support ESP32-C2 and ESP32-C3.
  #endif
 #endif
 /* ToDo: remove. ES7243 is controlled via compiler defines
   Until this configuration is moved to the webinterface
 */
 // if you have problems to get your microphone work on the left channel, uncomment the following line
 //#define I2S_USE_RIGHT_CHANNEL    // (experimental) define this to use right channel (digital mics only)
 // Uncomment the line below to utilize ADC1 _exclusively_ for I2S sound input.
 // benefit: analog mic inputs will be sampled contiously -> better response times and less "glitches"
 // WARNING: this option WILL lock-up your device in case that any other analogRead() operation is performed; 
 //          for example if you want to read "analog buttons"
 //#define I2S_GRAB_ADC1_COMPLETELY // (experimental) continously sample analog ADC microphone. WARNING will cause analogRead() lock-up
 // data type requested from the I2S driver - currently we always use 32bit
 //#define I2S_USE_16BIT_SAMPLES   // (experimental) define this to request 16bit - more efficient but possibly less compatible
 #ifdef I2S_USE_16BIT_SAMPLES
 #define I2S_SAMPLE_RESOLUTION I2S_BITS_PER_SAMPLE_16BIT
 #define I2S_datatype int16_t
 #define I2S_unsigned_datatype uint16_t
 #define I2S_data_size I2S_BITS_PER_CHAN_16BIT
 #undef  I2S_SAMPLE_DOWNSCALE_TO_16BIT
 #else
 #define I2S_SAMPLE_RESOLUTION I2S_BITS_PER_SAMPLE_32BIT
 //#define I2S_SAMPLE_RESOLUTION I2S_BITS_PER_SAMPLE_24BIT 
 #define I2S_datatype int32_t
 #define I2S_unsigned_datatype uint32_t
 #define I2S_data_size I2S_BITS_PER_CHAN_32BIT
 #define I2S_SAMPLE_DOWNSCALE_TO_16BIT
 #endif
 /* There are several (confusing) options  in IDF 4.4.x:
 * I2S_CHANNEL_FMT_RIGHT_LEFT, I2S_CHANNEL_FMT_ALL_RIGHT and I2S_CHANNEL_FMT_ALL_LEFT stands for stereo mode, which means two channels will transport different data.
 * I2S_CHANNEL_FMT_ONLY_RIGHT and I2S_CHANNEL_FMT_ONLY_LEFT they are mono mode, both channels will only transport same data.
 * I2S_CHANNEL_FMT_MULTIPLE means TDM channels, up to 16 channel will available, and they are stereo as default.
 * if you want to receive two channels, one is the actual data from microphone and another channel is suppose to receive 0, it's different data in two channels, you need to choose I2S_CHANNEL_FMT_RIGHT_LEFT in this case.
 */
 #if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)) && (ESP_IDF_VERSION <= ESP_IDF_VERSION_VAL(4, 4, 4))
 // espressif bug: only_left has no sound, left and right are swapped 
 // https://github.com/espressif/esp-idf/issues/9635  I2S mic not working since 4.4 (IDFGH-8138)
 // https://github.com/espressif/esp-idf/issues/8538  I2S channel selection issue? (IDFGH-6918)
 // https://github.com/espressif/esp-idf/issues/6625  I2S: left/right channels are swapped for read (IDFGH-4826)
 #ifdef I2S_USE_RIGHT_CHANNEL
 #define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_LEFT
 #define I2S_MIC_CHANNEL_TEXT "right channel only (work-around swapped channel bug in IDF 4.4)."
 #define I2S_PDM_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_RIGHT
 #define I2S_PDM_MIC_CHANNEL_TEXT "right channel only"
 #else
 //#define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_ALL_LEFT
 //#define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_RIGHT_LEFT
 #define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_RIGHT
 #define I2S_MIC_CHANNEL_TEXT "left channel only (work-around swapped channel bug in IDF 4.4)."
 #define I2S_PDM_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_LEFT
 #define I2S_PDM_MIC_CHANNEL_TEXT "left channel only."
 #endif
 #else
 // not swapped
 #ifdef I2S_USE_RIGHT_CHANNEL
 #define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_RIGHT
 #define I2S_MIC_CHANNEL_TEXT "right channel only."
 #else
 #define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_LEFT
 #define I2S_MIC_CHANNEL_TEXT "left channel only."
 #endif
 #define I2S_PDM_MIC_CHANNEL I2S_MIC_CHANNEL
 #define I2S_PDM_MIC_CHANNEL_TEXT I2S_MIC_CHANNEL_TEXT
 #endif
 /* Interface class
   AudioSource serves as base class for all microphone types
   This enables accessing all microphones with one single interface
   which simplifies the caller code
 */
 class AudioSource {
  public:
    /* All public methods are virtual, so they can be overridden
       Everything but the destructor is also removed, to make sure each mic
       Implementation provides its version of this function
    */
    virtual ~AudioSource() {};
    /* Initialize
       This function needs to take care of anything that needs to be done
       before samples can be obtained from the microphone.
    */
    virtual void initialize(int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE) = 0;
    /* Deinitialize
       Release all resources and deactivate any functionality that is used
       by this microphone
    */
    virtual void deinitialize() = 0;
    /* getSamples
       Read num_samples from the microphone, and store them in the provided
       buffer
    */
    virtual void getSamples(float *buffer, uint16_t num_samples) = 0;
    /* check if the audio source driver was initialized successfully */
    virtual bool isInitialized(void) {return(_initialized);}
    /* identify Audiosource type - I2S-ADC or I2S-digital */
    typedef enum{Type_unknown=0, Type_I2SAdc=1, Type_I2SDigital=2} AudioSourceType;
    virtual AudioSourceType getType(void) {return(Type_I2SDigital);}               // default is "I2S digital source" - ADC type overrides this method
  protected:
    /* Post-process audio sample - currently on needed for I2SAdcSource*/
    virtual I2S_datatype postProcessSample(I2S_datatype sample_in) {return(sample_in);}   // default method can be overriden by instances (ADC) that need sample postprocessing
    // Private constructor, to make sure it is not callable except from derived classes
    AudioSource(SRate_t sampleRate, int blockSize, float sampleScale) :
      _sampleRate(sampleRate),
      _blockSize(blockSize),
      _initialized(false),
      _sampleScale(sampleScale)
    {};
    SRate_t _sampleRate;            // Microphone sampling rate
    int _blockSize;                 // I2S block size
    bool _initialized;              // Gets set to true if initialization is successful
    float _sampleScale;             // pre-scaling factor for I2S samples
 };
 /* Basic I2S microphone source
   All functions are marked virtual, so derived classes can replace them
 */
 class I2SSource : public AudioSource {
  public:
    I2SSource(SRate_t sampleRate, int blockSize, float sampleScale = 1.0f) :
      AudioSource(sampleRate, blockSize, sampleScale) {
      _config = {
        .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX),
        .sample_rate = _sampleRate,
        .bits_per_sample = I2S_SAMPLE_RESOLUTION,
        .channel_format = I2S_MIC_CHANNEL,
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 2, 0)
        .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_STAND_I2S),
        //.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2,
        .dma_buf_count = 8,
        .dma_buf_len = _blockSize,
        .use_apll = 0,
        .bits_per_chan = I2S_data_size,
 #else
        .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
        .dma_buf_count = 8,
        .dma_buf_len = _blockSize,
        .use_apll = false
 #endif
      };
    }
    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("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
          DEBUGSR_PRINTF("\nAR: Failed to allocate I2S pins: ws=%d, sd=%d\n",  i2swsPin, i2ssdPin); 
          return;
        }
      }
      // 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)) {
          DEBUGSR_PRINTF("\nAR: Failed to allocate I2S pins: sck=%d\n",  i2sckPin); 
          return;
        }
      } else {
        #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 2, 0)
          #if !defined(SOC_I2S_SUPPORTS_PDM_RX)
          #warning this MCU does not support PDM microphones
          #endif
        #endif
        #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3)
        // This is an I2S PDM microphone, these microphones only use a clock and
        // data line, to make it simpler to debug, use the WS pin as CLK and SD pin as DATA
        // example from espressif: https://github.com/espressif/esp-idf/blob/release/v4.4/examples/peripherals/i2s/i2s_audio_recorder_sdcard/main/i2s_recorder_main.c
        // note to self: PDM has known bugs on S3, and does not work on C3 
        //  * S3: PDM sample rate only at 50% of expected rate: https://github.com/espressif/esp-idf/issues/9893
        //  * S3: I2S PDM has very low amplitude: https://github.com/espressif/esp-idf/issues/8660
        //  * C3: does not support PDM to PCM input. SoC would allow PDM RX, but there is no hardware to directly convert to PCM so it will not work. https://github.com/espressif/esp-idf/issues/8796
        _config.mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_PDM); // Change mode to pdm if clock pin not provided. PDM is not supported on ESP32-S2. PDM RX not supported on ESP32-C3
        _config.channel_format =I2S_PDM_MIC_CHANNEL;                             // seems that PDM mono mode always uses left channel.
        _config.use_apll = true;                                                 // experimental - use aPLL clock source to improve sampling quality
        #endif
      }
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 2, 0)
      if (mclkPin != I2S_PIN_NO_CHANGE) {
        _config.use_apll = true; // experimental - use aPLL clock source to improve sampling quality, and to avoid glitches.
        // //_config.fixed_mclk = 512 * _sampleRate;
        // //_config.fixed_mclk = 256 * _sampleRate;
      }
      #if !defined(SOC_I2S_SUPPORTS_APLL)
        #warning this MCU does not have an APLL high accuracy clock for audio
        // S3: not supported; S2: supported; C3: not supported
        _config.use_apll = false; // APLL not supported on this MCU
      #endif
      #if defined(ARDUINO_ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S3) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3)
      if (ESP.getChipRevision() == 0) _config.use_apll = false; // APLL is broken on ESP32 revision 0
      #endif
 #endif
      // Reserve the master clock pin if provided
      _mclkPin = mclkPin;
      if (mclkPin != I2S_PIN_NO_CHANGE) {
        if(!pinManager.allocatePin(mclkPin, true, PinOwner::UM_Audioreactive)) { 
          DEBUGSR_PRINTF("\nAR: Failed to allocate I2S pin: MCLK=%d\n",  mclkPin); 
          return;
        } else
        _routeMclk(mclkPin);
      }
      _pinConfig = {
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
        .mck_io_num = mclkPin,            // "classic" ESP32 supports setting MCK on GPIO0/GPIO1/GPIO3 only. i2s_set_pin() will fail if wrong mck_io_num is provided.
 #endif
        .bck_io_num = i2sckPin,
        .ws_io_num = i2swsPin,
        .data_out_num = I2S_PIN_NO_CHANGE,
        .data_in_num = i2ssdPin
      };
      //DEBUGSR_PRINTF("[AR] I2S: SD=%d, WS=%d, SCK=%d, MCLK=%d\n", i2ssdPin, i2swsPin, i2sckPin, mclkPin);
      esp_err_t err = i2s_driver_install(I2S_NUM_0, &_config, 0, nullptr);
      if (err != ESP_OK) {
        DEBUGSR_PRINTF("AR: Failed to install i2s driver: %d\n", err);
        return;
      }
      DEBUGSR_PRINTF("AR: I2S#0 driver %s aPLL; fixed_mclk=%d.\n", _config.use_apll? "uses":"without", _config.fixed_mclk);
      DEBUGSR_PRINTF("AR: %d bits, Sample scaling factor = %6.4f\n",  _config.bits_per_sample, _sampleScale);
      if (_config.mode & I2S_MODE_PDM) {
          DEBUGSR_PRINTLN(F("AR: I2S#0 driver installed in PDM MASTER mode."));
      } else { 
          DEBUGSR_PRINTLN(F("AR: I2S#0 driver installed in MASTER mode."));
      }
      err = i2s_set_pin(I2S_NUM_0, &_pinConfig);
      if (err != ESP_OK) {
        DEBUGSR_PRINTF("AR: Failed to set i2s pin config: %d\n", err);
        i2s_driver_uninstall(I2S_NUM_0);  // uninstall already-installed driver
        return;
      }
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 2, 0)
      err = i2s_set_clk(I2S_NUM_0, _sampleRate, I2S_SAMPLE_RESOLUTION, I2S_CHANNEL_MONO);  // set bit clocks. Also takes care of MCLK routing if needed.
      if (err != ESP_OK) {
        DEBUGSR_PRINTF("AR: Failed to configure i2s clocks: %d\n", err);
        i2s_driver_uninstall(I2S_NUM_0);  // uninstall already-installed driver
        return;
      }
 #endif
      _initialized = true;
    }
    virtual void deinitialize() {
      _initialized = false;
      esp_err_t err = i2s_driver_uninstall(I2S_NUM_0);
      if (err != ESP_OK) {
        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);
      // Release the master clock pin
      if (_mclkPin != I2S_PIN_NO_CHANGE) pinManager.deallocatePin(_mclkPin, PinOwner::UM_Audioreactive);
    }
    virtual void getSamples(float *buffer, uint16_t num_samples) {
      if (_initialized) {
        esp_err_t err;
        size_t bytes_read = 0;        /* Counter variable to check if we actually got enough data */
        I2S_datatype newSamples[num_samples]; /* Intermediary sample storage */
        err = i2s_read(I2S_NUM_0, (void *)newSamples, sizeof(newSamples), &bytes_read, portMAX_DELAY);
        if (err != ESP_OK) {
          DEBUGSR_PRINTF("Failed to get samples: %d\n", err);
          return;
        }
        // For correct operation, we need to read exactly sizeof(samples) bytes from i2s
        if (bytes_read != sizeof(newSamples)) {
          DEBUGSR_PRINTF("Failed to get enough samples: wanted: %d read: %d\n", sizeof(newSamples), bytes_read);
          return;
        }
        // Store samples in sample buffer and update DC offset
        for (int i = 0; i < num_samples; i++) {
          newSamples[i] = postProcessSample(newSamples[i]);  // perform postprocessing (needed for ADC samples)
          float currSample = 0.0f;
 #ifdef I2S_SAMPLE_DOWNSCALE_TO_16BIT
              currSample = (float) newSamples[i] / 65536.0f;      // 32bit input -> 16bit; keeping lower 16bits as decimal places
 #else
              currSample = (float) newSamples[i];                 // 16bit input -> use as-is
 #endif
          buffer[i] = currSample;
          buffer[i] *= _sampleScale;                              // scale samples
        }
      }
    }
  protected:
    void _routeMclk(int8_t mclkPin) {
 #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
  // MCLK routing by writing registers is not needed any more with IDF > 4.4.0
  #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4, 4, 0)
    // this way of MCLK routing only works on "classic" ESP32
      /* Enable the mclk routing depending on the selected mclk pin (ESP32: only 0,1,3)
          Only I2S_NUM_0 is supported
      */
      if (mclkPin == GPIO_NUM_0) {
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0_CLK_OUT1);
        WRITE_PERI_REG(PIN_CTRL,0xFFF0);
      } else if (mclkPin == GPIO_NUM_1) {
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD_CLK_OUT3);
        WRITE_PERI_REG(PIN_CTRL, 0xF0F0);
      } else {
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_U0RXD_CLK_OUT2);
        WRITE_PERI_REG(PIN_CTRL, 0xFF00);
      }
  #endif
 #endif
    }
    i2s_config_t _config;
    i2s_pin_config_t _pinConfig;
    int8_t _mclkPin;
 };
 /* ES7243 Microphone
   This is an I2S microphone that requires ininitialization over
   I2C before I2S data can be received
 */
 class ES7243 : public I2SSource {
  private:
    void _es7243I2cWrite(uint8_t reg, uint8_t val) {
      #ifndef ES7243_ADDR
        #define ES7243_ADDR 0x13   // default address
      #endif
      Wire.beginTransmission(ES7243_ADDR);
      Wire.write((uint8_t)reg);
      Wire.write((uint8_t)val);
      uint8_t i2cErr = Wire.endTransmission();  // i2cErr == 0 means OK
      if (i2cErr != 0) {
        DEBUGSR_PRINTF("AR: ES7243 I2C write failed with error=%d  (addr=0x%X, reg 0x%X, val 0x%X).\n", i2cErr, ES7243_ADDR, reg, val);
      }
    }
    void _es7243InitAdc() {
      _es7243I2cWrite(0x00, 0x01);
      _es7243I2cWrite(0x06, 0x00);
      _es7243I2cWrite(0x05, 0x1B);
      _es7243I2cWrite(0x01, 0x00); // 0x00 for 24 bit to match INMP441 - not sure if this needs adjustment to get 16bit samples from I2S
      _es7243I2cWrite(0x08, 0x43);
      _es7243I2cWrite(0x05, 0x13);
    }
 public:
    ES7243(SRate_t sampleRate, int blockSize, float sampleScale = 1.0f) :
      I2SSource(sampleRate, blockSize, sampleScale) {
      _config.channel_format = I2S_CHANNEL_FMT_ONLY_RIGHT;
    };
    void initialize(int8_t i2swsPin, int8_t i2ssdPin, int8_t i2sckPin, int8_t mclkPin) {
      DEBUGSR_PRINTLN("ES7243:: initialize();");
      if ((i2sckPin < 0) || (mclkPin < 0)) {
        DEBUGSR_PRINTF("\nAR: invalid I2S pin: SCK=%d, MCLK=%d\n", i2sckPin, mclkPin); 
        return;
      }
      // First route mclk, then configure ADC over I2C, then configure I2S
      _es7243InitAdc();
      I2SSource::initialize(i2swsPin, i2ssdPin, i2sckPin, mclkPin);
    }
    void deinitialize() {
      I2SSource::deinitialize();
    }
 };
 /* ES8388 Sound Modude
   This is an I2S sound processing unit that requires ininitialization over
   I2C before I2S data can be received. 
 */
 class ES8388Source : public I2SSource {
  private:
    void _es8388I2cWrite(uint8_t reg, uint8_t val) {
 #ifndef ES8388_ADDR
      Wire.beginTransmission(0x10);
      #define ES8388_ADDR 0x10   // default address
 #else
      Wire.beginTransmission(ES8388_ADDR);
 #endif
      Wire.write((uint8_t)reg);
      Wire.write((uint8_t)val);
      uint8_t i2cErr = Wire.endTransmission();  // i2cErr == 0 means OK
      if (i2cErr != 0) {
        DEBUGSR_PRINTF("AR: ES8388 I2C write failed with error=%d  (addr=0x%X, reg 0x%X, val 0x%X).\n", i2cErr, ES8388_ADDR, reg, val);
      }
    }
    void _es8388InitAdc() {
      // https://dl.radxa.com/rock2/docs/hw/ds/ES8388%20user%20Guide.pdf Section 10.1
      // http://www.everest-semi.com/pdf/ES8388%20DS.pdf Better spec sheet, more clear. 
      // https://docs.google.com/spreadsheets/d/1CN3MvhkcPVESuxKyx1xRYqfUit5hOdsG45St9BCUm-g/edit#gid=0 generally
      // Sets ADC to around what AudioReactive expects, and loops line-in to line-out/headphone for monitoring.
      // Registries are decimal, settings are binary as that's how everything is listed in the docs
      // ...which makes it easier to reference the docs.
      //
      _es8388I2cWrite( 8,0b00000000); // I2S to slave
      _es8388I2cWrite( 2,0b11110011); // Power down DEM and STM
      _es8388I2cWrite(43,0b10000000); // Set same LRCK
      _es8388I2cWrite( 0,0b00000101); // Set chip to Play & Record Mode
      _es8388I2cWrite(13,0b00000010); // Set MCLK/LRCK ratio to 256
      _es8388I2cWrite( 1,0b01000000); // Power up analog and lbias
      _es8388I2cWrite( 3,0b00000000); // Power up ADC, Analog Input, and Mic Bias
      _es8388I2cWrite( 4,0b11111100); // Power down DAC, Turn on LOUT1 and ROUT1 and LOUT2 and ROUT2 power
      _es8388I2cWrite( 2,0b01000000); // Power up DEM and STM and undocumented bit for "turn on line-out amp"
      // #define use_es8388_mic
    #ifdef use_es8388_mic
      // The mics *and* line-in are BOTH connected to LIN2/RIN2 on the AudioKit
      // so there's no way to completely eliminate the mics. It's also hella noisy. 
      // Line-in works OK on the AudioKit, generally speaking, as the mics really need
      // amplification to be noticable in a quiet room. If you're in a very loud room, 
      // the mics on the AudioKit WILL pick up sound even in line-in mode. 
      // TL;DR: Don't use the AudioKit for anything, use the LyraT. 
      //
      // The LyraT does a reasonable job with mic input as configured below.
      // Pick one of these. If you have to use the mics, use a LyraT over an AudioKit if you can:
      _es8388I2cWrite(10,0b00000000); // Use Lin1/Rin1 for ADC input (mic on LyraT)
      //_es8388I2cWrite(10,0b01010000); // Use Lin2/Rin2 for ADC input (mic *and* line-in on AudioKit)
      _es8388I2cWrite( 9,0b10001000); // Select Analog Input PGA Gain for ADC to +24dB (L+R)
      _es8388I2cWrite(16,0b00000000); // Set ADC digital volume attenuation to 0dB (left)
      _es8388I2cWrite(17,0b00000000); // Set ADC digital volume attenuation to 0dB (right)
      _es8388I2cWrite(38,0b00011011); // Mixer - route LIN1/RIN1 to output after mic gain
      _es8388I2cWrite(39,0b01000000); // Mixer - route LIN to mixL, +6dB gain
      _es8388I2cWrite(42,0b01000000); // Mixer - route RIN to mixR, +6dB gain
      _es8388I2cWrite(46,0b00100001); // LOUT1VOL - 0b00100001 = +4.5dB
      _es8388I2cWrite(47,0b00100001); // ROUT1VOL - 0b00100001 = +4.5dB
      _es8388I2cWrite(48,0b00100001); // LOUT2VOL - 0b00100001 = +4.5dB
      _es8388I2cWrite(49,0b00100001); // ROUT2VOL - 0b00100001 = +4.5dB
      // Music ALC - the mics like Auto Level Control
      // You can also use this for line-in, but it's not really needed.
      //
      _es8388I2cWrite(18,0b11111000); // ALC: stereo, max gain +35.5dB, min gain -12dB 
      _es8388I2cWrite(19,0b00110000); // ALC: target -1.5dB, 0ms hold time
      _es8388I2cWrite(20,0b10100110); // ALC: gain ramp up = 420ms/93ms, gain ramp down = check manual for calc
      _es8388I2cWrite(21,0b00000110); // ALC: use "ALC" mode, no zero-cross, window 96 samples
      _es8388I2cWrite(22,0b01011001); // ALC: noise gate threshold, PGA gain constant, noise gate enabled 
    #else
      _es8388I2cWrite(10,0b01010000); // Use Lin2/Rin2 for ADC input ("line-in")
      _es8388I2cWrite( 9,0b00000000); // Select Analog Input PGA Gain for ADC to 0dB (L+R)
      _es8388I2cWrite(16,0b01000000); // Set ADC digital volume attenuation to -32dB (left)
      _es8388I2cWrite(17,0b01000000); // Set ADC digital volume attenuation to -32dB (right)
      _es8388I2cWrite(38,0b00001001); // Mixer - route LIN2/RIN2 to output
      _es8388I2cWrite(39,0b01010000); // Mixer - route LIN to mixL, 0dB gain
      _es8388I2cWrite(42,0b01010000); // Mixer - route RIN to mixR, 0dB gain
      _es8388I2cWrite(46,0b00011011); // LOUT1VOL - 0b00011110 = +0dB, 0b00011011 = LyraT balance fix
      _es8388I2cWrite(47,0b00011110); // ROUT1VOL - 0b00011110 = +0dB
      _es8388I2cWrite(48,0b00011110); // LOUT2VOL - 0b00011110 = +0dB
      _es8388I2cWrite(49,0b00011110); // ROUT2VOL - 0b00011110 = +0dB
    #endif
    }
  public:
    ES8388Source(SRate_t sampleRate, int blockSize, float sampleScale = 1.0f, bool i2sMaster=true) :
      I2SSource(sampleRate, blockSize, sampleScale) {
      _config.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT;
    };
    void initialize(int8_t i2swsPin, int8_t i2ssdPin, int8_t i2sckPin, int8_t mclkPin) {
      DEBUGSR_PRINTLN("ES8388Source:: initialize();");
      if ((i2sckPin < 0) || (mclkPin < 0)) {
        DEBUGSR_PRINTF("\nAR: invalid I2S pin: SCK=%d, MCLK=%d\n", i2sckPin, mclkPin); 
        return;
      }
      // First route mclk, then configure ADC over I2C, then configure I2S
      _es8388InitAdc();
      I2SSource::initialize(i2swsPin, i2ssdPin, i2sckPin, mclkPin);
    }
    void deinitialize() {
      I2SSource::deinitialize();
    }
 };
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 2, 0)
 #if !defined(SOC_I2S_SUPPORTS_ADC) && !defined(SOC_I2S_SUPPORTS_ADC_DAC)
  #warning this MCU does not support analog sound input
 #endif
 #endif
 #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
 // ADC over I2S is only availeable in "classic" ESP32
 /* ADC over I2S Microphone
   This microphone is an ADC pin sampled via the I2S interval
   This allows to use the I2S API to obtain ADC samples with high sample rates
   without the need of manual timing of the samples
 */
 class I2SAdcSource : public I2SSource {
  public:
    I2SAdcSource(SRate_t sampleRate, int blockSize, float sampleScale = 1.0f) :
      I2SSource(sampleRate, blockSize, sampleScale) {
      _config = {
        .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_ADC_BUILT_IN),
        .sample_rate = _sampleRate,
        .bits_per_sample = I2S_SAMPLE_RESOLUTION,
        .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 2, 0)
        .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_STAND_I2S),
 #else
        .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
 #endif
        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
        .dma_buf_count = 8,
        .dma_buf_len = _blockSize,
        .use_apll = false,
        .tx_desc_auto_clear = false,
        .fixed_mclk = 0        
      };
    }
    /* identify Audiosource type - I2S-ADC*/
    AudioSourceType getType(void) {return(Type_I2SAdc);}
    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("I2SAdcSource:: initialize().");
      _myADCchannel = 0x0F;
      if(!pinManager.allocatePin(audioPin, false, PinOwner::UM_Audioreactive)) {
         DEBUGSR_PRINTF("failed to allocate GPIO for audio analog input: %d\n", audioPin);
        return;
      }
      _audioPin = audioPin;
      // Determine Analog channel. Only Channels on ADC1 are supported
      int8_t channel = digitalPinToAnalogChannel(_audioPin);
      if (channel > 9) {
        DEBUGSR_PRINTF("Incompatible GPIO used for analog audio input: %d\n", _audioPin);
        return;
      } else {
        adc_gpio_init(ADC_UNIT_1, adc_channel_t(channel));
        _myADCchannel = channel;
      }
      // Install Driver
      esp_err_t err = i2s_driver_install(I2S_NUM_0, &_config, 0, nullptr);
      if (err != ESP_OK) {
        DEBUGSR_PRINTF("Failed to install i2s driver: %d\n", err);
        return;
      }
      adc1_config_width(ADC_WIDTH_BIT_12);   // ensure that ADC runs with 12bit resolution
      // Enable I2S mode of ADC
      err = i2s_set_adc_mode(ADC_UNIT_1, adc1_channel_t(channel));
      if (err != ESP_OK) {
        DEBUGSR_PRINTF("Failed to set i2s adc mode: %d\n", err);
        return;
      }
      // see example in https://github.com/espressif/arduino-esp32/blob/master/libraries/ESP32/examples/I2S/HiFreq_ADC/HiFreq_ADC.ino
      adc1_config_channel_atten(adc1_channel_t(channel), ADC_ATTEN_DB_11);   // configure ADC input amplification
      #if defined(I2S_GRAB_ADC1_COMPLETELY)
      // according to docs from espressif, the ADC needs to be started explicitly
      // fingers crossed
        err = i2s_adc_enable(I2S_NUM_0);
        if (err != ESP_OK) {
            DEBUGSR_PRINTF("Failed to enable i2s adc: %d\n", err);
            //return;
        }
      #else
        // bugfix: do not disable ADC initially - its already disabled after driver install.
        //err = i2s_adc_disable(I2S_NUM_0);
 		    // //err = i2s_stop(I2S_NUM_0);
        //if (err != ESP_OK) {
        //    DEBUGSR_PRINTF("Failed to initially disable i2s adc: %d\n", err);
        //}
      #endif
      _initialized = true;
    }
    I2S_datatype postProcessSample(I2S_datatype sample_in) {
      static I2S_datatype lastADCsample = 0;          // last good sample
      static unsigned int broken_samples_counter = 0; // number of consecutive broken (and fixed) ADC samples
      I2S_datatype sample_out = 0;
      // bring sample down down to 16bit unsigned
      I2S_unsigned_datatype rawData = * reinterpret_cast<I2S_unsigned_datatype *> (&sample_in); // C++ acrobatics to get sample as "unsigned"
      #ifndef I2S_USE_16BIT_SAMPLES
        rawData = (rawData >> 16) & 0xFFFF;                       // scale input down from 32bit -> 16bit
        I2S_datatype lastGoodSample = lastADCsample / 16384 ;     // prepare "last good sample" accordingly (26bit-> 12bit with correct sign handling)
      #else
        rawData = rawData & 0xFFFF;                               // input is already in 16bit, just mask off possible junk
        I2S_datatype lastGoodSample = lastADCsample * 4;          // prepare "last good sample" accordingly (10bit-> 12bit)
      #endif
      // decode ADC sample data fields
      uint16_t the_channel = (rawData >> 12) & 0x000F;           // upper 4 bit = ADC channel
      uint16_t the_sample  =  rawData & 0x0FFF;                  // lower 12bit -> ADC sample (unsigned)
      I2S_datatype finalSample = (int(the_sample) - 2048);       // convert unsigned sample to signed (centered at 0);
      if ((the_channel != _myADCchannel) && (_myADCchannel != 0x0F)) { // 0x0F means "don't know what my channel is" 
        // fix bad sample
        finalSample = lastGoodSample;                             // replace with last good ADC sample
        broken_samples_counter ++;
        if (broken_samples_counter > 256) _myADCchannel = 0x0F;   // too  many bad samples in a row -> disable sample corrections
        //Serial.print("\n!ADC rogue sample 0x"); Serial.print(rawData, HEX); Serial.print("\tchannel:");Serial.println(the_channel);
      } else broken_samples_counter = 0;                          // good sample - reset counter
      // back to original resolution
      #ifndef I2S_USE_16BIT_SAMPLES
        finalSample = finalSample << 16;                          // scale up from 16bit -> 32bit;
      #endif
      finalSample = finalSample / 4;                              // mimic old analog driver behaviour (12bit -> 10bit)
      sample_out = (3 * finalSample + lastADCsample) / 4;         // apply low-pass filter (2-tap FIR)
      //sample_out = (finalSample + lastADCsample) / 2;             // apply stronger low-pass filter (2-tap FIR)
      lastADCsample = sample_out;                                 // update ADC last sample
      return(sample_out);
    }
    void getSamples(float *buffer, uint16_t num_samples) {
      /* Enable ADC. This has to be enabled and disabled directly before and
       * after sampling, otherwise Wifi dies
       */
      if (_initialized) {
        #if !defined(I2S_GRAB_ADC1_COMPLETELY)
          // old code - works for me without enable/disable, at least on ESP32.
          //esp_err_t err = i2s_start(I2S_NUM_0);
          esp_err_t err = i2s_adc_enable(I2S_NUM_0);
          if (err != ESP_OK) {
            DEBUGSR_PRINTF("Failed to enable i2s adc: %d\n", err);
            return;
          }
        #endif
        I2SSource::getSamples(buffer, num_samples);
        #if !defined(I2S_GRAB_ADC1_COMPLETELY)
          // old code - works for me without enable/disable, at least on ESP32.
          err = i2s_adc_disable(I2S_NUM_0);  //i2s_adc_disable() may cause crash with IDF 4.4 (https://github.com/espressif/arduino-esp32/issues/6832)
          //err = i2s_stop(I2S_NUM_0);
          if (err != ESP_OK) {
            DEBUGSR_PRINTF("Failed to disable i2s adc: %d\n", err);
            return;
          }
        #endif
      }
    }
    void deinitialize() {
      pinManager.deallocatePin(_audioPin, PinOwner::UM_Audioreactive);
      _initialized = false;
      _myADCchannel = 0x0F;
      esp_err_t err;
      #if defined(I2S_GRAB_ADC1_COMPLETELY)
        // according to docs from espressif, the ADC needs to be stopped explicitly
        // fingers crossed
        err = i2s_adc_disable(I2S_NUM_0);
        if (err != ESP_OK) {
          DEBUGSR_PRINTF("Failed to disable i2s adc: %d\n", err);
        }
      #endif
      i2s_stop(I2S_NUM_0);
      err = i2s_driver_uninstall(I2S_NUM_0);
      if (err != ESP_OK) {
        DEBUGSR_PRINTF("Failed to uninstall i2s driver: %d\n", err);
        return;
      }
    }
  private:
    int8_t _audioPin;
    int8_t _myADCchannel = 0x0F;       // current ADC channel for analog input. 0x0F means "undefined"
 };
 #endif
 /* SPH0645 Microphone
   This is an I2S microphone with some timing quirks that need
   special consideration.
 */
 // https://github.com/espressif/esp-idf/issues/7192  SPH0645 i2s microphone issue when migrate from legacy esp-idf version (IDFGH-5453)
 // a user recommended this: Try to set .communication_format to I2S_COMM_FORMAT_STAND_I2S and call i2s_set_clk() after i2s_set_pin().
 class SPH0654 : public I2SSource {
  public:
    SPH0654(SRate_t sampleRate, int blockSize, float sampleScale = 1.0f) :
      I2SSource(sampleRate, blockSize, sampleScale)
    {}
    void initialize(int8_t i2swsPin, int8_t i2ssdPin, int8_t i2sckPin, int8_t = I2S_PIN_NO_CHANGE) {
      DEBUGSR_PRINTLN("SPH0654:: initialize();");
      I2SSource::initialize(i2swsPin, i2ssdPin, i2sckPin);
 #if !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S3)
 // these registers are only existing in "classic" ESP32
      REG_SET_BIT(I2S_TIMING_REG(I2S_NUM_0), BIT(9));
      REG_SET_BIT(I2S_CONF_REG(I2S_NUM_0), I2S_RX_MSB_SHIFT);
 #else
      #warning FIX ME! Please.
 #endif
    }
 };
 #endif
--- a/usermods/audioreactive/readme.md
+++ b/usermods/audioreactive/readme.md
@ -1,73 +0,0 @@
 # Audioreactive usermod
 Enabless controlling LEDs via audio input. Audio source can be a microphone or analog-in (AUX) using an appropriate adapter.
 Supported microphones range from analog (MAX4466, MAX9814, ...) to digital (INMP441, ICS-43434, ...).
 Does audio processing and provides data structure that specially written effects can use.
 **does not** provide effects or draw anything to an LED strip/matrix.
 ## Additional Documentation
 This usermod is an evolution of [SR-WLED](https://github.com/atuline/WLED), and a lot of documentation and information can be found in the [SR-WLED wiki](https://github.com/atuline/WLED/wiki):
 * [getting started with audio](https://github.com/atuline/WLED/wiki/First-Time-Setup#sound)
 * [Sound settings](https://github.com/atuline/WLED/wiki/Sound-Settings) - similar to options on the usemod settings page in WLED.
 * [Digital Audio](https://github.com/atuline/WLED/wiki/Digital-Microphone-Hookup)
 * [Analog Audio](https://github.com/atuline/WLED/wiki/Analog-Audio-Input-Options)
 * [UDP Sound sync](https://github.com/atuline/WLED/wiki/UDP-Sound-Sync)
 ## Supported MCUs
 This audioreactive usermod works best on "classic ESP32" (dual core), and on ESP32-S3 which also has dual core and hardware floating point support. 
 It will compile succesfully for ESP32-S2 and ESP32-C3, however might not work well, as other WLED functions will become slow. Audio processing requires a lot of computing power, which can be problematic on smaller MCUs like -S2 and -C3. 
 Analog audio is only possible on "classic" ESP32, but not on other MCUs like ESP32-S3.
 Currently ESP8266 is not supported, due to low speed and small RAM of this chip. 
 There are however plans to create a lightweight audioreactive for the 8266, with reduced features.
 ## Installation 
 ### using customised _arduinoFFT_ library for use with this usermod
 Add `-D USERMOD_AUDIOREACTIVE` to your PlatformIO environment `build_flags`, as well as `https://github.com/blazoncek/arduinoFFT.git` to your `lib_deps`.
 If you are not using PlatformIO (which you should) try adding `#define USERMOD_AUDIOREACTIVE` to *my_config.h* and make sure you have _arduinoFFT_ library downloaded and installed.
 Customised _arduinoFFT_ library for use with this usermod can be found at https://github.com/blazoncek/arduinoFFT.git
 ### using latest (develop) _arduinoFFT_ library
 Alternatively, you can use the latest arduinoFFT development version.
 ArduinoFFT `develop` library is slightly more accurate, and slighly faster than our customised library, however also needs additional 2kB RAM.
 * `build_flags` = `-D USERMOD_AUDIOREACTIVE` `-D UM_AUDIOREACTIVE_USE_NEW_FFT`
 * `lib_deps`= `https://github.com/kosme/arduinoFFT#develop @ 1.9.2`
 ## Configuration
 All parameters are runtime configurable. Some may require a hard reset after changing them (I2S microphone or selected GPIOs).
 If you want to define default GPIOs during compile time, use the following (default values in parentheses):
 - `-D SR_DMTYPE=x` : defines digital microphone type: 0=analog, 1=generic I2S (default), 2=ES7243 I2S, 3=SPH0645 I2S, 4=generic I2S with master clock, 5=PDM I2S
 - `-D AUDIOPIN=x`  : GPIO for analog microphone/AUX-in (36)
 - `-D I2S_SDPIN=x` : GPIO for SD pin on digital microphone (32)
 - `-D I2S_WSPIN=x` : GPIO for WS pin on digital microphone (15)
 - `-D I2S_CKPIN=x` : GPIO for SCK pin on digital microphone (14)
 - `-D MCLK_PIN=x`  : GPIO for master clock pin on digital Line-In boards (-1)
 - `-D ES7243_SDAPIN` : GPIO for I2C SDA pin on ES7243 microphone (-1)
 - `-D ES7243_SCLPIN` : GPIO for I2C SCL pin on ES7243 microphone (-1)
 **NOTE** I2S is used for analog audio sampling. Hence, the analog *buttons* (i.e. potentiometers) are disabled when running this usermod with an analog microphone.
 ### Advanced Compile-Time Options
 You can use the following additional flags in your `build_flags`
 * `-D SR_SQUELCH=x`  : Default "squelch" setting (10)
 * `-D SR_GAIN=x`     : Default "gain" setting (60)
 * `-D I2S_USE_RIGHT_CHANNEL`: Use RIGHT instead of LEFT channel (not recommended unless you strictly need this).
 * `-D I2S_USE_16BIT_SAMPLES`: Use 16bit instead of 32bit for internal sample buffers. Reduces sampling quality, but frees some RAM ressources (not recommended unless you absolutely need this).
 * `-D I2S_GRAB_ADC1_COMPLETELY`: Experimental: continously sample analog ADC microphone. Only effective on ESP32. WARNING this _will_ cause conflicts(lock-up) with any analogRead() call.
 * `-D MIC_LOGGER`     : (debugging) Logs samples from the microphone to serial USB. Use with serial plotter (Arduino IDE)
 * `-D SR_DEBUG`       : (debugging) Additional error diagnostics and debug info on serial USB.
 ## Release notes
 * 2022-06 Ported from [soundreactive WLED](https://github.com/atuline/WLED) - by @blazoncek (AKA Blaz Kristan) and the [SR-WLED team](https://github.com/atuline/WLED/wiki#sound-reactive-wled-fork-team).
 * 2022-11 Updated to align with "[MoonModules/WLED](https://amg.wled.me)" audioreactive usermod - by @softhack007 (AKA Frank M&ouml;hle).
--- a/usermods/battery_keypad_controller/wled06_usermod.ino
+++ b/usermods/battery_keypad_controller/wled06_usermod.ino
@ -54,27 +54,35 @@ void userLoop()
            switch (myKey) {
                case '1':
                    applyPreset(1);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case '2':
                    applyPreset(2);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case '3':
                    applyPreset(3);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case '4':
                    applyPreset(4);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case '5':
                    applyPreset(5);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case '6':
                    applyPreset(6);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case 'A':
                    applyPreset(7);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case 'B':
                    applyPreset(8);
                    colorUpdated(CALL_MODE_FX_CHANGED);
                    break;
                case '7':
--- a/usermods/battery_status_basic/assets/battery_connection_schematic_01.png
+++ b/usermods/battery_status_basic/assets/battery_connection_schematic_01.png
--- a/usermods/battery_status_basic/assets/battery_connection_schematic_02.png
+++ b/usermods/battery_status_basic/assets/battery_connection_schematic_02.png
--- a/Show More
+++ b/Show More
`@ -1,2 +1,2 @@`
	`github: [Aircoookie,blazoncek]`	`github: [Aircoookie]`
	`custom: ['https://paypal.me/Aircoookie','https://paypal.me/blazoncek']`	`custom: ['https://paypal.me/Aircoookie']`
		`@ -1 +0,0 @@`
			`{"0":{},"2":{"n":"▲","win":"U0=2"},"1":{"n":"▼","win":"U0=1"}}`