readme.md aktualisiert

plus fixing a small typo in VERSION

.github/FUNDING.yml

@@ -1,5 +1,2 @@
-github: [Aircoookie]
-custom: ['https://paypal.me/Aircoookie']
-
-github: [blazoncek]
-custom: ['https://paypal.me/blazoncek']
+github: [Aircoookie,blazoncek]
+custom: ['https://paypal.me/Aircoookie','https://paypal.me/blazoncek']

.github/ISSUE_TEMPLATE/bug.yml

@@ -56,6 +56,9 @@ body:
       options:
         - ESP8266
         - ESP32
+        - ESP32-S3
+        - ESP32-S2
+        - ESP32-C3
         - Other
     validations:
       required: true

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/question.md

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

.github/workflows/wled-ci.yml

@@ -8,21 +8,23 @@ jobs:
     name: Gather Environments
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Cache pip
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       with:
         path: ~/.cache/pip
         key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
         restore-keys: |
           ${{ runner.os }}-pip-
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v4
+      with:
+        python-version: '3.9'
     - name: Install PlatformIO
       run: pip install -r requirements.txt
     - name: Get default environments
       id: envs
       run: |
-        echo "::set-output name=environments::$(pio project config --json-output | jq -cr '.[0][1][0][1]')"
+        echo "environments=$(pio project config --json-output | jq -cr '.[0][1][0][1]')" >> $GITHUB_OUTPUT
     outputs:
       environments: ${{ steps.envs.outputs.environments }}
 
@@ -32,24 +34,27 @@ 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@v2
+    - uses: actions/checkout@v3
     - name: Cache pip
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       with:
         path: ~/.cache/pip
         key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
         restore-keys: |
           ${{ runner.os }}-pip-
     - name: Cache PlatformIO
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       with:
         path: ~/.platformio
         key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
+      with:
+          python-version: '3.9'
     - name: Install PlatformIO
       run: pip install -r requirements.txt
     - name: Build firmware

.gitignore

@@ -1,20 +1,24 @@
-.pio
 .cache
+.clang-format
+.direnv
+.DS_Store
+.gitignore
+.idea
+.pio
 .pioenvs
 .piolibdeps
 .vscode
-/wled00/Release
-/wled00/extLibs
-/platformio_override.ini
-/wled00/my_config.h
-/build_output
-.DS_Store
-.gitignore
-.clang-format
-node_modules
-.idea
-.direnv
-wled-update.sh
+
 esp01-update.sh
-/wled00/LittleFS
+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

.gitpod.Dockerfile

@@ -1,5 +1,3 @@
 FROM gitpod/workspace-full
 
 USER gitpod
-
-RUN pip3 install -U platformio

.gitpod.yml

@@ -1,12 +1,11 @@
 tasks:
-  - command: platformio run
+  - command: pip3 install -U platformio && platformio run
 
 image:
   file: .gitpod.Dockerfile
 
 vscode:
   extensions:
-    - ms-vscode.cpptools@0.26.3:u3GsZ5PK12Ddr79vh4TWgQ==
-    - eamodio.gitlens@10.2.1:e0IYyp0efFqVsrZwsIe8CA==
-    - Atishay-Jain.All-Autocomplete@0.0.23:fbZNfSpnd8XkAHGfAPS2rA==
-    - 2gua.rainbow-brackets@0.0.6:Tbu8dTz0i+/bgcKQTQ5b8g==
+    - Atishay-Jain.All-Autocomplete
+    - esbenp.prettier-vscode
+    - shardulm94.trailing-spaces

.vscode/tasks.json

@@ -9,8 +9,8 @@
       ],
       "dependsOrder": "sequence",
       "problemMatcher": [
-        "$platformio"
-      ]
+        "$platformio",
+      ],
     },
     {
       "type": "PlatformIO",
@@ -18,7 +18,7 @@
       "task": "Build",
       "group": {
         "kind": "build",
-        "isDefault": true
+        "isDefault": true,
       },
       "problemMatcher": [
         "$platformio"
@@ -37,14 +37,6 @@
       "presentation": {
         "panel": "shared"
       }
-    },
-    {
-      "type": "PlatformIO",
-      "task": "Verbose Build",
-      "problemMatcher": [
-        "$platformio"
-      ],
-      "label": "PlatformIO: Verbose Build"
     }
   ]
 }

CHANGELOG.md

@@ -1,5 +1,216 @@
 ## WLED changelog
 
+#### Build 2310010, build 2310130
+-   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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "wled",
-  "version": "0.14.0-b0",
+  "version": "0.14.0",
   "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.4",
+    "nodemon": "^2.0.20",
     "zlib": "^1.0.5"
   }
 }

platformio.ini

@@ -6,16 +6,18 @@
 # 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)
 # ------------------------------------------------------------------------------
 
-# Travis CI binaries (use `platformio_override.ini` when building for your own board; see `platformio_override.ini.sample` for an example)
-; default_envs = travis_esp8266, travis_esp32
+# CI binaries
+; 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 = 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, esp32s2_saola, esp32c3
+; default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth, lolin_s2_mini, esp32c3dev, esp32s3dev_8MB
 
 # 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, travis_esp8266, travis_esp32, 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, 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
 
 # Single binaries (uncomment your board)
 ; default_envs = elekstube_ips
@@ -38,6 +40,8 @@ default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth, esp32s
 ; 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
@@ -57,26 +61,39 @@ 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_2_0}
+platform_wled_default = ${common.arduino_core_3_1_2}
 # We use 2.7.4.7 for all, includes PWM flicker fix and Wstring optimization
-platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
-                    platformio/toolchain-xtensa @ ~2.40802.200502
-                    platformio/tool-esptool @ ~1.413.0
-                    platformio/tool-esptoolpy @ ~1.30000.0
+#platform_packages = tasmota/framework-arduinoespressif8266 @ 3.20704.7
+platform_packages = platformio/framework-arduinoespressif8266
+                    platformio/toolchain-xtensa @ ~2.100300.220621 #2.40802.200502
+                    platformio/tool-esptool #@ ~1.413.0
+                    platformio/tool-esptoolpy #@ ~1.30000.0
+
+## previous platform for 8266, in case of problems with the new one
+## you'll need  makuna/NeoPixelBus@ 2.6.9 for arduino_core_3_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 -DDEBUG_ESP_WIFI -DDEBUG_ESP_HTTP_CLIENT -DDEBUG_ESP_HTTP_UPDATE -DDEBUG_ESP_HTTP_SERVER -DDEBUG_ESP_UPDATER -DDEBUG_ESP_OTA -DDEBUG_TLS_MEM
-#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
+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 ;; 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)
@@ -101,11 +118,13 @@ debug_flags = -D DEBUG=1 -D WLED_DEBUG -DDEBUG_ESP_WIFI -DDEBUG_ESP_HTTP_CLIENT
 #  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
@@ -113,20 +132,17 @@ 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
@@ -156,28 +172,29 @@ 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 changd) in the source:
-#     ArduinoJson@5.13.5, Blynk@0.5.4(changed), E131@1.0.0(changed), Time@1.5, Timezone@1.2.1
+#   The following libraries have been included (and some of them changed) in the source:
+#     ArduinoJson@5.13.5, E131@1.0.0(changed), Time@1.5, Timezone@1.2.1
 # ------------------------------------------------------------------------------
 lib_compat_mode = strict
 lib_deps =
-    fastled/FastLED @ 3.5.0
+    fastled/FastLED @ 3.6.0
     IRremoteESP8266 @ 2.8.2
-    https://github.com/Aircoookie/ESPAsyncWebServer.git @ ~2.0.5
-    marvinroger/AsyncMqttClient@^0.9.0
+    makuna/NeoPixelBus @ 2.7.5
+    https://github.com/Aircoookie/ESPAsyncWebServer.git @ ~2.0.7
   #For use of the TTGO T-Display ESP32 Module with integrated TFT display uncomment the following line
     #TFT_eSPI
-  #For use SSD1306 OLED display uncomment following
-    #U8g2@~2.28.8
-    #U8g2@~2.32.10
-  #For Dallas sensor uncomment following 2 lines
-    #OneWire@~2.3.5
-    #milesburton/DallasTemperature@^3.9.0
+  #For compatible OLED display uncomment following
+    #U8g2 #@ ~2.33.15
+  #For Dallas sensor uncomment following
+    #OneWire @ ~2.3.7
   #For BME280 sensor uncomment following
-    #BME280@~3.0.0
+    #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}
 
@@ -186,88 +203,123 @@ build_flags =
   -DESP8266
   -DFP_IN_IROM
   ;-Wno-deprecated-declarations
-  ;-Wno-register
-	;-Wno-misleading-indentation
-; NONOSDK22x_190703 = 2.2.2-dev(38a443e)
+  ;-Wno-register  ;; leaves some warnings when compiling C files: command-line option '-Wno-register' is valid for C++/ObjC++ but not for C
+  ;-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
-;  -DPIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH
-; lwIP 1.4 - Higher Bandwidth (Aircoookie has)
+  ; lwIP 2 - Higher Bandwidth no Features
+  ;  -DPIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH
+  ; lwIP 1.4 - Higher Bandwidth (Aircoookie has)
   -DPIO_FRAMEWORK_ARDUINO_LWIP_HIGHER_BANDWIDTH
-; VTABLES in Flash
+  ; VTABLES in Flash
   -DVTABLES_IN_FLASH
-; restrict to minimal mime-types
+  ; 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 =
-  ${env.lib_deps}
   #https://github.com/lorol/LITTLEFS.git
   ESPAsyncTCP @ 1.2.2
   ESPAsyncUDP
-  makuna/NeoPixelBus @ 2.6.9
+  ${env.lib_deps}
 
 [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
   -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
+  #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 =
-  ${env.lib_deps}
   https://github.com/lorol/LITTLEFS.git
-  makuna/NeoPixelBus @ 2.6.9
   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}
 
 [esp32s2]
+;; generic definitions for all ESP32-S2 boards
+platform = espressif32@5.3.0
+platform_packages =
 build_flags = -g
   -DARDUINO_ARCH_ESP32
   -DARDUINO_ARCH_ESP32S2
-  -DCONFIG_IDF_TARGET_ESP32S2
+  -DCONFIG_IDF_TARGET_ESP32S2=1
   -D CONFIG_ASYNC_TCP_USE_WDT=0
+  -DARDUINO_USB_MSC_ON_BOOT=0 -DARDUINO_USB_DFU_ON_BOOT=0
   -DCO
+  -DARDUINO_USB_MODE=0 ;; this flag is mandatory for ESP32-S2 !
+  ;; please make sure that the following flags are properly set (to 0 or 1) by your board.json, or included in your custom platformio_override.ini entry:
+  ;; ARDUINO_USB_CDC_ON_BOOT
 
 lib_deps =
-  ${env.lib_deps}
-  makuna/NeoPixelBus @ 2.6.9
   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
+  -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 =
-  ${env.lib_deps}
-  makuna/NeoPixelBus @ 2.6.9
   https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  ${env.lib_deps}
 
 [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
+  -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 =
-  ${env.lib_deps}
-  ;; currently we need the latest NeoPixelBus dev version, because it contains important bugfixes for -S3
-  https://github.com/Makuna/NeoPixelBus.git#master @ 2.7.0
   https://github.com/pbolduc/AsyncTCP.git @ 1.2.0
+  ${env.lib_deps}
 
 
 # ------------------------------------------------------------------------------
@@ -280,7 +332,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
+build_flags = ${common.build_flags_esp8266} -D WLED_RELEASE_NAME=ESP8266 #-DWLED_DISABLE_2D
 lib_deps = ${esp8266.lib_deps}
 monitor_filters = esp8266_exception_decoder
 
@@ -300,6 +352,7 @@ 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]
@@ -345,30 +398,60 @@ 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 #-D WLED_DISABLE_BLYNK #-D WLED_DISABLE_BROWNOUT_DET
+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_BLYNK #-D WLED_DISABLE_BROWNOUT_DET
+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_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_BLYNK
+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}
 
@@ -381,32 +464,73 @@ 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:esp32c3]
-board = esp32-c3-devkitm-1
-platform = https://github.com/tasmota/platform-espressif32/releases/download/v2.0.2.2/platform-tasmota-espressif32-2.0.2.zip
-platform_packages =
+[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
+;; ESP32-S3-DevKitC-1 development board, with 8MB FLASH, no PSRAM (flash_mode: qio)
 board = esp32-s3-devkitc-1
-platform = espressif32@5.1.1
-platform_packages = platformio/framework-arduinoespressif32@3.20004.220825
+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_MODE=1 -D ARDUINO_USB_CDC_ON_BOOT=0 -D ARDUINO_USB_MSC_ON_BOOT=0
+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}
@@ -470,14 +594,19 @@ 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 = espressif32@5.1.1
+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}
-build_flags = ${common.build_flags} ${esp32s2.build_flags} #-D WLED_RELEASE_NAME=LolinS2
+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
-  -D ARDUINO_USB_CDC_ON_BOOT
+  -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
@@ -496,9 +625,28 @@ 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 = espressif32@3.2
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
 upload_speed = 460800
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32}
@@ -510,9 +658,12 @@ 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]
@@ -520,7 +671,8 @@ 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 = espressif32@3.2
+platform = ${esp32.platform}
+platform_packages = ${esp32.platform_packages}
 board_build.partitions = ${esp32.default_partitions}
 
 [env:sp501e]
@@ -537,20 +689,58 @@ 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:athom7w]
-board = esp_wroom_02
+[env:Athom_RGBCW]        ;7w and 5w(GU10) bulbs
+board = esp8285
 platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
-build_flags = ${common.build_flags_esp8266} -D WLED_MAX_CCT_BLEND=0 -D BTNPIN=-1 -D IRPIN=-1 -D WLED_DISABLE_INFRARED
+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
+                                            -D DEFAULT_LED_TYPE=TYPE_ANALOG_5CH -D WLED_DISABLE_INFRARED -D WLED_MAX_CCT_BLEND=0
 lib_deps = ${esp8266.lib_deps}
 
-[env:athom15w]
-board = esp_wroom_02
+
+[env:Athom_15w_RGBCW]        ;15w bulb
+board = esp8285
 platform = ${common.platform_wled_default}
+platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
-build_flags = ${common.build_flags_esp8266} -D WLED_USE_IC_CCT -D BTNPIN=-1 -D IRPIN=-1 -D WLED_DISABLE_INFRARED
+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
+                                            -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}
@@ -560,28 +750,12 @@ 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}
 
-# ------------------------------------------------------------------------------
-# travis test board configurations
-# ------------------------------------------------------------------------------
-
-[env:travis_esp8266]
-extends = env:d1_mini
-build_type = debug
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp8266} ${common.debug_flags} ${common.build_flags_all_features}
-
-[env:travis_esp32]
-extends = env:esp32dev
-; build_type = debug
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp32} ${common.debug_flags} ${common.build_flags_all_features}
-
 # ------------------------------------------------------------------------------
 # 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}
@@ -590,7 +764,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}
@@ -604,7 +778,8 @@ lib_deps = ${esp8266.lib_deps}
 # ------------------------------------------------------------------------------
 [env:elekstube_ips]
 board = esp32dev
-platform = espressif32@3.2
+platform = ${esp32.platform}
+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
@@ -612,7 +787,6 @@ 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_BLYNK
   -D DEFAULT_LED_COUNT=6
   # Display config
   -D ST7789_DRIVER

platformio_override.ini.sample

@@ -26,7 +26,6 @@ build_flags = ${common.build_flags_esp8266}
 ; disable specific features
 ;  -D WLED_DISABLE_OTA
 ;  -D WLED_DISABLE_ALEXA
-;  -D WLED_DISABLE_BLYNK
 ;  -D WLED_DISABLE_HUESYNC
 ;  -D WLED_DISABLE_INFRARED
 ;  -D WLED_DISABLE_WEBSOCKETS

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/KuqP7NE"><img src="https://img.shields.io/discord/473448917040758787.svg?colorB=blue&label=discord&style=flat-square"></a>
+  <a href="https://discord.gg/QAh7wJHrRM"><img src="https://img.shields.io/discord/473448917040758787.svg?colorB=blue&label=discord&style=flat-square"></a>
   <a href="https://kno.wled.ge"><img src="https://img.shields.io/badge/quick_start-wiki-blue.svg?style=flat-square"></a>
   <a href="https://github.com/Aircoookie/WLED-App"><img src="https://img.shields.io/badge/app-wled-blue.svg?style=flat-square"></a>
   <a href="https://gitpod.io/#https://github.com/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 integrated for over 100 special effects  
+- WS2812FX library with more than 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 parts of the LEDs  
-- Settings page - configuration over network  
+- Segments to set different effects and colors to user defined parts of the LED string  
+- Settings page - configuration via the network  
 - Access Point and station mode - automatic failsafe AP  
 - Up to 10 LED outputs per instance
 - Support for RGBW strips  
@@ -28,14 +28,13 @@ A fast and feature-rich implementation of an ESP8266/ESP32 webserver to control
 - 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 Auto Brightness limit for safer operation  
+- Configurable Auto Brightness limit for safe 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)
@@ -51,10 +50,10 @@ 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 made by the community and helpful tools to help you get your new lamp up and running!
+[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!
 
 ## 🖼️ User interface
-<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
 
@@ -67,15 +66,19 @@ Credits [here](https://kno.wled.ge/about/contributors/)!
 
 Join the Discord server to discuss everything about WLED!
 
-<a href="https://discord.gg/KuqP7NE"><img src="https://discordapp.com/api/guilds/473448917040758787/widget.png?style=banner2" width="25%"></a>
+<a href="https://discord.gg/QAh7wJHrRM"><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.  
-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)
+
+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 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.  
-In case you still want to try, don't use strobe, lighting or noise modes or high effect speed settings.
+
+If you are prone to photosensitive epilepsy, we recommended you do **not** use this software.  
+If you still want to try, don't use strobe, lighting or noise modes or high effect speed settings.
+
 As per the MIT license, I assume no liability for any damage to you or any other person or equipment.  
 

requirements.txt

@@ -4,67 +4,55 @@
 #
 #    pip-compile
 #
-aiofiles==0.8.0
+aiofiles==22.1.0
     # via platformio
 ajsonrpc==1.2.0
     # via platformio
-anyio==3.6.1
+anyio==3.6.2
     # via starlette
-async-timeout==4.0.2
-    # via zeroconf
-bottle==0.12.23
+bottle==0.12.25
     # via platformio
-certifi==2022.6.15
+certifi==2023.7.22
     # via requests
-charset-normalizer==2.1.1
+charset-normalizer==3.1.0
     # via requests
 click==8.1.3
     # via
     #   platformio
     #   uvicorn
-colorama==0.4.5
-    # via
-    #   click
-    #   platformio
-h11==0.13.0
+colorama==0.4.6
+    # via platformio
+h11==0.14.0
     # via
     #   uvicorn
     #   wsproto
-idna==3.3
+idna==3.4
     # via
     #   anyio
     #   requests
-ifaddr==0.2.0
-    # via zeroconf
-marshmallow==3.17.0
+marshmallow==3.19.0
     # via platformio
-packaging==21.3
+packaging==23.1
     # via marshmallow
-platformio==6.1.4
+platformio==6.1.6
     # via -r requirements.in
 pyelftools==0.29
     # via platformio
-pyparsing==3.0.9
-    # via packaging
 pyserial==3.5
     # via platformio
-requests==2.28.1
+requests==2.31.0
     # via platformio
 semantic-version==2.10.0
     # via platformio
-sniffio==1.2.0
+sniffio==1.3.0
     # via anyio
-starlette==0.20.4
+starlette==0.23.1
     # via platformio
-tabulate==0.8.10
+tabulate==0.9.0
     # via platformio
-typing-extensions==4.3.0
-    # via starlette
-urllib3==1.26.11
+urllib3==1.26.15
     # via requests
-uvicorn==0.18.2
+uvicorn==0.20.0
     # via platformio
-wsproto==1.1.0
-    # via platformio
-zeroconf==0.39.0
+wsproto==1.2.0
     # via platformio

tools/WLED_ESP32_16MB_9MB_FS.csv

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

tools/WLED_ESP32_2MB_noOTA.csv

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

tools/WLED_ESP32_8MB.csv

@@ -3,4 +3,5 @@ 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,0x3F0000,
+spiffs,   data, spiffs,  0x410000,0x3E0000,
+coredump, data, coredump,,64K

tools/cdata.js

@@ -220,6 +220,9 @@ function writeChunks(srcDir, specs, resultFile) {
 
 writeHtmlGzipped("wled00/data/index.htm", "wled00/html_ui.h", 'index');
 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",
@@ -387,12 +390,6 @@ const char PAGE_dmxmap[] PROGMEM = R"=====()=====";
       method: "gzip",
       filter: "html-minify",
     },
-    {
-      file: "liveviewws.htm",
-      name: "PAGE_liveviewws",
-      method: "gzip",
-      filter: "html-minify",
-    },
     {
       file: "liveviewws2D.htm",
       name: "PAGE_liveviewws2D",

usermods/ADS1115_v2/ChannelSettings.h

@@ -0,0 +1,15 @@
+#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;
+  };
+}

usermods/ADS1115_v2/readme.md

@@ -0,0 +1,10 @@
+# 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`

usermods/ADS1115_v2/usermod_ads1115.h

@@ -0,0 +1,255 @@
+#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);
+    }
+};

usermods/Analog_Clock/Analog_Clock.h

@@ -0,0 +1,256 @@
+#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;
+    }
+};

usermods/Animated_Staircase/Animated_Staircase.h

@@ -25,6 +25,7 @@ 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;
@@ -65,7 +66,7 @@ class Animated_Staircase : public Usermod {
     // The maximum number of configured segments.
     // Dynamically updated based on user configuration.
     byte maxSegmentId = 1;
-    byte mainSegmentId = 0;
+    byte minSegmentId = 0;
 
     // These values are used by the API to read the
     // last sensor state, or trigger a sensor
@@ -90,38 +91,37 @@ 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() {
-      mainSegmentId = strip.getMainSegmentId();
-      for (int i = 0; i < strip.getSegmentsNum(); i++) {
+      for (int i = minSegmentId; i < maxSegmentId; i++) {
         Segment &seg = strip.getSegment(i);
-        if (!seg.isActive()) {
-          maxSegmentId = i - 1;
-          break;
-        }
+        if (!seg.isActive()) continue; // skip gaps
         if (i >= onIndex && i < offIndex) {
           seg.setOption(SEG_OPTION_ON, true);
-
           // 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
-          // segments->mode = mainsegment.mode;
-          // segments->colors[0] = mainsegment.colors[0];
+          // seg.setMode(mainsegment.mode);
+          // seg.setColor(0, mainsegment.colors[0]);
         } else {
           seg.setOption(SEG_OPTION_ON, false);
         }
         // Always mark segments as "transitional", we are animating the staircase
-        seg.setOption(SEG_OPTION_TRANSITIONAL, true);
+        //seg.setOption(SEG_OPTION_TRANSITIONAL, true); // not needed anymore as setOption() does it
       }
+      strip.trigger();  // force strip refresh
+      stateChanged = true;  // inform external devices/UI of change
       colorUpdated(CALL_MODE_DIRECT_CHANGE);
     }
 
@@ -198,6 +198,7 @@ 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;
 
@@ -207,9 +208,9 @@ class Animated_Staircase : public Usermod {
             if (onIndex == offIndex) {
               // Position the indices for a correct on-swipe
               if (swipe == SWIPE_UP) {
-                onIndex = mainSegmentId;
+                onIndex = minSegmentId;
               } else {
-                onIndex = maxSegmentId+1;
+                onIndex = maxSegmentId;
               }
               offIndex = onIndex;
             }
@@ -221,7 +222,7 @@ class Animated_Staircase : public Usermod {
     }
 
     void autoPowerOff() {
-      if (on && ((millis() - lastSwitchTime) > on_time_ms)) {
+      if ((millis() - lastSwitchTime) > on_time_ms) {
         // if sensors are still on, do nothing
         if (bottomSensorState || topSensorState) return;
 
@@ -238,10 +239,12 @@ 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(mainSegmentId, onIndex - 1);
-          offIndex = MIN(maxSegmentId + 1, offIndex + 1);
+          onIndex  = MAX(minSegmentId, onIndex - 1);
+          offIndex = MIN(maxSegmentId, offIndex + 1);
         } else {
           if (swipe == SWIPE_UP) {
             onIndex = MIN(offIndex, onIndex + 1);
@@ -249,7 +252,10 @@ class Animated_Staircase : public Usermod {
             offIndex = MAX(onIndex, offIndex - 1);
           }
         }
-        updateSegments();
+        if (oldOn != onIndex || oldOff != offIndex) {
+          updateSegments(); // reduce the number of updates to necessary ones
+          if (togglePower && onIndex == offIndex && !offMode && !on) toggleOnOff();  // toggle power off for all segments off
+        }
       }
     }
 
@@ -287,16 +293,23 @@ 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.getSegmentsNum(); i++) {
+        for (int i = 0; i <= strip.getLastActiveSegmentId(); i++) {
           Segment &seg = strip.getSegment(i);
-          if (!seg.isActive()) {
-            maxSegmentId = i - 1;
-            break;
-          }
+          if (!seg.isActive()) continue; // skip vector gaps
           seg.setOption(SEG_OPTION_ON, true);
         }
+        strip.trigger();  // force strip update
+        stateChanged = true;  // inform external dvices/UI of change
         colorUpdated(CALL_MODE_DIRECT_CHANGE);
         DEBUG_PRINTLN(F("Animated Staircase disabled."));
       }
@@ -332,13 +345,16 @@ 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();
-      autoPowerOff();
+      if (on) 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)
@@ -376,6 +392,7 @@ class Animated_Staircase : public Usermod {
         mqtt->subscribe(subuf, 0);
       }
     }
+#endif
 
     void addToJsonState(JsonObject& root) {
       JsonObject staircase = root[FPSTR(_name)];
@@ -392,14 +409,16 @@ 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>()) {
-          enabled   = staircase[FPSTR(_enabled)].as<bool>();
+          en = staircase[FPSTR(_enabled)].as<bool>();
         } else {
           String str = staircase[FPSTR(_enabled)]; // checkbox -> off or on
-          enabled = (bool)(str!="off"); // off is guaranteed to be present
+          en = (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."));
       }
@@ -432,6 +451,7 @@ 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."));
     }
 
@@ -476,6 +496,8 @@ 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
@@ -499,7 +521,7 @@ class Animated_Staircase : public Usermod {
         if (changed) setup();
       }
       // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-      return true;
+      return !top[FPSTR(_togglePower)].isNull();
     }
 
     /*
@@ -539,3 +561,4 @@ 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";

usermods/Animated_Staircase/README.md

@@ -1,14 +1,14 @@
 # Usermod Animated Staircase
-This usermod makes your staircase look cool by switching it on with an animation. It uses
+This usermod makes your staircase look cool by illuminating it with an animation. It uses
 PIR or ultrasonic sensors at the top and bottom of your stairs to:
 
-- Light up the steps in your walking direction, leading the way.
+- Light up the steps in the direction you're walking.
 - 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 therewith handle multiple people on the stairs gracefully.
+  is still running. It can gracefully handle multiple people on the stairs.
 
 The Animated Staircase can be controlled by the WLED API. Change settings such as
-speed, on/off time and distance settings by sending an HTTP request, see below.
+speed, on/off time and distance by sending an HTTP request, see below.
 
 ## WLED integration
 To include this usermod in your WLED setup, you have to be able to [compile WLED from source](https://github.com/Aircoookie/WLED/wiki/Compiling-WLED).
@@ -20,17 +20,16 @@ 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 Usermods settings page.
-Please enter GPIO pins for PIR sensors or ultrasonic sensor (trigger and echo).
+You can configure usermod using the Usermods settings page.
+Please enter GPIO pins for PIR or ultrasonic sensors (trigger and echo).
 If you use PIR sensor enter -1 for echo pin.
-Maximum distance for ultrasonic sensor can be configured as a time needed for echo (see below).
+Maximum distance for ultrasonic sensor can be configured as the time needed for an echo (see below).
 
 ## Hardware installation
-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
-   of your stairs.
+1. Attach the LED strip to each step of the stairs.
+2. Connect the ESP8266 pin D4 or ESP32 pin D2 to the first LED data pin at the bottom step.
 3. Connect the data-out pin at the end of each strip per step to the data-in pin on the 
-   other end of the next step, creating one large virtual LED strip.
+   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
@@ -62,7 +61,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 status element:
+The staircase settings and sensor states are inside the WLED "state" element:
 
 ```json
 {
@@ -70,14 +69,14 @@ The staircase settings and sensor states are inside the WLED status element:
         "staircase": {
             "enabled": true,
             "bottom-sensor": false,
-            "tops-ensor": false
+            "top-sensor": 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 to play with the lights without the usermod switching them on or off.
+activity. This enables you to play with the lights without the usermod switching them on or off.
 
 To disable the usermod:
 
@@ -92,17 +91,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 and so on.
+Using _Usermod_ Settings page you can define different usermod parameters, includng sensor pins, delay between segment activation etc.
 
 When an ultrasonic sensor is enabled you can enter maximum detection distance in centimeters separately for top and bottom sensors.
 
-**Please note:** that using an HC-SR04 sensor, particularly when detecting echos at longer
-distances creates delays in the WLED software, and _might_ introduce timing hickups in your animations or
+**Please note:** 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
 a less responsive web interface. It is therefore advised to keep the detection distance as short as possible.
 
 ### Animation triggering through the API
-Instead of stairs activation by one of the sensors, you can also trigger the animation through
-the API. To simulate triggering the bottom sensor, use:
+In addition to activation by one of the stair sensors, you can also trigger the animation manually
+via the API. To simulate triggering the bottom sensor, use:
 
 ```bash
 curl -X POST -H "Content-Type: application/json" \
@@ -110,7 +109,7 @@ curl -X POST -H "Content-Type: application/json" \
      xxx.xxx.xxx.xxx/json/state
 ```
 
-Likewise, to trigger the top sensor, use:
+Likewise, to trigger the top sensor:
 
 ```bash
 curl -X POST -H "Content-Type: application/json" \
@@ -119,7 +118,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 usermod.
+You can also use `on` or `off` for enabling or disabling the usermod.
 
 Have fun with this usermod.<br/>
 www.rolfje.com

usermods/BH1750_v2/platformio_override.ini

@@ -1,16 +0,0 @@
-; Options
-; -------
-; USERMOD_BH1750                                - define this to have this user mod included wled00\usermods_list.cpp
-; 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_FIRST_MEASUREMENT_AT           - the number of milliseconds after boot to take first measurement, defaults to 10 seconds
-; USERMOD_BH1750_OFFSET_VALUE                   - the offset value to report on, defaults to 1
-;
-[env:usermod_BH1750_d1_mini]
-extends = env:d1_mini
-build_flags =
-    ${common.build_flags_esp8266}
-    -D USERMOD_BH1750
-lib_deps = 
-    ${env.lib_deps}
-    claws/BH1750 @ ^1.2.0

usermods/BH1750_v2/readme.md

@@ -1,24 +1,49 @@
 # BH1750 usermod
 
-This usermod will read from an ambient light sensor like the BH1750 sensor.
-The luminance is displayed both in the Info section of the web UI as well as published to the `/luminance` MQTT topic if enabled.
+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.
 
-## Installation
+## 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.
 
-Copy the example `platformio_override.ini` to the root directory.  This file should be placed in the same directory as `platformio.ini`.
+## Compiliation
 
-### Define Your Options
+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
+```
 
-*   `USERMOD_BH1750`                                - define this to have this user mod included wled00\usermods_list.cpp
+### 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_FIRST_MEASUREMENT_AT`           - the number of milliseconds after boot to take first measurement, defaults to 10 seconds
 *   `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
 
-All parameters can be configured at runtime using Usermods settings page.
+In addition, the Usermod screen allows you to:
+- enable/disable the usermod
+- Enable Home Assistant Discovery of usermod
+- Configure the SCL/SDA pins
 
-### PlatformIO requirements
-
-If you are using `platformio_override.ini`, you should be able to refresh the task list and see your custom task, for example `env:usermod_BH1750_d1_mini`.
+## 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`

usermods/BH1750_v2/usermod_bh1750.h

@@ -1,7 +1,13 @@
+// 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 <Wire.h>
 #include <BH1750.h>
 
 // the max frequency to check photoresistor, 10 seconds
@@ -39,7 +45,7 @@ private:
   bool getLuminanceComplete = false;
 
   // flag set at startup
-  bool disabled = false;
+  bool enabled = true;
 
   // strings to reduce flash memory usage (used more than twice)
   static const char _name[];
@@ -47,6 +53,15 @@ private:
   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;
@@ -56,16 +71,56 @@ private:
     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()
   {
-    Wire.begin();
-    lightMeter.begin();
+    if (i2c_scl<0 || i2c_sda<0) { enabled = false; return; }
+    sensorFound = lightMeter.begin();
+    initDone = true;
   }
 
   void loop()
   {
-    if (disabled || strip.isUpdating())
+    if ((!enabled) || strip.isUpdating())
       return;
 
     unsigned long now = millis();
@@ -88,18 +143,27 @@ public:
     {
       lastLux = lux;
       lastSend = millis();
+#ifndef WLED_DISABLE_MQTT
       if (WLED_MQTT_CONNECTED)
       {
-        char subuf[45];
-        strcpy(subuf, mqttDeviceTopic);
-        strcat_P(subuf, PSTR("/luminance"));
-        mqtt->publish(subuf, 0, true, String(lux).c_str());
+        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("Missing MQTT connection. Not publishing data");
+        DEBUG_PRINTLN(F("Missing MQTT connection. Not publishing data"));
+      }
+#endif
     }
   }
+
+  inline float getIlluminance() {
+    return (float)lastLux;
   }
 
   void addToJsonInfo(JsonObject &root)
@@ -109,43 +173,39 @@ public:
       user = root.createNestedObject(F("u"));
 
     JsonArray lux_json = user.createNestedArray(F("Luminance"));
-
-    if (!getLuminanceComplete)
-    {
+    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"));
     }
-
-  uint16_t getId()
-  {
-    return USERMOD_ID_BH1750;
   }
 
-  /**
-     * addToConfig() (called from set.cpp) stores persistent properties to cfg.json
-     */
+  // (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)] = !disabled;
+    top[FPSTR(_enabled)] = enabled;
     top[FPSTR(_maxReadInterval)] = maxReadingInterval;
     top[FPSTR(_minReadInterval)] = minReadingInterval;
+    top[FPSTR(_HomeAssistantDiscovery)] = HomeAssistantDiscovery;
     top[FPSTR(_offset)] = offset;
 
-    DEBUG_PRINTLN(F("Photoresistor config saved."));
+    DEBUG_PRINTLN(F("BH1750 config saved."));
   }
 
-  /**
-  * readFromConfig() is called before setup() to populate properties from values stored in cfg.json
-  */
+  // called before setup() to populate properties from values stored in cfg.json
   bool readFromConfig(JsonObject &root)
   {
     // we look for JSON object.
@@ -153,20 +213,34 @@ public:
     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);
 
-    disabled = !(top[FPSTR(_enabled)] | !disabled);
-    maxReadingInterval = (top[FPSTR(_maxReadInterval)] | maxReadingInterval); // ms
-    minReadingInterval = (top[FPSTR(_minReadInterval)] | minReadingInterval); // ms
-    offset = top[FPSTR(_offset)] | offset;
     DEBUG_PRINT(FPSTR(_name));
+    if (!initDone) {
+      DEBUG_PRINTLN(F(" config loaded."));
+    } else {
       DEBUG_PRINTLN(F(" config (re)loaded."));
-
-    // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-    return true;
     }
+
+    return configComplete;
+    
+  }
+
+  uint16_t getId()
+  {
+    return USERMOD_ID_BH1750;
+  }
+
 };
 
 // strings to reduce flash memory usage (used more than twice)
@@ -174,4 +248,5 @@ const char Usermod_BH1750::_name[] PROGMEM = "BH1750";
 const char Usermod_BH1750::_enabled[] PROGMEM = "enabled";
 const char Usermod_BH1750::_maxReadInterval[] PROGMEM = "max-read-interval-ms";
 const char Usermod_BH1750::_minReadInterval[] PROGMEM = "min-read-interval-ms";
+const char Usermod_BH1750::_HomeAssistantDiscovery[] PROGMEM = "HomeAssistantDiscoveryLux";
 const char Usermod_BH1750::_offset[] PROGMEM = "offset-lx";

usermods/BH1750_v2/usermods_list.cpp

@@ -1,14 +0,0 @@
-#include "wled.h"
-/*
- * Register your v2 usermods here!
- */
-#ifdef USERMOD_BH1750
-#include "../usermods/BH1750_v2/usermod_BH1750.h"
-#endif
-
-void registerUsermods()
-{
-#ifdef USERMOD_BH1750
-  usermods.add(new Usermod_BH1750());
-#endif
-}

usermods/BME280_v2/README.md

@@ -6,14 +6,14 @@ This Usermod is designed to read a `BME280` or `BMP280` sensor and output the fo
 - Heat Index (`BME280` only)
 - Dew Point (`BME280` only)
 
-Configuration is all completed via the Usermod menu.  There are no settings to set in code!  The following settings can be configured in the Usermod Menu:
+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:
 - Temperature Decimals (number of decimal places to output)
 - Humidity Decimals
 - Pressure Decimals
-- Temperature Interval (how many seconds between reads of temperature and humidity)
+- 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 Farenheit)
+- Use Celsius (turn off to use Fahrenheit)
 - Home Assistant Discovery (turn on to sent MQTT Discovery entries for Home Assistant)
 - SCL/SDA GPIO Pins
 
@@ -23,7 +23,7 @@ Dependencies
   - `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 listening on the serial TX pin of your board will get confused by log messages!
+- 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.
 
@@ -37,7 +37,7 @@ Methods also exist to read the read/calculated values from other WLED modules th
 - `getHeatIndexC()`
 - `getHeatIndexF()`
 
-# Complilation
+# Compiling
 
 To enable, compile with `USERMOD_BME280` defined  (e.g. in `platformio_override.ini`)
 ```ini
@@ -63,7 +63,7 @@ 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 seperate from the main WLED device and will contain sensors for Pressure, Humidity, Temperature, Dew Point and Heat Index.
+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
@@ -82,8 +82,8 @@ Apr 2021
 
 Dec 2020
 - Ported to V2 Usermod format
-- Customisable `measure intervals`
-- Customisable number of `decimal places` in published sensor values
+- 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

usermods/BME280_v2/usermod_bme280.h

@@ -1,11 +1,14 @@
 // 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
 
@@ -16,20 +19,20 @@ private:
   // NOTE: Do not implement any compile-time variables, anything the user needs to configure
   // should be configurable from the Usermod menu using the methods below
   // key settings set via usermod menu
-  unsigned long TemperatureDecimals = 0;  // Number of decimal places in published temperaure values
-  unsigned long  HumidityDecimals = 0;    // Number of decimal places in published humidity values
-  unsigned long  PressureDecimals = 0;    // Number of decimal places in published pressure values
-  unsigned long  TemperatureInterval = 5; // Interval to measure temperature (and humidity, dew point if available) in seconds
-  unsigned long  PressureInterval = 300;  // Interval to measure pressure in seconds
+  uint8_t  TemperatureDecimals = 0;  // Number of decimal places in published temperaure values
+  uint8_t  HumidityDecimals = 0;    // Number of decimal places in published humidity values
+  uint8_t  PressureDecimals = 0;    // Number of decimal places in published pressure values
+  uint16_t TemperatureInterval = 5; // Interval to measure temperature (and humidity, dew point if available) in seconds
+  uint16_t PressureInterval = 300;  // Interval to measure pressure in seconds
   bool PublishAlways = false;             // Publish values even when they have not changed
   bool UseCelsius = true;                 // Use Celsius for Reporting
   bool HomeAssistantDiscovery = false;    // Publish Home Assistant Device Information
+  bool enabled = true;
 
   // set the default pins based on the architecture, these get overridden by Usermod menu settings
   #ifdef ESP8266
     //uint8_t RST_PIN = 16; // Uncoment for Heltec WiFi-Kit-8
   #endif
-  int8_t ioPin[2] = {i2c_scl, i2c_sda};   // I2C pins: SCL, SDA...defaults to Arch hardware pins but overridden at setup()
   bool initDone = false;
 
   // BME280 sensor settings
@@ -70,15 +73,10 @@ private:
 
   // MQTT topic strings for publishing Home Assistant discovery topics
   bool mqttInitialized = false;
-  String mqttTemperatureTopic = "";
-  String mqttHumidityTopic = "";
-  String mqttPressureTopic = "";
-  String mqttHeatIndexTopic = "";
-  String mqttDewPointTopic = "";
 
-  // Store packet IDs of MQTT publications
-  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)
@@ -95,7 +93,7 @@ private:
       sensorTemperature = _temperature;
       sensorHumidity = _humidity;
       sensorPressure = _pressure;
-      tempScale = "°C";
+      tempScale = F("°C");
       if (sensorType == 1)
       {
         sensorHeatIndex = EnvironmentCalculations::HeatIndex(_temperature, _humidity, envTempUnit);
@@ -111,7 +109,7 @@ private:
       sensorTemperature = _temperature;
       sensorHumidity = _humidity;
       sensorPressure = _pressure;
-      tempScale = "°F";
+      tempScale = F("°F");
       if (sensorType == 1)
       {
         sensorHeatIndex = EnvironmentCalculations::HeatIndex(_temperature, _humidity, envTempUnit);
@@ -123,18 +121,23 @@ private:
   // Procedure to define all MQTT discovery Topics 
   void _mqttInitialize()
   {
-    mqttTemperatureTopic = String(mqttDeviceTopic) + F("/temperature");
-    mqttPressureTopic = String(mqttDeviceTopic) + F("/pressure");
-    mqttHumidityTopic = String(mqttDeviceTopic) + F("/humidity");
-    mqttHeatIndexTopic = String(mqttDeviceTopic) + F("/heat_index");
-    mqttDewPointTopic = String(mqttDeviceTopic) + F("/dew_point");
+    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, F("temperature"), tempScale);
-      _createMqttSensor(F("Pressure"), mqttPressureTopic, F("pressure"), F("hPa"));
-      _createMqttSensor(F("Humidity"), mqttHumidityTopic, F("humidity"), F("%"));
-      _createMqttSensor(F("HeatIndex"), mqttHeatIndexTopic, F("temperature"), tempScale);
-      _createMqttSensor(F("DewPoint"), mqttDewPointTopic, F("temperature"), tempScale);
+      _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);
     }
   }
 
@@ -169,21 +172,24 @@ private:
     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()
   {
-    bool HW_Pins_Used = (ioPin[0]==i2c_scl && ioPin[1]==i2c_sda); // note whether architecture-based hardware SCL/SDA pins used
-    PinOwner po = PinOwner::UM_BME280; // defaults to being pinowner for SCL/SDA pins
-    PinManagerPinType pins[2] = { { ioPin[0], true }, { ioPin[1], true } };  // allocate pins
-    if (HW_Pins_Used) po = PinOwner::HW_I2C; // allow multiple allocations of HW I2C bus pins
-    if (!pinManager.allocateMultiplePins(pins, 2, po)) { sensorType=0; return; }
-    
-    Wire.begin(ioPin[1], ioPin[0]);
+    if (i2c_scl<0 || i2c_sda<0) { enabled = false; sensorType = 0; return; }
     
     if (!bme.begin())
     {
       sensorType = 0;
-      DEBUG_PRINTLN(F("Could not find BME280I2C sensor!"));
+      DEBUG_PRINTLN(F("Could not find BME280 I2C sensor!"));
     }
     else
     {
@@ -207,14 +213,16 @@ public:
 
   void loop()
   {
+    if (!enabled || strip.isUpdating()) return;
+
     // BME280 sensor MQTT publishing
-    // Check if sensor present and MQTT Connected, otherwise it will crash the MCU
-    if (sensorType != 0 && WLED_MQTT_CONNECTED)
+    // Check if sensor present and Connected, otherwise it will crash the MCU
+    if (sensorType != 0)
     {
       // Timer to fetch new temperature, humidity and pressure data at intervals
       timer = millis();
 
-      if (timer - lastTemperatureMeasure >= TemperatureInterval * 1000 || mqttTemperaturePub == 0)
+      if (timer - lastTemperatureMeasure >= TemperatureInterval * 1000)
       {
         lastTemperatureMeasure = timer;
 
@@ -223,18 +231,11 @@ public:
         float temperature = roundf(sensorTemperature * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals);
         float humidity, heatIndex, dewPoint;
 
-        if (WLED_MQTT_CONNECTED && !mqttInitialized)
-        {
-          _mqttInitialize();
-          mqttInitialized = true;
-        }
-
         // 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)
         {
-          String topic = String(mqttDeviceTopic) + "/temperature";
-          mqttTemperaturePub = mqtt->publish(topic.c_str(), 0, false, String(temperature, TemperatureDecimals).c_str());
+          publishMqtt("temperature", String(temperature, TemperatureDecimals).c_str());
         }
 
         lastTemperature = temperature; // Update last sensor temperature for next loop
@@ -247,20 +248,17 @@ public:
 
           if (humidity != lastHumidity || PublishAlways)
           {
-            String topic = String(mqttDeviceTopic) + F("/humidity");
-            mqtt->publish(topic.c_str(), 0, false, String(humidity, HumidityDecimals).c_str());
+            publishMqtt("humidity", String(humidity, HumidityDecimals).c_str());
           }
 
           if (heatIndex != lastHeatIndex || PublishAlways)
           {
-            String topic = String(mqttDeviceTopic) + F("/heat_index");
-            mqtt->publish(topic.c_str(), 0, false, String(heatIndex, TemperatureDecimals).c_str());
+            publishMqtt("heat_index", String(heatIndex, TemperatureDecimals).c_str());
           }
 
           if (dewPoint != lastDewPoint || PublishAlways)
           {
-            String topic = String(mqttDeviceTopic) + F("/dew_point");
-            mqtt->publish(topic.c_str(), 0, false, String(dewPoint, TemperatureDecimals).c_str());
+            publishMqtt("dew_point", String(dewPoint, TemperatureDecimals).c_str());
           }
 
           lastHumidity = humidity;
@@ -269,7 +267,7 @@ public:
         }
       }
 
-      if (timer - lastPressureMeasure >= PressureInterval * 1000 || mqttPressurePub == 0)
+      if (timer - lastPressureMeasure >= PressureInterval * 1000)
       {
         lastPressureMeasure = timer;
 
@@ -277,8 +275,7 @@ public:
 
         if (pressure != lastPressure || PublishAlways)
         {
-          String topic = String(mqttDeviceTopic) + F("/pressure");
-          mqttPressurePub = mqtt->publish(topic.c_str(), 0, true, String(pressure, PressureDecimals).c_str());
+          publishMqtt("pressure", String(pressure, PressureDecimals).c_str());
         }
 
         lastPressure = pressure;
@@ -286,6 +283,15 @@ public:
     }
   }
 
+  void onMqttConnect(bool sessionPresent)
+  {
+    if (WLED_MQTT_CONNECTED && !mqttInitialized)
+    {
+      _mqttInitialize();
+      mqttInitialized = true;
+    }
+  }
+
     /*
      * API calls te enable data exchange between WLED modules
      */
@@ -295,8 +301,8 @@ public:
       } 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;
@@ -304,12 +310,15 @@ public:
         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);
@@ -317,6 +326,7 @@ public:
         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;
@@ -324,13 +334,16 @@ public:
         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() {
+    }
+
+    inline float getHeatIndexF() {
       if (UseCelsius) {
         return ((float)roundf(sensorHeatIndex * powf(10, TemperatureDecimals)) / powf(10, TemperatureDecimals) -32) * 0.56f;
       } else {
@@ -384,7 +397,8 @@ public:
   // Save Usermod Config Settings
   void addToConfig(JsonObject& root)
   {
-    JsonObject top = root.createNestedObject(F("BME280/BMP280"));
+    JsonObject top = root.createNestedObject(FPSTR(_name));
+    top[FPSTR(_enabled)] = enabled;
     top[F("TemperatureDecimals")] = TemperatureDecimals;
     top[F("HumidityDecimals")] = HumidityDecimals;
     top[F("PressureDecimals")] = PressureDecimals;
@@ -393,9 +407,6 @@ public:
     top[F("PublishAlways")] = PublishAlways;
     top[F("UseCelsius")] = UseCelsius;
     top[F("HomeAssistantDiscovery")] = HomeAssistantDiscovery;
-    JsonArray io_pin = top.createNestedArray(F("pin"));
-    for (byte i=0; i<2; i++) io_pin.add(ioPin[i]);
-    top[F("help4Pins")] = F("SCL,SDA"); // help for Settings page
     DEBUG_PRINTLN(F("BME280 config saved."));
   }
 
@@ -405,17 +416,15 @@ public:
     // 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)
 
-
-    int8_t newPin[2]; for (byte i=0; i<2; i++) newPin[i] = ioPin[i]; // prepare to note changed pins
-
-    JsonObject top = root[F("BME280/BMP280")];
+    JsonObject top = root[FPSTR(_name)];
     if (top.isNull()) {
-      DEBUG_PRINT(F("BME280/BMP280"));
+      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);
@@ -425,27 +434,14 @@ public:
     configComplete &= getJsonValue(top[F("PublishAlways")], PublishAlways, false);
     configComplete &= getJsonValue(top[F("UseCelsius")], UseCelsius, true);
     configComplete &= getJsonValue(top[F("HomeAssistantDiscovery")], HomeAssistantDiscovery, false);
-    for (byte i=0; i<2; i++) configComplete &= getJsonValue(top[F("pin")][i], newPin[i], ioPin[i]);
 
-    DEBUG_PRINT(FPSTR(F("BME280/BMP280")));
+    DEBUG_PRINT(FPSTR(_name));
     if (!initDone) {
       // first run: reading from cfg.json
-      for (byte i=0; i<2; i++) ioPin[i] = newPin[i];
       DEBUG_PRINTLN(F(" config loaded."));
     } else {
       DEBUG_PRINTLN(F(" config (re)loaded."));
       // changing parameters from settings page
-      bool pinsChanged = false;
-      for (byte i=0; i<2; i++) if (ioPin[i] != newPin[i]) { pinsChanged = true; break; } // check if any pins changed
-      if (pinsChanged) { //if pins changed, deallocate old pins and allocate new ones
-        PinOwner po = PinOwner::UM_BME280;
-        if (ioPin[0]==i2c_scl && ioPin[1]==i2c_sda) po = PinOwner::HW_I2C;  // allow multiple allocations of HW I2C bus pins
-        pinManager.deallocateMultiplePins((const uint8_t *)ioPin, 2, po);  // deallocate pins
-        for (byte i=0; i<2; i++) ioPin[i] = newPin[i];
-        setup();
-      }
-      // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-      return !top[F("pin")].isNull();
     }
 
     return configComplete;
@@ -455,3 +451,6 @@ public:
     return USERMOD_ID_BME280;
   }
 };
+
+const char UsermodBME280::_name[]                      PROGMEM = "BME280/BMP280";
+const char UsermodBME280::_enabled[]                   PROGMEM = "enabled";

usermods/Battery/battery_defaults.h

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

usermods/Battery/readme.md

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

usermods/Battery/usermod_v2_Battery.h

@@ -0,0 +1,787 @@
+#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";

usermods/Cronixie/usermod_cronixie.h

@@ -271,6 +271,7 @@ class UsermodCronixie : public Usermod {
     {
       if (root["nx"].is<const char*>()) {
         strncpy(cronixieDisplay, root["nx"], 6);
+        setCronixie();
       }
     }
 

usermods/DHT/platformio_override.ini

@@ -6,12 +6,13 @@
 ; 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.lib_deps}
+lib_deps = ${env:d1_mini.lib_deps}
     https://github.com/alwynallan/DHT_nonblocking
 
 [env:custom32_LEDPIN_16_usermod_dht_C]

usermods/DHT/readme.md

@@ -1,9 +1,13 @@
 # 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.
+The sensor readings are displayed in the Info section of the web UI (and optionally sent to an MQTT broker).
 
-If sensor is not detected after a while (10 update intervals), this usermod will be disabled.
+If sensor is not detected after 10 update intervals, the 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
 
@@ -11,12 +15,13 @@ Copy the example `platformio_override.ini` to the root directory.  This file sho
 
 ### Define Your Options
 
-* `USERMOD_DHT`                      - define this to have this user mod included wled00\usermods_list.cpp
+* `USERMOD_DHT`                      - define this to include this user mod wled00\usermods_list.cpp
 * `USERMOD_DHT_DHTTYPE`              - DHT model: 11, 21, 22 for DHT11, DHT21, or DHT22, defaults to 22/DHT22
 * `USERMOD_DHT_PIN`                  - pin to which DTH is connected, defaults to Q2 pin on QuinLed Dig-Uno's board
-* `USERMOD_DHT_CELSIUS`              - define this to report temperatures in degrees 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_CELSIUS`              - define this to report temperatures in degrees Celsius, otherwise Fahrenheit will be reported
+* `USERMOD_DHT_MEASUREMENT_INTERVAL` - the number of milliseconds between measurements, defaults to 60000 ms
+* `USERMOD_DHT_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 90000 ms
+* `USERMOD_DHT_MQTT`                 - publish measurements to an MQTT broker
 * `USERMOD_DHT_STATS`                - For debug, report delay stats
 
 ## Project link
@@ -29,10 +34,12 @@ 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 readings out by measurement interval; hope this helps to avoid occasional bursts of readings with errors
+* 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
 * 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

usermods/DHT/usermod_dht.h

@@ -1,6 +1,10 @@
 #pragma once
 
 #include "wled.h"
+#ifndef WLED_ENABLE_MQTT
+#error "This user mod requires MQTT to be enabled."
+#endif
+
 
 #include <dht_nonblocking.h>
 
@@ -62,6 +66,10 @@ 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;
@@ -76,6 +84,10 @@ 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
@@ -110,6 +122,25 @@ 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;

usermods/EXAMPLE_v2/usermod_v2_example.h

@@ -22,8 +22,12 @@
 
 //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
+
+    // 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)
@@ -37,15 +41,56 @@ 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;
     }
 
 
@@ -69,6 +114,11 @@ 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();
@@ -81,19 +131,25 @@ 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)
     {
-      int reading = 20;
-      //this code adds "u":{"Light":[20," lux"]} to the info object
+      // if "u" object does not exist yet wee need to create it
       JsonObject user = root["u"];
       if (user.isNull()) user = root.createNestedObject("u");
 
-      JsonArray lightArr = user.createNestedArray("Light"); //name
-      lightArr.add(reading); //value
-      lightArr.add(" lux"); //unit
+      //this code adds "u":{"ExampleUsermod":[20," lux"]} to the info object
+      //int reading = 20;
+      //JsonArray lightArr = user.createNestedArray(FPSTR(_name))); //name
+      //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"));
     }
-    */
 
 
     /*
@@ -102,7 +158,12 @@ class MyExampleUsermod : public Usermod {
      */
     void addToJsonState(JsonObject& root)
     {
-      //root["user0"] = userVar0;
+      if (!initDone || !enabled) return;  // prevent crash on boot applyPreset()
+
+      JsonObject usermod = root[FPSTR(_name)];
+      if (usermod.isNull()) usermod = root.createNestedObject(FPSTR(_name));
+
+      //usermod["user0"] = userVar0;
     }
 
 
@@ -112,7 +173,14 @@ class MyExampleUsermod : public Usermod {
      */
     void readFromJsonState(JsonObject& root)
     {
-      userVar0 = root["user0"] | userVar0; //if "user0" key exists in JSON, update, else keep old value
+      if (!initDone) return;  // prevent crash on boot applyPreset()
+
+      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!"));
     }
 
@@ -154,8 +222,10 @@ class MyExampleUsermod : public Usermod {
      */
     void addToConfig(JsonObject& root)
     {
-      JsonObject top = root.createNestedObject("exampleUsermod");
-      top["great"] = userVar0; //save these vars persistently whenever settings are saved
+      JsonObject top = root.createNestedObject(FPSTR(_name));
+      top[FPSTR(_enabled)] = enabled;
+      //save these vars persistently whenever settings are saved
+      top["great"] = userVar0;
       top["testBool"] = testBool;
       top["testInt"] = testInt;
       top["testLong"] = testLong;
@@ -188,7 +258,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["exampleUsermod"];
+      JsonObject top = root[FPSTR(_name)];
 
       bool configComplete = !top.isNull();
 
@@ -201,6 +271,8 @@ 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);
 
@@ -208,6 +280,21 @@ 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.
@@ -219,6 +306,71 @@ class MyExampleUsermod : public Usermod {
     }
 
 
+    /**
+     * 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.
@@ -231,3 +383,24 @@ 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
+}

usermods/EleksTube_IPS/TFTs.h

@@ -133,13 +133,13 @@ private:
       return false;
     }
 
-    read32(bmpFS); // filesize in bytes
-    read32(bmpFS); // reserved
+    (void) read32(bmpFS); // filesize in bytes
+    (void) read32(bmpFS); // reserved
     seekOffset = read32(bmpFS); // start of bitmap
     headerSize = read32(bmpFS); // header size
     w = read32(bmpFS); // width
     h = read32(bmpFS); // height
-    read16(bmpFS); // color planes (must be 1)
+    (void) read16(bmpFS); // color planes (must be 1)
     bitDepth = read16(bmpFS);
 
     if (read32(bmpFS) != 0 || (bitDepth != 24 && bitDepth != 1 && bitDepth != 4 && bitDepth != 8)) {
@@ -151,9 +151,9 @@ private:
     uint32_t palette[256];
     if (bitDepth <= 8) // 1,4,8 bit bitmap: read color palette
     {
-      read32(bmpFS); read32(bmpFS); read32(bmpFS); // size, w resolution, h resolution
+      (void) read32(bmpFS); (void) read32(bmpFS); (void) read32(bmpFS); // size, w resolution, h resolution
       paletteSize = read32(bmpFS);
-      if (paletteSize == 0) paletteSize = bitDepth * bitDepth; //if 0, size is 2^bitDepth
+      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);
@@ -198,7 +198,7 @@ private:
           }
           b = c; g = c >> 8; r = c >> 16;
         }
-        if (dimming != 255) { // only dimm when needed
+        if (dimming != 255) { // only dim when needed
           r *= dimming; g *= dimming; b *= dimming;
           r  = r  >> 8; g  = g  >> 8; b  = b  >> 8;
         }

usermods/EleksTube_IPS/readme.md

@@ -15,7 +15,7 @@ Not supported:
 - On-device setup with buttons (WiFi setup only)
 
 Your images must be 1-135 pixels wide and 1-240 pixels high.
-For BMP, 1, 4, 8, and 24 bits per pixel formats are supported.
+BMP 1, 4, 8, and 24 bits per pixel formats are supported.
 
 ## Installation 
 
@@ -26,11 +26,11 @@ 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 only using 2/3rds of the file size a 24 BPP `.bmp` has.
-The drawback is that this format cannot be handled by common image programs and that an extra conversion step is needed.
+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.
+The drawback is this format cannot be handled by common image programs and 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`).  
 Thank you to @RedNax67 for adding .bin and .clk support.  
-For most clockface designs, using 4 or 8 BPP BMP formats will save even more file size:
+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
 | --- | --- | --- | --- |

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 saving display lifetime
+-   Auto display shutoff for extending display lifetime
 -   Dallas temperature sensor
 -   Reporting temperature to MQTT broker
 
@@ -39,15 +39,15 @@ default_envs = esp07
 ...
 lib_deps_external =
   ...
-  #For use SSD1306 OLED display uncomment following
+  #To use the SSD1306 OLED display, uncomment following
   U8g2@~2.27.3
-  #For Dallas sensor uncomment following 2 lines
+  #For Dallas sensor, uncomment the 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 =
   ...
-  #For use SSD1306 OLED display uncomment following
+  #To use the SSD1306 OLED display, uncomment following
   U8g2@~2.27.3
   #For BME280 sensor uncomment following
   BME280@~3.0.0

usermods/Enclosure_with_OLED_temp_ESP07/usermod.cpp

@@ -1,3 +1,7 @@
+#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/

usermods/Enclosure_with_OLED_temp_ESP07/usermod_bme280.cpp

@@ -1,3 +1,7 @@
+#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/

usermods/Fix_unreachable_netservices_v2/readme.md

@@ -2,15 +2,16 @@
 
 **Attention: This usermod compiles only for ESP8266**
 
-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.
+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.
 
 The modification works with static or DHCP IP address configuration.
 
 _Story:_
 
-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.
+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.
+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 for 60 seconds until the next ping request.
+With this modification, in the worst case, the network functions are not available until the next ping request. (60 seconds)
 
 ## Webinterface
 

usermods/Internal_Temperature_v2/readme.md

@@ -0,0 +1,17 @@
+# 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)

usermods/Internal_Temperature_v2/usermod_internal_temperature.h

@@ -0,0 +1,117 @@
+#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
+}

usermods/JSON_IR_remote/readme.md

@@ -2,8 +2,8 @@
 
 ## Purpose 
 
-The JSON IR remote allows users to customize IR remote behavior without writing custom code and compiling. 
-It also enables using any remote that is compatible with your IR receiver. Using the JSON IR remote, you can
+The JSON IR remote enables 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
 map buttons from any remote to any HTTP request API or JSON API command.  
 
 ## Usage

usermods/PIR_sensor_switch/readme.md

@@ -7,71 +7,35 @@ _Story:_
 I use the PIR Sensor to automatically turn on the WLED analog clock in my home office room when I am there.
 The LED strip is switched [using a relay](https://github.com/Aircoookie/WLED/wiki/Control-a-relay-with-WLED) to keep the power consumption low when it is switched off.
 
-## Webinterface
+## Web interface
 
 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.
 
 ## Sensor connection
 
-My setup uses an HC-SR501 or HC-SR602 sensor, a HC-SR505 should also work.
+My setup uses an HC-SR501 or HC-SR602 sensor, an 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
 
-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`.
+**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`.
 
-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());
-
-}
-```
-
-**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.
-
-## API to enable/disable the PIR sensor from outside. For example from another usermod.
+## 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 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).
+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
+(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 the other usermod in `usermods_list.cpp'
+1. Include `usermod_PIR_sensor_switch.h` **before** you include other usermods in `usermods_list.cpp'
 
 or
 
@@ -100,7 +64,7 @@ class MyUsermod : public Usermod {
 
 ### Configuration options
 
-Usermod can be configured in Usermods settings page.
+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
@@ -108,8 +72,8 @@ Usermod can be configured in Usermods settings page.
 * `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` - only send MQTT messages, do not interact with WLED
-* `off-only` - only trigger presets or turn WLED on/off in WLED is not already on (displaying effect)
+* `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
 
 
@@ -122,3 +86,8 @@ Have fun - @gegu & @blazoncek
 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.

usermods/PIR_sensor_switch/usermod_PIR_sensor_switch.h

@@ -11,65 +11,54 @@
   #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() {}
-  /**
-   * desctructor
-   */
+  // destructor
   ~PIRsensorSwitch() {}
 
-  /**
-   * Enable/Disable the PIR sensor
-   */
-  void EnablePIRsensor(bool en) { enabled = en; }
-  /**
-   * Get PIR sensor enabled/disabled state
-   */
-  bool PIRsensorEnabled() { return enabled; }
+  //Enable/Disable the PIR sensor
+  inline void EnablePIRsensor(bool en) { enabled = en; }
+  
+  // Get PIR sensor enabled/disabled state
+  inline bool PIRsensorEnabled() { return enabled; }
 
 private:
 
   byte prevPreset   = 0;
   byte prevPlaylist = 0;
 
-  uint32_t offTimerStart = 0;                   // off timer start time
+  volatile unsigned long offTimerStart = 0;     // off timer start time
+  volatile bool PIRtriggered           = false; // did PIR trigger?
   byte NotifyUpdateMode  = CALL_MODE_NO_NOTIFY; // notification mode for stateUpdated(): CALL_MODE_NO_NOTIFY or CALL_MODE_DIRECT_CHANGE
   byte sensorPinState    = LOW;                 // current PIR sensor pin state
   bool initDone          = false;               // status of initialization
-  bool PIRtriggered      = false;
   unsigned long lastLoop = 0;
 
   // configurable parameters
   bool enabled              = true;           // PIR sensor enabled
   int8_t PIRsensorPin       = PIR_SENSOR_PIN; // PIR sensor pin
-  uint32_t m_switchOffDelay = 600000;         // delay before switch off after the sensor state goes LOW (10min)
+  uint32_t m_switchOffDelay = PIR_SENSOR_OFF_SEC*1000;  // delay before switch off after the sensor state goes LOW (10min)
   uint8_t m_onPreset        = 0;              // on preset
   uint8_t m_offPreset       = 0;              // off preset
   bool m_nightTimeOnly      = false;          // flag to indicate that PIR sensor should activate WLED during nighttime only
@@ -77,6 +66,10 @@ private:
   // 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 m_override           = false;
+
+  // Home Assistant
+  bool HomeAssistantDiscovery = false;        // is HA discovery turned on
 
   // strings to reduce flash memory usage (used more than twice)
   static const char _name[];
@@ -87,13 +80,124 @@ 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
    */
-  bool isDayTime() {
+  static bool isDayTime();
+
+  /**
+   * switch strip on/off
+   */
+  void switchStrip(bool switchOn);
+  void publishMqtt(const char* state);
+
+  // 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 publishHomeAssistantAutodiscovery();
+
+  /**
+   * Read and update PIR sensor state.
+   * Initilize/reset switch off timer
+   */
+  bool updatePIRsensorState();
+
+  /**
+   * switch off the strip if the delay has elapsed 
+   */
+  bool handleOffTimer();
+
+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();
+
+  /**
+   * 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);
@@ -111,16 +215,14 @@ private:
     }
   }
   return false;
-  }
+}
 
-  /**
-   * switch strip on/off
-   */
-  void switchStrip(bool switchOn)
-  {
+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) {
@@ -143,7 +245,7 @@ private:
     }
   } else {
     if (m_offPreset) {
-        if (currentPreset==m_onPreset || currentPlaylist==m_onPreset) applyPreset(m_offPreset, NotifyUpdateMode);
+      applyPreset(m_offPreset, NotifyUpdateMode);
       return;
     } else if (prevPlaylist) {
       if (currentPreset==m_onPreset || currentPlaylist==m_onPreset) applyPreset(prevPlaylist, NotifyUpdateMode);
@@ -162,25 +264,57 @@ private:
       stateUpdated(NotifyUpdateMode);
     }
   }
-  }
+}
 
-  void publishMqtt(const char* state)
-  {
+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 subuf[64];
-      strcpy(subuf, mqttDeviceTopic);
-      strcat_P(subuf, PSTR("/motion"));
-      mqtt->publish(subuf, 0, false, state);
-    }
+  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
+}
 
-  /**
-   * Read and update PIR sensor state.
-   * Initilize/reset switch off timer
-   */
-  bool updatePIRsensorState()
-  {
+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
@@ -198,34 +332,26 @@ private:
     return true;
   }
   return false;
-  }
+}
 
-  /**
-   * switch off the strip if the delay has elapsed 
-   */
-  bool handleOffTimer()
-  {
+bool PIRsensorSwitch::handleOffTimer()
+{
   if (offTimerStart > 0 && millis() - offTimerStart > m_switchOffDelay) {
     offTimerStart = 0;
     if (enabled == true) {
-        if (!m_mqttOnly && (!m_nightTimeOnly || (m_nightTimeOnly && !isDayTime()))) switchStrip(false);
+      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;
-  }
+}
 
-public:
-  //Functions called by WLED
+//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()
-  {
+void PIRsensorSwitch::setup()
+{
   if (enabled) {
     // pin retrieved from cfg.json (readFromConfig()) prior to running setup()
     if (PIRsensorPin >= 0 && pinManager.allocatePin(PIRsensorPin, false, PinOwner::UM_PIR)) {
@@ -241,21 +367,17 @@ public:
     }
   }
   initDone = true;
-  }
+}
 
-  /**
-   * connected() is called every time the WiFi is (re)connected
-   * Use it to initialize network interfaces
-   */
-  void connected()
-  {
+void PIRsensorSwitch::onMqttConnect(bool sessionPresent)
+{
+  if (HomeAssistantDiscovery) {
+    publishHomeAssistantAutodiscovery();
   }
+}
 
-  /**
-   * loop() is called continuously. Here you can check for events, read sensors, etc.
-   */
-  void loop()
-  {
+void PIRsensorSwitch::loop()
+{
   // only check sensors 4x/s
   if (!enabled || millis() - lastLoop < 250 || strip.isUpdating()) return;
   lastLoop = millis();
@@ -263,15 +385,10 @@ public:
   if (!updatePIRsensorState()) {
     handleOffTimer();
   }
-  }
+}
 
-  /**
-   * 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)
-  {
+void PIRsensorSwitch::addToJsonInfo(JsonObject &root)
+{
   JsonObject user = root["u"];
   if (user.isNull()) user = root.createNestedObject("u");
 
@@ -328,25 +445,21 @@ public:
   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;
+  DEBUG_PRINT(F("PIR: offTimerStart=")); DEBUG_PRINTLN(offTimerStart);
+  if (m_override && PIRtriggered && offTimerStart) { // debounce
+    // checking PIRtriggered and offTimerStart will prevent cancellation upon On trigger
+    DEBUG_PRINTLN(F("PIR: Canceled."));
+    offTimerStart = 0;
+    PIRtriggered = false;
   }
+}
 
-  /**
-   * 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)
-  {
+void PIRsensorSwitch::readFromJsonState(JsonObject &root)
+{
   if (!initDone) return;  // prevent crash on boot applyPreset()
   JsonObject usermod = root[FPSTR(_name)];
   if (!usermod.isNull()) {
@@ -354,14 +467,10 @@ public:
       enabled = usermod[FPSTR(_enabled)].as<bool>();
     }
   }
-  }
+}
 
-
-  /**
-   * provide the changeable values
-   */
-  void addToConfig(JsonObject &root)
-  {
+void PIRsensorSwitch::addToConfig(JsonObject &root)
+{
   JsonObject top = root.createNestedObject(FPSTR(_name));
   top[FPSTR(_enabled)]        = enabled;
   top[FPSTR(_switchOffDelay)] = m_switchOffDelay / 1000;
@@ -371,18 +480,21 @@ public:
   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."));
-  }
+}
 
-  /**
-   * 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)
-  {
+void PIRsensorSwitch::appendConfigData()
+{
+  oappend(SET_F("addInfo('PIRsensorSwitch:HA-discovery',1,'HA=Home Assistant');"));     // 0 is field type, 1 is actual field
+  oappend(SET_F("addInfo('PIRsensorSwitch: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
+}
+
+bool PIRsensorSwitch::readFromConfig(JsonObject &root)
+{
   bool oldEnabled = enabled;
   int8_t oldPin = PIRsensorPin;
 
@@ -407,6 +519,8 @@ public:
   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;
 
@@ -435,26 +549,5 @@ public:
     DEBUG_PRINTLN(F(" config (re)loaded."));
   }
   // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-    return !top[FPSTR(_notify)].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";
-const char PIRsensorSwitch::_notify[]         PROGMEM = "notifications";
+  return !top[FPSTR(_override)].isNull();
+}

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 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 _tacho_ (RPM) output you can set the _tacho-pin_ to -1 to not use that feature.
+This usermod requires the Dallas Temperature usermod to obtain temperature information. If it's not available, the fan will 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.
 
-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%.
+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%.
 
-If the _tacho_ is supported the current speed (in RPM) will be repored in WLED Info page.
+If the _tachometer_ is supported, the current speed (in RPM) will be displayed on the WLED Info page.
 
 ## Installation
 
@@ -20,7 +20,7 @@ All of the parameters are configured during run-time using Usermods settings pag
 This includes:
 
 * PWM output pin (can be configured at compile time `-D PWM_PIN=xx`)
-* tacho input pin (can be configured at compile time `-D TACHO_PIN=xx`)
+* tachometer input pin (can be configured at compile time `-D TACHO_PIN=xx`)
 * sampling frequency in seconds
 * threshold temperature in degees C
 
@@ -32,10 +32,10 @@ No special requirements.
 
 ## Control PWM fan speed using JSON API
 
-You can use e.g. `{"PWM-fan":{"speed":30,"lock":true}}` to set fan speed to 30 percent of maximum speed (replace 30 with arbitrary value between 0 and 100) and lock the speed.
-If you include `speed` property you can set fan speed in percent (%) of maximum speed.
-If you include `lock` property you can lock (_true_) or unlock (_false_) fan speed.
-If the fan speed is unlocked it will revert to temperature controlled speed on next update cycle. Once fan speed is locked it will remain so until it is unlocked by next API call.
+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
 

usermods/PWM_fan/usermod_PWM_fan.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef USERMOD_DALLASTEMPERATURE
-#error The "PWM fan" usermod requires "Dallas Temeprature" usermod to function properly.
+#if !defined(USERMOD_DALLASTEMPERATURE) && !defined(USERMOD_SHT)
+#error The "PWM fan" usermod requires "Dallas Temeprature" or "SHT" usermod to function properly.
 #endif
 
 #include "wled.h"
@@ -42,14 +42,16 @@ class PWMFanUsermod : public Usermod {
 
     #ifdef USERMOD_DALLASTEMPERATURE
     UsermodTemperature* tempUM;
+    #elif defined(USERMOD_SHT)
+    ShtUsermod* tempUM;
     #endif
 
     // configurable parameters
     int8_t  tachoPin          = TACHO_PIN;
     int8_t  pwmPin            = PWM_PIN;
     uint8_t tachoUpdateSec    = 30;
-    float   targetTemperature = 25.0;
-    uint8_t minPWMValuePct    = 50;
+    float   targetTemperature = 35.0;
+    uint8_t minPWMValuePct    = 0;
     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;
 
@@ -145,7 +147,7 @@ class PWMFanUsermod : public Usermod {
     }
 
     float getActualTemperature(void) {
-      #ifdef USERMOD_DALLASTEMPERATURE
+      #if defined(USERMOD_DALLASTEMPERATURE) || defined(USERMOD_SHT)
       if (tempUM != nullptr)
         return tempUM->getTemperatureC();
       #endif
@@ -189,6 +191,8 @@ 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();

usermods/RTC/readme.md

@@ -1,6 +1,6 @@
 # DS1307/DS3231 Real time clock
 
-Gets the time from I2C RTC module on boot. This allows clocks to operate e.g. if temporarily no WiFi is available.
+Gets the time from I2C RTC module on boot. This allows clock operation if WiFi is not available.
 The stored time is updated each time NTP is synced. 
 
 ## Installation 

usermods/RTC/usermod_rtc.h

@@ -12,8 +12,7 @@ class RTCUsermod : public Usermod {
   public:
 
     void setup() {
-      PinManagerPinType pins[2] = { { i2c_scl, true }, { i2c_sda, true } };
-      if (!pinManager.allocateMultiplePins(pins, 2, PinOwner::HW_I2C)) { disabled = true; return; }
+      if (i2c_scl<0 || i2c_sda<0) { disabled = true; return; }
       RTC.begin();
       time_t rtcTime = RTC.get();
       if (rtcTime) {
@@ -25,8 +24,8 @@ class RTCUsermod : public Usermod {
     }
 
     void loop() {
-      if (strip.isUpdating()) return;
-      if (!disabled && toki.isTick()) {
+      if (disabled || strip.isUpdating()) return;
+      if (toki.isTick()) {
         time_t t = toki.second();
         if (t != RTC.get()) RTC.set(t); //set RTC to NTP/UI-provided value
       }

usermods/RelayBlinds/readme.md

@@ -1,8 +1,8 @@
 # RelayBlinds usermod
 
-This simple usermod toggles two relay pins momentarily (default for 500ms) when `userVar0` is set.  
-This can be used to e.g. "push" the buttons of a window blinds motor controller.
+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.  
-Also, a simple `presets.json` file is available, this makes the relay actions controllable via two presets to facilitate control e.g. via the default UI or Alexa.
+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.

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 sensor.
-The luminance is displayed both in the Info section of the web UI as well as published to the `/luminance` MQTT topic if enabled.
+This usermod will read from an attached photoresistor sensor like the KY-018.
+The luminance is displayed in both 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`                      - define this to have this user mod included wled00\usermods_list.cpp
-* `USERMOD_SN_PHOTORESISTOR_MEASUREMENT_INTERVAL` - the number of milliseconds between measurements, defaults to 60 seconds
-* `USERMOD_SN_PHOTORESISTOR_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 20 seconds
-* `USERMOD_SN_PHOTORESISTOR_REFERENCE_VOLTAGE`    - the voltage supplied to the sensor, defaults to 5v
-* `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`       - the resistor size, defaults to 10000.0 (10K hms)
-* `USERMOD_SN_PHOTORESISTOR_OFFSET_VALUE`         - the offset value to report on, defaults to 25
+* `USERMOD_SN_PHOTORESISTOR`                      - Enables this user mod. wled00\usermods_list.cpp
+* `USERMOD_SN_PHOTORESISTOR_MEASUREMENT_INTERVAL` - Number of milliseconds between measurements. Defaults to 60000 ms
+* `USERMOD_SN_PHOTORESISTOR_FIRST_MEASUREMENT_AT` - Number of milliseconds after boot to take first measurement. Defaults to 20000 ms
+* `USERMOD_SN_PHOTORESISTOR_REFERENCE_VOLTAGE`    - Voltage supplied to the sensor. Defaults to 5v
+* `USERMOD_SN_PHOTORESISTOR_ADC_PRECISION`        - ADC precision. Defaults to 10 bits
+* `USERMOD_SN_PHOTORESISTOR_RESISTOR_VALUE`       - Resistor size, defaults to 10000.0 (10K Ohms)
+* `USERMOD_SN_PHOTORESISTOR_OFFSET_VALUE`         - Offset value to report on. Defaults to 25
 
-All parameters can be configured at runtime using Usermods settings page.
+All parameters can be configured at runtime via the Usermods settings page.
 
 ## Project link
 

usermods/SN_Photoresistor/usermod_sn_photoresistor.h

@@ -109,6 +109,7 @@ public:
     {
       lastLDRValue = currentLDRValue;
 
+#ifndef WLED_DISABLE_MQTT
       if (WLED_MQTT_CONNECTED)
       {
         char subuf[45];
@@ -121,6 +122,7 @@ public:
         DEBUG_PRINTLN("Missing MQTT connection. Not publishing data");
       }
     }
+#endif
   }
 
   uint16_t getLastLDRValue()

usermods/ST7789_display/README.md

@@ -1,15 +1,15 @@
-# ST7789 TFT IPS Color display 240x240pxwith ESP32 boards
+# Using the ST7789 TFT IPS 240x240 pixel color display with ESP32 boards
 
-This usermod allow to use 240x240 display to display following:
+This usermod enables display of the following:
 
-* current date and time;
+* Current date and time;
 * Network SSID;
 * IP address;
 * WiFi signal strength;
 * Brightness;
-* Chosen effect;
-* Chosen palette;
-* effect speed and intensity;
+* Selected effect;
+* Selected palette;
+* Effect speed and intensity;
 * Estimated current in mA;
 
 ## Hardware
@@ -41,9 +41,9 @@ lib_deps =
 ...
 ```
 
-Also, while in the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
+In the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
 
-Add lines to section:
+Add the following lines to section:
 
 ```ini
 default_envs = esp32dev
@@ -64,14 +64,14 @@ build_flags = ${common.build_flags_esp32}
     ;-DCONFIG_SPIRAM_SUPPORT=1
 ```
 
-Save the `platformio.ini` file.  Once this is saved, the required library files should be automatically downloaded for modifications in a later step.
+Save the `platformio.ini` file.  Once 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.
+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.
 
-Edit `Setup_ST7789.h` file and uncomment nad changep GPIO pin numbers in lines containing `TFT_MOSI`, `TFT_SCLK`, `TFT_RST`, `TFT_DC`.
+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` by uncommentig the line containing `#include <User_Setups/Setup24_ST7789.h>` and commenting out line containing `#include <User_Setup.h>`.
+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>`.
 
-If your display includes backlight enable pin, #define TFT_BL with backlight enable GPIO number.
+If your display uses the backlight enable pin, add this definition: #define TFT_BL with backlight enable GPIO number.

usermods/ST7789_display/ST7789_display.h

@@ -17,12 +17,6 @@
     #ifndef TFT_HEIGHT
         #error Please define TFT_HEIGHT
     #endif
-    #ifndef TFT_MOSI
-        #error Please define TFT_MOSI
-    #endif
-    #ifndef TFT_SCLK
-        #error Please define TFT_SCLK
-    #endif
     #ifndef TFT_DC
         #error Please define TFT_DC
     #endif
@@ -140,8 +134,14 @@ class St7789DisplayUsermod : public Usermod {
      */
     void setup()
     {
-        PinManagerPinType pins[] = { { TFT_MOSI, true }, { TFT_MISO, false}, { TFT_SCLK, true }, { TFT_CS, true}, { TFT_DC, true}, { TFT_RST, true }, { TFT_BL, true } };
-        if (!pinManager.allocateMultiplePins(pins, 7, PinOwner::UM_FourLineDisplay)) { enabled = false; return; }
+        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.
@@ -365,9 +365,6 @@ class St7789DisplayUsermod : public Usermod {
     {
       JsonObject top = root.createNestedObject("ST7789");
       JsonArray pins = top.createNestedArray("pin");
-      pins.add(TFT_MOSI);
-      pins.add(TFT_MISO);
-      pins.add(TFT_SCLK);
       pins.add(TFT_CS);
       pins.add(TFT_DC);
       pins.add(TFT_RST);
@@ -376,6 +373,13 @@ class St7789DisplayUsermod : public Usermod {
     }
 
 
+    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)

usermods/Si7021_MQTT_HA/readme.md

@@ -2,14 +2,14 @@
 
 This usermod implements support for [Si7021 I²C temperature and humidity sensors](https://www.silabs.com/documents/public/data-sheets/Si7021-A20.pdf).
 
-The sensor data will *not* be shown on the WLED UI (so far) but published via MQTT to WLED's "build in" MQTT device topic. 
+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
 ```
 
-Additionally the following sensors can be published:
+The following sensors can also be published:
 
 ```
 heat_index: $mqttDeviceTopic/si7021_heat_index
@@ -17,7 +17,7 @@ dew_point: $mqttDeviceTopic/si7021_dew_point
 absolute_humidity: $mqttDeviceTopic/si7021_absolute_humidity
 ```
 
-Sensor data will be updated/send every 60 seconds.
+Sensor data will be updated/sent every 60 seconds.
 
 This usermod also supports Home Assistant Auto Discovery.
 

usermods/Si7021_MQTT_HA/usermod_si7021_mqtt_ha.h

@@ -1,3 +1,7 @@
+#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)
@@ -9,14 +13,6 @@
 
 Adafruit_Si7021 si7021;
 
-#ifdef ARDUINO_ARCH_ESP32 //ESP32 boards
-uint8_t SCL_PIN = 22;
-uint8_t SDA_PIN = 21;
-#else //ESP8266 boards
-uint8_t SCL_PIN = 5;
-uint8_t SDA_PIN = 4;
-#endif
-
 class Si7021_MQTT_HA : public Usermod
 {
   private:
@@ -180,7 +176,6 @@ class Si7021_MQTT_HA : public Usermod
     {
       if (enabled) {
         Serial.println("Si7021_MQTT_HA: Starting!");
-        Wire.begin(SDA_PIN, SCL_PIN);
         Serial.println("Si7021_MQTT_HA: Initializing sensors.. ");
         _initializeSensor();
       }

usermods/TTGO-T-Display/README.md

@@ -1,19 +1,19 @@
 # TTGO T-Display ESP32 with 240x135 TFT via SPI with TFT_eSPI
-This usermod allows use of the TTGO T-Display ESP32 module with integrated 240x135 display
+This usermod enables use of the TTGO 240x135 T-Display ESP32 module
 for controlling WLED and showing the following information: 
 * Current SSID
-* IP address if obtained
-  * If connected to a network, current brightness % is shown 
-  * in AP mode AP IP and password are shown
+* IP address, if obtained
+  * If connected to a network, current brightness percentage is shown 
+  * In AP mode, AP, IP and password are shown
 * Current effect
 * Current palette
-* 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)
+* Estimated current in mA (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 next to the side actuated reset button of the TTGO T-Display board.
+Button pin is mapped to the onboard button adjacent to the 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, 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.
+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.
 
-Usermod based on a rework of the ssd1306_i2c_oled_u8g2 usermod from the WLED repo.
+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 @@ Usermod based on a rework of the ssd1306_i2c_oled_u8g2 usermod from the WLED rep
 Functionality checked with:
 * TTGO T-Display
 * PlatformIO
-* 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 off the supply (in addition to dropping the 12v supply down to 5v with a buck regulator for the ESP module and level shifter).
+* Group of 4 individual Neopixels from Adafruit and 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).
 
 ## 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 =
 ...
 ```
 
-Also, while in the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
+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
-# Travis CI binaries (comment this out when building for single board)
-; default_envs = travis_esp8266, esp01, esp01_1m_ota, travis_esp32
+# Release binaries
+; default_envs = nodemcuv2, esp8266_2m, esp01_1m_full, esp32dev, esp32_eth, esp32s2_saola, esp32c3
 ```
-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 this is saved, the required library files should be automatically downloaded for modifications in a later step.
+Save the `platformio.ini` file.  Once 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)
-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.
+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.
 
 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
 ```
 
-Run the build and it should complete correctly.  If you see a failure like this:
+Build the file.  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
 ```
-Just try building again - I find that sometimes this happens on the first build attempt and subsequent attempts will build correctly.
+try building again. Sometimes this happens on the first build attempt and subsequent attempts build correctly.
 
 ## Arduino IDE
 - UNTESTED

usermods/Temperature/platformio_override.ini

@@ -1,13 +1,12 @@
 ; 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 -D USERMOD_DALLASTEMPERATURE_CELSIUS
+build_flags = ${common.build_flags_esp8266} -D USERMOD_DALLASTEMPERATURE
 lib_deps = ${env.lib_deps}
-    milesburton/DallasTemperature@^3.9.0
-    OneWire@~2.3.5
+  paulstoffregen/OneWire@~2.3.7
+# you may want to use following with ESP32
+;  https://github.com/blazoncek/OneWire.git # fixes Sensor error on ESP32

usermods/Temperature/readme.md

@@ -1,22 +1,24 @@
 # Temperature usermod
 
-Based on the excellent `QuinLED_Dig_Uno_Temp_MQTT` by srg74 and 400killer!  
-This usermod will read from an attached DS18B20 temperature sensor (as available on the QuinLED Dig-Uno)  
-The temperature is displayed both in the Info section of the web UI as well as published to the `/temperature` MQTT topic if enabled.  
-This usermod may be expanded with support for different sensor types in the future.
+Based on the excellent `QuinLED_Dig_Uno_Temp_MQTT` usermod by srg74 and 400killer!  
+Reads 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.  
+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`                      - define this to have this user mod included wled00\usermods_list.cpp
-* `USERMOD_DALLASTEMPERATURE_FIRST_MEASUREMENT_AT` - the number of milliseconds after boot to take first measurement, defaults to 20 seconds
+* `USERMOD_DALLASTEMPERATURE`                      - enables this user mod wled00/usermods_list.cpp
+* `USERMOD_DALLASTEMPERATURE_MEASUREMENT_INTERVAL` - number of milliseconds between measurements, defaults to 60000 ms (60s)
 
-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.
+All parameters can be configured at runtime via the Usermods settings page, including pin, temperature in degrees Celsius or Farenheit and measurement interval.
 
 ## Project link
 
@@ -27,7 +29,6 @@ All parameters can be configured at runtime using Usermods settings page, includ
 
 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
@@ -43,16 +44,20 @@ default_envs = d1_mini
 lib_deps =
   ...
   #For Dallas sensor uncomment following line
-  OneWire@~2.3.5
-...
+  OneWire@~2.3.7
+  # ... 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
-* Do not report low temperatures that indicate an error to mqtt
+* Changed to use async non-blocking implementation
+* Do not report erroneous low temperatures to MQTT
 * Disable plugin if temperature sensor not detected
 * Report the number of seconds until the first read in the info screen instead of sensor error
 2021-04
 * Adaptation for runtime configuration.
+2023-05
+* Rewrite to conform to newer recommendations.
+* Recommended @blazoncek fork of OneWire for ESP32 to avoid Sensor error

usermods/Temperature/usermod_temperature.h

@@ -29,6 +29,7 @@ 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
@@ -53,9 +54,50 @@ class UsermodTemperature : public Usermod {
     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();
+    void readTemperature();
+    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;
@@ -88,27 +130,29 @@ class UsermodTemperature : public Usermod {
   }
   for (byte i=1; i<9; i++) data[0] &= data[i];
   return data[0]==0xFF ? -127.0f : retVal;
-    }
+}
 
-    void requestTemperatures() {
+void UsermodTemperature::requestTemperatures() {
   DEBUG_PRINTLN(F("Requesting temperature."));
   oneWire->reset();
   oneWire->skip();                        // skip ROM
-      oneWire->write(0x44,parasite);          // request new temperature reading (TODO: parasite would need special handling)
+  oneWire->write(0x44,parasite);          // request new temperature reading
+  if (parasite && parasitePin >=0 ) digitalWrite(parasitePin, HIGH); // has to happen within 10us (open MOSFET)
   lastTemperaturesRequest = millis();
   waitingForConversion = true;
-    }
+}
 
-    void readTemperature() {
+void UsermodTemperature::readTemperature() {
+  if (parasite && parasitePin >=0 ) digitalWrite(parasitePin, LOW); // deactivate power (close MOSFET)
   temperature = readDallas();
   lastMeasurement = millis();
   waitingForConversion = false;
   //DEBUG_PRINTF("Read temperature %2.1f.\n", temperature); // does not work properly on 8266
   DEBUG_PRINT(F("Read temperature "));
   DEBUG_PRINTLN(temperature);
-    }
+}
 
-    bool findSensor() {
+bool UsermodTemperature::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
@@ -132,9 +176,10 @@ class UsermodTemperature : public Usermod {
   }
   DEBUG_PRINTLN(F("Sensor NOT found."));
   return false;
-    }
+}
 
-    void publishHomeAssistantAutodiscovery() {
+#ifndef WLED_DISABLE_MQTT
+void UsermodTemperature::publishHomeAssistantAutodiscovery() {
   if (!WLED_MQTT_CONNECTED) return;
 
   char json_str[1024], buf[128];
@@ -154,11 +199,10 @@ class UsermodTemperature : public Usermod {
   sprintf_P(buf, PSTR("homeassistant/sensor/%s/config"), escapedMac.c_str());
   mqtt->publish(buf, 0, true, json_str, payload_size);
   HApublished = true;
-    }
+}
+#endif
 
-  public:
-
-    void setup() {
+void UsermodTemperature::setup() {
   int retries = 10;
   sensorFound = 0;
   temperature = -127.0f; // default to -127, DS18B20 only goes down to -50C
@@ -173,6 +217,12 @@ class UsermodTemperature : public Usermod {
           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."));
@@ -182,9 +232,9 @@ class UsermodTemperature : public Usermod {
   }
   lastMeasurement = millis() - readingInterval + 10000;
   initDone = true;
-    }
+}
 
-    void loop() {
+void UsermodTemperature::loop() {
   if (!enabled || !sensorFound || strip.isUpdating()) return;
 
   static uint8_t errorCount = 0;
@@ -212,6 +262,7 @@ class UsermodTemperature : public Usermod {
     }
     errorCount = 0;
 
+#ifndef WLED_DISABLE_MQTT
     if (WLED_MQTT_CONNECTED) {
       char subuf[64];
       strcpy(subuf, mqttDeviceTopic);
@@ -227,42 +278,35 @@ class UsermodTemperature : public Usermod {
         // publish something else to indicate status?
       }
     }
+#endif
   }
-    }
+}
 
-    /**
+/**
  * connected() is called every time the WiFi is (re)connected
  * Use it to initialize network interfaces
  */
-    //void connected() {}
+//void UsermodTemperature::connected() {}
 
-    /**
+#ifndef WLED_DISABLE_MQTT
+/**
  * subscribe to MQTT topic if needed
  */
-    void onMqttConnect(bool sessionPresent) {
+void UsermodTemperature::onMqttConnect(bool sessionPresent) {
   //(re)subscribe to required topics
   //char subuf[64];
   if (mqttDeviceTopic[0] != 0) {
     publishHomeAssistantAutodiscovery();
   }
-    }
+}
+#endif
 
-    /*
-     * API calls te enable data exchange between WLED modules
-     */
-    inline float getTemperatureC() {
-      return (float)temperature;
-    }
-    inline float getTemperatureF() {
-      return (float)temperature * 1.8f + 32;
-    }
-
-    /*
+/*
   * 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) {
+void UsermodTemperature::addToJsonInfo(JsonObject& root) {
   // dont add temperature to info if we are disabled
   if (!enabled) return;
 
@@ -277,37 +321,37 @@ class UsermodTemperature : public Usermod {
     return;
   }
 
-      temp.add(degC ? getTemperatureC() : getTemperatureF());
-      temp.add(degC ? F("°C") : F("°F"));
+  temp.add(getTemperature());
+  temp.add(getTemperatureUnit());
 
   JsonObject sensor = root[F("sensor")];
   if (sensor.isNull()) sensor = root.createNestedObject(F("sensor"));
-      temp = sensor.createNestedArray(F("temp"));
-      temp.add(degC ? temperature : (float)temperature * 1.8f + 32);
-      temp.add(degC ? F("°C") : F("°F"));
-    }
+  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 addToJsonState(JsonObject &root)
-    //{
-    //}
+//void UsermodTemperature::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
  * Read "<usermodname>_<usermodparam>" from json state and and change settings (i.e. GPIO pin) used.
  */
-    //void readFromJsonState(JsonObject &root) {
-    //  if (!initDone) return;  // prevent crash on boot applyPreset()
-    //}
+//void UsermodTemperature::readFromJsonState(JsonObject &root) {
+//  if (!initDone) return;  // prevent crash on boot applyPreset()
+//}
 
-    /**
+/**
  * addToConfig() (called from set.cpp) stores persistent properties to cfg.json
  */
-    void addToConfig(JsonObject &root) {
+void UsermodTemperature::addToConfig(JsonObject &root) {
   // we add JSON object: {"Temperature": {"pin": 0, "degC": true}}
   JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
   top[FPSTR(_enabled)] = enabled;
@@ -315,15 +359,16 @@ class UsermodTemperature : public Usermod {
   top["degC"] = degC;  // usermodparam
   top[FPSTR(_readInterval)] = readingInterval / 1000;
   top[FPSTR(_parasite)] = parasite;
+  top[FPSTR(_parasitePin)] = parasitePin;
   DEBUG_PRINTLN(F("Temperature 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) {
+bool UsermodTemperature::readFromConfig(JsonObject &root) {
   // we look for JSON object: {"Temperature": {"pin": 0, "degC": true}}
   int8_t newTemperaturePin = temperaturePin;
   DEBUG_PRINT(FPSTR(_name));
@@ -340,6 +385,7 @@ class UsermodTemperature : public Usermod {
   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;
 
   if (!initDone) {
     // first run: reading from cfg.json
@@ -354,22 +400,33 @@ class UsermodTemperature : public Usermod {
       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(_parasite)].isNull();
-    }
+  return !top[FPSTR(_parasitePin)].isNull();
+}
 
-    uint16_t getId()
-    {
-      return USERMOD_ID_TEMPERATURE;
-    }
-};
+void UsermodTemperature::appendConfigData() {
+  oappend(SET_F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(SET_F(":")); oappend(String(FPSTR(_parasite)).c_str());
+  oappend(SET_F("',1,'<i>(if no Vcc connected)</i>');"));  // 0 is field type, 1 is actual field
+  oappend(SET_F("addInfo('")); oappend(String(FPSTR(_name)).c_str()); oappend(SET_F(":")); oappend(String(FPSTR(_parasitePin)).c_str());
+  oappend(SET_F("',1,'<i>(for external MOSFET)</i>');"));  // 0 is field type, 1 is actual field
+}
+
+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";

usermods/Temperature/usermods_list.cpp

@@ -1,31 +0,0 @@
-#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());
-}

usermods/VL53L0X_gestures/readme.md

@@ -1,17 +1,16 @@
 # Description
 
-That usermod implements support of simple hand gestures with VL53L0X sensor: on/off and brightness correction.
-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).
-                           "macroLongPress" is also called here.
+Implements support of simple hand gestures via a VL53L0X sensor: on/off and brightness adjustment.
+Useful for controlling strips when you want to avoid touching anything.
+ - on/off - swipe your hand below the sensor ("shortPressAction" is called. Can be customized via WLED macros)
+ - brightness adjustment - hold your hand below the 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).
    
 ## 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 = ${common.build_flags_esp8266} -D RLYPIN=12 -D USERMOD_VL53L0X_GESTURES`
+In my case, for example: `build_flags = ${env.build_flags} -D USERMOD_VL53L0X_GESTURES`
 3. Add "pololu/VL53L0X" dependency below to `lib_deps` like this:
 ```ini
 lib_deps = ${env.lib_deps}
@@ -21,15 +20,10 @@ lib_deps = ${env.lib_deps}
 My entire `platformio_override.ini` for example (for nodemcu board):
 ```ini
 [platformio]
-default_envs = nodemcu
+default_envs = nodemcuv2
 
-[env:nodemcu]
-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
+[env:nodemcuv2]
+build_flags = ${env.build_flags} -D USERMOD_VL53L0X_GESTURES
 lib_deps = ${env.lib_deps}
            pololu/VL53L0X @ ^1.3.0
 ```

usermods/VL53L0X_gestures/usermod_vl53l0x_gestures.h

@@ -3,14 +3,13 @@
  * 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).
- *                           "macroLongPress" is also called here.
+        Configure brightness by changing distance to the sensor (see parameters below for customization).
  *
- * Enabling this mod usermod:
+ * Enabling this 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.
- * In my case, for example: build_flags = ${common.build_flags_esp8266} -D RLYPIN=12 -D USERMOD_VL53L0X_GESTURES
- * 3. Add "pololu/VL53L0X" dependency to lib_deps like this:
+ * 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`
+ * 3. Add "pololu/VL53L0X" dependency below to `lib_deps` like this:
  * lib_deps = ${env.lib_deps}
  *     pololu/VL53L0X @ ^1.3.0
  */
@@ -22,11 +21,11 @@
 #include <VL53L0X.h>
 
 #ifndef VL53L0X_MAX_RANGE_MM
-#define VL53L0X_MAX_RANGE_MM 230 // max height in millimiters to react for motions
+#define VL53L0X_MAX_RANGE_MM 230 // max height in millimeters to react for motions
 #endif
 
 #ifndef VL53L0X_MIN_RANGE_OFFSET
-#define VL53L0X_MIN_RANGE_OFFSET 60 // minimal range in millimiters that sensor can detect. Used in long motions to correct brightnes calculation.
+#define VL53L0X_MIN_RANGE_OFFSET 60 // minimal range in millimeters that sensor can detect. Used in long motions to correct brightness calculation.
 #endif
 
 #ifndef VL53L0X_DELAY_MS
@@ -34,7 +33,7 @@
 #endif
 
 #ifndef VL53L0X_LONG_MOTION_DELAY_MS
-#define VL53L0X_LONG_MOTION_DELAY_MS 1000 // how often to get data from sensor 
+#define VL53L0X_LONG_MOTION_DELAY_MS 1000 // switch onto "long motion" action after this delay
 #endif
 
 class UsermodVL53L0XGestures : public Usermod {
@@ -51,9 +50,7 @@ class UsermodVL53L0XGestures : public Usermod {
   public:
 
     void setup() {
-      PinManagerPinType pins[2] = { { i2c_scl, true }, { i2c_sda, true } };
-      if (!pinManager.allocateMultiplePins(pins, 2, PinOwner::HW_I2C)) { enabled = false; return; }
-      Wire.begin();
+      if (i2c_scl<0 || i2c_sda<0) { enabled = false; return; }
 
       sensor.setTimeout(150);
       if (!sensor.init())
@@ -72,40 +69,34 @@ class UsermodVL53L0XGestures : public Usermod {
         lastTime = millis();
 
         int range = sensor.readRangeSingleMillimeters();
-        DEBUG_PRINTF(F("range: %d, brightness: %d"), range, bri);
+        DEBUG_PRINTF("range: %d, brightness: %d\r\n", range, bri);
 
         if (range < VL53L0X_MAX_RANGE_MM)
         {
           if (!wasMotionBefore)
           {
             motionStartTime = millis();
-            DEBUG_PRINTF(F("motionStartTime: %d"), motionStartTime);
+            DEBUG_PRINTF("motionStartTime: %d\r\n", motionStartTime);
           }
           wasMotionBefore = true;
 
           if (millis() - motionStartTime > VL53L0X_LONG_MOTION_DELAY_MS) //long motion
           {
-            DEBUG_PRINTF(F("long motion: %d"), motionStartTime);
+            DEBUG_PRINTF("long motion: %d\r\n", 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(F("new brightness: %d"), bri);
+            DEBUG_PRINTF("new brightness: %d", bri);
             stateUpdated(1);
           }
         } else if (wasMotionBefore) { //released
-          long dur = millis() - motionStartTime;
-
           if (!isLongMotion)
           { //short press
-            DEBUG_PRINTF(F("shortPressAction..."));
+            DEBUG_PRINTLN(F("shortPressAction..."));
             shortPressAction();
           }
           wasMotionBefore = false;

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 saving display lifetime
+-   Auto display shutoff for extending display lifetime
 -   Dallas temperature sensor
 -   Reporting temperature to MQTT broker
--   Relay for energy saving
+-   Relay for saving energy
 
 ## Hardware
 ![Shield](https://github.com/srg74/WLED-wemos-shield/blob/master/resources/Images/Assembly_8.jpg)

usermods/Wemos_D1_mini+Wemos32_mini_shield/usermod.cpp

@@ -101,6 +101,7 @@ 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)
     {
@@ -116,6 +117,7 @@ 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.

usermods/Wemos_D1_mini+Wemos32_mini_shield/usermod_bme280.cpp

@@ -103,6 +103,7 @@ void userLoop() {
   {
     lastMeasure = tempTimer;    
 
+#ifndef WLED_DISABLE_MQTT
 // Check if MQTT Connected, otherwise it will crash the 8266
     if (mqtt != nullptr)
     {
@@ -122,6 +123,7 @@ 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.

usermods/audioreactive/audio_source.h

@@ -1,6 +1,5 @@
 #pragma once
-
-#include <Wire.h>
+#ifdef ARDUINO_ARCH_ESP32
 #include "wled.h"
 #include <driver/i2s.h>
 #include <driver/adc.h>
@@ -23,11 +22,15 @@
 
 // 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_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32H2)
+#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
-  #warning This audio reactive usermod does not support ESP32-C2, ESP32-C3 or ESP32-S2.
+  #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
@@ -68,7 +71,7 @@
  * 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, 3))
+#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)
@@ -76,11 +79,15 @@
 #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
@@ -92,6 +99,9 @@
 #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
 
 
@@ -112,7 +122,7 @@ class AudioSource {
        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, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE) = 0;
+    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
@@ -138,15 +148,17 @@ class AudioSource {
     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) :
+    AudioSource(SRate_t sampleRate, int blockSize, float sampleScale) :
       _sampleRate(sampleRate),
       _blockSize(blockSize),
-      _initialized(false)
+      _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
@@ -154,8 +166,8 @@ class AudioSource {
 */
 class I2SSource : public AudioSource {
   public:
-    I2SSource(SRate_t sampleRate, int blockSize) :
-      AudioSource(sampleRate, blockSize) {
+    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,
@@ -179,7 +191,8 @@ class I2SSource : public AudioSource {
       };
     }
 
-    virtual void initialize(int8_t i2swsPin = I2S_PIN_NO_CHANGE, int8_t i2ssdPin = I2S_PIN_NO_CHANGE, int8_t i2sckPin = I2S_PIN_NO_CHANGE, int8_t mclkPin = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE) {
+    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
@@ -195,18 +208,51 @@ class I2SSource : public AudioSource {
           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
+        // 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)) return;
+        if(!pinManager.allocatePin(mclkPin, true, PinOwner::UM_Audioreactive)) { 
+          DEBUGSR_PRINTF("\nAR: Failed to allocate I2S pin: MCLK=%d\n",  mclkPin); 
+          return;
+        } else
         _routeMclk(mclkPin);
       }
 
@@ -220,15 +266,25 @@ class I2SSource : public AudioSource {
         .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("Failed to install i2s driver: %d\n", err);
+        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("Failed to set i2s pin config: %d\n", err);
+        DEBUGSR_PRINTF("AR: Failed to set i2s pin config: %d\n", err);
         i2s_driver_uninstall(I2S_NUM_0);  // uninstall already-installed driver
         return;
       }
@@ -236,7 +292,7 @@ class I2SSource : public AudioSource {
 #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("Failed to configure i2s clocks: %d\n", err);
+        DEBUGSR_PRINTF("AR: Failed to configure i2s clocks: %d\n", err);
         i2s_driver_uninstall(I2S_NUM_0);  // uninstall already-installed driver
         return;
       }
@@ -288,6 +344,7 @@ class I2SSource : public AudioSource {
               currSample = (float) newSamples[i];                 // 16bit input -> use as-is
 #endif
           buffer[i] = currSample;
+          buffer[i] *= _sampleScale;                              // scale samples
         }
       }
     }
@@ -326,24 +383,21 @@ class I2SSource : public AudioSource {
 */
 class ES7243 : public I2SSource {
   private:
-    // I2C initialization functions for ES7243
-    void _es7243I2cBegin() {
-      Wire.begin(pin_ES7243_SDA, pin_ES7243_SCL, 100000U);
-    }
 
     void _es7243I2cWrite(uint8_t reg, uint8_t val) {
-#ifndef ES7243_ADDR
-      Wire.beginTransmission(0x13);
-#else
+      #ifndef ES7243_ADDR
+        #define ES7243_ADDR 0x13   // default address
+      #endif
       Wire.beginTransmission(ES7243_ADDR);
-#endif
       Wire.write((uint8_t)reg);
       Wire.write((uint8_t)val);
-      Wire.endTransmission();
+      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() {
-      _es7243I2cBegin();
       _es7243I2cWrite(0x00, 0x01);
       _es7243I2cWrite(0x06, 0x00);
       _es7243I2cWrite(0x05, 0x1B);
@@ -353,38 +407,151 @@ class ES7243 : public I2SSource {
     }
 
 public:
-    ES7243(SRate_t sampleRate, int blockSize) :
-      I2SSource(sampleRate, blockSize) {
+    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 sdaPin, int8_t sclPin, int8_t i2swsPin, int8_t i2ssdPin, int8_t i2sckPin, int8_t mclkPin) {
-      // Reserve SDA and SCL pins of the I2C interface
-      if (!pinManager.allocatePin(sdaPin, true, PinOwner::HW_I2C) ||
-          !pinManager.allocatePin(sclPin, true, PinOwner::HW_I2C)) {
+    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;
       }
 
-      pin_ES7243_SDA = sdaPin;
-      pin_ES7243_SCL = sclPin;
-
       // First route mclk, then configure ADC over I2C, then configure I2S
       _es7243InitAdc();
       I2SSource::initialize(i2swsPin, i2ssdPin, i2sckPin, mclkPin);
     }
 
     void deinitialize() {
-      // Release SDA and SCL pins of the I2C interface
-      pinManager.deallocatePin(pin_ES7243_SDA, PinOwner::HW_I2C);
-      pinManager.deallocatePin(pin_ES7243_SCL, PinOwner::HW_I2C);
+      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();
     }
 
-  private:
-    int8_t pin_ES7243_SDA;
-    int8_t pin_ES7243_SCL;
 };
 
+#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
 
@@ -395,8 +562,8 @@ public:
 */
 class I2SAdcSource : public I2SSource {
   public:
-    I2SAdcSource(SRate_t sampleRate, int blockSize) :
-      I2SSource(sampleRate, blockSize) {
+    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,
@@ -419,7 +586,8 @@ class I2SAdcSource : public I2SSource {
     /* 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, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE) {
+    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);
@@ -430,7 +598,7 @@ class I2SAdcSource : public I2SSource {
       // Determine Analog channel. Only Channels on ADC1 are supported
       int8_t channel = digitalPinToAnalogChannel(_audioPin);
       if (channel > 9) {
-        DEBUGSR_PRINTF("Incompatible GPIO used for audio in: %d\n", _audioPin);
+        DEBUGSR_PRINTF("Incompatible GPIO used for analog audio input: %d\n", _audioPin);
         return;
       } else {
         adc_gpio_init(ADC_UNIT_1, adc_channel_t(channel));
@@ -465,11 +633,12 @@ class I2SAdcSource : public I2SSource {
             //return;
         }
       #else
-        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);
-        }
+        // 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;
@@ -585,11 +754,12 @@ class I2SAdcSource : public I2SSource {
 // 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) :
-      I2SSource(sampleRate, blockSize)
+    SPH0654(SRate_t sampleRate, int blockSize, float sampleScale = 1.0f) :
+      I2SSource(sampleRate, blockSize, sampleScale)
     {}
 
-    void initialize(uint8_t i2swsPin, uint8_t i2ssdPin, uint8_t i2sckPin, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE, int8_t = I2S_PIN_NO_CHANGE) {
+    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
@@ -600,3 +770,4 @@ class SPH0654 : public I2SSource {
 #endif
     }
 };
+#endif

usermods/audioreactive/readme.md

@@ -1,36 +1,73 @@
 # Audioreactive usermod
 
-This usermod allows controlling LEDs using audio input. Audio input can be either microphone or analog-in (AUX) using appropriate adapter.
+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, ...).
 
-The usermod does audio processing and provides data structure that specially written effect can use.
+Does audio processing and provides data structure that specially written effects can use.
 
-The usermod **does not** provide effects or draws anything to LED strip/matrix.
+**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 
 
-Add `-D USERMOD_AUDIOREACTIVE` to your PlatformIO environment as well as `arduinoFFT` to your `lib_deps`.
+### 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 though some may require hard boot after change (I2S microphone or selected GPIOs).
+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):
+If you want to define default GPIOs during compile time, use the following (default values in parentheses):
 
-- `DMTYPE=x` : defines digital microphone type: 0=analog, 1=generic I2S, 2=ES7243 I2S, 3=SPH0645 I2S, 4=generic I2S with master clock, 5=PDM I2S
-- `AUDIOPIN=x` : GPIO for analog microphone/AUX-in (36)
-- `I2S_SDPIN=x` : GPIO for SD pin on digital mcrophone (32)
-- `I2S_WSPIN=x` : GPIO for WS pin on digital mcrophone (15)
-- `I2S_CKPIN=x` : GPIO for SCK pin on digital mcrophone (14)
-- `ES7243_SDAPIN` : GPIO for I2C SDA pin on ES7243 microphone (-1)
-- `ES7243_SCLPIN` : GPIO for I2C SCL pin on ES7243 microphone (-1)
-- `MCLK_PIN=x` : GPIO for master clock pin on digital mcrophone (-1)
+- `-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** Due to the fact that usermod uses I2S peripherial for analog audio sampling, use of analog *buttons* (i.e. potentiometers) is disabled while running this usermod with analog microphone.
+**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](https://github.com/atuline/WLED) by @blazoncek (AKA Blaz Kristan)
+* 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öhle).

usermods/battery_status_basic/readme.md

@@ -1,69 +0,0 @@
-# :battery: Battery status/level Usermod :battery:
-
-This Usermod allows you to monitor the battery level of your battery powered project.
-
-You can see the battery level and voltage in the `info modal`. 
-
-For this to work the positive side of the (18650) battery must be connected to pin `A0` of the d1mini/esp8266 with a 100k ohm resistor (see [Useful Links](#useful-links)).
-
-If you have a esp32 board it is best to connect the positive side of the battery to ADC1 (GPIO32 - GPIO39)
-
-<p align="center">
-  <img width="300" src="assets/battery_info_screen.png">
-</p>
-
-## Installation
-
-define `USERMOD_BATTERY_STATUS_BASIC` in `my_config.h`
-
-### Basic wiring diagram
-<p align="center">
-  <img width="300" src="assets/battery_connection_schematic_01.png">
-</p>
-
-### Define Your Options
-
-* `USERMOD_BATTERY_STATUS_BASIC`                   - define this (in `my_config.h`) to have this user mod included wled00\usermods_list.cpp
-* `USERMOD_BATTERY_MEASUREMENT_PIN`                - defaults to A0 on esp8266 and GPIO32 on esp32
-* `USERMOD_BATTERY_MEASUREMENT_INTERVAL`           - the frequency to check the battery, defaults to 30 seconds
-* `USERMOD_BATTERY_MIN_VOLTAGE`                    - minimum voltage of the Battery used, default is 2.6 (18650 battery standard)
-* `USERMOD_BATTERY_MAX_VOLTAGE`                    - maximum voltage of the Battery used, default is 4.2 (18650 battery standard)
-
-All parameters can be configured at runtime using Usermods settings page.
-
-## Important :warning:
-* Make sure you know your battery specification ! not every battery is 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
-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
-

usermods/battery_status_basic/usermod_v2_battery_status_basic.h

@@ -1,398 +0,0 @@
-#pragma once
-
-#include "wled.h"
-
-
-
-
-// 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 32
-  #else //ESP8266 boards
-    #define USERMOD_BATTERY_MEASUREMENT_PIN A0
-  #endif
-#endif
-
-// esp32 has a 12bit adc resolution
-// esp8266 only 10bit
-#ifndef USERMOD_BATTERY_ADC_PRECISION
-  #ifdef ARDUINO_ARCH_ESP32
-    // 12 bits
-    #define USERMOD_BATTERY_ADC_PRECISION 4095.0f
-  #else
-    // 10 bits
-    #define USERMOD_BATTERY_ADC_PRECISION 1024.0f
-  #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
-  #define USERMOD_BATTERY_MIN_VOLTAGE 2.6f
-#endif
-
-#ifndef USERMOD_BATTERY_MAX_VOLTAGE
-  #define USERMOD_BATTERY_MAX_VOLTAGE 4.2f
-#endif
-
-class UsermodBatteryBasic : 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;
-    // 0 - 1024 for esp8266 (10-bit resolution)
-    // 0 - 4095 for esp32 (Default is 12-bit resolution)
-    float adcPrecision = USERMOD_BATTERY_ADC_PRECISION;
-    // raw analog reading 
-    float rawValue = 0.0;
-    // calculated voltage            
-    float voltage = 0.0;
-    // mapped battery level based on voltage
-    long batteryLevel = 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[];
-    
-
-    // 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 truncate(float val, byte dec) 
-    {
-      float x = val * pow(10, dec);
-      float y = round(x);
-      float z = x - y;
-      if ((int)z == 5)
-      {
-          y++;
-      }
-      x = y / pow(10, dec);
-      return x;
-    }
-
-
-
-  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
-        DEBUG_PRINTLN(F("Allocating battery pin..."));
-        if (batteryPin >= 0 && pinManager.allocatePin(batteryPin, false)) 
-        {
-          DEBUG_PRINTLN(F("Battery pin allocation succeeded."));
-        } else {
-          if (batteryPin >= 0) DEBUG_PRINTLN(F("Battery pin allocation failed."));
-          batteryPin = -1;  // allocation failed
-        }
-      #else //ESP8266 boards have only one analog input pin A0
-
-        pinMode(batteryPin, INPUT);
-      #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;
-
-      // check the battery level every USERMOD_BATTERY_MEASUREMENT_INTERVAL (ms)
-      if (millis() < nextReadTime) return;
-
-
-      nextReadTime = millis() + readingInterval;
-      lastReadTime = millis();
-      initializing = false;
-
-      // read battery raw input
-      rawValue = analogRead(batteryPin);
-
-      // calculate the voltage     
-      voltage = (rawValue / adcPrecision) * maxBatteryVoltage ;
-      // check if voltage is within specified voltage range
-      voltage = voltage<minBatteryVoltage||voltage>maxBatteryVoltage?-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
-      */
-      batteryLevel = mapf(voltage, minBatteryVoltage, maxBatteryVoltage, 0, 100);
-
-
-      // SmartHome stuff
-      if (WLED_MQTT_CONNECTED) {
-        char subuf[64];
-        strcpy(subuf, mqttDeviceTopic);
-        strcat_P(subuf, PSTR("/voltage"));
-        mqtt->publish(subuf, 0, false, String(voltage).c_str());
-      }
-
-    }
-
-
-    /*
-     * 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");
-
-      // info modal display names
-      JsonArray batteryPercentage = user.createNestedArray("Battery level");
-      JsonArray batteryVoltage = user.createNestedArray("Battery voltage");
-
-      if (initializing) {
-        batteryPercentage.add((nextReadTime - millis()) / 1000);
-        batteryPercentage.add(" sec");
-        batteryVoltage.add((nextReadTime - millis()) / 1000);
-        batteryVoltage.add(" sec");
-        return;
-      }
-
-      if(batteryLevel < 0) {
-        batteryPercentage.add(F("invalid"));
-      } else {
-        batteryPercentage.add(batteryLevel);
-      }
-      batteryPercentage.add(F(" %"));
-
-      if(voltage < 0) {
-        batteryVoltage.add(F("invalid"));
-      } else {
-        batteryVoltage.add(truncate(voltage, 2));
-      }
-      batteryVoltage.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)
-    {
-      // created JSON object: 
-      /*
-      {
-        "Battery-Level": {
-          "pin": "A0",              <--- only when using esp32 boards
-          "minBatteryVoltage": 2.6, 
-          "maxBatteryVoltage": 4.2,
-          "read-interval-ms": 30000  
-        }
-      }
-      */ 
-      JsonObject battery = root.createNestedObject(FPSTR(_name)); // usermodname
-      #ifdef ARDUINO_ARCH_ESP32
-        battery["pin"] = batteryPin;                              // usermodparam
-      #endif
-      battery["minBatteryVoltage"] = minBatteryVoltage;           // usermodparam
-      battery["maxBatteryVoltage"] = maxBatteryVoltage;           // usermodparam
-      battery[FPSTR(_readInterval)] = readingInterval;
-
-      DEBUG_PRINTLN(F("Battery config saved."));
-    }
-
-
-    /*
-     * 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)
-    {
-      // looking for JSON object: 
-      /*
-      {
-        "BatteryLevel": {
-          "pin": "A0",              <--- only when using esp32 boards
-          "minBatteryVoltage": 2.6, 
-          "maxBatteryVoltage": 4.2,
-          "read-interval-ms": 30000  
-        }
-      }
-      */
-      #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["pin"] | newBatteryPin;
-      #endif
-      minBatteryVoltage   = battery["minBatteryVoltage"] | minBatteryVoltage;
-      //minBatteryVoltage = min(12.0f, (int)readingInterval);
-      maxBatteryVoltage   = battery["maxBatteryVoltage"] | maxBatteryVoltage;
-      //maxBatteryVoltage = min(14.4f, max(3.3f,(int)readingInterval));
-      readingInterval     = battery["read-interval-ms"] | readingInterval;
-      readingInterval     = max(3000, (int)readingInterval); // minimum repetition is >5000ms (5s)
-
-      DEBUG_PRINT(FPSTR(_name));
-
-      #ifdef ARDUINO_ARCH_ESP32
-        if (!initDone) 
-        {
-          // first run: reading from cfg.json
-          newBatteryPin = batteryPin;
-          DEBUG_PRINTLN(F(" config loaded."));
-        } 
-        else 
-        {
-          DEBUG_PRINTLN(F(" config (re)loaded."));
-
-          // changing paramters from settings page
-          if (newBatteryPin != batteryPin) 
-          {
-            // deallocate pin
-            pinManager.deallocatePin(batteryPin);
-            batteryPin = newBatteryPin;
-            // initialise
-            setup();
-          }
-        }
-      #endif
-
-      return !battery[FPSTR(_readInterval)].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_BATTERY_STATUS_BASIC;
-    }
-};
-
-// strings to reduce flash memory usage (used more than twice)
-const char UsermodBatteryBasic::_name[]         PROGMEM = "Battery-level";
-const char UsermodBatteryBasic::_readInterval[] PROGMEM = "read-interval-ms";

usermods/blynk_relay_control/README.md

@@ -1,28 +0,0 @@
-# Blynk controllable relay
-This usermod allows controlling a relay state from the user variables. It also allows the user variables to be set over Blynk.
-
-Optionally, the servo can have a reset timer to go back to it's default state after an interval. This interval is set through userVar1.
-
-## Instalation
-
-Replace the WLED06_usermod.ino file in Aircoookies WLED folder with the one here.
-
-## Customizations
-
-Update the following parameters in WLED06_usermod.ino to configure the mod's behavior:
-
-```cpp
-//Which pin is the relay connected to
-#define RELAY_PIN 5
-//Which pin state should the relay default to
-#define RELAY_PIN_DEFAULT LOW
-//If >0 The controller returns to RELAY_PIN_DEFAULT after this time in milliseconds
-#define RELAY_PIN_TIMER_DEFAULT 3000
-
-//Blynk virtual pin for controlling relay
-#define BLYNK_USER_VAR0_PIN V9
-//Blynk virtual pin for controlling relay timer
-#define BLYNK_USER_VAR1_PIN V10
-//Number of milliseconds between updating blynk
-#define BLYNK_RELAY_UPDATE_INTERVAL 5000
-```

usermods/blynk_relay_control/wled06_usermod.ino

@@ -1,96 +0,0 @@
-/*
- * This 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 wled_eeprom.h)
- * bytes 2400+ are currently ununsed, but might be used for future wled features
- */
-
-//Use userVar0 (API calls &U0=, uint16_t) to set relay state
-#define relayPinState userVar0
-//Use userVar1 (API calls &U1=, uint16_t) to set relay timer duration
-//Ignored if 0, otherwise number of milliseconds to allow relay to stay in
-//non default state.
-#define relayTimerInterval userVar1
-
-//Which pin is the relay connected to
-#define RELAY_PIN 5
-//Which pin state should the relay default to
-#define RELAY_PIN_DEFAULT LOW
-//If >0 The controller returns to RELAY_PIN_DEFAULT after this time in milliseconds
-#define RELAY_PIN_TIMER_DEFAULT 3000
-
-//Blynk virtual pin for controlling relay
-#define BLYNK_USER_VAR0_PIN V9
-//Blynk virtual pin for controlling relay timer
-#define BLYNK_USER_VAR1_PIN V10
-//Number of milliseconds between updating blynk
-#define BLYNK_RELAY_UPDATE_INTERVAL 5000
-
-//Is the timer for resetting the relay active
-bool relayTimerStarted = false;
-//millis() time after which relay will be reset
-unsigned long relayTimeToDefault = 0;
-//millis() time after which relay vars in Blynk will be sent
-unsigned long relayBlynkUpdateTime = 0;
-
-//gets called once at boot. Do all initialization that doesn't depend on network here
-void userSetup()
-{
-  relayPinState = RELAY_PIN_DEFAULT;
-  relayTimerInterval = RELAY_PIN_TIMER_DEFAULT;
-  pinMode(RELAY_PIN, OUTPUT);
-  digitalWrite(RELAY_PIN, relayPinState);
-}
-
-//gets called every time WiFi is (re-)connected. Initialize own network interfaces here
-void userConnected()
-{
-}
-
-//loop. You can use "if (WLED_CONNECTED)" to check for successful connection
-void userLoop()
-{
-  //Normalize relayPinState to an accepted value
-  if (relayPinState != HIGH && relayPinState != LOW) {
-    relayPinState = RELAY_PIN_DEFAULT;
-  }
-  //If relay changes and relayTimerInterval is set, start a timer to change back
-  if (relayTimerInterval != 0 &&
-      relayPinState != RELAY_PIN_DEFAULT &&
-      !relayTimerStarted ) {
-    relayTimerStarted = true;
-    relayTimeToDefault = millis() + relayTimerInterval;
-  }
-  //If manually changed back to default, cancel timer
-  if (relayTimerStarted && relayPinState == RELAY_PIN_DEFAULT ) {
-    relayTimerStarted = false;
-  }
-  //If timer completes, set relay back to default
-  if (relayTimerStarted && millis() > relayTimeToDefault) {
-    relayPinState = RELAY_PIN_DEFAULT;
-    relayTimerStarted = false;
-  }
-  digitalWrite(RELAY_PIN, relayPinState);
-  updateRelayBlynk();
-}
-
-//Update Blynk with state of userVars at BLYNK_RELAY_UPDATE_INTERVAL
-void updateRelayBlynk()
-{
-  if (!WLED_CONNECTED) return;
-  if (relayBlynkUpdateTime > millis()) return;
-  Blynk.virtualWrite(BLYNK_USER_VAR0_PIN, userVar0);
-  Blynk.virtualWrite(BLYNK_USER_VAR1_PIN, userVar1);
-  relayBlynkUpdateTime = millis() + BLYNK_RELAY_UPDATE_INTERVAL;
-}
-
-//Add Blynk callback for setting userVar0
-BLYNK_WRITE(BLYNK_USER_VAR0_PIN)
-{
-  userVar0 = param.asInt();
-}
-//Add Blynk callback for setting userVar1
-BLYNK_WRITE(BLYNK_USER_VAR1_PIN)
-{
-  userVar1 = param.asInt();
-}

usermods/boblight/boblight.h

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

usermods/boblight/readme.md

@@ -0,0 +1,37 @@
+# BobLight usermod
+
+This usermod allows displaying BobLight ambilight protocol on WLED device with a limited command set (not a full implementation).
+BobLight protocol uses a TCP connection which guarantees packet delivery at the possible expense of latency delays. It is not very efficient (as it uses plaintext comands) so is not suited for large number of LEDs.
+
+This implementation is intended for TV backlight in combination with XBMC/Kodi BobLight add-on.
+
+The LEDs can be configured in usermod settings page. The configuration is simple: you enter the number of LED pixels on each side of your TV (top, right, bottom, left).
+The LEDs should be wired in a clockwise orientation starting in the middle of bottom side (left half of bottom leds is where the string should start).
+
+```
++-------->-------+
+|                |
+^                v
+|                |
++---<--+  ---<---+
+       ^
+     start
+```
+
+## Installation 
+
+Add `-D USERMOD_BOBLIGHT` to your PlatformIO environment.
+If you are not using PlatformIO (which you should) try adding `#define USERMOD_BOBLIGHT` to *my_config.h*.
+
+## Configuration
+
+All parameters are runtime configurable though changing port may require reboot.
+
+If you want to define default port during compile time use the following (default values in parentheses):
+
+- `BOB_PORT=x` : defines default TCP port for usermod to listen on (19333)
+
+
+## Release notes
+
+2022-11 Initial implementation by @blazoncek (AKA Blaz Kristan)

usermods/mpu6050_imu/readme.md

@@ -1,13 +1,13 @@
 # MPU-6050 Six-Axis (Gyro + Accelerometer) Driver
 
-This usermod-v2 modification allows the connection of a MPU-6050 IMU sensor to
-allow for effects that are controlled by the orientation or motion of the WLED Device.
+v2 of this usermod enables connection of a MPU-6050 IMU sensor to
+work with effects controlled by the orientation or motion of the WLED Device.
 
-The MPU6050 has a built in "Digital Motion Processor" which does a lot of the heavy
-lifting in integrating the gyro and accel measurements to get potentially more
+The MPU6050 has a built in "Digital Motion Processor" which does the "heavy lifting"
+integrating the gyro and accelerometer measurements to get potentially more
 useful gravity vector and orientation output.
 
-It is pretty straightforward to comment out some of the variables being read off the device if they're not needed to save CPU/Mem/Bandwidth.
+It is fairly straightforward to comment out variables being read from the device if they're not needed. Saves CPU/Memory/Bandwidth.
 
 _Story:_
 
@@ -36,7 +36,7 @@ lib_deps =
     AsyncTCP@1.0.3
     Esp Async WebServer@1.2.0
     IRremoteESP8266@2.7.3
-    I2Cdevlib-MPU6050@fbde122cc5
+    jrowberg/I2Cdevlib-MPU6050@^1.0.0
 ```
 
 ## Wiring
@@ -78,7 +78,7 @@ to the info object
 ## Usermod installation
 
 1. Copy the file `usermod_mpu6050_imu.h` to the `wled00` directory.
-2. Register the usermod by adding `#include "usermod_mpu6050_imu.h.h"` in the top and `registerUsermod(new MPU6050Driver());` in the bottom of `usermods_list.cpp`.
+2. Register the usermod by adding `#include "usermod_mpu6050_imu.h"` in the top and `registerUsermod(new MPU6050Driver());` in the bottom of `usermods_list.cpp`.
 
 Example **usermods_list.cpp**:
 

usermods/mpu6050_imu/usermod_mpu6050_imu.h

@@ -85,12 +85,9 @@ class MPU6050Driver : public Usermod {
      * setup() is called once at boot. WiFi is not yet connected at this point.
      */
     void setup() {
-      PinManagerPinType pins[2] = { { i2c_scl, true }, { i2c_sda, true } };
-      if (!pinManager.allocateMultiplePins(pins, 2, PinOwner::HW_I2C)) { enabled = false; return; }
-      // join I2C bus (I2Cdev library doesn't do this automatically)
+      if (i2c_scl<0 || i2c_sda<0) { enabled = false; return; }
       #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
-        Wire.begin();
-        Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
+        Wire.setClock(400000U); // 400kHz I2C clock. Comment this line if having compilation difficulties
       #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
         Fastwire::setup(400, true);
       #endif
@@ -138,7 +135,7 @@ class MPU6050Driver : public Usermod {
         // (if it's going to break, usually the code will be 1)
         DEBUG_PRINT(F("DMP Initialization failed (code "));
         DEBUG_PRINT(devStatus);
-        DEBUG_PRINTLN(F(")"));
+        DEBUG_PRINTLN(")");
       }
     }
 
@@ -209,7 +206,7 @@ class MPU6050Driver : public Usermod {
       JsonObject user = root["u"];
       if (user.isNull()) user = root.createNestedObject("u");
 
-      JsonArray imu_meas = user.createNestedObject("IMU");
+      JsonObject imu_meas = user.createNestedObject("IMU");
       JsonArray quat_json = imu_meas.createNestedArray("Quat");
       quat_json.add(qat.w);
       quat_json.add(qat.x);

usermods/multi_relay/readme.md

@@ -1,37 +1,40 @@
 # Multi Relay
 
-This usermod-v2 modification allows the connection of multiple relays each with individual delay and on/off mode.
+This usermod-v2 modification allows the connection of multiple relays, each with individual delay and on/off mode.
+Usermod supports PCF8574 I2C port expander to reduce GPIO use.
+PCF8574 supports 8 outputs and each output corresponds to a relay in WLED (relay 0 = port 0, etc). I you are using more than 8 relays with multiple PCF8574 make sure their addresses are set conscutively (e.g. 0x20 and 0x21). You can set address of first expander in settings.
+(**NOTE:** Will require Wire library and global I2C pins defined.)
 
 ## HTTP API
-All responses are returned as JSON. 
+All responses are returned in JSON format. 
 
 * Status Request: `http://[device-ip]/relays`
 * Switch Command: `http://[device-ip]/relays?switch=1,0,1,1`
 
-The number of numbers behind the switch parameter must correspond to the number of relays. The number 1 switches the relay on. The number 0 switches the relay off. 
+The number of values behind the switch parameter must correspond to the number of relays. The value 1 switches the relay on, 0 switches it off. 
 
 * Toggle Command: `http://[device-ip]/relays?toggle=1,0,1,1`
 
-The number of numbers behind the parameter switch must correspond to the number of relays. The number 1 causes a toggling of the relay. The number 0 leaves the state of the device.
+The number of values behind the parameter switch must correspond to the number of relays. The value 1 causes the relay to toggle, 0 leaves its state unchanged.
 
-Examples
+Examples:
 1. total of 4 relays, relay 2 will be toggled: `http://[device-ip]/relays?toggle=0,1,0,0`
 2. total of 3 relays, relay 1&3 will be switched on: `http://[device-ip]/relays?switch=1,0,1`
 
 ## JSON API
-You can switch relay state using the following JSON object transmitted to: `http://[device-ip]/json`
-
+You can toggle the relay state by sending the following JSON object to: `http://[device-ip]/json`
 
 Switch relay 0 on: `{"MultiRelay":{"relay":0,"on":true}}`
 
-Switch relay4 3 & 4 off: `{"MultiRelay":[{"relay":2,"on":false},{"relay":3,"on":false}]}`
+Switch relay 3 and 4 off: `{"MultiRelay":[{"relay":2,"on":false},{"relay":3,"on":false}]}`
+
 
 ## MQTT API
 
 * `wled`/_deviceMAC_/`relay`/`0`/`command` `on`|`off`|`toggle`
 * `wled`/_deviceMAC_/`relay`/`1`/`command` `on`|`off`|`toggle`
 
-When relay is switched it will publish a message:
+When a relay is switched, a message is published:
 
 * `wled`/_deviceMAC_/`relay`/`0` `on`|`off`
 
@@ -42,7 +45,7 @@ When relay is switched it will publish a message:
 or
 2. Use `#define USERMOD_MULTI_RELAY` in wled.h or `-D USERMOD_MULTI_RELAY` in your platformio.ini
 
-You can override the default maximum number (4) of relays by defining MULTI_RELAY_MAX_RELAYS.
+You can override the default maximum number of relays (which is 4) by defining MULTI_RELAY_MAX_RELAYS.
 
 Example **usermods_list.cpp**:
 
@@ -78,16 +81,18 @@ void registerUsermods()
 
 ## Configuration
 
-Usermod can be configured in Usermods settings page.
+Usermod can be configured via the Usermods settings page.
 
 * `enabled` - enable/disable usermod
-* `pin` - GPIO pin where relay is attached to ESP (can be configured at compile time `-D MULTI_RELAY_PINS=xx,xx,...`)
-* `delay-s` - delay in seconds after on/off command is received
-* `active-high` - toggle high/low activation of relay (can be used to reverse relay states)
-* `external` - if enabled WLED does not control relay, it can only be triggered by external command (MQTT, HTTP, JSON or button)
-* `button` - button (from LED Settings) that controls this relay
-* `broadcast`- time in seconds between state broadcasts using MQTT
+* `use-PCF8574` - use PCF8574 port expander instead of GPIO pins
+* `first-PCF8574` - I2C address of first expander (WARNING: enter *decimal* value)
+* `broadcast`- time in seconds between MQTT relay-state broadcasts
 * `HA-discovery`- enable Home Assistant auto discovery
+* `pin` - ESP GPIO pin the relay is connected to (can be configured at compile time `-D MULTI_RELAY_PINS=xx,xx,...`)
+* `delay-s` - delay in seconds after on/off command is received
+* `active-high` - assign high/low activation of relay (can be used to reverse relay states)
+* `external` - if enabled, WLED does not control relay, it can only be triggered by an external command (MQTT, HTTP, JSON or button)
+* `button` - button (from LED Settings) that controls this relay
 
 If there is no MultiRelay section, just save current configuration and re-open Usermods settings page. 
 
@@ -100,3 +105,6 @@ Have fun - @blazoncek
 2021-11
 * Added information about dynamic configuration options
 * Added button support.
+
+2023-05
+* Added support for PCF8574 I2C port expander (multiple)

usermods/multi_relay/usermod_multi_relay.h

@@ -4,10 +4,19 @@
 
 #ifndef MULTI_RELAY_MAX_RELAYS
   #define MULTI_RELAY_MAX_RELAYS 4
+#else
+  #if MULTI_RELAY_MAX_RELAYS>8
+    #undef MULTI_RELAY_MAX_RELAYS
+    #define MULTI_RELAY_MAX_RELAYS 8
+    #warning Maximum relays set to 8
+  #endif
 #endif
 
 #ifndef MULTI_RELAY_PINS
   #define MULTI_RELAY_PINS -1
+  #define MULTI_RELAY_ENABLED false
+#else
+  #define MULTI_RELAY_ENABLED true
 #endif
 
 #define WLED_DEBOUNCE_THRESHOLD 50 //only consider button input of at least 50ms as valid (debouncing)
@@ -15,21 +24,37 @@
 #define ON  true
 #define OFF false
 
+#ifndef USERMOD_USE_PCF8574
+  #undef USE_PCF8574
+  #define USE_PCF8574 false
+#else
+  #undef USE_PCF8574
+  #define USE_PCF8574 true
+#endif
+
+#ifndef PCF8574_ADDRESS
+  #define PCF8574_ADDRESS 0x20  // some may start at 0x38
+#endif
+
 /*
  * This usermod handles multiple relay outputs.
  * These outputs complement built-in relay output in a way that the activation can be delayed.
  * They can also activate/deactivate in reverse logic independently.
+ * 
+ * Written and maintained by @blazoncek
  */
 
 
 typedef struct relay_t {
   int8_t pin;
-  bool active;
-  bool mode;
-  bool state;
-  bool external;
-  uint16_t delay;
-  int8_t button;
+  struct { // reduces memory footprint
+    bool active   : 1;  // is the relay waiting to be switched
+    bool invert   : 1;  // does On mean 1 or 0
+    bool state    : 1;  // 1 relay is On, 0 relay is Off
+    bool external : 1;  // is the relay externally controlled
+    int8_t button : 4;  // which button triggers relay
+  };
+  uint16_t delay;       // amount of ms to wait after it is activated
 } Relay;
 
 
@@ -39,20 +64,15 @@ class MultiRelay : public Usermod {
     // array of relays
     Relay    _relay[MULTI_RELAY_MAX_RELAYS];
 
-    // switch timer start time
-    uint32_t _switchTimerStart = 0;
-    // old brightness
-    bool _oldMode;
-
-    // usermod enabled
-    bool enabled = false;  // needs to be configured (no default config)
-    // status of initialisation
-    bool initDone = false;
-
-    bool HAautodiscovery = false;
-
-    uint16_t periodicBroadcastSec = 60;
-    unsigned long lastBroadcast = 0;
+    uint32_t _switchTimerStart; // switch timer start time
+    bool     _oldMode;          // old brightness
+    bool     enabled;           // usermod enabled
+    bool     initDone;          // status of initialisation
+    bool     usePcf8574;
+    uint8_t  addrPcf8574;
+    bool     HAautodiscovery;
+    uint16_t periodicBroadcastSec;
+    unsigned long lastBroadcast;
 
     // strings to reduce flash memory usage (used more than twice)
     static const char _name[];
@@ -64,25 +84,146 @@ class MultiRelay : public Usermod {
     static const char _button[];
     static const char _broadcast[];
     static const char _HAautodiscovery[];
+    static const char _pcf8574[];
+    static const char _pcfAddress[];
 
-    void publishMqtt(int relay) {
+    void handleOffTimer();
+    void InitHtmlAPIHandle();
+    int getValue(String data, char separator, int index);
+    uint8_t getActiveRelayCount();
+
+    byte IOexpanderWrite(byte address, byte _data);
+    byte IOexpanderRead(int address);
+
+    void publishMqtt(int relay);
+#ifndef WLED_DISABLE_MQTT
+    void publishHomeAssistantAutodiscovery();
+#endif
+
+  public:
+    /**
+     * constructor
+     */
+    MultiRelay();
+
+    /**
+     * desctructor
+     */
+    //~MultiRelay() {}
+
+    /**
+     * Enable/Disable the usermod
+     */
+    inline void enable(bool enable) { enabled = enable; }
+
+    /**
+     * Get usermod enabled/disabled state
+     */
+    inline bool isEnabled() { return enabled; }
+
+    /**
+     * 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.
+     */
+    inline uint16_t getId() { return USERMOD_ID_MULTI_RELAY; }
+
+    /**
+     * switch relay on/off
+     */
+    void switchRelay(uint8_t relay, bool mode);
+
+    /**
+     * toggle relay
+     */
+    inline void toggleRelay(uint8_t relay) {
+      switchRelay(relay, !_relay[relay].state);
+    }
+
+    /**
+     * 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();
+
+    /**
+     * connected() is called every time the WiFi is (re)connected
+     * Use it to initialize network interfaces
+     */
+    inline void connected() { InitHtmlAPIHandle(); }
+
+    /**
+     * loop() is called continuously. Here you can check for events, read sensors, etc.
+     */
+    void loop();
+
+#ifndef WLED_DISABLE_MQTT
+    bool onMqttMessage(char* topic, char* payload);
+    void onMqttConnect(bool sessionPresent);
+#endif
+
+    /**
+     * 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);
+
+    /**
+     * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
+     */
+    void addToJsonInfo(JsonObject &root);
+
+    /**
+     * 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);
+
+    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);
+};
+
+
+// class implementetion
+
+void MultiRelay::publishMqtt(int relay) {
+#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/relay/%d"), mqttDeviceTopic, relay);
     mqtt->publish(subuf, 0, false, _relay[relay].state ? "on" : "off");
   }
-    }
+#endif
+}
 
-    /**
+/**
  * switch off the strip if the delay has elapsed 
  */
-    void handleOffTimer() {
+void MultiRelay::handleOffTimer() {
   unsigned long now = millis();
   bool activeRelays = false;
   for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
     if (_relay[i].active && _switchTimerStart > 0 && now - _switchTimerStart > (_relay[i].delay*1000)) {
-          if (!_relay[i].external) toggleRelay(i);
+      if (!_relay[i].external) switchRelay(i, !offMode);
       _relay[i].active = false;
     } else if (periodicBroadcastSec && now - lastBroadcast > (periodicBroadcastSec*1000)) {
       if (_relay[i].pin>=0) publishMqtt(i);
@@ -91,15 +232,15 @@ class MultiRelay : public Usermod {
   }
   if (!activeRelays) _switchTimerStart = 0;
   if (periodicBroadcastSec && now - lastBroadcast > (periodicBroadcastSec*1000)) lastBroadcast = now;
-    }
+}
 
-    /**
+/**
  * HTTP API handler
  * borrowed from:
  * https://github.com/gsieben/WLED/blob/master/usermods/GeoGab-Relays/usermod_GeoGab.h
  */
-    #define GEOGABVERSION "0.1.3"
-    void InitHtmlAPIHandle() {  // https://github.com/me-no-dev/ESPAsyncWebServer
+#define GEOGABVERSION "0.1.3"
+void MultiRelay::InitHtmlAPIHandle() {  // https://github.com/me-no-dev/ESPAsyncWebServer
   DEBUG_PRINTLN(F("Relays: Initialize HTML API"));
 
   server.on("/relays", HTTP_GET, [this](AsyncWebServerRequest *request) {
@@ -159,9 +300,9 @@ class MultiRelay : public Usermod {
     janswer += F("\"}");
     request->send(200, "application/json", janswer);
   });
-    }
+}
 
-    int getValue(String data, char separator, int index) {
+int MultiRelay::getValue(String data, char separator, int index) {
   int found = 0;
   int strIndex[] = {0, -1};
   int maxIndex = data.length()-1;
@@ -174,70 +315,89 @@ class MultiRelay : public Usermod {
     }
   }
   return found>index ? data.substring(strIndex[0], strIndex[1]).toInt() : -1;
-    }
+}
 
-  public:
-    /**
-     * constructor
-     */
-    MultiRelay() {
+//Write a byte to the IO expander
+byte MultiRelay::IOexpanderWrite(byte address, byte _data ) {
+  Wire.beginTransmission(address);
+  Wire.write(_data);
+  return Wire.endTransmission(); 
+}
+
+//Read a byte from the IO expander
+byte MultiRelay::IOexpanderRead(int address) {
+  byte _data = 0;
+  Wire.requestFrom(address, 1);
+  if (Wire.available()) {
+    _data = Wire.read();
+  }
+  return _data;
+}
+
+
+// public methods
+
+MultiRelay::MultiRelay()
+  : _switchTimerStart(0)
+  , enabled(MULTI_RELAY_ENABLED)
+  , initDone(false)
+  , usePcf8574(USE_PCF8574)
+  , addrPcf8574(PCF8574_ADDRESS)
+  , HAautodiscovery(false)
+  , periodicBroadcastSec(60)
+  , lastBroadcast(0)
+{
   const int8_t defPins[] = {MULTI_RELAY_PINS};
-      for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
+  for (size_t i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
     _relay[i].pin      = i<sizeof(defPins) ? defPins[i] : -1;
     _relay[i].delay    = 0;
-        _relay[i].mode     = false;
+    _relay[i].invert   = false;
     _relay[i].active   = false;
     _relay[i].state    = false;
     _relay[i].external = false;
     _relay[i].button   = -1;
   }
-    }
-    /**
-     * desctructor
-     */
-    ~MultiRelay() {}
+}
 
-    /**
-     * Enable/Disable the usermod
-     */
-    inline void enable(bool enable) { enabled = enable; }
-    /**
-     * Get usermod enabled/disabled state
-     */
-    inline bool isEnabled() { return enabled; }
-
-    /**
+/**
  * switch relay on/off
  */
-    void switchRelay(uint8_t relay, bool mode) {
+void MultiRelay::switchRelay(uint8_t relay, bool mode) {
   if (relay>=MULTI_RELAY_MAX_RELAYS || _relay[relay].pin<0) return;
   _relay[relay].state = mode;
+  if (usePcf8574 && _relay[relay].pin >= 100) {
+    // we need to send all ouputs at the same time
+    uint8_t state = 0;
+    for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
+      if (_relay[i].pin < 100) continue;
+      uint8_t pin = _relay[i].pin - 100;
+      state |= (_relay[i].invert ? !_relay[i].state : _relay[i].state) << pin; // fill relay states for all pins
+    }
+    IOexpanderWrite(addrPcf8574, state);
+    DEBUG_PRINT(F("Writing to PCF8574: ")); DEBUG_PRINTLN(state);
+  } else if (_relay[relay].pin < 100) {
     pinMode(_relay[relay].pin, OUTPUT);
-      digitalWrite(_relay[relay].pin, mode ? !_relay[relay].mode : _relay[relay].mode);
+    digitalWrite(_relay[relay].pin, _relay[relay].invert ? !_relay[relay].state : _relay[relay].state);
+  } else return;
   publishMqtt(relay);
-    }
+}
 
-    /**
-     * toggle relay
-     */
-    inline void toggleRelay(uint8_t relay) {
-      switchRelay(relay, !_relay[relay].state);
-    }
-
-    uint8_t getActiveRelayCount() {
+uint8_t MultiRelay::getActiveRelayCount() {
   uint8_t count = 0;
   for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) if (_relay[i].pin>=0) count++;
   return count;
-    }
+}
 
-    //Functions called by WLED
 
-    /**
+//Functions called by WLED
+
+#ifndef WLED_DISABLE_MQTT
+/**
  * handling of MQTT message
  * topic only contains stripped topic (part after /wled/MAC)
  * topic should look like: /relay/X/command; where X is relay number, 0 based
  */
-    bool onMqttMessage(char* topic, char* payload) {
+bool MultiRelay::onMqttMessage(char* topic, char* payload) {
   if (strlen(topic) > 8 && strncmp_P(topic, PSTR("/relay/"), 7) == 0 && strncmp_P(topic+8, PSTR("/command"), 8) == 0) {
     uint8_t relay = strtoul(topic+7, NULL, 10);
     if (relay<MULTI_RELAY_MAX_RELAYS) {
@@ -255,12 +415,12 @@ class MultiRelay : public Usermod {
     }
   }
   return false;
-    }
+}
 
-    /**
+/**
  * subscribe to MQTT topic for controlling relays
  */
-    void onMqttConnect(bool sessionPresent) {
+void MultiRelay::onMqttConnect(bool sessionPresent) {
   //(re)subscribe to required topics
   char subuf[64];
   if (mqttDeviceTopic[0] != 0) {
@@ -273,9 +433,9 @@ class MultiRelay : public Usermod {
       publishMqtt(i); //publish current state
     }
   }
-    }
+}
 
-    void publishHomeAssistantAutodiscovery() {
+void MultiRelay::publishHomeAssistantAutodiscovery() {
   for (int i = 0; i < MULTI_RELAY_MAX_RELAYS; i++) {
     char uid[24], json_str[1024], buf[128];
     size_t payload_size;
@@ -293,8 +453,8 @@ class MultiRelay : public Usermod {
 
       json[F("stat_t")]  = "~";
       json[F("cmd_t")]   = F("~/command");
-          json[F("pl_off")]  = F("off");
-          json[F("pl_on")]   = F("on");
+      json[F("pl_off")]  = "off";
+      json[F("pl_on")]   = "on";
       json[F("uniq_id")] = uid;
 
       strcpy(buf, mqttDeviceTopic); //max length: 33 + 7 = 40
@@ -312,40 +472,46 @@ class MultiRelay : public Usermod {
     sprintf_P(buf, PSTR("homeassistant/switch/%s/config"), uid);
     mqtt->publish(buf, 0, true, json_str, payload_size);
   }
-    }
+}
+#endif
 
-    /**
+/**
  * 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 MultiRelay::setup() {
   // pins retrieved from cfg.json (readFromConfig()) prior to running setup()
+  // if we want PCF8574 expander I2C pins need to be valid
+  if (i2c_sda<0 || i2c_scl<0) usePcf8574 = false;
+
+  uint8_t state = 0;
   for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
-        if (_relay[i].pin<0) continue;
-        if (!pinManager.allocatePin(_relay[i].pin,true, PinOwner::UM_MultiRelay)) {
-          _relay[i].pin = -1;  // allocation failed
-        } else {
+    if (usePcf8574 && _relay[i].pin >= 100) {
+      uint8_t pin = _relay[i].pin - 100;
+      if (!_relay[i].external) _relay[i].state = !offMode;
+      state |= (uint8_t)(_relay[i].invert ? !_relay[i].state : _relay[i].state) << pin;
+    } else if (_relay[i].pin<100 && _relay[i].pin>=0) {
+      if (pinManager.allocatePin(_relay[i].pin,true, PinOwner::UM_MultiRelay)) {
         if (!_relay[i].external) _relay[i].state = !offMode;
         switchRelay(i, _relay[i].state);
         _relay[i].active = false;
+      } else {
+        _relay[i].pin = -1;  // allocation failed
       }
     }
+  }
+  if (usePcf8574) {
+    IOexpanderWrite(addrPcf8574, state);  // init expander (set all outputs)
+    DEBUG_PRINTLN(F("PCF8574(s) inited."));
+  }
   _oldMode = offMode;
   initDone = true;
-    }
+}
 
-    /**
-     * connected() is called every time the WiFi is (re)connected
-     * Use it to initialize network interfaces
-     */
-    void connected() {
-      InitHtmlAPIHandle();
-    }
-
-    /**
+/**
  * loop() is called continuously. Here you can check for events, read sensors, etc.
  */
-    void loop() {
+void MultiRelay::loop() {
   yield();
   if (!enabled || strip.isUpdating()) return;
 
@@ -358,19 +524,19 @@ class MultiRelay : public Usermod {
     _oldMode = offMode;
     _switchTimerStart = millis();
     for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
-          if (_relay[i].pin>=0 && !_relay[i].external) _relay[i].active = true;
+      if ((_relay[i].pin>=0) && !_relay[i].external) _relay[i].active = true;
     }
   }
 
   handleOffTimer();
-    }
+}
 
-    /**
+/**
  * 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) {
+bool MultiRelay::handleButton(uint8_t b) {
   yield();
   if (!enabled
     || buttonType[b] == BTN_TYPE_NONE
@@ -457,12 +623,12 @@ class MultiRelay : public Usermod {
     }
   }
   return handled;
-    }
+}
 
-    /**
+/**
  * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
  */
-    void addToJsonInfo(JsonObject &root) {
+void MultiRelay::addToJsonInfo(JsonObject &root) {
   if (enabled) {
     JsonObject user = root["u"];
     if (user.isNull())
@@ -493,13 +659,13 @@ class MultiRelay : public Usermod {
       infoArr.add(uiDomString);
     }
   }
-    }
+}
 
-    /**
+/**
  * addToJsonState() can be used to add custom entries to the /json/state part of the JSON API (state object).
  * Values in the state object may be modified by connected clients
  */
-    void addToJsonState(JsonObject &root) {
+void MultiRelay::addToJsonState(JsonObject &root) {
   if (!initDone || !enabled) return;  // prevent crash on boot applyPreset()
   JsonObject multiRelay = root[FPSTR(_name)];
   if (multiRelay.isNull()) {
@@ -517,13 +683,13 @@ class MultiRelay : public Usermod {
   multiRelay[FPSTR(_relay_str)] = 0;
   multiRelay[F("state")] = _relay[0].state;
   #endif
-    }
+}
 
-    /**
+/**
  * 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 MultiRelay::readFromJsonState(JsonObject &root) {
   if (!initDone || !enabled) return;  // prevent crash on boot applyPreset()
   JsonObject usermod = root[FPSTR(_name)];
   if (!usermod.isNull()) {
@@ -548,36 +714,45 @@ class MultiRelay : public Usermod {
       }
     }
   }
-    }
+}
 
-    /**
+/**
  * provide the changeable values
  */
-    void addToConfig(JsonObject &root) {
+void MultiRelay::addToConfig(JsonObject &root) {
   JsonObject top = root.createNestedObject(FPSTR(_name));
 
   top[FPSTR(_enabled)] = enabled;
+  top[FPSTR(_pcf8574)] = usePcf8574;
+  top[FPSTR(_pcfAddress)] = addrPcf8574;
   top[FPSTR(_broadcast)] = periodicBroadcastSec;
+  top[FPSTR(_HAautodiscovery)] = HAautodiscovery;
   for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
     String parName = FPSTR(_relay_str); parName += '-'; parName += i;
     JsonObject relay = top.createNestedObject(parName);
     relay["pin"]              = _relay[i].pin;
-        relay[FPSTR(_activeHigh)] = _relay[i].mode;
+    relay[FPSTR(_activeHigh)] = _relay[i].invert;
     relay[FPSTR(_delay_str)]  = _relay[i].delay;
     relay[FPSTR(_external)]   = _relay[i].external;
     relay[FPSTR(_button)]     = _relay[i].button;
   }
-      top[FPSTR(_HAautodiscovery)] = HAautodiscovery;
   DEBUG_PRINTLN(F("MultiRelay config saved."));
-    }
+}
 
-    /**
+void MultiRelay::appendConfigData() {
+  oappend(SET_F("addInfo('MultiRelay:PCF8574-address',1,'<i>(not hex!)</i>');"));
+  oappend(SET_F("addInfo('MultiRelay:broadcast-sec',1,'(MQTT message)');"));
+  //oappend(SET_F("addInfo('MultiRelay:relay-0:pin',1,'(use -1 for PCF8574)');"));
+  oappend(SET_F("d.extra.push({'MultiRelay':{pin:[['P0',100],['P1',101],['P2',102],['P3',103],['P4',104],['P5',105],['P6',106],['P7',107]]}});"));
+}
+
+/**
  * 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) {
+bool MultiRelay::readFromConfig(JsonObject &root) {
   int8_t oldPin[MULTI_RELAY_MAX_RELAYS];
 
   JsonObject top = root[FPSTR(_name)];
@@ -587,7 +762,13 @@ class MultiRelay : public Usermod {
     return false;
   }
 
+  //bool configComplete = !top.isNull();
+  //configComplete &= getJsonValue(top[FPSTR(_enabled)], enabled);
   enabled = top[FPSTR(_enabled)] | enabled;
+  usePcf8574 = top[FPSTR(_pcf8574)] | usePcf8574;
+  addrPcf8574 = top[FPSTR(_pcfAddress)] | addrPcf8574;
+  // if I2C is not globally initialised just ignore
+  if (i2c_sda<0 || i2c_scl<0) usePcf8574 = false;
   periodicBroadcastSec = top[FPSTR(_broadcast)] | periodicBroadcastSec;
   periodicBroadcastSec = min(900,max(0,(int)periodicBroadcastSec));
   HAautodiscovery = top[FPSTR(_HAautodiscovery)] | HAautodiscovery;
@@ -596,14 +777,14 @@ class MultiRelay : public Usermod {
     String parName = FPSTR(_relay_str); parName += '-'; parName += i;
     oldPin[i]          = _relay[i].pin;
     _relay[i].pin      = top[parName]["pin"] | _relay[i].pin;
-        _relay[i].mode     = top[parName][FPSTR(_activeHigh)] | _relay[i].mode;
+    _relay[i].invert   = top[parName][FPSTR(_activeHigh)] | _relay[i].invert;
     _relay[i].external = top[parName][FPSTR(_external)]   | _relay[i].external;
     _relay[i].delay    = top[parName][FPSTR(_delay_str)]  | _relay[i].delay;
     _relay[i].button   = top[parName][FPSTR(_button)]     | _relay[i].button;
     // begin backwards compatibility (beta) remove when 0.13 is released
     parName += '-';
     _relay[i].pin      = top[parName+"pin"] | _relay[i].pin;
-        _relay[i].mode     = top[parName+FPSTR(_activeHigh)] | _relay[i].mode;
+    _relay[i].invert   = top[parName+FPSTR(_activeHigh)] | _relay[i].invert;
     _relay[i].external = top[parName+FPSTR(_external)]   | _relay[i].external;
     _relay[i].delay    = top[parName+FPSTR(_delay_str)]  | _relay[i].delay;
     // end compatibility
@@ -617,37 +798,16 @@ class MultiRelay : public Usermod {
   } else {
     // deallocate all pins 1st
     for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++)
-          if (oldPin[i]>=0) {
+      if (oldPin[i]>=0 && oldPin[i]<100) {
         pinManager.deallocatePin(oldPin[i], PinOwner::UM_MultiRelay);
       }
     // allocate new pins
-        for (int i=0; i<MULTI_RELAY_MAX_RELAYS; i++) {
-          if (_relay[i].pin>=0 && pinManager.allocatePin(_relay[i].pin, true, PinOwner::UM_MultiRelay)) {
-            if (!_relay[i].external) {
-              _relay[i].state = !offMode;
-              switchRelay(i, _relay[i].state);
-              _oldMode = offMode;
-            }
-          } else {
-            _relay[i].pin = -1;
-          }
-          _relay[i].active = false;
-        }
+    setup();
     DEBUG_PRINTLN(F(" config (re)loaded."));
   }
   // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-      return !top[FPSTR(_HAautodiscovery)].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_MULTI_RELAY;
-    }
-};
+  return !top[FPSTR(_pcf8574)].isNull();
+}
 
 // strings to reduce flash memory usage (used more than twice)
 const char MultiRelay::_name[]            PROGMEM = "MultiRelay";
@@ -659,3 +819,5 @@ const char MultiRelay::_external[]   PROGMEM = "external";
 const char MultiRelay::_button[]          PROGMEM = "button";
 const char MultiRelay::_broadcast[]       PROGMEM = "broadcast-sec";
 const char MultiRelay::_HAautodiscovery[] PROGMEM = "HA-autodiscovery";
+const char MultiRelay::_pcf8574[]         PROGMEM = "use-PCF8574";
+const char MultiRelay::_pcfAddress[]      PROGMEM = "PCF8574-address";

usermods/photoresistor_sensor_mqtt_v1/README.md

@@ -1,10 +1,12 @@
 # Photoresister sensor with MQTT
 
-This simple usermod allows attaching a photoresistor sensor like the KY-018 and publish the readings in percentage over MQTT. The frequency of MQTT messages can be modified, and there is a threshold value that can be set so that significant changes in the readings can be published immediately instead of waiting for the next update. This was found to be a good compromise between spamming MQTT messages and delayed updates.
+Enables attaching a photoresistor sensor like the KY-018 and publishing the readings as a percentage, via MQTT. The frequency of MQTT messages is user definable.
+A threshold value can be set so significant changes in the readings are published immediately vice waiting for the next update. This was found to be a good compromise between excessive MQTT traffic and delayed updates.
 
-I also found it useful to limit the frequency of analog pin reads because otherwise the board hangs.
+I also found it useful to limit the frequency of analog pin reads, otherwise the board hangs.
 
-This usermod has only been tested with the KY-018 sensor though should work for any other analog pin sensor. Note that this does not control the LED strip directly, it only publishes MQTT readings for use with other integrations like Home Assistant.
+This usermod has only been tested with the KY-018 sensor though it should work for any other analog pin sensor.
+Note: this does not control the LED strip directly, it only publishes MQTT readings for use with other integrations like Home Assistant.
 
 ## Installation
 

usermods/project_cars_shiftlight/readme.md

@@ -1,12 +1,11 @@
 ### Shift Light for Project Cars
 
 Turn your WLED lights into a rev light and shift indicator for Project Cars.
+It's easy to use.
 
-It is pretty straight forward to use.
+1. Make sure your WLED device and your PC/console are on the same network and can talk to each other
 
-1. Make sure, your WLED device and your PC/console are on the same network and can talk to each other
-
-2. Go to the gameplay settings menu in PCARS and enable UDP. There are 9 numbers you can choose from. This is the refresh rate. The lower the number, the better. But you might run into problems at faster rates.
+2. Go to the gameplay settings menu in PCARS and enable UDP. There are 9 numbers you can choose from. This is the refresh rate. The lower the number, the better. However, you might run into problems at faster rates.
 
 | Number | Updates/Second |
 | ------ | -------------- |
@@ -20,4 +19,5 @@ It is pretty straight forward to use.
 | 8      | 05             |
 | 9      | 1              |
 
-3. once you enter a race, WLED should automatically shift to PCARS mode. Done.
+3. Once you enter a race, WLED should automatically shift to PCARS mode.
+4. Done.

usermods/pwm_outputs/readme.md

@@ -0,0 +1,27 @@
+# PWM outputs
+
+v2 Usermod to add generic PWM outputs to WLED. Usermode could be used to control servo motors, LED brightness or any other device controlled by PWM signal.
+
+## Installation
+
+Add the compile-time option `-D USERMOD_PWM_OUTPUTS` to your `platformio.ini` (or `platformio_override.ini`). By default upt to 3 PWM outputs could be configured, to increase that limit add build argument `-D USERMOD_PWM_OUTPUT_PINS=10` (replace 10 by desired amount).
+
+Currently only ESP32 is supported.
+
+## Configuration
+
+By default PWM outputs are disabled, navigate to Usermods settings and configure desired PWM pins and frequencies.
+
+## Usage
+
+If PWM output is configured, it starts to publish its duty cycle value (0-1) both to state JSON and to info JSON (visible in UI info panel). To set PWM duty cycle, use JSON api (over HTTP or over Serial)
+
+```json
+{
+    "pwm": {
+        "0": {"duty": 0.1},
+        "1": {"duty": 0.2},
+        ...
+    }
+}
+```

usermods/pwm_outputs/usermod_pwm_outputs.h

@@ -0,0 +1,221 @@
+#pragma once
+#include "wled.h"
+
+#ifndef ESP32
+  #error This usermod does not support the ESP8266.
+#endif
+
+#ifndef USERMOD_PWM_OUTPUT_PINS
+  #define USERMOD_PWM_OUTPUT_PINS 3
+#endif
+
+
+class PwmOutput {
+  public:
+
+    void open(int8_t pin, uint32_t freq) {
+
+      if (enabled_) {
+        if (pin == pin_ && freq == freq_) {
+          return;  // PWM output is already open
+        } else {
+          close();  // Config has changed, close and reopen
+        }
+      }
+
+      pin_ = pin;
+      freq_ = freq;
+      if (pin_ < 0)
+        return;
+
+      DEBUG_PRINTF("pwm_output[%d]: setup to freq %d\n", pin_, freq_);
+      if (!pinManager.allocatePin(pin_, true, PinOwner::UM_PWM_OUTPUTS))
+        return;
+      
+      channel_ = pinManager.allocateLedc(1);
+      if (channel_ == 255) {
+        DEBUG_PRINTF("pwm_output[%d]: failed to quire ledc\n", pin_);
+        pinManager.deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
+        return;
+      }
+
+      ledcSetup(channel_, freq_, bit_depth_);
+      ledcAttachPin(pin_, channel_);
+      DEBUG_PRINTF("pwm_output[%d]: init successful\n", pin_);
+      enabled_ = true;
+    }
+
+    void close() {
+      DEBUG_PRINTF("pwm_output[%d]: close\n", pin_);
+      if (!enabled_)
+        return;
+      pinManager.deallocatePin(pin_, PinOwner::UM_PWM_OUTPUTS);
+      if (channel_ != 255)
+        pinManager.deallocateLedc(channel_, 1);
+      channel_ = 255;
+      duty_ = 0.0f;
+      enabled_ = false;
+    }
+
+    void setDuty(const float duty) {
+      DEBUG_PRINTF("pwm_output[%d]: set duty %f\n", pin_, duty);
+      if (!enabled_)
+        return;
+      duty_ = min(1.0f, max(0.0f, duty));
+      const uint32_t value = static_cast<uint32_t>((1 << bit_depth_) * duty_);
+      ledcWrite(channel_, value);
+    }
+
+    void setDuty(const uint16_t duty) {
+      setDuty(static_cast<float>(duty) / 65535.0f);
+    }
+
+    bool isEnabled() const {
+      return enabled_;
+    }
+
+    void addToJsonState(JsonObject& pwmState) const {
+      pwmState[F("duty")] = duty_;
+    }
+
+    void readFromJsonState(JsonObject& pwmState) {
+      if (pwmState.isNull()) {
+        return;
+      }
+      float duty;
+      if (getJsonValue(pwmState[F("duty")], duty)) {
+        setDuty(duty);
+      }
+    }
+
+    void addToJsonInfo(JsonObject& user) const {
+      if (!enabled_)
+        return;
+      char buffer[12];
+      sprintf_P(buffer, PSTR("PWM pin %d"), pin_);
+      JsonArray data = user.createNestedArray(buffer);
+      data.add(1e2f * duty_);
+      data.add(F("%"));
+    }
+
+    void addToConfig(JsonObject& pwmConfig) const {
+      pwmConfig[F("pin")] = pin_;
+      pwmConfig[F("freq")] = freq_;
+    }
+
+    bool readFromConfig(JsonObject& pwmConfig) {
+      if (pwmConfig.isNull())
+        return false;
+        
+      bool configComplete = true;
+      int8_t newPin = pin_;
+      uint32_t newFreq = freq_;
+      configComplete &= getJsonValue(pwmConfig[F("pin")], newPin);  
+      configComplete &= getJsonValue(pwmConfig[F("freq")], newFreq);
+
+      open(newPin, newFreq);
+
+      return configComplete;
+    }
+
+  private:
+    int8_t pin_ {-1};
+    uint32_t freq_ {50};
+    static const uint8_t bit_depth_ {12};
+    uint8_t channel_ {255};
+    float duty_ {0.0f};
+    bool enabled_ {false};
+};
+
+
+class PwmOutputsUsermod : public Usermod {
+  public:
+
+    static const char USERMOD_NAME[];
+    static const char PWM_STATE_NAME[];
+
+    void setup() {
+      // By default all PWM outputs are disabled, no setup do be done
+    }
+
+    void loop() {
+    }
+
+    void addToJsonState(JsonObject& root) {
+      JsonObject pwmStates = root.createNestedObject(PWM_STATE_NAME);
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        const PwmOutput& pwm = pwms_[i];
+        if (!pwm.isEnabled())
+          continue;
+        char buffer[4];
+        sprintf_P(buffer, PSTR("%d"), i);
+        JsonObject pwmState = pwmStates.createNestedObject(buffer);
+        pwm.addToJsonState(pwmState);
+      }
+    }
+
+    void readFromJsonState(JsonObject& root) {
+      JsonObject pwmStates = root[PWM_STATE_NAME];
+      if (pwmStates.isNull())
+        return;
+
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        PwmOutput& pwm = pwms_[i];
+        if (!pwm.isEnabled())
+          continue;
+        char buffer[4];
+        sprintf_P(buffer, PSTR("%d"), i);
+        JsonObject pwmState = pwmStates[buffer];
+        pwm.readFromJsonState(pwmState);
+      }
+    }
+
+    void addToJsonInfo(JsonObject& root) {
+      JsonObject user = root[F("u")];
+      if (user.isNull())
+        user = root.createNestedObject(F("u"));
+
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        const PwmOutput& pwm = pwms_[i];
+        pwm.addToJsonInfo(user);
+      }
+    }
+
+    void addToConfig(JsonObject& root) {
+      JsonObject top = root.createNestedObject(USERMOD_NAME);
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        const PwmOutput& pwm = pwms_[i];
+        char buffer[8];
+        sprintf_P(buffer, PSTR("PWM %d"), i);
+        JsonObject pwmConfig = top.createNestedObject(buffer);
+        pwm.addToConfig(pwmConfig);
+      }
+    }
+
+    bool readFromConfig(JsonObject& root) {
+      JsonObject top = root[USERMOD_NAME];
+      if (top.isNull())
+        return false;
+
+      bool configComplete = true;
+      for (int i = 0; i < USERMOD_PWM_OUTPUT_PINS; i++) {
+        PwmOutput& pwm = pwms_[i];
+        char buffer[8];
+        sprintf_P(buffer, PSTR("PWM %d"), i);
+        JsonObject pwmConfig = top[buffer];
+        configComplete &= pwm.readFromConfig(pwmConfig);
+      }
+      return configComplete;
+    }
+
+    uint16_t getId() {
+      return USERMOD_ID_PWM_OUTPUTS;
+    }
+
+  private:
+    PwmOutput pwms_[USERMOD_PWM_OUTPUT_PINS];
+
+};
+
+const char PwmOutputsUsermod::USERMOD_NAME[] PROGMEM = "PwmOutputs";
+const char PwmOutputsUsermod::PWM_STATE_NAME[] PROGMEM = "pwm";

usermods/quinled-an-penta/readme.md

@@ -1,5 +1,5 @@
 # QuinLED-An-Penta
-The (un)official usermod to get the best out of the QuinLED-An-Penta (https://quinled.info/quinled-an-penta/), like using the OLED and the SHT30 temperature/humidity sensor.
+The (un)official usermod to get the best out of the QuinLED-An-Penta (https://quinled.info/quinled-an-penta/), e.g. using the OLED and the SHT30 temperature/humidity sensor.
 
 ## Requirements
 * "u8gs" by olikraus, v2.28 or higher: https://github.com/olikraus/u8g2
@@ -31,15 +31,15 @@ lib_deps = ${esp32.lib_deps}
 ## Some words about the (optional) OLED
 This mod has been optimized for an SSD1306 driven 128x64 OLED. Using a smaller OLED or an OLED using a different driver will result in unexpected results.
 I highly recommend using these "two color monochromatic OLEDs", which have the first 16 pixels in a different color than the other 48, e.g. a yellow/blue OLED.
-Also note, you need to have an **SPI** driven OLED, **not i2c**!
+Note: you _must_ use an **SPI** driven OLED, **not an i2c one**!
 
 ### Limitations combined with Ethernet
-The initial development of this mod had been done with a beta version of the QuinLED-An-Penta, which had a different IO layout for the OLED: The CS pin used to be IO_0, but has been changed to IO27 with the first v1 public release. Unfortunately, IO27 is used by the Ethernet boards, so WLED will not let you enable the OLED screen, if you're using it with Ethernet. This unfortunately makes the development I've done to support/show Ethernet information void, as it cannot be used.
-However (and I've not tried this, as I don't own a v1 board): You can try to modify this mod and try to use IO27 for the OLED and share it with the Ethernet board. It is "just" the chip select pin, so there is a chance that both can coexist and use the same IO. You need to skip WLEDs PinManager for the CS pin, so WLED will not block using it. If you don't know how this works: Leave it. If you know what I'm talking about: Try it and please let me know on the Intermit.Tech (QuinLED) Discord server: https://discord.gg/WdbAauG
+The initial development of this mod was done with a beta version of the QuinLED-An-Penta, which had a different IO layout for the OLED: The CS pin _was_ IO_0, but has been changed to IO27 with the first v1 public release. Unfortunately, IO27 is used by Ethernet boards, so WLED will not let you enable the OLED screen, if you're using it with Ethernet. Unfortunately, that makes the development I've done to support/show Ethernet information invalid, as it cannot be used.
+However, (and I've not tried this, as I don't own a v1 board) you can modify this usermod and try to use IO27 for the OLED and share it with the Ethernet board. It is "just" the chip select pin, so there is a chance that both can coexist and use the same IO. You need to skip WLEDs PinManager for the CS pin, so WLED will not block using it. If you don't know how this works, don't change it. If you know what I'm talking about, try it and please let me know on the Intermit.Tech (QuinLED) Discord server: https://discord.gg/WdbAauG
 
 ### My OLED flickers after some time, what should I do?
-That's a tricky one: During development I saw that the OLED sometimes starts to "bug out" / flicker and won't work anymore. This seems to be caused by the high PWM interference the board produces. It seems to loose its settings and then doesn't know how to draw anymore. Turns out the only way to fix this is to call the libraries `begin()` method again which will re-initialize the display.
-If you're facing this issue, you can enable a setting I've added which will call the `begin()` roughly every 60 seconds between a page change. This will make the page change take ~500ms, but will fix the display.
+That's a tricky one. During development I saw that the OLED sometimes starts to "drop out" / flicker and won't work anymore. This seems to be caused by the high PWM interference the board produces. It seems to lose its settings then doesn't know how to draw anymore. Turns out the only way to fix this is to call the libraries `begin()` method again which re-initializes the display.
+If you're facing this issue, you can enable a setting which will call the `begin()` roughly every 60 seconds between page changes. This will make the page change take ~500ms, but will fix the display.
 
 
 ## Configuration
@@ -53,11 +53,11 @@ Navigate to the "Config" and then to the "Usermods" section. If you compiled WLE
   * Possible values: Enabled/Disabled
   * Default: Disabled
 * OLED-Flip-Screen-180:
-  * What it does: Flips the screen 180° / upside-down
+  * What it does: Flips the screen 180°
   * Possible values: Enabled/Disabled
   * Default: Disabled
 * OLED-Seconds-Per-Page:
-  * What it does: Defines how long the OLED should stay on one page in seconds before changing to the next
+  * What it does: Number of seconds the OLED should stay on one page before changing pages
   * Possible values: Enabled/Disabled
   * Default: 10
 * OLED-Fix-Bugged-Screen:

usermods/readme.md

@@ -2,17 +2,17 @@
 
 This folder serves as a repository for usermods (custom `usermod.cpp` files)!
 
-If you have created an usermod that you believe is useful (for example to support a particular sensor, display, feature...), feel free to contribute by opening a pull request!
+If you have created a usermod you believe is useful (for example to support a particular sensor, display, feature...), feel free to contribute by opening a pull request!
 
 In order for other people to be able to have fun with your usermod, please keep these points in mind:
 
 -   Create a folder in this folder with a descriptive name (for example `usermod_ds18b20_temp_sensor_mqtt`)  
 -   Include your custom files 
--   If your usermod requires changes to other WLED files, please write a `readme.md` outlining the steps one has to take to use the usermod  
+-   If your usermod requires changes to other WLED files, please write a `readme.md` outlining the steps one needs to take  
 -   Create a pull request!  
 -   If your feature is useful for the majority of WLED users, I will consider adding it to the base code!  
 
-While I do my best to not break too much, keep in mind that as WLED is being updated, usermods might break.  
+While I do my best to not break too much, keep in mind that as WLED is updated, usermods might break.  
 I am not actively maintaining any usermod in this directory, that is your responsibility as the creator of the usermod.
 
 For new usermods, I would recommend trying out the new v2 usermod API, which allows installing multiple usermods at once and new functions!

usermods/rgb-rotary-encoder/readme.md

@@ -5,8 +5,8 @@ This usermod-v2 adds support for the awesome RGB Rotary Encoder Board by Adam Ze
 https://user-images.githubusercontent.com/3090131/124680599-0180ab80-dec7-11eb-9065-a6d08ebe0287.mp4
 
 ## Credits
-The actual / original code that does the different LED modes is from Adam Zeloof. So I don't take credit for these. But I ported it to WLED, which involved replacing the LED library he used (because, guess what, WLED already has one; so no need to add another one, but use whatever WLED uses), plus the rotary encoder library, because that one was not compatible with ESP, only Arduino.
-So it was quite more work than I hoped, but I got there eventually :)
+The actual / original code that controls the LED modes is from Adam Zeloof. I take no credit for it. I ported it to WLED, which involved replacing the LED library he used, (because WLED already has one, so no need to add another one) plus the rotary encoder library because it was not compatible with ESP, only Arduino.
+It was quite a bit more work than I hoped, but I got there eventually :)
 
 ## Requirements
 * "ESP Rotary" by Lennart Hennigs, v1.5.0 or higher: https://github.com/LennartHennigs/ESPRotary
@@ -33,25 +33,25 @@ lib_deps = ${esp8266.lib_deps}
 ```
 
 ## How to connect the board to your ESP
-We gonna need (minimum) three or (maximum) four GPIOs for the board:
-* "ea": Basically tells if the encoder goes into one or the other direction
-* "eb": Same thing, but the other direction
-* "di": LED data in. To actually control the LEDs
-* *(optional)* "sw": The integrated switch in the rotary encoder. Can be omitted for the bare functionality of just controlling the brightness
+We'll need (minimum) three or (maximum) four GPIOs for the board:
+* "ea": reports the encoder direction
+* "eb": Same thing, opposite direction
+* "di": LED data in.
+* *(optional)* "sw": The integrated switch in the rotary encoder. Can be omitted for the bare functionality of controlling only the brightness
 
-We also gonna need some power, so:
+We'll also need power:
 
 * "vdd": Needs to be connected to **+5V**.
-* "gnd": Well, it's GND.
+* "gnd": Ground.
 
-You can freely pick the GPIOs, it doesn't matter. Those will be configured in the "Usermods" section in the WLED web panel:
+You can freely pick the GPIOs, it doesn't matter. Those will be configured in the "Usermods" section of the WLED web panel:
 
 ## Configuration
-Navigate to the "Config" and then to the "Usermods" section. If you compiled WLED with `-D RGB_ROTARY_ENCODER`, you will see the config for it there. The settings there are the GPIOs we mentioned before (*Note: The switch pin is not there, as this can just be configured the "normal" button on the "LED Preferences" page*), plus a few more:
+Navigate to the "Config" and then to the "Usermods" section. If you compiled WLED with `-D RGB_ROTARY_ENCODER`, you will see the config for it there. The settings there are the aforementioned GPIOs, (*Note: The switch pin is not there, as this can just be configured the "normal" button on the "LED Preferences" page*) plus a few more:
 * LED pin:
   * Possible values: Any valid and available GPIO
   * Default: 3
-  * What it does: Pin to control the LED ring
+  * What it does: controls the LED ring
 * ea pin:
   * Possible values: Any valid and available GPIO
   * Default: 15
@@ -63,7 +63,7 @@ Navigate to the "Config" and then to the "Usermods" section. If you compiled WLE
 * LED Mode:
   * Possible values: 1-3
   * Default: 3
-  * What it does: The usermod provides three different modes of how the LEDs can look like. Here's an example: https://github.com/isotope-engineering/RGB-Encoder-Board/blob/master/images/rgb-encoder-animations.gif
+  * What it does: The usermod provides three different modes of how the LEDs can appear. Here's an example: https://github.com/isotope-engineering/RGB-Encoder-Board/blob/master/images/rgb-encoder-animations.gif
     * Up left is "1"
     * Up right is not supported / doesn't make sense for brightness control
     * Bottom left is "2"
@@ -71,15 +71,15 @@ Navigate to the "Config" and then to the "Usermods" section. If you compiled WLE
 * LED Brightness:
   * Possible values: 1-255
   * Default: 64
-  * What it does: Brightness of the LED ring
+  * What it does: sets LED ring Brightness
 * Steps per click:
   * Possible values: Any positive number
   * Default: 4
-  * What it does: With each "click", a rotary encoder actually increments it's "steps". Most rotary encoder do four "steps" per "click". I know this sounds super weird, so just leave this the default value, unless your rotary encoder behaves weirdly, like with one click, it makes two LEDs light up, or you sometimes need two click for one LED. Then you should play around with this value or write a small sketch using the same "ESP Rotary" library and read out the steps it does.
+  * What it does: With each "click", a rotary encoder actually increments its "steps". Most rotary encoders produce four "steps" per "click". Leave this at the default value unless your rotary encoder behaves strangely. e.g. with one click, it makes two LEDs light up, or you need two clicks for one LED. If that's the case, adjust this value or write a small sketch using the same "ESP Rotary" library and read out the steps it produce.
 * Increment per click:
   * Possible values: Any positive number
   * Default: 5
-  * What it does: Most rotary encoder have 20 "clicks", so basically 20 positions. This value should be set to 100 / `number of clicks`
+  * What it does: Most rotary encoders have 20 "clicks" or positions. This value should be set to 100/`number of clicks`
 
 ## Change log
 2021-07

usermods/sd_card/readme.md

@@ -0,0 +1,34 @@
+# SD-card mod
+
+## Build
+- modify `platformio.ini` and add to the `build_flags` of your configuration the following
+- choose the way your SD is connected
+  1. via `-D WLED_USE_SD_MMC` when connected via MMC
+  2. via `-D WLED_USE_SD_SPI` when connected via SPI (use usermod page to setup SPI pins)
+
+### Test
+- enable `-D SD_PRINT_HOME_DIR` and `-D WLED_DEBUG`
+- this will print all files in `/` on boot via serial
+
+## Configuration
+### MMC
+- The MMC port / pins needs no configuration as they are specified by Espressif
+### SPI
+- The SPI port / pins can be modified via the WLED web-UI: `Config → Usermod → SD Card`
+  | option            | effect                                                                                           | default |
+  | ----------------- | ------------------------------------------------------------------------------------------------ | ------- |
+  | `pinSourceSelect` | GPIO that is connected to SD's `SS`(source select) / `CS`(chip select)                           | 16      |
+  | `pinSourceClock`  | GPIO that is connected to SD's `SCLK` (source clock) / `CLK`(clock)                              | 14      |
+  | `pinPoci`         | GPIO that is connected to SD's `POCI`<sup>☨</sup> (Peripheral-Out-Ctrl-In) / `MISO` (deprecated) | 36      |
+  | `pinPico`         | GPIO that is connected to SD's `PICO`<sup>☨</sup> (Peripheral-In-Ctrl-Out) / `MOSI` (deprecated) | 14      |
+  | `sdEnable`        | Enable to read data from the SD-card                                                             | true    |
+
+  <sup>☨</sup><sub>Following new naming convention of [OSHWA](https://www.oshwa.org/a-resolution-to-redefine-spi-signal-names/)</sub>
+
+## Usage in other mods
+- creates a macro `SD_ADAPTER` which is either mapped to `SD` or `SD_MMC` (see `SD_Test.ino` how to use SD / SD_MMC functions)
+
+-  checks if the specified file is available on the SD card
+   ```cpp
+   bool file_onSD(const char *filepath) {...}
+   ```

usermods/sd_card/usermod_sd_card.h

@@ -0,0 +1,243 @@
+#pragma once
+
+#include "wled.h"
+
+// SD connected via MMC / SPI
+#if defined(WLED_USE_SD_MMC)
+  #define USED_STORAGE_FILESYSTEMS "SD MMC, LittleFS"
+  #define SD_ADAPTER SD_MMC
+  #include "SD_MMC.h"
+// SD connected via SPI (adjustable via usermod config)
+#elif defined(WLED_USE_SD_SPI)
+  #define SD_ADAPTER SD
+  #define USED_STORAGE_FILESYSTEMS "SD SPI, LittleFS"
+  #include "SD.h"
+  #include "SPI.h"
+#endif
+
+#ifdef WLED_USE_SD_MMC
+#elif defined(WLED_USE_SD_SPI)
+  SPIClass spiPort = SPIClass(VSPI);
+#endif
+
+void listDir( const char * dirname, uint8_t levels);
+
+class UsermodSdCard : public Usermod {
+  private:
+    bool sdInitDone = false;
+
+    #ifdef WLED_USE_SD_SPI
+      int8_t configPinSourceSelect = 16;
+      int8_t configPinSourceClock = 14;
+      int8_t configPinPoci = 36; // confusing names? Then have a look :)
+      int8_t configPinPico = 15; // https://www.oshwa.org/a-resolution-to-redefine-spi-signal-names/
+
+      //acquired and initialize the SPI port
+      void init_SD_SPI()
+      {
+        if(!configSdEnabled) return;
+        if(sdInitDone) return;
+
+        PinManagerPinType pins[5] = {
+        { configPinSourceSelect, true },
+        { configPinSourceClock, true },
+        { configPinPoci, false },
+        { configPinPico, true }
+        };
+
+        if (!pinManager.allocateMultiplePins(pins, 4, PinOwner::UM_SdCard)) {
+            DEBUG_PRINTF("[%s] SD (SPI) pin allocation failed!\n", _name);
+            sdInitDone = false;
+            return;
+        }
+
+        bool returnOfInitSD = false;
+
+        #if defined(WLED_USE_SD_SPI)
+          spiPort.begin(configPinSourceClock, configPinPoci, configPinPico, configPinSourceSelect);
+          returnOfInitSD = SD_ADAPTER.begin(configPinSourceSelect, spiPort);
+        #endif
+
+        if(!returnOfInitSD) {
+          DEBUG_PRINTF("[%s] SPI begin failed!\n", _name);
+          sdInitDone = false;
+          return;
+        }
+
+        sdInitDone = true;
+      }
+
+      //deinitialize the acquired SPI port
+      void deinit_SD_SPI()
+      {
+        if(!sdInitDone) return;
+
+        SD_ADAPTER.end();
+
+        DEBUG_PRINTF("[%s] deallocate pins!\n", _name);
+        pinManager.deallocatePin(configPinSourceSelect, PinOwner::UM_SdCard);
+        pinManager.deallocatePin(configPinSourceClock,  PinOwner::UM_SdCard);
+        pinManager.deallocatePin(configPinPoci,         PinOwner::UM_SdCard);
+        pinManager.deallocatePin(configPinPico,         PinOwner::UM_SdCard);
+
+        sdInitDone = false;
+      }
+
+      // some SPI pin was changed, while SPI was initialized, reinit to new port
+      void reinit_SD_SPI()
+      {
+          deinit_SD_SPI();
+          init_SD_SPI();
+      }
+    #endif
+
+    #ifdef WLED_USE_SD_MMC
+      void init_SD_MMC() {
+        if(sdInitDone) return;
+        bool returnOfInitSD = false;
+        returnOfInitSD = SD_ADAPTER.begin();
+        DEBUG_PRINTF("[%s] MMC begin\n", _name);
+
+        if(!returnOfInitSD) {
+          DEBUG_PRINTF("[%s] MMC begin failed!\n", _name);
+          sdInitDone = false;
+          return;
+        }
+
+        sdInitDone = true;
+      }
+    #endif
+
+  public:
+    static bool configSdEnabled;
+    static const char _name[];
+
+    void setup() {
+      DEBUG_PRINTF("[%s] usermod loaded \n", _name);
+      #if defined(WLED_USE_SD_SPI)
+        init_SD_SPI();
+      #elif defined(WLED_USE_SD_MMC)
+        init_SD_MMC();
+      #endif
+ 
+      #if defined(SD_ADAPTER) && defined(SD_PRINT_HOME_DIR)  
+        listDir("/", 0);        
+      #endif
+    }
+
+    void loop(){
+      
+    }
+
+    uint16_t getId()
+    {
+      return USERMOD_ID_SD_CARD;
+    }
+
+    void addToConfig(JsonObject& root)
+    {
+      #ifdef WLED_USE_SD_SPI
+      JsonObject top = root.createNestedObject(FPSTR(_name));
+      top["pinSourceSelect"] = configPinSourceSelect;
+      top["pinSourceClock"] = configPinSourceClock;
+      top["pinPoci"] = configPinPoci;
+      top["pinPico"] = configPinPico;
+      top["sdEnabled"] = configSdEnabled;
+      #endif
+    }
+
+    bool readFromConfig(JsonObject &root)
+    {
+      #ifdef WLED_USE_SD_SPI
+        JsonObject top = root[FPSTR(_name)];
+        if (top.isNull()) {
+          DEBUG_PRINTF("[%s] No config found. (Using defaults.)\n", _name);
+          return false;
+        }
+
+        uint8_t oldPinSourceSelect  = configPinSourceSelect;
+        uint8_t oldPinSourceClock = configPinSourceClock;
+        uint8_t oldPinPoci = configPinPoci;
+        uint8_t oldPinPico = configPinPico;
+        bool    oldSdEnabled = configSdEnabled;
+
+        getJsonValue(top["pinSourceSelect"], configPinSourceSelect);
+        getJsonValue(top["pinSourceClock"],  configPinSourceClock);
+        getJsonValue(top["pinPoci"],         configPinPoci);
+        getJsonValue(top["pinPico"],         configPinPico);
+        getJsonValue(top["sdEnabled"],       configSdEnabled);
+
+        if(configSdEnabled != oldSdEnabled) {
+          configSdEnabled ? init_SD_SPI() : deinit_SD_SPI();
+          DEBUG_PRINTF("[%s] SD card %s\n", _name, configSdEnabled ? "enabled" : "disabled");
+        }
+
+        if( configSdEnabled && (
+            oldPinSourceSelect  != configPinSourceSelect ||
+            oldPinSourceClock   != configPinSourceClock  ||
+            oldPinPoci          != configPinPoci         ||
+            oldPinPico          != configPinPico)
+          )
+        {
+          DEBUG_PRINTF("[%s] Init SD card based of config\n", _name);
+          DEBUG_PRINTF("[%s] Config changes \n - SS: %d -> %d\n - MI: %d -> %d\n - MO: %d -> %d\n - En: %d -> %d\n", _name, oldPinSourceSelect, configPinSourceSelect, oldPinSourceClock, configPinSourceClock, oldPinPoci, configPinPoci, oldPinPico, configPinPico);
+          reinit_SD_SPI();
+        }
+      #endif
+
+      return true;
+    }
+};
+
+const char UsermodSdCard::_name[] PROGMEM = "SD Card";
+bool UsermodSdCard::configSdEnabled = true;
+
+#ifdef SD_ADAPTER
+//checks if the file is available on SD card
+bool file_onSD(const char *filepath)
+{
+  #ifdef WLED_USE_SD_SPI
+    if(!UsermodSdCard::configSdEnabled) return false;
+  #endif
+
+  uint8_t cardType = SD_ADAPTER.cardType();
+  if(cardType == CARD_NONE) {
+    DEBUG_PRINTF("[%s] not attached / cardType none\n", UsermodSdCard::_name);
+    return false; // no SD card attached
+  }
+  if(cardType == CARD_MMC || cardType == CARD_SD || cardType == CARD_SDHC)
+  {
+    return SD_ADAPTER.exists(filepath);
+  }
+
+  return false; // unknown card type
+}
+
+void listDir( const char * dirname, uint8_t levels){
+    DEBUG_PRINTF("Listing directory: %s\n", dirname);
+
+    File root = SD_ADAPTER.open(dirname);
+    if(!root){
+        DEBUG_PRINTF("Failed to open directory\n");
+        return;
+    }
+    if(!root.isDirectory()){
+        DEBUG_PRINTF("Not a directory\n");
+        return;
+    }
+
+    File file = root.openNextFile();
+    while(file){
+        if(file.isDirectory()){
+            DEBUG_PRINTF("  DIR : %s\n",file.name());
+            if(levels){
+                listDir(file.name(), levels -1);
+            }
+        } else {
+            DEBUG_PRINTF("  FILE: %s  SIZE: %d\n",file.name(), file.size());
+        }
+        file = root.openNextFile();
+    }
+}
+
+#endif

usermods/sensors_to_mqtt/readme.md

@@ -1,12 +1,12 @@
-# Sensors To Home Assistant (or mqtt)
+# Send sensor data To Home Assistant
 
-This usermod will publish values of the BMP280, CCS811 and Si7021 sensors to Home Assistant via MQTT.
+Publishes BMP280, CCS811 and Si7021 measurements to Home Assistant via MQTT.
 
-Its using home assistant automatic device discovery feature.
+Uses Home Assistant Automatic Device Discovery.
 
-The use of Home Assistant is not mandatory; it will publish the sensor values via MQTT just fine without it.
+The use of Home Assistant is not mandatory. The mod will publish sensor values via MQTT just fine without it.
 
-Its resusing the mqtt connection set in the WLED web user interface.
+Uses the MQTT connection set in the WLED web user interface.
 
 ## Maintainer
 
@@ -15,12 +15,12 @@ twitter.com/mpronk89
 ## Features
 
 - Reads BMP280, CCS811 and Si7021 senors
-- Publishes via MQTT, configured via webui of wled
+- Publishes via MQTT, configured via WLED webUI
 - Announces device in Home Assistant for easy setup
 - Efficient energy usage
 - Updates every 60 seconds
 
-## Example mqtt topics:
+## Example MQTT topics:
 
 `$mqttDeviceTopic` is set in webui of WLED!
 
@@ -40,7 +40,7 @@ IAQ:  $mqttDeviceTopic/iaq
 ### Requirements
 
 1. BMP280/CCS811/Si7021 sensor. E.g. https://aliexpress.com/item/32979998543.html
-2. A microcontroller which can talk i2c, e.g. esp32
+2. A microcontroller that supports i2c. e.g. esp32
 
 ### installation
 
@@ -77,7 +77,7 @@ SDA_PIN = 4;
   adafruit/Adafruit Si7021 Library @ 1.4.0
 ```
 
-The #ifdefs in `usermods_list.cpp` should do the rest :)
+The #ifdefs in `usermods_list.cpp` should do the rest
 
 # Credits