v0.13.0-b2

Reduced unneeded websockets pushes

CHANGELOG.md

@@ -2,6 +2,72 @@
 
 ### Builds after release 0.12.0
 
+#### Build 2107100
+
+-   Version bump to 0.13.0-b2 "Toki"
+-   Accept hex color strings in individual LED API
+-   Fixed transition property not applying unless power/bri/color changed next
+-   Moved transition field below segments (temporarily)
+-   Reduced unneeded websockets pushes
+
+#### Build 2107091
+
+-   Fixed presets using wrong call mode (e.g. causing buttons to send UDP under direct change type)
+-   Increased hue buffer
+-   Renamed `NOTIFIER_CALL_MODE_` to `CALL_MODE_`
+
+#### Build 2107090
+
+-   Busses extend total configured LEDs if required
+-   Fixed extra button pins defaulting to 0 on first boot
+
+#### Build 2107080
+
+-   Made Peek use the main websocket connection instead of opening a second one
+-   Temperature usermod fix (from @blazoncek's dev branch)
+
+#### Build 2107070
+
+-   More robust initial resource loading in UI
+-   Added `getJsonValue()` for usermod config parsing (PR #2061)
+-   Fixed preset saving over websocket
+-   Alpha ESP32 S2 support (filesystem does not work) (PR #2067)
+
+#### Build 2107042
+
+-   Updated ArduinoJson to 6.18.1
+-   Improved Twinkleup effect
+-   Fixed preset immediately deselecting when set via HTTP API `PL=`
+
+#### Build 2107041
+
+-   Restored support for "PL=~" mistakenly removed in 2106300
+-   JSON IR improvements
+
+#### Build 2107040
+
+-   Playlist entries are now more compact
+-   Added the possibility to enter negative numbers for segment offset
+
+#### Build 2107021
+
+-   Added WebSockets support to UI
+
+#### Build 2107020
+
+-   Send websockets on every state change
+-   Improved Aurora effect
+
+#### Build 2107011
+
+-   Added MQTT button feedback option (PR #2011)
+
+#### Build 2107010
+
+-   Added JSON IR codes (PR #1941)
+-   Adjusted the width of WiFi and LED settings input fields
+-   Fixed a minor visual issue with slider trail not reaching thumb on low values
+
 #### Build 2106302
 
 -   Fixed settings page broken by using "%" in input fields

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "wled",
-  "version": "0.13.0-b0",
+  "version": "0.13.0-b2",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

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

pio-scripts/output_bins.py

@@ -32,7 +32,7 @@ def bin_rename_copy(source, target, env):
 
     release_name = _get_cpp_define_value(env, "WLED_RELEASE_NAME")
 
-    if release_name and os.getenv("WLED_RELEASE"):
+    if release_name:
         _create_dirs(["release"])
         version = _get_cpp_define_value(env, "WLED_VERSION")
         release_file = "{}release{}WLED_{}_{}.bin".format(OUTPUT_DIR, os.path.sep, version, release_name)

platformio.ini

@@ -73,7 +73,6 @@ debug_flags = -D DEBUG=1 -D WLED_DEBUG -DDEBUG_ESP_WIFI -DDEBUG_ESP_HTTP_CLIENT
 
 # ------------------------------------------------------------------------------
 # FLAGS: ldscript (available ldscripts at https://github.com/esp8266/Arduino/tree/master/tools/sdk/ld)
-#    ldscript_512k ( 512 KB) =  487 KB sketch, 4 KB eeprom,      no spiffs, 16 KB reserved
 #    ldscript_1m0m (1024 KB) =  999 KB sketch, 4 KB eeprom,      no spiffs, 16 KB reserved
 #    ldscript_2m1m (2048 KB) = 1019 KB sketch, 4 KB eeprom, 1004 KB spiffs, 16 KB reserved
 #    ldscript_4m1m (4096 KB) = 1019 KB sketch, 4 KB eeprom, 1002 KB spiffs, 16 KB reserved, 2048 KB empty/ota?
@@ -129,28 +128,6 @@ ldscript_2m512k = eagle.flash.2m512.ld
 ldscript_2m1m = eagle.flash.2m1m.ld
 ldscript_4m1m = eagle.flash.4m1m.ld
 
-[esp8266]
-build_flags =
-  -DESP8266
-  -DFP_IN_IROM
-  ;-Wno-deprecated-declarations
-  ;-Wno-register
-; 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)
-   -DPIO_FRAMEWORK_ARDUINO_LWIP_HIGHER_BANDWIDTH
-; VTABLES in Flash
-  -DVTABLES_IN_FLASH
-; restrict to minimal mime-types
-  -DMIMETYPE_MINIMAL
-
-[esp32]
-build_flags = -g
-  -DARDUINO_ARCH_ESP32
-  -DCONFIG_LITTLEFS_FOR_IDF_3_2
-
 [scripts_defaults]
 extra_scripts =
   pre:pio-scripts/set_version.py
@@ -179,12 +156,8 @@ upload_speed = 115200
 # ------------------------------------------------------------------------------
 lib_compat_mode = strict
 lib_deps =
-    fastled/FastLED @ 3.3.2
-    NeoPixelBus @ 2.6.0
-    ESPAsyncTCP @ 1.2.0
-    ESPAsyncUDP
-    AsyncTCP @ 1.0.3
-    IRremoteESP8266 @ 2.7.3
+    fastled/FastLED @ 3.4.0
+    IRremoteESP8266 @ 2.7.18
     https://github.com/lorol/LITTLEFS.git
     https://github.com/Aircoookie/ESPAsyncWebServer.git @ ~2.0.2
   #For use of the TTGO T-Display ESP32 Module with integrated TFT display uncomment the following line
@@ -192,19 +165,61 @@ lib_deps =
   #For use SSD1306 OLED display uncomment following
     #U8g2@~2.27.2
   #For Dallas sensor uncomment following 2 lines
-    OneWire@~2.3.5
-    milesburton/DallasTemperature@^3.9.0
+    #OneWire@~2.3.5
+    #milesburton/DallasTemperature@^3.9.0
   #For BME280 sensor uncomment following
     #BME280@~3.0.0
     ; adafruit/Adafruit BMP280 Library @ 2.1.0
     ; adafruit/Adafruit CCS811 Library @ 1.0.4
     ; adafruit/Adafruit Si7021 Library @ 1.4.0
 
-lib_ignore =
-    AsyncTCP
-
 extra_scripts             = ${scripts_defaults.extra_scripts}
 
+[esp8266]
+build_flags =
+  -DESP8266
+  -DFP_IN_IROM
+  ;-Wno-deprecated-declarations
+  ;-Wno-register
+; 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)
+   -DPIO_FRAMEWORK_ARDUINO_LWIP_HIGHER_BANDWIDTH
+; VTABLES in Flash
+  -DVTABLES_IN_FLASH
+; restrict to minimal mime-types
+  -DMIMETYPE_MINIMAL
+
+lib_deps = 
+  ${env.lib_deps}
+  # ESPAsyncTCP @ 1.2.0
+  ESPAsyncUDP
+  makuna/NeoPixelBus @ 2.6.4 # 2.6.5 and newer do not compile on ESP core < 3.0.0
+
+[esp32]
+build_flags = -g
+  -DARDUINO_ARCH_ESP32
+  -DCONFIG_LITTLEFS_FOR_IDF_3_2
+
+lib_deps =
+  ${env.lib_deps}
+  https://github.com/Makuna/NeoPixelBus.git # until next upstream release
+  AsyncTCP @ 1.0.3
+
+[esp32s2]
+build_flags = -g
+  -DARDUINO_ARCH_ESP32
+  -DCONFIG_LITTLEFS_FOR_IDF_3_2
+  -DARDUINO_ARCH_ESP32S2
+  -DCONFIG_IDF_TARGET_ESP32S2
+
+lib_deps =
+  ${env.lib_deps}
+  https://github.com/Makuna/NeoPixelBus.git # until next upstream release
+  AsyncTCP @ 1.0.3
+
 # ------------------------------------------------------------------------------
 # WLED BUILDS
 # ------------------------------------------------------------------------------
@@ -216,6 +231,7 @@ 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
+lib_deps = ${esp8266.lib_deps}
 
 [env:esp01_1m_full]
 board = esp01_1m
@@ -224,6 +240,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
+lib_deps = ${esp8266.lib_deps}
 
 [env:esp07]
 board = esp07
@@ -232,6 +249,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
+lib_deps = ${esp8266.lib_deps}
 
 [env:d1_mini]
 board = d1_mini
@@ -241,6 +259,7 @@ upload_speed = 921600
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
+lib_deps = ${esp8266.lib_deps}
 monitor_filters = esp8266_exception_decoder
 
 [env:heltec_wifi_kit_8]
@@ -250,6 +269,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
+lib_deps = ${esp8266.lib_deps}
 
 [env:h803wf]
 board = d1_mini
@@ -258,25 +278,35 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D LEDPIN=1 -D WLED_DISABLE_INFRARED
+lib_deps = ${esp8266.lib_deps}
 
 [env:esp32dev]
 board = esp32dev
-platform = espressif32@3.2
+platform = espressif32@2.0
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32
-lib_ignore =
-  ESPAsyncTCP
-  ESPAsyncUDP
+build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32 #-D WLED_DISABLE_BROWNOUT_DET
+lib_deps = ${esp32.lib_deps}
 
 [env:esp32_eth]
 board = esp32-poe
-platform = espressif32@3.2
+platform = espressif32@2.0
 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
-lib_ignore =
-  ESPAsyncTCP
-  ESPAsyncUDP
+lib_deps = ${esp32.lib_deps}
+
+[env:esp32s2_saola]
+board = esp32dev
+board_build.mcu = esp32s2
+platform = espressif32
+platform_packages =
+    toolchain-xtensa32s2
+    framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#2.0.0-alpha1
+framework = arduino
+board_build.partitions = tools/WLED_ESP32_4MB_1MB_FS.csv
+upload_speed = 460800
+build_unflags = ${common.build_unflags}
+lib_deps = ${esp32s2.lib_deps}
 
 [env:esp8285_4CH_MagicHome]
 board = esp8285
@@ -285,6 +315,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_DISABLE_OTA
+lib_deps = ${esp8266.lib_deps}
 
 [env:esp8285_4CH_H801]
 board = esp8285
@@ -293,6 +324,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_DISABLE_OTA
+lib_deps = ${esp8266.lib_deps}
 
 [env:esp8285_5CH_H801]
 board = esp8285
@@ -301,6 +333,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_DISABLE_OTA
+lib_deps = ${esp8266.lib_deps}
 
 [env:d1_mini_5CH_Shojo_PCB]
 board = d1_mini
@@ -309,6 +342,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D WLED_USE_SHOJO_PCB
+lib_deps = ${esp8266.lib_deps}
 
 # ------------------------------------------------------------------------------
 # DEVELOPMENT BOARDS
@@ -322,6 +356,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} ${common.debug_flags}
+lib_deps = ${esp8266.lib_deps}
 
 [env:d1_mini_ota]
 board = d1_mini
@@ -333,6 +368,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
+lib_deps = ${esp8266.lib_deps}
 
 [env:anavi_miracle_controller]
 board = d1_mini
@@ -341,98 +377,35 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266} -D LEDPIN=12 -D IRPIN=-1 -D RLYPIN=2
+lib_deps = ${esp8266.lib_deps}
 
 # ------------------------------------------------------------------------------
 # custom board configurations
 # ------------------------------------------------------------------------------
 
-[env:custom_LEDPIN_4]
-board = d1_mini
-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 LEDPIN=4 -D IRPIN=5
-
-[env:custom_LEDPIN_16]
-board = d1_mini
-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 LEDPIN=16
-
-
-[env:custom_LEDPIN_3]
-board = d1_mini
-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 LEDPIN=3
-
-[env:custom_APA102]
-board = d1_mini
-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 USE_APA102
-
-[env:custom_WS2801]
-board = d1_mini
-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 USE_WS2801
-
-[env:custom32_LEDPIN_16]
-board = esp32dev
-platform = espressif32@3.2
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp32} -D LEDPIN=16 -D RLYPIN=19
-lib_ignore =
-  ESPAsyncTCP
-  ESPAsyncUDP
-
-[env:custom32_APA102]
-board = esp32dev
-platform = espressif32@3.2
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp32} -D USE_APA102
-lib_ignore =
-  ESPAsyncTCP
-  ESPAsyncUDP
-
-[env:custom32_TOUCHPIN_T0]
-board = esp32dev
-platform = espressif32@3.2
-build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp32} -D TOUCHPIN=T0
-lib_ignore =
-  ESPAsyncTCP
-  ESPAsyncUDP
-
 [env:wemos_shield_esp32]
 board = esp32dev
 platform = espressif32@3.2
-upload_port = /dev/cu.SLAB_USBtoUART
-monitor_port = /dev/cu.SLAB_USBtoUART
 upload_speed = 460800
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags_esp32} -D LEDPIN=16 -D RLYPIN=19 -D BTNPIN=17
-lib_ignore =
-  ESPAsyncTCP
-  ESPAsyncUDP
+build_flags = ${common.build_flags_esp32}
+  -D LEDPIN=16
+  -D RLYPIN=19
+  -D BTNPIN=17
+  -D IRPIN=18
+  -D UWLED_USE_MY_CONFIG
+  -D USERMOD_DALLASTEMPERATURE
+  -D USERMOD_FOUR_LINE_DISPLAY
+  -D TEMPERATURE_PIN=23
+lib_deps = ${esp32.lib_deps}
+  OneWire@~2.3.5
+  U8g2@~2.28.11
 
 [env:m5atom]
 board = esp32dev
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp32} -D LEDPIN=27 -D BTNPIN=39
-lib_ignore =
-	ESPAsyncTCP
-	ESPAsyncUDP
+lib_deps = ${esp32.lib_deps}
 platform = espressif32@3.2
 
 [env:sp501e]
@@ -440,6 +413,7 @@ board = esp_wroom_02
 platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_flags = ${common.build_flags_esp8266} -D LEDPIN=3 -D BTNPIN=1
+lib_deps = ${esp8266.lib_deps}
 
 # ------------------------------------------------------------------------------
 # travis test board configurations
@@ -469,6 +443,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
+lib_deps = ${esp8266.lib_deps}
 
 [env:codm-controller-0.6-rev2]
 board = esp_wroom_02
@@ -477,6 +452,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
+lib_deps = ${esp8266.lib_deps}
 
 # ------------------------------------------------------------------------------
 # EleksTube-IPS
@@ -485,8 +461,6 @@ build_flags = ${common.build_flags_esp8266}
 board = esp32dev
 platform = espressif32@3.2
 upload_speed = 921600
-lib_deps = ${env.lib_deps}
-  TFT_eSPI
 build_flags = ${common.build_flags_esp32} -D WLED_DISABLE_BROWNOUT_DET -D WLED_DISABLE_INFRARED
   -D USERMOD_RTC
   -D USERMOD_ELEKSTUBE_IPS
@@ -508,6 +482,4 @@ build_flags = ${common.build_flags_esp32} -D WLED_DISABLE_BROWNOUT_DET -D WLED_D
   -D SPI_FREQUENCY=40000000
   -D USER_SETUP_LOADED
 monitor_filters = esp32_exception_decoder
-lib_ignore =
-  ESPAsyncTCP
-  ESPAsyncUDP
+lib_deps = ${esp32.lib_deps} TFT_eSPI

platformio_override.ini.sample

@@ -14,6 +14,7 @@ platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_1m128k}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags_esp8266}
+lib_deps = ${esp8266.lib_deps}
 ; *********************************************************************
 ; *** Use custom settings from file my_config.h
    -DWLED_USE_MY_CONFIG

readme.md

@@ -9,7 +9,6 @@
   <a href="https://gitpod.io/#https://github.com/Aircoookie/WLED"><img src="https://img.shields.io/badge/Gitpod-ready--to--code-blue?style=flat-square&logo=gitpod"></a>
 
   </p>
-  
 # Welcome to my project WLED! ✨
 
 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!

usermods/Animated_Staircase/Animated_Staircase.h

@@ -123,7 +123,7 @@ class Animated_Staircase : public Usermod {
         // Always mark segments as "transitional", we are animating the staircase
         segments->setOption(SEG_OPTION_TRANSITIONAL, 1, 1);
       }
-      colorUpdated(NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+      colorUpdated(CALL_MODE_DIRECT_CHANGE);
     }
 
     /*
@@ -298,7 +298,7 @@ class Animated_Staircase : public Usermod {
           }
           segments->setOption(SEG_OPTION_ON, 1, 1);
         }
-        colorUpdated(NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+        colorUpdated(CALL_MODE_DIRECT_CHANGE);
         DEBUG_PRINTLN(F("Animated Staircase disabled."));
       }
       enabled = enable;

usermods/EXAMPLE_v2/usermod_v2_example.h

@@ -23,12 +23,20 @@
 //class name. Use something descriptive and leave the ": public Usermod" part :)
 class MyExampleUsermod : public Usermod {
   private:
-    // sample usermod default value for variable (you can also use constructor)
-    int userVar0 = 42;
-
     //Private class members. You can declare variables and functions only accessible to your usermod here
     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)
+    bool testBool = false;
+    unsigned long testULong = 42424242;
+    float testFloat = 42.42;
+    String testString = "Forty-Two";
+
+    // These config variables have defaults set inside readFromConfig()
+    int testInt;
+    long testLong;
+    int8_t testPins[2];
+
   public:
     //Functions called by WLED
 
@@ -118,40 +126,85 @@ class MyExampleUsermod : public Usermod {
      * 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 also not yet add your setting to one of the settings pages automatically.
-     * To make that work you still have to add the setting to the HTML, xml.cpp and set.cpp manually.
+     * 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 top = root.createNestedObject("exampleUsermod");
-      top["great"] = userVar0; //save this var persistently whenever settings are saved
+      top["great"] = userVar0; //save these vars persistently whenever settings are saved
+      top["testBool"] = testBool;
+      top["testInt"] = testInt;
+      top["testLong"] = testLong;
+      top["testULong"] = testULong;
+      top["testFloat"] = testFloat;
+      top["testString"] = testString;
+      JsonArray pinArray = top.createNestedArray("pin");
+      pinArray.add(testPins[0]);
+      pinArray.add(testPins[1]); 
     }
 
 
     /*
      * 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)
+     * 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 your config was complete, or false if you'd like WLED to save your defaults to disk
+     * 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)
     {
-      //set defaults for variables when declaring the variable (class definition or constructor)
+      // 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"];
-      if (!top.isNull()) return false;
 
-      userVar0 = top["great"] | userVar0; 
+      bool configComplete = !top.isNull();
 
-      // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-      return true;
+      configComplete &= getJsonValue(top["great"], userVar0);
+      configComplete &= getJsonValue(top["testBool"], testBool);
+      configComplete &= getJsonValue(top["testULong"], testULong);
+      configComplete &= getJsonValue(top["testFloat"], testFloat);
+      configComplete &= getJsonValue(top["testString"], testString);
+
+      // 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);
+      configComplete &= getJsonValue(top["pin"][0], testPins[0], -1);
+      configComplete &= getJsonValue(top["pin"][1], testPins[1], -1);
+
+      return configComplete;
     }
 
    

usermods/JSON_IR_remote/21-key_ir.json

@@ -0,0 +1,119 @@
+{
+  "desc": "21-key",
+  "0xFFA25D": {
+    "label": "On",
+    "pos": "1x1",
+    "cmd": "T=1"
+  },
+  "0xFF629D": {
+    "label": "Off",
+    "pos": "1x2",
+    "cmd": "T=0"
+  },
+  "0xFFE21D": {
+    "label": "Flash",
+    "pos": "1x3",
+    "cmnt": "Cycle Effects",
+    "cmd": "CY=0&FX=~"
+  },
+  "0xFF22DD": {
+    "label": "Strobe",
+    "pos": "2x1",
+    "cmnt": "Sinelon Dual",
+    "cmd": "CY=0&FX=93"
+  },
+  "0xFF02FD": {
+    "label": "Fade",
+    "pos": "2x2",
+    "cmnt": "Rain",
+    "cmd": "CY=0&FX=43"
+  },
+  "0xFFC23D": {
+    "label": "Smooth",
+    "pos": "2x3",
+    "cmnt": "Aurora",
+    "cmd": "CY=0&FX=38"
+  },
+  "0xFFE01F": {
+    "label": "Bright +",
+    "pos": "3x1",
+    "cmd": "A=~16"
+  },
+  "0xFFA857": {
+    "label": "Bright -",
+    "pos": "3x2",
+    "cmd": "A=~-16"
+  },
+  "0xFF906F": {
+    "label": "White",
+    "pos": "3x3",
+    "cmd": "FP=5&CL=hFFFFFF&C2=hFFFFFF&C3=hA8A8A8"
+  },
+  "0xFF6897": {
+    "label": "Red",
+    "pos": "4x1",
+    "cmnt": "Lava",
+    "cmd": "FP=8"
+  },
+  "0xFF9867": {
+    "label": "Green",
+    "pos": "4x2",
+    "cmnt": "Forest",
+    "cmd": "FP=10"
+  },
+  "0xFFB04F": {
+    "label": "Blue",
+    "pos": "4x3",
+    "cmnt": "Breeze",
+    "cmd": "FP=15"
+  },
+  "0xFF30CF": {
+    "label": "Tomato",
+    "pos": "5x1",
+    "cmd": "FP=5&CL=hFF6347&C2=hFFBF47&C3=hA85859"
+  },
+  "0xFF18E7": {
+    "label": "LightGreen",
+    "pos": "5x2",
+    "cmnt": "Rivendale",
+    "cmd": "FP=14"
+  },
+  "0xFF7A85": {
+    "label": "SkyBlue",
+    "pos": "5x3",
+    "cmnt": "Ocean",
+    "cmd": "FP=9"
+  },
+  "0xFF10EF": {
+    "label": "Orange",
+    "pos": "6x1",
+    "cmnt": "Orangery",
+    "cmd": "FP=47"
+  },
+  "0xFF38C7": {
+    "label": "Aqua",
+    "pos": "6x2",
+    "cmd": "FP=5&CL=hFFFF&C2=h7FFF&C3=h39A895"
+  },
+  "0xFF5AA5": {
+    "label": "Purple",
+    "pos": "6x3",
+    "cmd": "FP=5&CL=h663399&C2=h993399&C3=h473864"
+  },
+  "0xFF42BD": {
+    "label": "Yellow",
+    "pos": "7x1",
+    "cmd": "FP=5&CL=hFFFF00&C2=hFFC800&C3=hFDFFDE"
+  },
+  "0xFF4AB5": {
+    "label": "Cyan",
+    "pos": "7x2",
+    "cmnt": "Beech",
+    "cmd": "FP=22"
+  },
+  "0xFF52AD": {
+    "label": "Pink",
+    "pos": "7x3",
+    "cmd": "FP=5&CL=hFFC0CB&C2=hFFD4C0&C3=hA88C96"
+  }
+}

usermods/JSON_IR_remote/24-key_ir.json

@@ -0,0 +1,147 @@
+{
+  "desc": "24-key",
+  "0xF700FF": {
+    "label": "+",
+    "pos": "1x1",
+    "cmnt": "Speed +",
+    "cmd": "SX=~16"
+  },
+  "0xF7807F": {
+    "label": "-",
+    "pos": "1x2",
+    "cmnt": "Speed -",
+    "cmd": "SX=~-16"
+  },
+  "0xF740BF": {
+    "label": "On/Off",
+    "pos": "1x3",
+    "cmnt": "Toggle On/Off",
+    "cmd": "T=2"
+  },
+  "0xF7C03F": {
+    "label": "W",
+    "pos": "1x4",
+    "cmnt": "Cycle color palette",
+    "cmd": "FP=~"
+  },
+  "0xF720DF": {
+    "label": "R",
+    "pos": "2x1",
+    "cmnt": "Lava",
+    "cmd": "FP=8"
+  },
+  "0xF7A05F": {
+    "label": "G",
+    "pos": "2x2",
+    "cmnt": "Forest",
+    "cmd": "FP=10"
+  },
+  "0xF7609F": {
+    "label": "B",
+    "pos": "2x3",
+    "cmnt": "Breeze",
+    "cmd": "FP=15"
+  },
+  "0xF7E01F": {
+    "label": "Bright -",
+    "pos": "2x4",
+    "cmnt": "Bright -",
+    "cmd": "A=~-16"
+  },
+  "0xF710EF": {
+    "label": "Timer1H",
+    "pos": "3x1",
+    "cmnt": "Timer 60 min",
+    "cmd": "NL=60&NT=0"
+  },
+  "0xF7906F": {
+    "label": "Timer4H",
+    "pos": "3x2",
+    "cmnt": "Timer 30 min",
+    "cmd": "NL=30&NT=0"
+  },
+  "0xF750AF": {
+    "label": "Timer8H",
+    "pos": "3x3",
+    "cmnt": "Timer 15 min",
+    "cmd": "NL=15&NT=0"
+  },
+  "0xF7D02F": {
+    "label": "Bright128",
+    "pos": "3x4",
+    "cmnt": "Bright 128",
+    "cmd": "A=128"
+  },
+  "0xF730CF": {
+    "label": "Music1",
+    "pos": "4x1",
+    "cmnt": "Cycle FX +",
+    "cmd": "FX=~"
+  },
+  "0xF7B04F": {
+    "label": "Music2",
+    "pos": "4x2",
+    "cmnt": "Cycle FX -",
+    "cmd": "FX=~-1"
+  },
+  "0xF7708F": {
+    "label": "Music3",
+    "pos": "4x3",
+    "cmnt": "Reset FX and FP",
+    "cmd": "FX=1&PF=6"
+  },
+  "0xF7F00F": {
+    "label": "Bright +",
+    "pos": "4x4",
+    "cmnt": "Bright +",
+    "cmd": "A=~16"
+  },
+  "0xF708F7": {
+    "label": "Mode1",
+    "pos": "5x1",
+    "cmnt": "Preset 1",
+    "cmd": "PL=1"
+  },
+  "0xF78877": {
+    "label": "Mode2",
+    "pos": "5x2",
+    "cmnt": "Preset 2",
+    "cmd": "PL=2"
+  },
+  "0xF748B7": {
+    "label": "Mode3",
+    "pos": "5x3",
+    "cmnt": "Preset 3",
+    "cmd": "PL=3"
+  },
+  "0xF7C837": {
+    "label": "Up",
+    "pos": "5x4",
+    "cmnt": "Intensity +",
+    "cmd": "IX=~16"
+  },
+  "0xF728D7": {
+    "label": "Mode4",
+    "pos": "6x1",
+    "cmnt": "Preset 4",
+    "cmd": "PL=4"
+  },
+  "0xF7A857": {
+    "label": "Mode5",
+    "pos": "6x2",
+    "cmnt": "Preset 5",
+    "cmd": "PL=5"
+  },
+  "0xF76897": {
+    "label": "Cycle",
+    "pos": "6x3",
+    "cmnt": "Toggle preset cycle",
+    "cmd": "CY=1&PT=60000"
+  },
+  "0xF7E817": {
+    "label": "Down",
+    "pos": "6x4",
+    "cmnt": "Intensity -",
+    "cmd": "IX=~-16"
+  }
+}

usermods/JSON_IR_remote/32-key_ir.json

@@ -0,0 +1,185 @@
+{
+  "desc": "32-key",
+  "0xFF08F7": {
+    "label": "On",
+    "pos": "1x1",
+    "cmd": "T=1"
+  },
+  "0xFFC03F": {
+    "label": "Off",
+    "pos": "1x2",
+    "cmd": "T=0"
+  },
+  "0xFF807F": {
+    "label": "Auto",
+    "pos": "1x3",
+    "cmnt": "Toggle preset cycle",
+    "cmd": "CY=2"
+  },
+  "0xFF609F": {
+    "label": "Mode",
+    "pos": "1x4",
+    "cmnt": "Cycle effects",
+    "cmd": "FX=~&CY=0"
+  },
+  "0xFF906F": {
+    "label": "4H",
+    "pos": "2x1",
+    "cmnt": "Timer 60min",
+    "cmd": "NL=60&NT=0"
+  },
+  "0xFFB847": {
+    "label": "6H",
+    "pos": "2x2",
+    "cmnt": "Timer 90min",
+    "cmd": "NL=90&NT=0"
+  },
+  "0xFFF807": {
+    "label": "8H",
+    "pos": "2x3",
+    "cmnt": "Timer 120min",
+    "cmd": "NL=120&NT=0"
+  },
+  "0xFFB04F": {
+    "label": "Timer Off",
+    "pos": "2x4",
+    "cmd": "NL=0"
+  },
+  "0xFF9867": {
+    "label": "Red",
+    "pos": "3x1",
+    "cmnt": "Lava",
+    "cmd": "FP=8"
+  },
+  "0xFFD827": {
+    "label": "Green",
+    "pos": "3x2",
+    "cmnt": "Forest",
+    "cmd": "FP=10"
+  },
+  "0xFF8877": {
+    "label": "Blue",
+    "pos": "3x3",
+    "cmnt": "Breeze",
+    "cmd": "FP=15"
+  },
+  "0xFFA857": {
+    "label": "White",
+    "pos": "3x4",
+    "cmd": "FP=5&CL=hFFFFFF&C2=hFFE4CD&C3=hE4E4FF"
+  },
+  "0xFFE817": {
+    "label": "OrangeRed",
+    "pos": "4x1",
+    "cmnt": "Sakura",
+    "cmd": "FP=49"
+  },
+  "0xFF48B7": {
+    "label": "SeaGreen",
+    "pos": "4x2",
+    "cmnt": "Rivendale",
+    "cmd": "FP=14"
+  },
+  "0xFF6897": {
+    "label": "RoyalBlue",
+    "pos": "4x3",
+    "cmnt": "Ocean",
+    "cmd": "FP=9"
+  },
+  "0xFFB24D": {
+    "label": "DarkBlue",
+    "pos": "4x4",
+    "cmnt": "Breeze",
+    "cmd": "FP=15"
+  },
+  "0xFF02FD": {
+    "label": "Orange",
+    "pos": "5x1",
+    "cmnt": "Orangery",
+    "cmd": "FP=47"
+  },
+  "0xFF32CD": {
+    "label": "YellowGreen",
+    "pos": "5x2",
+    "cmnt": "Aurora",
+    "cmd": "FP=37"
+  },
+  "0xFF20DF": {
+    "label": "SkyBlue",
+    "pos": "5x3",
+    "cmnt": "Beech",
+    "cmd": "FP=22"
+  },
+  "0xFF00FF": {
+    "label": "Orchid",
+    "pos": "5x4",
+    "cmd": "FP=5&CL=hDA70D6&C2=hDA70A0&C3=h89618F"
+  },
+  "0xFF50AF": {
+    "label": "Yellow",
+    "pos": "6x1",
+    "cmd": "FP=5&CL=hFFFF00&C2=hFFC800&C3=hFDFFDE"
+  },
+  "0xFF7887": {
+    "label": "DarkGreen",
+    "pos": "6x2",
+    "cmnt": "Orange and Teal",
+    "cmd": "FP=44"
+  },
+  "0xFF708F": {
+    "label": "RebeccaPurple",
+    "pos": "6x3",
+    "cmd": "FP=5&CL=h800080&C2=h800040&C3=h4B1C54"
+  },
+  "0xFF58A7": {
+    "label": "Plum",
+    "pos": "6x4",
+    "cmd": "FP=5&CL=hDDA0DD&C2=hDDA0BE&C3=h8D7791"
+  },
+  "0xFF38C7": {
+    "label": "Strobe",
+    "pos": "7x1",
+    "cmnt": "Dancing Shadows",
+    "cmd": "FX=112&CY=0"
+  },
+  "0xFF28D7": {
+    "label": "In Waves",
+    "pos": "7x2",
+    "cmnt": "Noise 1",
+    "cmd": "FX=70&CY=0"
+  },
+  "0xFFF00F": {
+    "label": "Speed +",
+    "pos": "7x3",
+    "cmd": "SX=~16"
+  },
+  "0xFF30CF": {
+    "label": "Speed -",
+    "pos": "7x4",
+    "cmd": "SX=~-16"
+  },
+  "0xFF40BF": {
+    "label": "Jump",
+    "pos": "8x1",
+    "cmnt": "Colortwinkles",
+    "cmd": "FX=74&CY=0"
+  },
+  "0xFF12ED": {
+    "label": "Fade",
+    "pos": "8x2",
+    "cmnt": "Sunrise",
+    "cmd": "FX=104&CY=0"
+  },
+  "0xFF2AD5": {
+    "label": "Flash",
+    "pos": "8x3",
+    "cmnt": "Railway",
+    "cmd": "FX=78&CY=0"
+  },
+  "0xFFA05F": {
+    "label": "Chase Flash",
+    "pos": "8x4",
+    "cmnt": "Washing Machine",
+    "cmd": "FX=113&CY=0"
+  }
+}

usermods/JSON_IR_remote/40-key-black_ir.json

@@ -0,0 +1,233 @@
+{
+  "desc": "40-key-black",
+  "0xFF3AC5": {
+    "label": "Bright +",
+    "pos": "1x1",
+    "cmd": "A=~16"
+  },
+  "0xFFBA45": {
+    "label": "Bright -",
+    "pos": "1x2",
+    "cmd": "A=~-16"
+  },
+  "0xFF827D": {
+    "label": "Off",
+    "pos": "1x3",
+    "cmd": "T=0"
+  },
+  "0xFF02FD": {
+    "label": "On",
+    "pos": "1x4",
+    "cmd": "T=1"
+  },
+  "0xFF1AE5": {
+    "label": "Red",
+    "pos": "2x1",
+    "cmnt": "Lava",
+    "cmd": "FP=8"
+  },
+  "0xFF9A65": {
+    "label": "Green",
+    "pos": "2x2",
+    "cmnt": "Forest",
+    "cmd": "FP=10"
+  },
+  "0xFFA25D": {
+    "label": "Blue",
+    "pos": "2x3",
+    "cmnt": "Breeze",
+    "cmd": "FP=15"
+  },
+  "0xFF22DD": {
+    "label": "White",
+    "pos": "2x4",
+    "cmd": "FP=5&CL=hFFFFFF&C2=hFFFFFF&C3=hA8A8A8"
+  },
+  "0xFF2AD5": {
+    "label": "Tomato",
+    "pos": "3x1",
+    "cmnt": "Yelmag",
+    "cmd": "FP=5&CL=hFF6347&C2=hFFBF47&C3=hA85859"
+  },
+  "0xFFAA55": {
+    "label": "LightGreen",
+    "pos": "3x2",
+    "cmnt": "Rivendale",
+    "cmd": "FP=14"
+  },
+  "0xFF926D": {
+    "label": "SkyBlue",
+    "pos": "3x3",
+    "cmnt": "Ocean",
+    "cmd": "FP=9"
+  },
+  "0xFF12ED": {
+    "label": "WarmWhite",
+    "pos": "3x4",
+    "cmnt": "Warm White",
+    "cmd": "FP=5&CL=hFFE4CD&C2=hFFFCCD&C3=hA89892"
+  },
+  "0xFF0AF5": {
+    "label": "OrangeRed",
+    "pos": "4x1",
+    "cmnt": "Sakura",
+    "cmd": "FP=49"
+  },
+  "0xFF8A75": {
+    "label": "Cyan",
+    "pos": "4x2",
+    "cmnt": "Beech",
+    "cmd": "FP=22"
+  },
+  "0xFFB24D": {
+    "label": "RebeccaPurple",
+    "pos": "4x3",
+    "cmd": "FP=5&CL=h663399&C2=h993399&C3=h473864"
+  },
+  "0xFF32CD": {
+    "label": "CoolWhite",
+    "pos": "4x4",
+    "cmnt": "Cool White",
+    "cmd": "FP=5&CL=hE4E4FF&C2=hF1E4FF&C3=h9C9EA8"
+  },
+  "0xFF38C7": {
+    "label": "Orange",
+    "pos": "5x1",
+    "cmnt": "Orangery",
+    "cmd": "FP=47"
+  },
+  "0xFFB847": {
+    "label": "Turquoise",
+    "pos": "5x2",
+    "cmd": "FP=5&CL=h40E0D0&C2=h40A0E0&C3=h4E9381"
+  },
+  "0xFF7887": {
+    "label": "Purple",
+    "pos": "5x3",
+    "cmd": "FP=5&CL=h800080&C2=h800040&C3=h4B1C54"
+  },
+  "0xFFF807": {
+    "label": "MedGray",
+    "pos": "5x4",
+    "cmnt": "Cycle palette +",
+    "cmd": "FP=~"
+  },
+  "0xFF18E7": {
+    "label": "Yellow",
+    "pos": "6x1",
+    "cmd": "FP=5&CL=hFFFF00&C2=h7FFF00&C3=hA89539"
+  },
+  "0xFF9867": {
+    "label": "DarkCyan",
+    "pos": "6x2",
+    "cmd": "FP=5&CL=h8B8B&C2=h458B&C3=h1F5B51"
+  },
+  "0xFF58A7": {
+    "label": "Plum",
+    "pos": "6x3",
+    "cmnt": "Magenta",
+    "cmd": "FP=40"
+  },
+  "0xFFD827": {
+    "label": "DarkGray",
+    "pos": "6x4",
+    "cmnt": "Cycle palette -",
+    "cmd": "FP=~-"
+  },
+  "0xFF28D7": {
+    "label": "Jump3",
+    "pos": "7x1",
+    "cmnt": "Colortwinkles",
+    "cmd": "CY=0&FX=74"
+  },
+  "0xFFA857": {
+    "label": "Fade3",
+    "pos": "7x2",
+    "cmnt": "Rain",
+    "cmd": "CY=0&FX=43"
+  },
+  "0xFF6897": {
+    "label": "Flash",
+    "pos": "7x3",
+    "cmnt": "Cycle Effects",
+    "cmd": "CY=0&FX=~"
+  },
+  "0xFFE817": {
+    "label": "Quick",
+    "pos": "7x4",
+    "cmnt": "Fx speed +16",
+    "cmd": "SX=~16"
+  },
+  "0xFF08F7": {
+    "label": "Jump7",
+    "pos": "8x1",
+    "cmnt": "Sinelon Dual",
+    "cmd": "CY=0&FX=93"
+  },
+  "0xFF8877": {
+    "label": "Fade7",
+    "pos": "8x2",
+    "cmnt": "Lighthouse",
+    "cmd": "CY=0&FX=41"
+  },
+  "0xFF48B7": {
+    "label": "Auto",
+    "pos": "8x3",
+    "cmnt": "Toggle preset cycle",
+    "cmd": "CY=2"
+  },
+  "0xFFC837": {
+    "label": "Slow",
+    "pos": "8x4",
+    "cmnt": "FX speed -16",
+    "cmd": "SX=~-16"
+  },
+  "0xFF30CF": {
+    "label": "Custom1",
+    "pos": "9x1",
+    "cmnt": "Noise 1",
+    "cmd": "CY=0&FX=70"
+  },
+  "0xFFB04F": {
+    "label": "Custom2",
+    "pos": "9x2",
+    "cmnt": "Dancing Shadows",
+    "cmd": "CY=0&FX=112"
+  },
+  "0xFF708F": {
+    "label": "Music +",
+    "pos": "9x3",
+    "cmnt": "FX Intensity +16",
+    "cmd": "IX=~16"
+  },
+  "0xFFF00F": {
+    "label": "Timer60",
+    "pos": "9x4",
+    "cmnt": "Timer 60 min",
+    "cmd": "NL=60&NT=0"
+  },
+  "0xFF10EF": {
+    "label": "Custom3",
+    "pos": "10x1",
+    "cmnt": "Twinklefox",
+    "cmd": "CY=0&FX=80"
+  },
+  "0xFF906F": {
+    "label": "Custom4",
+    "pos": "10x2",
+    "cmnt": "Twinklecat",
+    "cmd": "CY=0&FX=81"
+  },
+  "0xFF50AF": {
+    "label": "Music -",
+    "pos": "10x3",
+    "cmnt": "FX Intesity -16",
+    "cmd": "IX=~-16"
+  },
+  "0xFFD02F": {
+    "label": "Timer120",
+    "pos": "10x4",
+    "cmnt": "Timer 120 min",
+    "cmd": "NL=120&NT=0"
+  }
+}

usermods/JSON_IR_remote/40-key-blue_ir.json

@@ -0,0 +1,217 @@
+{
+  "desc": "40-key-blue",
+  "0xFF3AC5": {
+    "label": "Bright +",
+    "pos": "1x1",
+    "cmd": "A=~16"
+  },
+  "0xFFBA45": {
+    "label": "Bright -",
+    "pos": "1x2",
+    "cmd": "A=~-16"
+  },
+  "0xFF827D": {
+    "label": "Off",
+    "pos": "1x3",
+    "cmd": "T=0"
+  },
+  "0xFF02FD": {
+    "label": "On",
+    "pos": "1x4",
+    "cmd": "T=1"
+  },
+  "0xFF1AE5": {
+    "label": "Red",
+    "pos": "2x1",
+    "cmnt": "Lava",
+    "cmd": "FP=8"
+  },
+  "0xFF9A65": {
+    "label": "Green",
+    "pos": "2x2",
+    "cmnt": "Forest",
+    "cmd": "FP=10"
+  },
+  "0xFFA25D": {
+    "label": "Blue",
+    "pos": "2x3",
+    "cmnt": "Breeze",
+    "cmd": "FP=15"
+  },
+  "0xFF22DD": {
+    "label": "White",
+    "pos": "2x4",
+    "cmd": "FP=5&CL=hFFFFFF&C2=hFFFFFF&C3=hA8A8A8"
+  },
+  "0xFF2AD5": {
+    "label": "Tomato",
+    "pos": "3x1",
+    "cmnt": "Yelmag",
+    "cmd": "FP=5&CL=hFF6347&C2=hFFBF47&C3=hA85859"
+  },
+  "0xFFAA55": {
+    "label": "LightGreen",
+    "pos": "3x2",
+    "cmnt": "Rivendale",
+    "cmd": "FP=14"
+  },
+  "0xFF926D": {
+    "label": "SkyBlue",
+    "pos": "3x3",
+    "cmnt": "Ocean",
+    "cmd": "FP=9"
+  },
+  "0xFF12ED": {
+    "label": "WarmWhite",
+    "pos": "3x4",
+    "cmnt": "Warm White",
+    "cmd": "FP=5&CL=hFFE4CD&C2=hFFFCCD&C3=hA89892"
+  },
+  "0xFF0AF5": {
+    "label": "OrangeRed",
+    "pos": "4x1",
+    "cmnt": "Sakura",
+    "cmd": "FP=49"
+  },
+  "0xFF8A75": {
+    "label": "Cyan",
+    "pos": "4x2",
+    "cmnt": "Beech",
+    "cmd": "FP=22"
+  },
+  "0xFFB24D": {
+    "label": "RebeccaPurple",
+    "pos": "4x3",
+    "cmd": "FP=5&CL=h663399&C2=h993399&C3=h473864"
+  },
+  "0xFF32CD": {
+    "label": "CoolWhite",
+    "pos": "4x4",
+    "cmnt": "Cool White",
+    "cmd": "FP=5&CL=hE4E4FF&C2=hF1E4FF&C3=h9C9EA8"
+  },
+  "0xFF38C7": {
+    "label": "Orange",
+    "pos": "5x1",
+    "cmnt": "Orangery",
+    "cmd": "FP=47"
+  },
+  "0xFFB847": {
+    "label": "Turquoise",
+    "pos": "5x2",
+    "cmd": "FP=5&CL=h40E0D0&C2=h40A0E0&C3=h4E9381"
+  },
+  "0xFF7887": {
+    "label": "Purple",
+    "pos": "5x3",
+    "cmd": "FP=5&CL=h800080&C2=h800040&C3=h4B1C54"
+  },
+  "0xFFF807": {
+    "label": "MedGray",
+    "pos": "5x4",
+    "cmnt": "Cycle palette +",
+    "cmd": "FP=~"
+  },
+  "0xFF18E7": {
+    "label": "Yellow",
+    "pos": "6x1",
+    "cmd": "FP=5&CL=hFFFF00&C2=h7FFF00&C3=hA89539"
+  },
+  "0xFF9867": {
+    "label": "DarkCyan",
+    "pos": "6x2",
+    "cmd": "FP=5&CL=h8B8B&C2=h458B&C3=h1F5B51"
+  },
+  "0xFF58A7": {
+    "label": "Plum",
+    "pos": "6x3",
+    "cmnt": "Magenta",
+    "cmd": "FP=40"
+  },
+  "0xFFD827": {
+    "label": "DarkGray",
+    "pos": "6x4",
+    "cmnt": "Cycle palette -",
+    "cmd": "FP=~-"
+  },
+  "0xFF28D7": {
+    "label": "W +",
+    "pos": "7x1"
+  },
+  "0xFFA857": {
+    "label": "W -",
+    "pos": "7x2"
+  },
+  "0xFF6897": {
+    "label": "W On",
+    "pos": "7x3"
+  },
+  "0xFFE817": {
+    "label": "W Off",
+    "pos": "7x4"
+  },
+  "0xFF08F7": {
+    "label": "W25",
+    "pos": "8x1"
+  },
+  "0xFF8877": {
+    "label": "W50",
+    "pos": "8x2"
+  },
+  "0xFF48B7": {
+    "label": "W75",
+    "pos": "8x3"
+  },
+  "0xFFC837": {
+    "label": "W100",
+    "pos": "8x4"
+  },
+  "0xFF30CF": {
+    "label": "Jump3",
+    "pos": "9x1",
+    "cmnt": "Colortwinkles",
+    "cmd": "CY=0&FX=74"
+  },
+  "0xFFB04F": {
+    "label": "Fade3",
+    "pos": "9x2",
+    "cmnt": "Rain",
+    "cmd": "CY=0&FX=43"
+  },
+  "0xFF708F": {
+    "label": "Jump7",
+    "pos": "9x3",
+    "cmnt": "Sinelon Dual",
+    "cmd": "CY=0&FX=93"
+  },
+  "0xFFF00F": {
+    "label": "Quick",
+    "pos": "9x4",
+    "cmnt": "Fx speed +16",
+    "cmd": "SX=~16"
+  },
+  "0xFF10EF": {
+    "label": "Fade",
+    "pos": "10x1",
+    "cmnt": "Lighthouse",
+    "cmd": "CY=0&FX=41"
+  },
+  "0xFF906F": {
+    "label": "Flash",
+    "pos": "10x2",
+    "cmnt": "Cycle Effects",
+    "cmd": "CY=0&FX=~"
+  },
+  "0xFF50AF": {
+    "label": "Auto",
+    "pos": "10x3",
+    "cmnt": "Toggle preset cycle",
+    "cmd": "CY=2"
+  },
+  "0xFFD02F": {
+    "label": "Slow",
+    "pos": "10x4",
+    "cmnt": "Sinelon Dual",
+    "cmd": "CY=0&FX=93"
+  }
+}

usermods/JSON_IR_remote/44-key_ir.json

@@ -0,0 +1,241 @@
+{
+  "desc": "44-key",
+  "0xFF3AC5": {
+    "label": "Bright +",
+    "pos": "1x1",
+    "cmd": "A=~16"
+  },
+  "0xFFBA45": {
+    "label": "Bright -",
+    "pos": "1x2",
+    "cmd": "A=~-16"
+  },
+  "0xFF827D": {
+    "label": "Off",
+    "pos": "1x3",
+    "cmd": "T=0"
+  },
+  "0xFF02FD": {
+    "label": "On",
+    "pos": "1x4",
+    "cmd": "T=1"
+  },
+  "0xFF1AE5": {
+    "label": "Red",
+    "pos": "2x1",
+    "cmnt": "Lava",
+    "cmd": "FP=8"
+  },
+  "0xFF9A65": {
+    "label": "Green",
+    "pos": "2x2",
+    "cmnt": "Forest",
+    "cmd": "FP=10"
+  },
+  "0xFFA25D": {
+    "label": "Blue",
+    "pos": "2x3",
+    "cmnt": "Breeze",
+    "cmd": "FP=15"
+  },
+  "0xFF22DD": {
+    "label": "White",
+    "pos": "2x4",
+    "cmd": "FP=5&CL=hFFFFFF&C2=hFFFFFF&C3=hA8A8A8"
+  },
+  "0xFF2AD5": {
+    "label": "Tomato",
+    "pos": "3x1",
+    "cmd": "FP=5&CL=hFF6347&C2=hFFBF47&C3=hA85859"
+  },
+  "0xFFAA55": {
+    "label": "LightGreen",
+    "pos": "3x2",
+    "cmnt": "Rivendale",
+    "cmd": "FP=14"
+  },
+  "0xFF926D": {
+    "label": "DeepBlue",
+    "pos": "3x3",
+    "cmnt": "Ocean",
+    "cmd": "FP=9"
+  },
+  "0xFF12ED": {
+    "label": "Warmwhite2",
+    "pos": "3x4",
+    "cmnt": "Warm White",
+    "cmd": "FP=5&CL=hFFE4CD&C2=hFFFCCD&C3=hA89892"
+  },
+  "0xFF0AF5": {
+    "label": "Orange",
+    "pos": "4x1",
+    "cmnt": "Sakura",
+    "cmd": "FP=49"
+  },
+  "0xFF8A75": {
+    "label": "Turquoise",
+    "pos": "4x2",
+    "cmnt": "Beech",
+    "cmd": "FP=22"
+  },
+  "0xFFB24D": {
+    "label": "Purple",
+    "pos": "4x3",
+    "cmd": "FP=5&CL=h663399&C2=h993399&C3=h473864"
+  },
+  "0xFF32CD": {
+    "label": "WarmWhite",
+    "pos": "4x4",
+    "cmd": "FP=5&CL=hE4E4FF&C2=hF1E4FF&C3=h9C9EA8"
+  },
+  "0xFF38C7": {
+    "label": "Yellowish",
+    "pos": "5x1",
+    "cmnt": "Orangery",
+    "cmd": "FP=47"
+  },
+  "0xFFB847": {
+    "label": "Cyan",
+    "pos": "5x2",
+    "cmnt": "Beech",
+    "cmd": "FP=22"
+  },
+  "0xFF7887": {
+    "label": "Magenta",
+    "pos": "5x3",
+    "cmd": "FP=5&CL=hFF00FF&C2=hFF007F&C3=h9539A8"
+  },
+  "0xFFF807": {
+    "label": "ColdWhite",
+    "pos": "5x4",
+    "cmd": "FP=5&CL=hE4E4FF&C2=hF1E4FF&C3=h9C9EA8"
+  },
+  "0xFF18E7": {
+    "label": "Yellow",
+    "pos": "6x1",
+    "cmd": "FP=5&CL=hFFFF00&C2=hFFC800&C3=hFDFFDE"
+  },
+  "0xFF9867": {
+    "label": "Aqua",
+    "pos": "6x2",
+    "cmd": "FP=5&CL=hFFFF&C2=h7FFF&C3=h39A895"
+  },
+  "0xFF58A7": {
+    "label": "Pink",
+    "pos": "6x3",
+    "cmd": "FP=5&CL=hFFC0CB&C2=hFFD4C0&C3=hA88C96"
+  },
+  "0xFFD827": {
+    "label": "ColdWhite2",
+    "pos": "6x4",
+    "cmd": "FP=5&CL=hE4E4FF&C2=hF1E4FF&C3=h9C9EA8"
+  },
+  "0xFF28D7": {
+    "label": "Red +",
+    "pos": "7x1",
+    "cmd": "FP=5&R=~16"
+  },
+  "0xFFA857": {
+    "label": "Green +",
+    "pos": "7x2",
+    "cmd": "FP=5&G=~16"
+  },
+  "0xFF6897": {
+    "label": "Blue +",
+    "pos": "7x3",
+    "cmd": "FP=5&B=~16"
+  },
+  "0xFFE817": {
+    "label": "Quick",
+    "pos": "7x4",
+    "cmnt": "Fx speed +16",
+    "cmd": "SX=~16"
+  },
+  "0xFF08F7": {
+    "label": "Red -",
+    "pos": "8x1",
+    "cmd": "FP=5&R=~-16"
+  },
+  "0xFF8877": {
+    "label": "Green -",
+    "pos": "8x2",
+    "cmd": "FP=5&G=~-16"
+  },
+  "0xFF48B7": {
+    "label": "Blue -",
+    "pos": "8x3",
+    "cmd": "FP=5&B=~-16"
+  },
+  "0xFFC837": {
+    "label": "Slow",
+    "pos": "8x4",
+    "cmnt": "FX speed -16",
+    "cmd": "SX=~-16"
+  },
+  "0xFF30CF": {
+    "label": "Diy1",
+    "pos": "9x1",
+    "cmd": "CY=0&PL=1"
+  },
+  "0xFFB04F": {
+    "label": "Diy2",
+    "pos": "9x2",
+    "cmd": "CY=0&PL=2"
+  },
+  "0xFF708F": {
+    "label": "Diy3",
+    "pos": "9x3",
+    "cmd": "CY=0&PL=3"
+  },
+  "0xFFF00F": {
+    "label": "Auto",
+    "pos": "9x4",
+    "cmnt": "Toggle preset cycle",
+    "cmd": "CY=2"
+  },
+  "0xFF10EF": {
+    "label": "Diy4",
+    "pos": "10x1",
+    "cmd": "CY=0&PL=4"
+  },
+  "0xFF906F": {
+    "label": "Diy5",
+    "pos": "10x2",
+    "cmd": "CY=0&PL=5"
+  },
+  "0xFF50AF": {
+    "label": "Diy6",
+    "pos": "10x3",
+    "cmd": "CY=0&PL=6"
+  },
+  "0xFFD02F": {
+    "label": "Flash",
+    "pos": "10x4",
+    "cmnt": "Cycle Effects",
+    "cmd": "CY=0&FX=~"
+  },
+  "0xFF20DF": {
+    "label": "Jump3",
+    "pos": "11x1",
+    "cmnt": "Colortwinkles",
+    "cmd": "CY=0&FX=74"
+  },
+  "0xFFA05F": {
+    "label": "Jump7",
+    "pos": "11x2",
+    "cmnt": "Sinelon Dual",
+    "cmd": "CY=0&FX=93"
+  },
+  "0xFF609F": {
+    "label": "Fade3",
+    "pos": "11x3",
+    "cmnt": "Rain",
+    "cmd": "CY=0&FX=43"
+  },
+  "0xFFE01F": {
+    "label": "Fade7",
+    "pos": "11x4",
+    "cmnt": "Lighthouse",
+    "cmd": "CY=0&FX=41"
+  }
+}

usermods/JSON_IR_remote/6-key_ir.json

@@ -0,0 +1,38 @@
+{
+  "desc": "6-key",
+  "0xFF0FF0": {
+    "label": "Power",
+    "pos": "1x1",
+    "cmd": "T=2"
+  },
+  "0xFF8F70": {
+    "label": "Channel +",
+    "pos": "2x1",
+    "cmnt": "Cycle palette up",
+    "cmd": "FP=~"
+  },
+  "0xFF4FB0": {
+    "label": "Channel -",
+    "pos": "3x1",
+    "cmnt": "Cycle palette down",
+    "cmd": "FP=~-"
+  },
+  "0xFFCF30": {
+    "label": "Volume +",
+    "pos": "4x1",
+    "cmnt": "Brighten",
+    "cmd": "A=~16"
+  },
+  "0xFF2FD0": {
+    "label": "Volume -",
+    "pos": "5x1",
+    "cmnt": "Dim",
+    "cmd": "A=~-16"
+  },
+  "0xFFAF50": {
+    "label": "Mute",
+    "pos": "6x1",
+    "cmnt": "Cycle effects",
+    "cmd": "CY=0&FX=~"
+  }
+}

usermods/JSON_IR_remote/9-key_ir.json

@@ -0,0 +1,47 @@
+{
+  "desc": "9-key",
+  "0xFF629D": {
+    "label": "Power",
+    "cmd": "T=2"
+  },
+  "0xFF22DD": {
+    "label": "A",
+    "cmnt": "Preset 1",
+    "cmd": "PL=1"
+  },
+  "0xFF02FD": {
+    "label": "B",
+    "cmnt": "Preset 2",
+    "cmd": "PL=2"
+  },
+  "0xFFC23D": {
+    "label": "C",
+    "cmnt": "Preset 3",
+    "cmd": "PL=3"
+  },
+  "0xFF30CF": {
+    "label": "Left",
+    "cmnt": "Speed -",
+    "cmd": "SI=~-16"
+  },
+  "0xFF7A85": {
+    "label": "Right",
+    "cmnt": "Speed +",
+    "cmd": "SI=~16"
+  },
+  "0xFF9867": {
+    "label": "Up",
+    "cmnt": "Bright +",
+    "cmd": "A=~16"
+  },
+  "0xFF38C7": {
+    "label": "Down",
+    "cmnt": "Bright -",
+    "cmd": "A=~-16"
+  },
+  "0xFF18E7": {
+    "label": "Select",
+    "cmnt": "Cycle effects",
+    "cmd": "CY=0&FX=~"
+  }
+}

usermods/JSON_IR_remote/ir_json_maker.py

@@ -0,0 +1,108 @@
+import colorsys
+import json
+import openpyxl
+
+named_colors = {'AliceBlue': '0xF0F8FF', 'AntiqueWhite': '0xFAEBD7', 'Aqua': '0x00FFFF',
+                'Aquamarine': '0x7FFFD4', 'Azure': '0xF0FFFF', 'Beige': '0xF5F5DC', 'Bisque': '0xFFE4C4',
+                'Black': '0x000000', 'BlanchedAlmond': '0xFFEBCD', 'Blue': '0x0000FF',
+                'BlueViolet': '0x8A2BE2', 'Brown': '0xA52A2A', 'BurlyWood': '0xDEB887',
+                'CadetBlue': '0x5F9EA0', 'Chartreuse': '0x7FFF00', 'Chocolate': '0xD2691E',
+                'Coral': '0xFF7F50', 'CornflowerBlue': '0x6495ED', 'Cornsilk': '0xFFF8DC',
+                'Crimson': '0xDC143C', 'Cyan': '0x00FFFF', 'DarkBlue': '0x00008B', 'DarkCyan': '0x008B8B',
+                'DarkGoldenRod': '0xB8860B', 'DarkGray': '0xA9A9A9', 'DarkGrey': '0xA9A9A9',
+                'DarkGreen': '0x006400', 'DarkKhaki': '0xBDB76B', 'DarkMagenta': '0x8B008B',
+                'DarkOliveGreen': '0x556B2F', 'DarkOrange': '0xFF8C00', 'DarkOrchid': '0x9932CC',
+                'DarkRed': '0x8B0000', 'DarkSalmon': '0xE9967A', 'DarkSeaGreen': '0x8FBC8F',
+                'DarkSlateBlue': '0x483D8B', 'DarkSlateGray': '0x2F4F4F', 'DarkSlateGrey': '0x2F4F4F',
+                'DarkTurquoise': '0x00CED1', 'DarkViolet': '0x9400D3', 'DeepPink': '0xFF1493',
+                'DeepSkyBlue': '0x00BFFF', 'DimGray': '0x696969', 'DimGrey': '0x696969',
+                'DodgerBlue': '0x1E90FF', 'FireBrick': '0xB22222', 'FloralWhite': '0xFFFAF0',
+                'ForestGreen': '0x228B22', 'Fuchsia': '0xFF00FF', 'Gainsboro': '0xDCDCDC',
+                'GhostWhite': '0xF8F8FF', 'Gold': '0xFFD700', 'GoldenRod': '0xDAA520', 'Gray': '0x808080',
+                'Grey': '0x808080', 'Green': '0x008000', 'GreenYellow': '0xADFF2F', 'HoneyDew': '0xF0FFF0',
+                'HotPink': '0xFF69B4', 'IndianRed': '0xCD5C5C', 'Indigo': '0x4B0082', 'Ivory': '0xFFFFF0',
+                'Khaki': '0xF0E68C', 'Lavender': '0xE6E6FA', 'LavenderBlush': '0xFFF0F5',
+                'LawnGreen': '0x7CFC00', 'LemonChiffon': '0xFFFACD', 'LightBlue': '0xADD8E6',
+                'LightCoral': '0xF08080', 'LightCyan': '0xE0FFFF', 'LightGoldenRodYellow': '0xFAFAD2',
+                'LightGray': '0xD3D3D3', 'LightGrey': '0xD3D3D3', 'LightGreen': '0x90EE90',
+                'LightPink': '0xFFB6C1', 'LightSalmon': '0xFFA07A', 'LightSeaGreen': '0x20B2AA',
+                'LightSkyBlue': '0x87CEFA', 'LightSlateGray': '0x778899', 'LightSlateGrey': '0x778899',
+                'LightSteelBlue': '0xB0C4DE', 'LightYellow': '0xFFFFE0', 'Lime': '0x00FF00',
+                'LimeGreen': '0x32CD32', 'Linen': '0xFAF0E6', 'Magenta': '0xFF00FF', 'Maroon': '0x800000',
+                'MediumAquaMarine': '0x66CDAA', 'MediumBlue': '0x0000CD', 'MediumOrchid': '0xBA55D3',
+                'MediumPurple': '0x9370DB', 'MediumSeaGreen': '0x3CB371', 'MediumSlateBlue': '0x7B68EE',
+                'MediumSpringGreen': '0x00FA9A', 'MediumTurquoise': '0x48D1CC', 'MediumVioletRed': '0xC71585',
+                'MidnightBlue': '0x191970', 'MintCream': '0xF5FFFA', 'MistyRose': '0xFFE4E1',
+                'Moccasin': '0xFFE4B5', 'NavajoWhite': '0xFFDEAD', 'Navy': '0x000080', 'OldLace': '0xFDF5E6',
+                'Olive': '0x808000', 'OliveDrab': '0x6B8E23', 'Orange': '0xFFA500', 'OrangeRed': '0xFF4500',
+                'Orchid': '0xDA70D6', 'PaleGoldenRod': '0xEEE8AA', 'PaleGreen': '0x98FB98',
+                'PaleTurquoise': '0xAFEEEE', 'PaleVioletRed': '0xDB7093', 'PapayaWhip': '0xFFEFD5',
+                'PeachPuff': '0xFFDAB9', 'Peru': '0xCD853F', 'Pink': '0xFFC0CB', 'Plum': '0xDDA0DD',
+                'PowderBlue': '0xB0E0E6', 'Purple': '0x800080', 'RebeccaPurple': '0x663399', 'Red': '0xFF0000',
+                'RosyBrown': '0xBC8F8F', 'RoyalBlue': '0x4169E1', 'SaddleBrown': '0x8B4513', 'Salmon': '0xFA8072',
+                'SandyBrown': '0xF4A460', 'SeaGreen': '0x2E8B57', 'SeaShell': '0xFFF5EE', 'Sienna': '0xA0522D',
+                'Silver': '0xC0C0C0', 'SkyBlue': '0x87CEEB', 'SlateBlue': '0x6A5ACD', 'SlateGray': '0x708090',
+                'SlateGrey': '0x708090', 'Snow': '0xFFFAFA', 'SpringGreen': '0x00FF7F', 'SteelBlue': '0x4682B4',
+                'Tan': '0xD2B48C', 'Teal': '0x008080', 'Thistle': '0xD8BFD8', 'Tomato': '0xFF6347',
+                'Turquoise': '0x40E0D0', 'Violet': '0xEE82EE', 'Wheat': '0xF5DEB3', 'White': '0xFFFFFF',
+                'WhiteSmoke': '0xF5F5F5', 'Yellow': '0xFFFF00', 'YellowGreen': '0x9ACD32'}
+
+def shift_color(col, shift=30, sat=1.0, val=1.0):
+    r = (col & (255 << 16)) >> 16
+    g = (col & (255 << 8)) >> 8
+    b = col & 255
+    hsv = colorsys.rgb_to_hsv(r, g, b)
+    h = (((hsv[0] * 360) + shift) % 360) / 360
+    rgb = colorsys.hsv_to_rgb(h, hsv[1] * sat, hsv[2] * val)
+    return (int(rgb[0]) << 16) + (int(rgb[1]) << 8) + int(rgb[2])
+
+def parse_sheet(ws):
+    print(f'Parsing worksheet {ws.title}')
+    ir = {"desc": ws.title}
+    rows = ws.rows
+    keys = [col.value.lower() for col in next(rows)]
+    for row in rows:
+        rec = dict(zip(keys, [col.value for col in row]))
+        if rec.get('code') is None:
+            continue
+        cd = {"label": rec.get('label')}
+        if rec.get('row'):
+            cd['pos'] = f'{rec["row"]}x{rec["col"]}'
+        if rec.get('comment'):
+            cd['cmnt'] = rec.get('comment')
+        if rec.get('rpt'):
+            cd['rpt'] = bool(rec['rpt'])
+                       
+        if rec.get('cmd'):
+            cd['cmd'] = rec['cmd']
+        elif all((rec.get('primary'), rec.get('secondary'), rec.get('tertiary'))):
+            c1 = int(rec.get('primary'), 16)
+            c2 = int(rec.get('secondary'), 16)
+            c3 = int(rec.get('tertiary'), 16)
+            cd['cmd'] = f'FP=5&CL=h{c1:X}&C2=h{c2:X}&C3=h{c3:X}'
+        elif all((rec.get('primary'), rec.get('secondary'))):
+            c1 = int(rec.get('primary'), 16)
+            c2 = int(rec.get('secondary'), 16)
+            c3 = shift_color(c1, -1, sat=0.66, val=0.66)
+            cd['cmd'] = f'FP=5&CL=h{c1:X}&C2=h{c2:X}&C3=h{c3:X}'
+        elif rec.get('primary'):
+            c1 = int(rec.get('primary'), 16)
+            c2 = shift_color(c1, 30)
+            c3 = shift_color(c1, -10, sat=0.66, val=0.66)
+            cd['cmd'] = f'FP=5&CL=h{c1:X}&C2=h{c2:X}&C3=h{c3:X}'
+        elif rec.get('label') in named_colors:
+            c1 = int(named_colors[rec.get('label')], 16)
+            c2 = shift_color(c1, 30)
+            c3 = shift_color(c1, -10, sat=0.66, val=0.66)
+            cd['cmd'] = f'FP=5&CL=h{c1:X}&C2=h{c2:X}&C3=h{c3:X}'
+        else:
+            print(f'Did not find a command or color for {rec["label"]}. Hint use named CSS colors as labels')
+        ir[rec['code']] = cd
+            
+    with open(f'{ws.title}_ir.json', 'w') as fp:
+        json.dump(ir, fp, indent=2)        
+
+if __name__ == '__main__':
+    wb = openpyxl.load_workbook('IR_Remote_Codes.xlsx')
+    for ws in wb.worksheets:
+        parse_sheet(ws)

usermods/JSON_IR_remote/readme.md

@@ -0,0 +1,33 @@
+# JSON IR remote
+
+## 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
+map buttons from any remote to any HTTP request API or JSON API command.  
+
+## Usage
+
+* Upload the IR config file, named _ir.json_ to your board using the [ip address]/edit url. Pick from one of the included files or create your own.
+* On the config > LED settings page, set the correct IR pin.
+* On the config > Sync Interfaces page, select "JSON Remote" as the Infrared remote.
+
+## Modification
+
+* See if there is a json file with the same number of buttons as your remote. Many remotes will have the same internals and emit the same codes but have different labels.
+* In the ir.json file, each key will be the hex encoded IR code.
+* The "cmd" property will be the HTTP Request API or JSON API to execute when that button is pressed.
+* A limited number of c functions are supported (!incBrightness, !decBrightness, !presetFallback)
+* When using !presetFallback, include properties PL (preset to load), FX (effect to fall back to) and FP (palette to fall back to)
+* If the command is _repeatable_ and does not contain the "~" character, add a "rpt": true property.
+* Other properties are ignored, but having a label property may help when editing.
+
+
+Sample:
+{
+  "0xFF629D": {"cmd": "T=2", "rpt": true, "label": "Toggle on/off"},  // HTTP command
+  "0xFF9867": {"cmd": "A=~16", "label": "Inc brightness"},            // HTTP command with incrementing          
+  "0xFF38C7": {"cmd": {"bri": 10}, "label": "Dim to 10"},             // JSON command 
+  "0xFF22DD": {"cmd": "!presetFallback", "PL": 1, "FX": 16, "FP": 6,  
+               "label": "Preset 1 or fallback to Saw - Party"},       // c function
+}

usermods/PIR_sensor_switch/PIR_Highlight_Standby

@@ -62,7 +62,7 @@ class PIRsensorSwitch : public Usermod {
     // PIR sensor pin
     const uint8_t PIRsensorPin = 13; // D7 on D1 mini
     // notification mode for colorUpdated()
-    const byte NotifyUpdateMode = NOTIFIER_CALL_MODE_NO_NOTIFY; // NOTIFIER_CALL_MODE_DIRECT_CHANGE
+    const byte NotifyUpdateMode = CALL_MODE_NO_NOTIFY; // CALL_MODE_DIRECT_CHANGE
     // 1 min delay before switch off after the sensor state goes LOW
     uint32_t m_switchOffDelay = 60000;
     // off timer start time

usermods/PIR_sensor_switch/usermod_PIR_sensor_switch.h

@@ -58,7 +58,7 @@ private:
   // PIR sensor pin
   int8_t PIRsensorPin = PIR_SENSOR_PIN;
   // notification mode for colorUpdated()
-  const byte NotifyUpdateMode = NOTIFIER_CALL_MODE_NO_NOTIFY; // NOTIFIER_CALL_MODE_DIRECT_CHANGE
+  const byte NotifyUpdateMode = CALL_MODE_NO_NOTIFY; // CALL_MODE_DIRECT_CHANGE
   // delay before switch off after the sensor state goes LOW
   uint32_t m_switchOffDelay = 600000; // 10min
   // off timer start time

usermods/ST7789_display/README.md

@@ -0,0 +1,72 @@
+# ST7789 TFT IPS Color display 240x240pxwith ESP32 boards
+
+This usermod allow to use 240x240 display to display following:
+
+* Network SSID;
+* IP address;
+* Brightness;
+* Chosen effect;
+* Chosen palette;
+* Estimated current in mA;
+
+## Hardware
+
+***
+![Hardware](images/ST7789_guide.jpg)
+
+## Library used
+
+[Bodmer/TFT_eSPI](https://github.com/Bodmer/TFT_eSPI)
+
+## Setup
+
+***
+
+### Platformio.ini changes
+
+In the `platformio.ini` file, uncomment the `TFT_eSPI` line within the [common] section, under `lib_deps`:
+
+```ini
+# platformio.ini
+...
+[common]
+...
+lib_deps =
+    ...
+  #For use of the TTGO T-Display ESP32 Module with integrated TFT display uncomment the following line  
+    #TFT_eSPI
+...
+```
+
+Also, while in the `platformio.ini` file, you must change the environment setup to build for just the esp32dev platform as follows:
+
+Add lines to section:
+
+```ini
+default_envs = esp32dev
+build_flags = ${common.build_flags_esp32}
+  -D USERMOD_ST7789_DISPLAY
+
+```
+
+Save the `platformio.ini` file.  Once this is saved, the required library files should be automatically downloaded for modifications in a later step.
+
+### TFT_eSPI Library Adjustments
+
+We need to modify a file in the `TFT_eSPI` library. If you followed the directions to modify and save the `platformio.ini` file above, the `User_Setup_Select.h` file can be found in the `/.pio/libdeps/esp32dev/TFT_eSPI` folder.
+
+Modify the  `User_Setup_Select.h` file as follows:
+
+* Comment out the following line (which is the 'default' setup file):
+
+```ini
+//#include <User_Setup.h>           // Default setup is root library folder
+```
+
+* Add following line:
+
+```ini
+#include <User_Setups/Setup_ST7789_Display.h>    // Setup file for ESP32 ST7789V SPI bus TFT
+```
+
+* Copy file `"Setup_ST7789_Display.h"` from usermod folder to `/.pio/libdeps/esp32dev/TFT_eSPI/User_Setups`

usermods/ST7789_display/ST7789_display.h

@@ -0,0 +1,350 @@
+// Credits to @mrVanboy, @gwaland and my dearest friend @westward
+// Also for @spiff72 for usermod TTGO-T-Display
+// 210217
+#pragma once
+
+#include "wled.h"
+#include <TFT_eSPI.h>
+#include <SPI.h>
+
+#define USERMOD_ST7789_DISPLAY 97
+
+#ifndef TFT_DISPOFF
+#define TFT_DISPOFF 0x28
+#endif
+
+#ifndef TFT_SLPIN
+#define TFT_SLPIN   0x10
+#endif
+
+#define TFT_MOSI            21
+#define TFT_SCLK            22
+#define TFT_DC              18
+#define TFT_RST             5
+#define TFT_BL              26  // Display backlight control pin
+
+TFT_eSPI tft = TFT_eSPI(240, 240); // Invoke custom library
+
+// How often we are redrawing screen
+#define USER_LOOP_REFRESH_RATE_MS 1000
+
+
+//class name. Use something descriptive and leave the ": public Usermod" part :)
+class St7789DisplayUsermod : public Usermod {
+  private:
+    //Private class members. You can declare variables and functions only accessible to your usermod here
+    unsigned long lastTime = 0;
+
+    bool displayTurnedOff = false;
+    long lastRedraw = 0;
+    // needRedraw marks if redraw is required to prevent often redrawing.
+    bool needRedraw = true;
+    // Next variables hold the previous known values to determine if redraw is required.
+    String knownSsid = "";
+    IPAddress knownIp;
+    uint8_t knownBrightness = 0;
+    uint8_t knownMode = 0;
+    uint8_t knownPalette = 0;
+    uint8_t tftcharwidth = 19;  // Number of chars that fit on screen with text size set to 2
+    long lastUpdate = 0;
+
+  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()
+    {
+        tft.init();
+        tft.setRotation(0);  //Rotation here is set up for the text to be readable with the port on the left. Use 1 to flip.
+        tft.fillScreen(TFT_BLACK);
+        tft.setTextColor(TFT_RED);
+        tft.setCursor(60, 100);
+        tft.setTextDatum(MC_DATUM);
+        tft.setTextSize(2);
+        tft.print("Loading...");
+        if (TFT_BL > 0) 
+        { // TFT_BL has been set in the TFT_eSPI library
+         pinMode(TFT_BL, OUTPUT); // Set backlight pin to output mode
+         digitalWrite(TFT_BL, HIGH); // Turn backlight on.
+        }
+    }
+
+    /*
+     * 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.
+     *
+     * Tips:
+     * 1. You can use "if (WLED_CONNECTED)" to check for a successful network connection.
+     *    Additionally, "if (WLED_MQTT_CONNECTED)" is available to check for a connection to an MQTT broker.
+     *
+     * 2. Try to avoid using the delay() function. NEVER use delays longer than 10 milliseconds.
+     *    Instead, use a timer check as shown here.
+     */
+    void loop() {
+// Check if we time interval for redrawing passes.
+    if (millis() - lastUpdate < USER_LOOP_REFRESH_RATE_MS)
+        {
+            return;
+        }
+    lastUpdate = millis();
+  
+// Turn off display after 5 minutes with no change.
+    if(!displayTurnedOff && millis() - lastRedraw > 5*60*1000)
+        {
+            digitalWrite(TFT_BL, LOW); // Turn backlight off. 
+            displayTurnedOff = true;
+        } 
+
+// Check if values which are shown on display changed from the last time.
+    if (((apActive) ? String(apSSID) : WiFi.SSID()) != knownSsid)
+    {
+    needRedraw = true;
+    }
+    else if (knownIp != (apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP()))
+    {
+    needRedraw = true;
+    }
+    else if (knownBrightness != bri)
+    {
+    needRedraw = true;
+    }
+    else if (knownMode != strip.getMode())
+    {
+    needRedraw = true;
+    }
+    else if (knownPalette != strip.getSegment(0).palette)
+    {
+    needRedraw = true;
+    }
+
+    if (!needRedraw)
+    {
+    return;
+    }
+    needRedraw = false;
+  
+    if (displayTurnedOff)
+    {
+        digitalWrite(TFT_BL, TFT_BACKLIGHT_ON); // Turn backlight on.
+        displayTurnedOff = false;
+    }
+    lastRedraw = millis();
+
+// Update last known values.
+    #if defined(ESP8266)
+        knownSsid = apActive ? WiFi.softAPSSID() : WiFi.SSID();
+    #else
+        knownSsid = WiFi.SSID();
+    #endif
+    knownIp = apActive ? IPAddress(4, 3, 2, 1) : WiFi.localIP();
+    knownBrightness = bri;
+    knownMode = strip.getMode();
+    knownPalette = strip.getSegment(0).palette;
+
+    tft.fillScreen(TFT_BLACK);
+    tft.setTextSize(2);
+// First row with Wifi name
+    tft.setTextColor(TFT_SILVER);
+    tft.setCursor(3, 40);
+    tft.print(knownSsid.substring(0, tftcharwidth > 1 ? tftcharwidth - 1 : 0));
+// Print `~` char to indicate that SSID is longer, than our dicplay
+    if (knownSsid.length() > tftcharwidth)
+        tft.print("~");
+
+// Second row with AP IP and Password or IP
+    tft.setTextColor(TFT_GREEN);
+    tft.setTextSize(2);
+    tft.setCursor(3, 64);
+// Print AP IP and password in AP mode or knownIP if AP not active.
+
+    if (apActive)
+    {
+    tft.setTextColor(TFT_YELLOW);
+    tft.print("AP IP: ");
+    tft.print(knownIp);
+    tft.setCursor(3,86);
+    tft.setTextColor(TFT_YELLOW);
+    tft.print("AP Pass:");
+    tft.print(apPass);
+    }
+    else
+    {
+    tft.setTextColor(TFT_GREEN);
+    tft.print("IP: ");
+    tft.print(knownIp);
+    tft.setCursor(3,86);
+    //tft.print("Signal Strength: ");
+    //tft.print(i.wifi.signal);
+    tft.setTextColor(TFT_WHITE);
+    tft.print("Bri: ");
+    tft.print(((float(bri)/255)*100),0);
+    tft.print("%");
+    }
+
+// Third row with mode name
+    tft.setCursor(3, 108);
+    uint8_t qComma = 0;
+    bool insideQuotes = false;
+    uint8_t printedChars = 0;
+    char singleJsonSymbol;
+// Find the mode name in JSON
+    for (size_t i = 0; i < strlen_P(JSON_mode_names); i++)
+    {
+        singleJsonSymbol = pgm_read_byte_near(JSON_mode_names + i);
+        switch (singleJsonSymbol)
+        {
+            case '"':
+            insideQuotes = !insideQuotes;
+        break;
+        case '[':
+        case ']':
+        break;
+        case ',':
+        qComma++;
+        default:
+            if (!insideQuotes || (qComma != knownMode))
+            break;
+        tft.setTextColor(TFT_MAGENTA);
+        tft.print(singleJsonSymbol);
+        printedChars++;
+        }
+    if ((qComma > knownMode) || (printedChars > tftcharwidth - 1))
+      break;
+    }
+// Fourth row with palette name
+    tft.setTextColor(TFT_YELLOW);
+    tft.setCursor(3, 130);
+    qComma = 0;
+    insideQuotes = false;
+    printedChars = 0;
+// Looking for palette name in JSON.
+    for (size_t i = 0; i < strlen_P(JSON_palette_names); i++)
+    {
+    singleJsonSymbol = pgm_read_byte_near(JSON_palette_names + i);
+        switch (singleJsonSymbol)
+        {
+        case '"':
+        insideQuotes = !insideQuotes;
+        break;
+        case '[':
+        case ']':
+        break;
+        case ',':
+        qComma++;
+        default:
+            if (!insideQuotes || (qComma != knownPalette))
+            break;
+        tft.print(singleJsonSymbol);
+        printedChars++;
+        }
+// The following is modified from the code from the u8g2/u8g8 based code (knownPalette was knownMode)
+    if ((qComma > knownPalette) || (printedChars > tftcharwidth - 1))
+      break;
+    }
+// Fifth row with estimated mA usage
+    tft.setTextColor(TFT_SILVER);
+    tft.setCursor(3, 152);
+// Print estimated milliamp usage (must specify the LED type in LED prefs for this to be a reasonable estimate).
+    tft.print("Current: ");
+    tft.print(strip.currentMilliamps);
+    tft.print("mA");
+    }
+    /*
+     * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
+     * Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
+     * Below it is shown how this could be used for e.g. a light sensor
+     */
+    /*
+    void addToJsonInfo(JsonObject& root)
+    {
+      int reading = 20;
+      //this code adds "u":{"Light":[20," lux"]} to the info object
+      JsonObject user = root["u"];
+      if (user.isNull()) user = root.createNestedObject("u");
+
+      JsonArray lightArr = user.createNestedArray("Light"); //name
+      lightArr.add(reading); //value
+      lightArr.add(" lux"); //unit
+    }
+    */
+
+
+    /*
+     * addToJsonState() can be used to add custom entries to the /json/state part of the JSON API (state object).
+     * Values in the state object may be modified by connected clients
+     */
+    void addToJsonState(JsonObject& root)
+    {
+      //root["user0"] = userVar0;
+    }
+
+
+    /*
+     * 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)
+    {
+      userVar0 = root["user0"] | userVar0; //if "user0" key exists in JSON, update, else keep old value
+      //if (root["bri"] == 255) Serial.println(F("Don't burn down your garage!"));
+    }
+
+
+    /*
+     * 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 also not yet add your setting to one of the settings pages automatically.
+     * To make that work you still have to add the setting to the HTML, xml.cpp and set.cpp manually.
+     *
+     * I highly recommend checking out the basics of ArduinoJson serialization and deserialization in order to use custom settings!
+     */
+    void addToConfig(JsonObject& root)
+    {
+      JsonObject top = root.createNestedObject("exampleUsermod");
+      top["great"] = userVar0; //save this var persistently whenever settings are 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 once immediately after boot)
+     *
+     * 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 :)
+     */
+    void readFromConfig(JsonObject& root)
+    {
+      JsonObject top = root["top"];
+      userVar0 = top["great"] | 42; //The value right of the pipe "|" is the default value in case your setting was not present in cfg.json (e.g. first boot)
+    }
+
+
+    /*
+     * 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_ST7789_DISPLAY;
+    }
+
+   //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!
+};

usermods/ST7789_display/Setup_ST7789_Display.h

@@ -0,0 +1,39 @@
+// Setup for the ESP32 board with 1.5" 240x240 display
+
+// See SetupX_Template.h for all options available
+
+#define ST7789_DRIVER
+#define TFT_SDA_READ   // Display has a bidirectionsl SDA pin
+
+#define TFT_WIDTH  240
+#define TFT_HEIGHT 240
+
+#define CGRAM_OFFSET      // Library will add offsets required
+
+//#define TFT_MISO -1
+
+#define TFT_MOSI            21
+#define TFT_SCLK            22
+//#define TFT_CS              5
+#define TFT_DC              18
+#define TFT_RST             5
+
+#define TFT_BL          26  // Display backlight control pin
+
+#define TFT_BACKLIGHT_ON HIGH  // HIGH or LOW are options
+
+#define LOAD_GLCD
+#define LOAD_FONT2
+#define LOAD_FONT4
+#define LOAD_FONT6
+#define LOAD_FONT7
+#define LOAD_FONT8
+#define LOAD_GFXFF
+
+//#define SMOOTH_FONT
+
+//#define SPI_FREQUENCY  27000000
+  #define SPI_FREQUENCY  40000000   // Maximum for ILI9341
+
+
+#define SPI_READ_FREQUENCY  6000000 // 6 MHz is the maximum SPI read speed for the ST7789V

usermods/Temperature/usermod_temperature.h

@@ -42,6 +42,8 @@ class UsermodTemperature : public Usermod {
     bool waitingForConversion = false;
     // flag set at startup if DS18B20 sensor not found, avoids trying to keep getting
     // temperature if flashed to a board without a sensor attached
+    bool sensorFound = false;
+
     bool enabled = true;
 
     // strings to reduce flash memory usage (used more than twice)
@@ -87,7 +89,9 @@ class UsermodTemperature : public Usermod {
       uint8_t deviceAddress[8] = {0,0,0,0,0,0,0,0};
       // find out if we have DS18xxx sensor attached
       oneWire->reset_search();
+      delay(10);
       while (oneWire->search(deviceAddress)) {
+        DEBUG_PRINTLN(F("Found something..."));
         if (oneWire->crc8(deviceAddress, 7) == deviceAddress[7]) {
           switch (deviceAddress[0]) {
             case 0x10:  // DS18S20
@@ -107,21 +111,23 @@ class UsermodTemperature : public Usermod {
 
     void setup() {
       int retries = 10;
-      // pin retrieved from cfg.json (readFromConfig()) prior to running setup()
-      if (!pinManager.allocatePin(temperaturePin,false)) {
-        temperaturePin = -1;  // allocation failed
-        enabled = false;
-        DEBUG_PRINTLN(F("Temperature pin allocation failed."));
-      } else {
-        if (enabled) {
-          // config says we are enabled
+      if (enabled) {
+        // config says we are enabled
+        DEBUG_PRINTLN(F("Allocating temperature pin..."));
+        // pin retrieved from cfg.json (readFromConfig()) prior to running setup()
+        if (temperaturePin >= 0 && pinManager.allocatePin(temperaturePin)) {
           oneWire = new OneWire(temperaturePin);
           if (!oneWire->reset())
-            enabled = false;   // resetting 1-Wire bus yielded an error
+            sensorFound = false;   // resetting 1-Wire bus yielded an error
           else
-            while ((enabled=findSensor()) && retries--) delay(25); // try to find sensor
+            while ((sensorFound=findSensor()) && retries--) delay(25); // try to find sensor
+        } else {
+          if (temperaturePin >= 0) DEBUG_PRINTLN(F("Temperature pin allocation failed."));
+          temperaturePin = -1;  // allocation failed
+          sensorFound = false;
         }
       }
+      lastMeasurement = millis() - readingInterval + 10000;
       initDone = true;
     }
 
@@ -189,7 +195,7 @@ class UsermodTemperature : public Usermod {
       JsonArray temp = user.createNestedArray(FPSTR(_name));
       //temp.add(F("Loaded."));
 
-      if (temperature <= -100) {
+      if (temperature <= -100.0 || (!sensorFound && temperature == -1.0)) {
         temp.add(0);
         temp.add(F(" Sensor Error!"));
         return;
@@ -249,6 +255,7 @@ class UsermodTemperature : public Usermod {
 
       enabled           = top[FPSTR(_enabled)] | enabled;
       newTemperaturePin = top["pin"] | newTemperaturePin;
+//      newTemperaturePin = min(33,max(-1,(int)newTemperaturePin)); // bounds check
       degC              = top["degC"] | degC;
       readingInterval   = top[FPSTR(_readInterval)] | readingInterval/1000;
       readingInterval   = min(120,max(10,(int)readingInterval)) * 1000;  // convert to ms
@@ -260,8 +267,10 @@ class UsermodTemperature : public Usermod {
         temperaturePin = newTemperaturePin;
         DEBUG_PRINTLN(F(" config loaded."));
       } else {
-        // changing parameters from settings page
+        DEBUG_PRINTLN(F(" config (re)loaded."));
+        // changing paramters from settings page
         if (newTemperaturePin != temperaturePin) {
+          DEBUG_PRINTLN(F("Re-init temperature."));
           // deallocate pin and release memory
           delete oneWire;
           pinManager.deallocatePin(temperaturePin);
@@ -269,7 +278,6 @@ class UsermodTemperature : public Usermod {
           // initialise
           setup();
         }
-        DEBUG_PRINTLN(F(" config (re)loaded."));
       }
       // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
       return !top[FPSTR(_parasite)].isNull();

usermods/battery_keypad_controller/wled06_usermod.ino

@@ -54,46 +54,46 @@ void userLoop()
             switch (myKey) {
                 case '1':
                     applyPreset(1);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '2':
                     applyPreset(2);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '3':
                     applyPreset(3);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '4':
                     applyPreset(4);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '5':
                     applyPreset(5);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '6':
                     applyPreset(6);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case 'A':
                     applyPreset(7);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case 'B':
                     applyPreset(8);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
 
                 case '7':
                     effectCurrent += 1;
                     if (effectCurrent >= MODE_COUNT) effectCurrent = 0;
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '*':
                     effectCurrent -= 1;
                     if (effectCurrent < 0) effectCurrent = (MODE_COUNT-1);
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
 
                 case '8':
@@ -102,7 +102,7 @@ void userLoop()
                     } else if (effectSpeed < 255) {
                         effectSpeed += 1;
                     }
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '0':
                     if (effectSpeed > 15) {
@@ -110,7 +110,7 @@ void userLoop()
                     } else if (effectSpeed > 0) {
                         effectSpeed -= 1;
                     }
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
 
                 case '9':
@@ -119,7 +119,7 @@ void userLoop()
                     } else if (effectIntensity < 255) {
                         effectIntensity += 1;
                     }
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case '#':
                     if (effectIntensity > 15) {
@@ -127,18 +127,18 @@ void userLoop()
                     } else if (effectIntensity > 0) {
                         effectIntensity -= 1;
                     }
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
 
                 case 'C':
                     effectPalette += 1;
                     if (effectPalette >= 50) effectPalette = 0;
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
                 case 'D':
                     effectPalette -= 1;
                     if (effectPalette <= 0) effectPalette = 50;
-                    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+                    colorUpdated(CALL_MODE_FX_CHANGED);
                     break;
 
             }

usermods/rgb-rotary-encoder/readme.md

@@ -0,0 +1,86 @@
+# RGB Encoder Board
+
+This usermod-v2 adds support for the awesome RGB Rotary Encoder Board by Adam Zeloof / "Isotope Engineering" to control the overall brightness of your WLED instance: https://github.com/isotope-engineering/RGB-Encoder-Board. A great DIY rotary encoder with 20 tiny SK6805 / "NeoPixel Nano" LEDs.
+
+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 :)
+
+## Requirements
+* "ESP Rotary" by Lennart Hennigs, v1.5.0 or higher: https://github.com/LennartHennigs/ESPRotary
+
+## Usermod installation
+Simply copy the below block (build task) to your `platformio_override.ini` and compile WLED using this new build task. Or use an existing one and add the buildflag `-D RGB_ROTARY_ENCODER`.
+
+ESP32:
+```
+[env:custom_esp32dev_usermod_rgb_encoder_board]
+extends = env:esp32dev
+build_flags = ${common.build_flags_esp32} -D WLED_RELEASE_NAME=ESP32 -D RGB_ROTARY_ENCODER
+lib_deps = ${esp32.lib_deps}
+    lennarthennigs/ESP Rotary@^1.5.0
+```
+
+ESP8266 / D1 Mini:
+```
+[env:custom_d1_mini_usermod_rgb_encoder_board]
+extends = env:d1_mini
+build_flags = ${common.build_flags_esp8266} -D RGB_ROTARY_ENCODER
+lib_deps = ${esp8266.lib_deps}
+    lennarthennigs/ESP Rotary@^1.5.0
+```
+
+## 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 also gonna need some power, so:
+
+* "vdd": Needs to be connected to **+5V**.
+* "gnd": Well, it's GND.
+
+You can freely pick the GPIOs, it doesn't matter. Those will be configured in the "Usermods" section in 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:
+* LED pin:
+  * Possible values: Any valid and available GPIO
+  * Default: 3
+  * What it does: Pin to control the LED ring
+* ea pin:
+  * Possible values: Any valid and available GPIO
+  * Default: 15
+  * What it does: First of the two rotary encoder pins
+* eb pin:
+  * Possible values: Any valid and available GPIO
+  * Default: 32
+  * What it does: Second of the two rotary encoder pins
+* 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
+    * Up left is "1"
+    * Up right is not supported / doesn't make sense for brightness control
+    * Bottom left is "2"
+    * Bottom right is "3"
+* LED Brightness:
+  * Possible values: 1-255
+  * Default: 64
+  * What it does: Brightness of the LED ring
+* 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.
+* 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`
+
+## Change log
+2021-07
+* First implementation.

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

@@ -0,0 +1,344 @@
+#pragma once
+
+#include "ESPRotary.h"
+#include <math.h>
+#include "wled.h"
+
+class RgbRotaryEncoderUsermod : public Usermod
+{
+  private:
+    bool enabled = false;
+    bool initDone = false;
+    bool isDirty = false;
+    BusDigital *ledBus;
+    /*
+    * Green - eb - Q4 - 32
+    * Red - ea - Q1 - 15
+    * Black - sw - Q2 - 12
+    */
+    ESPRotary *rotaryEncoder;
+    int8_t ledIo = 3; // GPIO to control the LEDs
+    int8_t eaIo = 15; // "ea" from RGB Encoder Board
+    int8_t ebIo = 32; // "eb" from RGB Encoder Board
+    byte stepsPerClick = 4; // How many "steps" your rotary encoder does per click. This varies per rotary encoder
+    /* This could vary per rotary encoder: Usually rotary encoders have 20 "clicks".
+      If yours has less/more, adjust this to: 100% = 20 LEDs * incrementPerClick */
+    byte incrementPerClick = 5;
+    byte ledMode = 3;
+    byte ledBrightness = 64;
+
+    // This is all needed to calculate the brightness, rotary position, etc.
+    const byte minPos = 5; // minPos is not zero, because if we want to turn the LEDs off, we use the built-in button ;)
+    const byte maxPos = 100; // maxPos=100, like 100%
+    const byte numLeds = 20;
+    byte lastKnownPos = 0;
+
+    byte currentColors[3];
+    byte lastKnownBri = 0;
+
+
+    void initRotaryEncoder()
+    {
+      if (!pinManager.allocatePin(eaIo, false)) {
+        eaIo = -1;
+      }
+      if (!pinManager.allocatePin(ebIo, false)) {
+        ebIo = -1;
+      }
+      if (eaIo == -1 || ebIo == -1) {
+        cleanup();
+        return;
+      }
+
+      // I don't know why, but setting the upper bound here does not work. It results into 1717922932 O_o
+      rotaryEncoder = new ESPRotary(eaIo, ebIo, stepsPerClick, incrementPerClick, maxPos, currentPos, incrementPerClick);
+      rotaryEncoder->setUpperBound(maxPos); // I have to again set it here and then it works / is actually 100...
+
+      rotaryEncoder->setChangedHandler(RgbRotaryEncoderUsermod::cbRotate);
+    }
+
+    void initLedBus()
+    {
+      byte _pins[5] = {(byte)ledIo, 255, 255, 255, 255};
+      BusConfig busCfg = BusConfig(TYPE_WS2812_RGB, _pins, 0, numLeds, COL_ORDER_GRB, false, 0);
+
+      ledBus = new BusDigital(busCfg, WLED_MAX_BUSSES - 1);
+      if (!ledBus->isOk()) {
+        cleanup();
+        return;
+      }
+
+      ledBus->setBrightness(ledBrightness);
+    }
+
+    void updateLeds()
+    {
+      switch (ledMode) {
+        case 2:
+          {
+            currentColors[0] = 255; currentColors[1] = 0; currentColors[2] = 0;
+            for (int i = 0; i < currentPos / incrementPerClick - 1; i++) {
+              ledBus->setPixelColor(i, 0);
+            }
+            ledBus->setPixelColor(currentPos / incrementPerClick - 1, colorFromRgbw(currentColors));
+            for (int i = currentPos / incrementPerClick; i < numLeds; i++) {
+              ledBus->setPixelColor(i, 0);
+            }
+          }
+          break;
+
+        default:
+        case 1:
+        case 3:
+          // WLED orange (of course), which we will use in mode 1
+          currentColors[0] = 255; currentColors[1] = 160; currentColors[2] = 0;
+          for (int i = 0; i < currentPos / incrementPerClick; i++) {
+            if (ledMode == 3) {
+              hsv2rgb((i) / float(numLeds), 1, .25);
+            }
+            ledBus->setPixelColor(i, colorFromRgbw(currentColors));
+          }
+          for (int i = currentPos / incrementPerClick; i < numLeds; i++) {
+            ledBus->setPixelColor(i, 0);
+          }
+          break;
+      }
+
+      isDirty = true;
+    }
+
+    void cleanup()
+    {
+      // Only deallocate pins if we allocated them ;)
+      if (eaIo != -1) {
+        pinManager.deallocatePin(eaIo);
+      }
+      if (ebIo != -1) {
+        pinManager.deallocatePin(ebIo);
+      }
+
+      delete rotaryEncoder;
+      delete ledBus;
+
+      enabled = false;
+    }
+
+    int getPositionForBrightness()
+    {
+      return int(((float)bri / (float)255) * 100);
+    }
+
+    float fract(float x) { return x - int(x); }
+
+    float mix(float a, float b, float t) { return a + (b - a) * t; }
+
+    void hsv2rgb(float h, float s, float v) {
+      currentColors[0] = int((v * mix(1.0, constrain(abs(fract(h + 1.0) * 6.0 - 3.0) - 1.0, 0.0, 1.0), s)) * 255);
+      currentColors[1] = int((v * mix(1.0, constrain(abs(fract(h + 0.6666666) * 6.0 - 3.0) - 1.0, 0.0, 1.0), s)) * 255);
+      currentColors[2] = int((v * mix(1.0, constrain(abs(fract(h + 0.3333333) * 6.0 - 3.0) - 1.0, 0.0, 1.0), s)) * 255);
+    }
+
+  public:
+    static byte currentPos;
+
+    // strings to reduce flash memory usage (used more than twice)
+    static const char _name[];
+    static const char _enabled[];
+    static const char _ledIo[];
+    static const char _eaIo[];
+    static const char _ebIo[];
+    static const char _ledMode[];
+    static const char _ledBrightness[];
+    static const char _stepsPerClick[];
+    static const char _incrementPerClick[];
+
+
+    static void cbRotate(ESPRotary& r) {
+      currentPos = r.getPosition();
+    }
+
+    /**
+     * Enable/Disable the usermod
+     */
+    // inline void enable(bool enable) { enabled = enable; }
+    /**
+     * Get usermod enabled/disabled state
+     */
+    // inline bool isEnabled() { return enabled; }
+
+    /*
+      * 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()
+    {
+      if (enabled) {
+        currentPos = getPositionForBrightness();
+        lastKnownBri = bri;
+
+        initRotaryEncoder();
+        initLedBus();
+
+        // No updating of LEDs here, as that's sometimes not working; loop() will take care of that
+
+        initDone = true;
+      }
+    }
+
+    /*
+      * loop() is called continuously. Here you can check for events, read sensors, etc.
+      * 
+      * Tips:
+      * 1. You can use "if (WLED_CONNECTED)" to check for a successful network connection.
+      *    Additionally, "if (WLED_MQTT_CONNECTED)" is available to check for a connection to an MQTT broker.
+      * 
+      * 2. Try to avoid using the delay() function. NEVER use delays longer than 10 milliseconds.
+      *    Instead, use a timer check as shown here.
+      */
+    void loop()
+    {
+      if (!enabled || strip.isUpdating()) return;
+
+      rotaryEncoder->loop();
+
+      // If the rotary was changed
+      if(lastKnownPos != currentPos) {
+        lastKnownPos = currentPos;
+
+        bri = min(int(round((2.55 * currentPos))), 255);
+        lastKnownBri = bri;
+
+        updateLeds();
+        colorUpdated(NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+      }
+
+      // If the brightness is changed not with the rotary, update the rotary
+      if (bri != lastKnownBri) {
+        currentPos = lastKnownPos = getPositionForBrightness();
+        lastKnownBri = bri;
+        rotaryEncoder->resetPosition(currentPos);
+        updateLeds();
+      }
+
+      // Update LEDs here in loop to also validate that we can update/show
+      if (isDirty && ledBus->canShow()) {
+        isDirty = false;
+        ledBus->show();
+      }
+    }
+
+    void addToConfig(JsonObject &root)
+    {
+      JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
+
+      top[FPSTR(_enabled)] = enabled;
+      top[FPSTR(_ledIo)] = ledIo;
+      top[FPSTR(_eaIo)] = eaIo;
+      top[FPSTR(_ebIo)] = ebIo;
+      top[FPSTR(_ledMode)] = ledMode;
+      top[FPSTR(_ledBrightness)] = ledBrightness;
+      top[FPSTR(_stepsPerClick)] = stepsPerClick;
+      top[FPSTR(_incrementPerClick)] = incrementPerClick;
+    }
+
+    /**
+     * 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)
+    {
+      JsonObject top = root[FPSTR(_name)];
+      if (top.isNull()) {
+        DEBUG_PRINTF("[%s] No config found. (Using defaults.)\n", _name);
+        return false;
+      }
+
+      bool oldEnabled = enabled;
+      int8_t oldLedIo = ledIo;
+      int8_t oldEaIo =  eaIo;
+      int8_t oldEbIo =  ebIo;
+      byte oldLedMode = ledMode;
+      byte oldStepsPerClick = stepsPerClick;
+      byte oldIncrementPerClick = incrementPerClick;
+      byte oldLedBrightness = ledBrightness;
+
+      getJsonValue(top[FPSTR(_enabled)], enabled);
+      getJsonValue(top[FPSTR(_ledIo)], ledIo);
+      getJsonValue(top[FPSTR(_eaIo)], eaIo);
+      getJsonValue(top[FPSTR(_ebIo)], ebIo);
+      getJsonValue(top[FPSTR(_stepsPerClick)], stepsPerClick);
+      getJsonValue(top[FPSTR(_incrementPerClick)], incrementPerClick);
+      ledMode = top[FPSTR(_ledMode)] > 0 && top[FPSTR(_ledMode)] < 4 ? top[FPSTR(_ledMode)] : ledMode;
+      ledBrightness = top[FPSTR(_ledBrightness)] > 0 && top[FPSTR(_ledBrightness)] <= 255 ? top[FPSTR(_ledBrightness)] : ledBrightness;
+
+      if (!initDone) {
+        // First run: reading from cfg.json
+        // Nothing to do here, will be all done in setup() 
+      }
+      // Mod was disabled, so run setup()
+      else if (enabled && enabled != oldEnabled) {
+        DEBUG_PRINTF("[%s] Usermod has been re-enabled\n", _name);
+        setup();
+      }
+      // Config has been changed, so adopt to changes
+      else {
+        if (!enabled) {
+          DEBUG_PRINTF("[%s] Usermod has been disabled\n", _name);
+          cleanup();
+        }
+        else {
+          DEBUG_PRINTF("[%s] Usermod is enabled\n", _name);
+          if (ledIo != oldLedIo) {
+            delete ledBus;
+            initLedBus();
+          }
+
+          if (ledBrightness != oldLedBrightness) {
+            ledBus->setBrightness(ledBrightness);
+            isDirty = true;
+          }
+
+          if (ledMode != oldLedMode) {
+            updateLeds();
+          }
+
+          if (eaIo != oldEaIo || ebIo != oldEbIo || stepsPerClick != oldStepsPerClick || incrementPerClick != oldIncrementPerClick) {
+            pinManager.deallocatePin(oldEaIo);
+            pinManager.deallocatePin(oldEbIo);
+            
+            delete rotaryEncoder;
+            initRotaryEncoder();
+          }
+        }
+
+        DEBUG_PRINTF("[%s] Config (re)loaded\n", _name);
+      }
+      
+      return true;
+    }
+
+    /*
+      * 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 0x4711;
+    }
+
+    //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!
+};
+
+byte RgbRotaryEncoderUsermod::currentPos = 5;
+// strings to reduce flash memory usage (used more than twice)
+const char RgbRotaryEncoderUsermod::_name[]              PROGMEM = "RGB-Rotary-Encoder";
+const char RgbRotaryEncoderUsermod::_enabled[]           PROGMEM = "Enabled";
+const char RgbRotaryEncoderUsermod::_ledIo[]             PROGMEM = "LED-pin";
+const char RgbRotaryEncoderUsermod::_eaIo[]              PROGMEM = "ea-pin";
+const char RgbRotaryEncoderUsermod::_ebIo[]              PROGMEM = "eb-pin";
+const char RgbRotaryEncoderUsermod::_ledMode[]           PROGMEM = "LED-Mode";
+const char RgbRotaryEncoderUsermod::_ledBrightness[]     PROGMEM = "LED-Brightness";
+const char RgbRotaryEncoderUsermod::_stepsPerClick[]     PROGMEM = "Steps-per-Click";
+const char RgbRotaryEncoderUsermod::_incrementPerClick[] PROGMEM = "Increment-per-Click";

usermods/rotary_encoder_change_brightness/usermod.cpp

@@ -1,62 +0,0 @@
-#include "wled.h"
-/*
- * 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 const.h)
- * bytes 2400+ are currently ununsed, but might be used for future wled features
- */
-
-//Use userVar0 and userVar1 (API calls &U0=,&U1=, uint16_t)
-
-/*
-** Rotary Encoder Example
-** Use the Sparkfun Rotary Encoder to vary brightness of LED
-**
-** Sample the encoder at 500Hz using the millis() function
-*/
-
-int fadeAmount = 5;  // how many points to fade the Neopixel with each step
-unsigned long currentTime;
-unsigned long loopTime;
-const int pinA = D6;  // DT from encoder
-const int pinB = D7;  // CLK from encoder
-
-unsigned char Enc_A;
-unsigned char Enc_B;
-unsigned char Enc_A_prev = 0;
-
-//gets called once at boot. Do all initialization that doesn't depend on network here
-void userSetup() {
-  pinMode(pinA, INPUT_PULLUP);
-  pinMode(pinB, INPUT_PULLUP);
-  currentTime = millis();
-  loopTime = currentTime;
-}
-
-//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() {
-  currentTime = millis();  // get the current elapsed time
-  if(currentTime >= (loopTime + 2))  // 2ms since last check of encoder = 500Hz 
-  {
-    int Enc_A = digitalRead(pinA);  // Read encoder pins
-    int Enc_B = digitalRead(pinB);   
-    if((! Enc_A) && (Enc_A_prev)) { // A has gone from high to low
-      if(Enc_B == HIGH) { // B is high so clockwise
-        if(bri + fadeAmount <= 255) bri += fadeAmount;   // increase the brightness, dont go over 255
-      
-      } else if (Enc_B == LOW) { // B is low so counter-clockwise
-        if(bri - fadeAmount >= 0) bri -= fadeAmount;   // decrease the brightness, dont go below 0          
-      }   
-    }   
-      Enc_A_prev = Enc_A;     // Store value of A for next time    
-      loopTime = currentTime;  // Updates loopTime
-    
-    //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
-    // 6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
-    colorUpdated(6);
-  }
-}

usermods/rotary_encoder_change_brightness/usermode_rotary_set.h

@@ -1,211 +0,0 @@
-#pragma once
-
-#include "wled.h"
-
-//v2 usermod that allows to change brightness and color using a rotary encoder, 
-//change between modes by pressing a button (many encoder have one included)
-class RotaryEncoderSet : public Usermod
-{
-private:
-  //Private class members. You can declare variables and functions only accessible to your usermod here
-  unsigned long lastTime = 0;
-  /*
-** Rotary Encoder Example
-** Use the Sparkfun Rotary Encoder to vary brightness of LED
-**
-** Sample the encoder at 500Hz using the millis() function
-*/
-
-  int fadeAmount = 5; // how many points to fade the Neopixel with each step
-  unsigned long currentTime;
-  unsigned long loopTime;
-  const int pinA = 5;             // DT from encoder
-  const int pinB = 18;            // CLK from encoder
-  const int pinC = 23;            // SW from encoder
-  unsigned char select_state = 0; // 0 = brightness 1 = color
-  unsigned char button_state = HIGH;
-  unsigned char prev_button_state = HIGH;
-  CRGB fastled_col;
-  CHSV prim_hsv;
-  int16_t new_val;
-
-  unsigned char Enc_A;
-  unsigned char Enc_B;
-  unsigned char Enc_A_prev = 0;
-
-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()
-  {
-    //Serial.println("Hello from my usermod!");
-    pinMode(pinA, INPUT_PULLUP);
-    pinMode(pinB, INPUT_PULLUP);
-    pinMode(pinC, INPUT_PULLUP);
-    currentTime = millis();
-    loopTime = currentTime;
-  }
-
-  /*
-     * 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.
-     * 
-     * Tips:
-     * 1. You can use "if (WLED_CONNECTED)" to check for a successful network connection.
-     *    Additionally, "if (WLED_MQTT_CONNECTED)" is available to check for a connection to an MQTT broker.
-     * 
-     * 2. Try to avoid using the delay() function. NEVER use delays longer than 10 milliseconds.
-     *    Instead, use a timer check as shown here.
-     */
-  void loop()
-  {
-    currentTime = millis(); // get the current elapsed time
-
-    if (currentTime >= (loopTime + 2)) // 2ms since last check of encoder = 500Hz
-    {
-      button_state = digitalRead(pinC);
-      if (prev_button_state != button_state)
-      {
-        if (button_state == LOW)
-        {
-          if (select_state == 1)
-          {
-            select_state = 0;
-          }
-          else
-          {
-            select_state = 1;
-          }
-          prev_button_state = button_state;
-        }
-        else
-        {
-          prev_button_state = button_state;
-        }
-      }
-      int Enc_A = digitalRead(pinA); // Read encoder pins
-      int Enc_B = digitalRead(pinB);
-      if ((!Enc_A) && (Enc_A_prev))
-      { // A has gone from high to low
-        if (Enc_B == HIGH)
-        { // B is high so clockwise
-          if (select_state == 0)
-          {
-            if (bri + fadeAmount <= 255)
-              bri += fadeAmount; // increase the brightness, dont go over 255
-          }
-          else
-          {
-            fastled_col.red = col[0];
-            fastled_col.green = col[1];
-            fastled_col.blue = col[2];
-            prim_hsv = rgb2hsv_approximate(fastled_col);
-            new_val = (int16_t)prim_hsv.h + fadeAmount;
-            if (new_val > 255)
-              new_val -= 255; // roll-over if  bigger than 255
-            if (new_val < 0)
-              new_val += 255; // roll-over if smaller than 0
-            prim_hsv.h = (byte)new_val;
-            hsv2rgb_rainbow(prim_hsv, fastled_col);
-            col[0] = fastled_col.red;
-            col[1] = fastled_col.green;
-            col[2] = fastled_col.blue;
-          }
-        }
-        else if (Enc_B == LOW)
-        { // B is low so counter-clockwise
-          if (select_state == 0)
-          {
-            if (bri - fadeAmount >= 0)
-              bri -= fadeAmount; // decrease the brightness, dont go below 0
-          }
-          else
-          {
-            fastled_col.red = col[0];
-            fastled_col.green = col[1];
-            fastled_col.blue = col[2];
-            prim_hsv = rgb2hsv_approximate(fastled_col);
-            new_val = (int16_t)prim_hsv.h - fadeAmount;
-            if (new_val > 255)
-              new_val -= 255; // roll-over if  bigger than 255
-            if (new_val < 0)
-              new_val += 255; // roll-over if smaller than 0
-            prim_hsv.h = (byte)new_val;
-            hsv2rgb_rainbow(prim_hsv, fastled_col);
-            col[0] = fastled_col.red;
-            col[1] = fastled_col.green;
-            col[2] = fastled_col.blue;
-          }
-        }
-        //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
-        // 6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
-        colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
-        updateInterfaces()
-      }
-      Enc_A_prev = Enc_A;     // Store value of A for next time
-      loopTime = currentTime; // Updates loopTime
-    }
-  }
-
-  /*
-     * addToJsonInfo() can be used to add custom entries to the /json/info part of the JSON API.
-     * Creating an "u" object allows you to add custom key/value pairs to the Info section of the WLED web UI.
-     * Below it is shown how this could be used for e.g. a light sensor
-     */
-  /*
-    void addToJsonInfo(JsonObject& root)
-    {
-      int reading = 20;
-      //this code adds "u":{"Light":[20," lux"]} to the info object
-      JsonObject user = root["u"];
-      if (user.isNull()) user = root.createNestedObject("u");
-
-      JsonArray lightArr = user.createNestedArray("Light"); //name
-      lightArr.add(reading); //value
-      lightArr.add(" lux"); //unit
-    }
-    */
-
-  /*
-     * addToJsonState() can be used to add custom entries to the /json/state part of the JSON API (state object).
-     * Values in the state object may be modified by connected clients
-     */
-  void addToJsonState(JsonObject &root)
-  {
-    //root["user0"] = userVar0;
-  }
-
-  /*
-     * 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)
-  {
-    userVar0 = root["user0"] | userVar0; //if "user0" key exists in JSON, update, else keep old value
-    //if (root["bri"] == 255) Serial.println(F("Don't burn down your garage!"));
-  }
-
-  /*
-     * 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 0xABCD;
-  }
-
-  //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!
-};

usermods/rotary_encoder_change_effect/wled06_usermod.ino

@@ -39,7 +39,7 @@ void userLoop() {
 
     //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
     // 6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
-    colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+    colorUpdated(CALL_MODE_FX_CHANGED);
     lastTime = millis();
   }
 }

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

@@ -42,7 +42,7 @@ class StairwayWipeUsermod : public Usermod {
       if (millis() + strip.timebase > (cycleTime - 25)) { //wipe complete
         effectCurrent = FX_MODE_STATIC;
         timeStaticStart = millis();
-        colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+        colorUpdated(CALL_MODE_NOTIFICATION);
         wipeState = 2;
       }
     } else if (wipeState == 2) { //static
@@ -54,7 +54,7 @@ class StairwayWipeUsermod : public Usermod {
       #ifdef STAIRCASE_WIPE_OFF
       effectCurrent = FX_MODE_COLOR_WIPE;
       strip.timebase = 360 + (255 - effectSpeed)*75 - millis(); //make sure wipe starts fully lit
-      colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+      colorUpdated(CALL_MODE_NOTIFICATION);
       wipeState = 4;
       #else
       turnOff();
@@ -100,7 +100,7 @@ class StairwayWipeUsermod : public Usermod {
     bool doReverse = (userVar0 == 2);
     seg.setOption(1, doReverse);
 
-    colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+    colorUpdated(CALL_MODE_NOTIFICATION);
     }
 
     void turnOff()
@@ -111,7 +111,7 @@ class StairwayWipeUsermod : public Usermod {
     transitionDelayTemp = 4000; //fade out slowly
     #endif
     bri = 0;
-    colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+    colorUpdated(CALL_MODE_NOTIFICATION);
     wipeState = 0;
     userVar0 = 0;
     previousUserVar0 = 0;

usermods/stairway_wipe_basic/wled06_usermod.ino

@@ -47,7 +47,7 @@ void userLoop()
       if (millis() + strip.timebase > (cycleTime - 25)) { //wipe complete
         effectCurrent = FX_MODE_STATIC;
         timeStaticStart = millis();
-        colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+        colorUpdated(CALL_MODE_NOTIFICATION);
         wipeState = 2;
       }
     } else if (wipeState == 2) { //static
@@ -59,7 +59,7 @@ void userLoop()
       #ifdef STAIRCASE_WIPE_OFF
       effectCurrent = FX_MODE_COLOR_WIPE;
       strip.timebase = 360 + (255 - effectSpeed)*75 - millis(); //make sure wipe starts fully lit
-      colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+      colorUpdated(CALL_MODE_NOTIFICATION);
       wipeState = 4;
       #else
       turnOff();
@@ -93,7 +93,7 @@ void startWipe()
   bool doReverse = (userVar0 == 2);
   seg.setOption(1, doReverse);
 
-  colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+  colorUpdated(CALL_MODE_NOTIFICATION);
 }
 
 void turnOff()
@@ -104,7 +104,7 @@ void turnOff()
   transitionDelayTemp = 4000; //fade out slowly
   #endif
   bri = 0;
-  colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+  colorUpdated(CALL_MODE_NOTIFICATION);
   wipeState = 0;
   userVar0 = 0;
   previousUserVar0 = 0;

usermods/usermod_rotary_brightness_color/README.md

@@ -0,0 +1,42 @@
+# Rotary Encoder (Brightness and Color)
+
+V2 usermod that allows changing brightness and color using a rotary encoder, 
+change between modes by pressing a button (many encoders have one included)
+
+but it will wait for AUTOSAVE_SETTLE_MS milliseconds, a "settle" 
+period in case there are other changes (any change will 
+extend the "settle" window).
+
+It will additionally load preset AUTOSAVE_PRESET_NUM at startup.
+during the first `loop()`.  Reasoning below.
+
+AutoSaveUsermod is standalone, but if FourLineDisplayUsermod is installed, it will notify the user of the saved changes.
+
+Note: I don't love that WLED doesn't respect the brightness of the preset being auto loaded, so the AutoSaveUsermod will set the AUTOSAVE_PRESET_NUM preset in the first loop, so brightness IS honored. This means WLED will effectively ignore Default brightness and Apply N preset at boot when the AutoSaveUsermod is installed.
+
+## Installation
+
+define `USERMOD_ROTARY_ENCODER_BRIGHTNESS_COLOR` e.g.
+
+`#define USERMOD_ROTARY_ENCODER_BRIGHTNESS_COLOR` in my_config.h
+
+or add `-D USERMOD_ROTARY_ENCODER_BRIGHTNESS_COLOR` to `build_flags` in platformio_override.ini
+
+### Define Your Options
+
+Open Usermod Settings in WLED to change settings:
+
+`fadeAmount` - how many points to fade the Neopixel with each step of the rotary encoder (default 5)
+`pin[3]` - pins to connect to the rotary encoder:
+- `pin[0]` is pin A on your rotary encoder
+- `pin[1]` is pin B on your rotary encoder
+- `pin[2]` is the button on your rotary encoder (optional, set to -1 to disable the button and the rotary encoder will control brightness only)
+
+### PlatformIO requirements
+
+No special requirements.
+
+## Change Log
+
+2021-07
+* Upgraded to work with the latest WLED code, and make settings configurable in Usermod Settings

usermods/usermod_rotary_brightness_color/usermod_rotary_brightness_color.h

@@ -0,0 +1,189 @@
+#pragma once
+
+#include "wled.h"
+
+//v2 usermod that allows to change brightness and color using a rotary encoder, 
+//change between modes by pressing a button (many encoders have one included)
+class RotaryEncoderBrightnessColor : public Usermod
+{
+private:
+  //Private class members. You can declare variables and functions only accessible to your usermod here
+  unsigned long lastTime = 0;
+  unsigned long currentTime;
+  unsigned long loopTime;
+
+  unsigned char select_state = 0; // 0 = brightness 1 = color
+  unsigned char button_state = HIGH;
+  unsigned char prev_button_state = HIGH;
+  CRGB fastled_col;
+  CHSV prim_hsv;
+  int16_t new_val;
+
+  unsigned char Enc_A;
+  unsigned char Enc_B;
+  unsigned char Enc_A_prev = 0;
+
+  // private class memebers configurable by Usermod Settings (defaults set inside readFromConfig())
+  int8_t pins[3]; // pins[0] = DT from encoder, pins[1] = CLK from encoder, pins[2] = CLK from encoder (optional)
+  int fadeAmount; // how many points to fade the Neopixel with each step
+
+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()
+  {
+    //Serial.println("Hello from my usermod!");
+    pinMode(pins[0], INPUT_PULLUP);
+    pinMode(pins[1], INPUT_PULLUP);
+    if(pins[2] >= 0) pinMode(pins[2], INPUT_PULLUP);
+    currentTime = millis();
+    loopTime = currentTime;
+  }
+
+  /*
+   * loop() is called continuously. Here you can check for events, read sensors, etc.
+   * 
+   * Tips:
+   * 1. You can use "if (WLED_CONNECTED)" to check for a successful network connection.
+   *    Additionally, "if (WLED_MQTT_CONNECTED)" is available to check for a connection to an MQTT broker.
+   * 
+   * 2. Try to avoid using the delay() function. NEVER use delays longer than 10 milliseconds.
+   *    Instead, use a timer check as shown here.
+   */
+  void loop()
+  {
+    currentTime = millis(); // get the current elapsed time
+
+    if (currentTime >= (loopTime + 2)) // 2ms since last check of encoder = 500Hz
+    {
+      if(pins[2] >= 0) {
+        button_state = digitalRead(pins[2]);
+        if (prev_button_state != button_state)
+        {
+          if (button_state == LOW)
+          {
+            if (select_state == 1)
+            {
+              select_state = 0;
+            }
+            else
+            {
+              select_state = 1;
+            }
+            prev_button_state = button_state;
+          }
+          else
+          {
+            prev_button_state = button_state;
+          }
+        }
+      }
+      int Enc_A = digitalRead(pins[0]); // Read encoder pins
+      int Enc_B = digitalRead(pins[1]);
+      if ((!Enc_A) && (Enc_A_prev))
+      { // A has gone from high to low
+        if (Enc_B == HIGH)
+        { // B is high so clockwise
+          if (select_state == 0)
+          {
+            if (bri + fadeAmount <= 255)
+              bri += fadeAmount; // increase the brightness, dont go over 255
+          }
+          else
+          {
+            fastled_col.red = col[0];
+            fastled_col.green = col[1];
+            fastled_col.blue = col[2];
+            prim_hsv = rgb2hsv_approximate(fastled_col);
+            new_val = (int16_t)prim_hsv.h + fadeAmount;
+            if (new_val > 255)
+              new_val -= 255; // roll-over if  bigger than 255
+            if (new_val < 0)
+              new_val += 255; // roll-over if smaller than 0
+            prim_hsv.h = (byte)new_val;
+            hsv2rgb_rainbow(prim_hsv, fastled_col);
+            col[0] = fastled_col.red;
+            col[1] = fastled_col.green;
+            col[2] = fastled_col.blue;
+          }
+        }
+        else if (Enc_B == LOW)
+        { // B is low so counter-clockwise
+          if (select_state == 0)
+          {
+            if (bri - fadeAmount >= 0)
+              bri -= fadeAmount; // decrease the brightness, dont go below 0
+          }
+          else
+          {
+            fastled_col.red = col[0];
+            fastled_col.green = col[1];
+            fastled_col.blue = col[2];
+            prim_hsv = rgb2hsv_approximate(fastled_col);
+            new_val = (int16_t)prim_hsv.h - fadeAmount;
+            if (new_val > 255)
+              new_val -= 255; // roll-over if  bigger than 255
+            if (new_val < 0)
+              new_val += 255; // roll-over if smaller than 0
+            prim_hsv.h = (byte)new_val;
+            hsv2rgb_rainbow(prim_hsv, fastled_col);
+            col[0] = fastled_col.red;
+            col[1] = fastled_col.green;
+            col[2] = fastled_col.blue;
+          }
+        }
+        //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
+        // 6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
+        colorUpdated(CALL_MODE_BUTTON);
+        updateInterfaces(CALL_MODE_BUTTON);
+      }
+      Enc_A_prev = Enc_A;     // Store value of A for next time
+      loopTime = currentTime; // Updates loopTime
+    }
+  }
+
+  void addToConfig(JsonObject& root)
+  {
+    JsonObject top = root.createNestedObject("rotEncBrightness");
+    top["fadeAmount"] = fadeAmount;
+    JsonArray pinArray = top.createNestedArray("pin");
+    pinArray.add(pins[0]);
+    pinArray.add(pins[1]); 
+    pinArray.add(pins[2]); 
+  }
+
+  /* 
+   * This example uses a more robust method of checking for missing values in the config, and setting back to defaults:
+   * - The getJsonValue() function copies the value to the variable only if the key requested is present, returning false with no copy if the value isn't present
+   * - configComplete is used to return false if any value is missing, not just if the main object is missing
+   * - The defaults are loaded every time readFromConfig() is run, not just once after boot
+   * 
+   * This ensures that missing values are added to the config, with their default values, in the rare but plauible cases of:
+   * - a single value being missing at boot, e.g. if the Usermod was upgraded and a new setting was added
+   * - a single value being missing after boot (e.g. if the cfg.json was manually edited and a value was removed)
+   * 
+   * If configComplete is false, the default values are already set, and by returning false, WLED now knows it needs to save the defaults by calling addToConfig()
+   */
+  bool readFromConfig(JsonObject& root)
+  {
+    // set defaults here, they will be set before setup() is called, and if any values parsed from ArduinoJson below are missing, the default will be used instead
+    fadeAmount = 5;
+    pins[0] = -1;
+    pins[1] = -1;
+    pins[2] = -1;
+
+    JsonObject top = root["rotEncBrightness"];
+
+    bool configComplete = !top.isNull();
+    configComplete &= getJsonValue(top["fadeAmount"], fadeAmount);
+    configComplete &= getJsonValue(top["pin"][0], pins[0]);
+    configComplete &= getJsonValue(top["pin"][1], pins[1]);
+    configComplete &= getJsonValue(top["pin"][2], pins[2]);
+
+    return configComplete;
+  }
+};

usermods/usermod_v2_rotary_encoder_ui/usermod_v2_rotary_encoder_ui.h

@@ -267,8 +267,8 @@ public:
 
     //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
     // 6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
-    colorUpdated(NOTIFIER_CALL_MODE_DIRECT_CHANGE);
-    updateInterfaces(NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+    colorUpdated(CALL_MODE_DIRECT_CHANGE);
+    updateInterfaces(CALL_MODE_DIRECT_CHANGE);
   }
 
   void changeBrightness(bool increase) {

usermods/word-clock-matrix/word-clock-matrix.cpp

@@ -64,13 +64,13 @@ void hourChime()
 {
   //strip.resetSegments();
   selectWordSegments(true);
-  colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+  colorUpdated(CALL_MODE_FX_CHANGED);
   savePreset(13, false);
   selectWordSegments(false);
   //strip.getSegment(0).setOption(0, true);
   strip.getSegment(0).setOption(2, true);
   applyPreset(12);
-  colorUpdated(NOTIFIER_CALL_MODE_FX_CHANGED);
+  colorUpdated(CALL_MODE_FX_CHANGED);
 }
 
 void displayTime(byte hour, byte minute)

wled00/FX.cpp

@@ -3519,7 +3519,7 @@ uint16_t WS2812FX::mode_twinkleup(void) {                 // A very short twinkl
     uint8_t ranstart = random8();                         // The starting value (aka brightness) for each pixel. Must be consistent each time through the loop for this to work.
     uint8_t pixBri = sin8(ranstart + 16 * now/(256-SEGMENT.speed));
     if (random8() > SEGMENT.intensity) pixBri = 0;
-    setPixelColor(i, color_blend(SEGCOLOR(1), color_from_palette(i*20, false, PALETTE_SOLID_WRAP, 0), pixBri));
+    setPixelColor(i, color_blend(SEGCOLOR(1), color_from_palette(random8()+now/100, false, PALETTE_SOLID_WRAP, 0), pixBri));
   }
 
   return FRAMETIME;
@@ -3957,7 +3957,6 @@ uint16_t WS2812FX::mode_tv_simulator(void) {
 */
 
 //CONFIG
-#define BACKLIGHT 5
 #define W_MAX_COUNT 20            //Number of simultaneous waves
 #define W_MAX_SPEED 6             //Higher number, higher speed
 #define W_WIDTH_FACTOR 6          //Higher number, smaller waves
@@ -4082,9 +4081,13 @@ uint16_t WS2812FX::mode_aurora(void) {
     }
   }
 
+  uint8_t backlight = 1; //dimmer backlight if less active colors
+  if (SEGCOLOR(0)) backlight++;
+  if (SEGCOLOR(1)) backlight++;
+  if (SEGCOLOR(2)) backlight++;
   //Loop through LEDs to determine color
   for(int i = 0; i < SEGLEN; i++) {    
-    CRGB mixedRgb = CRGB(BACKLIGHT, BACKLIGHT, BACKLIGHT);
+    CRGB mixedRgb = CRGB(backlight, backlight, backlight);
 
     //For each LED we must check each wave if it is "active" at this position.
     //If there are multiple waves active on a LED we multiply their values.
@@ -4096,7 +4099,7 @@ uint16_t WS2812FX::mode_aurora(void) {
       }
     }
 
-    setPixelColor(i, mixedRgb[0], mixedRgb[1], mixedRgb[2], BACKLIGHT);
+    setPixelColor(i, mixedRgb[0], mixedRgb[1], mixedRgb[2]);
   }
   
   return FRAMETIME;

wled00/FX.h

@@ -320,6 +320,27 @@ class WS2812FX {
           vLength = (vLength + 1) /2;  // divide by 2 if mirror, leave at least a single LED
         return vLength;
       }
+      uint8_t differs(Segment& b) {
+        uint8_t d = 0;
+        if (start != b.start)         d |= SEG_DIFFERS_BOUNDS;
+        if (stop != b.stop)           d |= SEG_DIFFERS_BOUNDS;
+        if (offset != b.offset)       d |= SEG_DIFFERS_GSO;
+        if (grouping != b.grouping)   d |= SEG_DIFFERS_GSO;
+        if (spacing != b.spacing)     d |= SEG_DIFFERS_GSO;
+        if (opacity != b.opacity)     d |= SEG_DIFFERS_BRI;
+        if (mode != b.mode)           d |= SEG_DIFFERS_FX;
+        if (speed != b.speed)         d |= SEG_DIFFERS_FX;
+        if (intensity != b.intensity) d |= SEG_DIFFERS_FX;
+        if (palette != b.palette)     d |= SEG_DIFFERS_FX;
+
+        if ((options & 0b00101111) != (b.options & 0b00101111)) d |= SEG_DIFFERS_OPT;
+        for (uint8_t i = 0; i < NUM_COLORS; i++)
+        {
+          if (colors[i] != b.colors[i]) d |= SEG_DIFFERS_COL;
+        }
+
+        return d;
+      }
     } segment;
 
   // segment runtime parameters
@@ -613,7 +634,6 @@ class WS2812FX {
       gammaCorrectBri = false,
       gammaCorrectCol = true,
       applyToAllSelected = true,
-      segmentsAreIdentical(Segment* a, Segment* b),
       setEffectConfig(uint8_t m, uint8_t s, uint8_t i, uint8_t p),
       // return true if the strip is being sent pixel updates
       isUpdating(void);

wled00/FX_fcn.cpp

@@ -1010,23 +1010,6 @@ uint32_t WS2812FX::color_from_palette(uint16_t i, bool mapping, bool wrap, uint8
   return crgb_to_col(fastled_col);
 }
 
-//@returns `true` if color, mode, speed, intensity and palette match
-bool WS2812FX::segmentsAreIdentical(Segment* a, Segment* b)
-{
-  //if (a->start != b->start) return false;
-  //if (a->stop != b->stop) return false;
-  for (uint8_t i = 0; i < NUM_COLORS; i++)
-  {
-    if (a->colors[i] != b->colors[i]) return false;
-  }
-  if (a->mode != b->mode) return false;
-  if (a->speed != b->speed) return false;
-  if (a->intensity != b->intensity) return false;
-  if (a->palette != b->palette) return false;
-  //if (a->getOption(SEG_OPTION_REVERSED) != b->getOption(SEG_OPTION_REVERSED)) return false;
-  return true;
-}
-
 
 //load custom mapping table from JSON file
 void WS2812FX::deserializeMap(void) {

wled00/alexa.cpp

@@ -44,10 +44,10 @@ void onAlexaChange(EspalexaDevice* dev)
       if (bri == 0)
       {
         bri = briLast;
-        colorUpdated(NOTIFIER_CALL_MODE_ALEXA);
+        colorUpdated(CALL_MODE_ALEXA);
       }
     } else {
-      applyPreset(macroAlexaOn);
+      applyPreset(macroAlexaOn, CALL_MODE_ALEXA);
       if (bri == 0) espalexaDevice->setValue(briLast); //stop Alexa from complaining if macroAlexaOn does not actually turn on
     }
   } else if (m == EspalexaDeviceProperty::off)
@@ -58,16 +58,16 @@ void onAlexaChange(EspalexaDevice* dev)
       {
         briLast = bri;
         bri = 0;
-        colorUpdated(NOTIFIER_CALL_MODE_ALEXA);
+        colorUpdated(CALL_MODE_ALEXA);
       }
     } else {
-      applyPreset(macroAlexaOff);
+      applyPreset(macroAlexaOff, CALL_MODE_ALEXA);
       if (bri != 0) espalexaDevice->setValue(0); //stop Alexa from complaining if macroAlexaOff does not actually turn off
     }
   } else if (m == EspalexaDeviceProperty::bri)
   {
     bri = espalexaDevice->getValue();
-    colorUpdated(NOTIFIER_CALL_MODE_ALEXA);
+    colorUpdated(CALL_MODE_ALEXA);
   } else //color
   {
     if (espalexaDevice->getColorMode() == EspalexaColorMode::ct) //shade of white
@@ -93,7 +93,7 @@ void onAlexaChange(EspalexaDevice* dev)
       col[2] = ( color        & 0xFF);
       col[3] = 0;
     }
-    colorUpdated(NOTIFIER_CALL_MODE_ALEXA);
+    colorUpdated(CALL_MODE_ALEXA);
   }
 }
 

wled00/blynk.cpp

@@ -44,45 +44,45 @@ void updateBlynk()
 BLYNK_WRITE(V0)
 {
   bri = param.asInt();//bri
-  colorUpdated(NOTIFIER_CALL_MODE_BLYNK);
+  colorUpdated(CALL_MODE_BLYNK);
 }
 
 BLYNK_WRITE(V1)
 {
   blHue = param.asInt();//hue
   colorHStoRGB(blHue*10,blSat,(false)? colSec:col);
-  colorUpdated(NOTIFIER_CALL_MODE_BLYNK);
+  colorUpdated(CALL_MODE_BLYNK);
 }
 
 BLYNK_WRITE(V2)
 {
   blSat = param.asInt();//sat
   colorHStoRGB(blHue*10,blSat,(false)? colSec:col);
-  colorUpdated(NOTIFIER_CALL_MODE_BLYNK);
+  colorUpdated(CALL_MODE_BLYNK);
 }
 
 BLYNK_WRITE(V3)
 {
   bool on = (param.asInt()>0);
-  if (!on != !bri) {toggleOnOff(); colorUpdated(NOTIFIER_CALL_MODE_BLYNK);}
+  if (!on != !bri) {toggleOnOff(); colorUpdated(CALL_MODE_BLYNK);}
 }
 
 BLYNK_WRITE(V4)
 {
   effectCurrent = param.asInt()-1;//fx
-  colorUpdated(NOTIFIER_CALL_MODE_BLYNK);
+  colorUpdated(CALL_MODE_BLYNK);
 }
 
 BLYNK_WRITE(V5)
 {
   effectSpeed = param.asInt();//sx
-  colorUpdated(NOTIFIER_CALL_MODE_BLYNK);
+  colorUpdated(CALL_MODE_BLYNK);
 }
 
 BLYNK_WRITE(V6)
 {
   effectIntensity = param.asInt();//ix
-  colorUpdated(NOTIFIER_CALL_MODE_BLYNK);
+  colorUpdated(CALL_MODE_BLYNK);
 }
 
 BLYNK_WRITE(V7)

wled00/bus_manager.h

@@ -27,6 +27,18 @@ struct BusConfig {
     else if (type > 40 && type < 46) nPins = NUM_PWM_PINS(type);
     for (uint8_t i = 0; i < nPins; i++) pins[i] = ppins[i];
   }
+
+  //validates start and length and extends total if needed
+  bool adjustBounds(uint16_t& total) {
+    if (!count) count = 1;
+    if (count > MAX_LEDS_PER_BUS) count = MAX_LEDS_PER_BUS;
+    if (start >= MAX_LEDS) return false;
+    //limit length of strip if it would exceed total permissible LEDs
+    if (start + count > MAX_LEDS) count = MAX_LEDS - start;
+    //extend total count accordingly
+    if (start + count > total) total = start + count;
+    return true;
+  }
 };
 
 //parent class of BusDigital and BusPwm
@@ -107,20 +119,20 @@ class BusDigital : public Bus {
   public:
   BusDigital(BusConfig &bc, uint8_t nr) : Bus(bc.type, bc.start) {
     if (!IS_DIGITAL(bc.type) || !bc.count) return;
+    if (!pinManager.allocatePin(bc.pins[0])) return;
     _pins[0] = bc.pins[0];
-    if (!pinManager.allocatePin(_pins[0])) return;
     if (IS_2PIN(bc.type)) {
-      _pins[1] = bc.pins[1];
-      if (!pinManager.allocatePin(_pins[1])) {
+      if (!pinManager.allocatePin(bc.pins[1])) {
         cleanup(); return;
       }
+      _pins[1] = bc.pins[1];
     }
     reversed = bc.reversed;
     _skip = bc.skipAmount;    //sacrificial pixels
     _len = bc.count + _skip;
     _iType = PolyBus::getI(bc.type, _pins, nr);
     if (_iType == I_NONE) return;
-    _busPtr = PolyBus::create(_iType, _pins, _len);
+    _busPtr = PolyBus::create(_iType, _pins, _len, nr);
     _valid = (_busPtr != nullptr);
     _colorOrder = bc.colorOrder;
     //Serial.printf("Successfully inited strip %u (len %u) with type %u and pins %u,%u (itype %u)\n",nr, len, type, pins[0],pins[1],_iType);
@@ -229,10 +241,11 @@ class BusPwm : public Bus {
     #endif
 
     for (uint8_t i = 0; i < numPins; i++) {
-      _pins[i] = bc.pins[i];
-      if (!pinManager.allocatePin(_pins[i])) {
+      uint8_t currentPin = bc.pins[i];
+      if (!pinManager.allocatePin(currentPin)) {
         deallocatePins(); return;
       }
+      _pins[i] = currentPin; // store only after allocatePin() succeeds
       #ifdef ESP8266
       pinMode(_pins[i], OUTPUT);
       #else

wled00/bus_wrapper.h

@@ -36,66 +36,38 @@
 
 /*** ESP32 Neopixel methods ***/
 //RGB
-#define I_32_R0_NEO_3 17
-#define I_32_R1_NEO_3 18
-#define I_32_R2_NEO_3 19
-#define I_32_R3_NEO_3 20
-#define I_32_R4_NEO_3 21
-#define I_32_R5_NEO_3 22
-#define I_32_R6_NEO_3 23
-#define I_32_R7_NEO_3 24
-#define I_32_I0_NEO_3 25
-#define I_32_I1_NEO_3 26
+#define I_32_RN_NEO_3 17
+#define I_32_I0_NEO_3 18
+#define I_32_I1_NEO_3 19
 //RGBW
-#define I_32_R0_NEO_4 27
-#define I_32_R1_NEO_4 28
-#define I_32_R2_NEO_4 29
-#define I_32_R3_NEO_4 30
-#define I_32_R4_NEO_4 31
-#define I_32_R5_NEO_4 32
-#define I_32_R6_NEO_4 33
-#define I_32_R7_NEO_4 34
-#define I_32_I0_NEO_4 35
-#define I_32_I1_NEO_4 36
+#define I_32_RN_NEO_4 20
+#define I_32_I0_NEO_4 21
+#define I_32_I1_NEO_4 22
 //400Kbps
-#define I_32_R0_400_3 37
-#define I_32_R1_400_3 38
-#define I_32_R2_400_3 39
-#define I_32_R3_400_3 40
-#define I_32_R4_400_3 41
-#define I_32_R5_400_3 42
-#define I_32_R6_400_3 43
-#define I_32_R7_400_3 44
-#define I_32_I0_400_3 45
-#define I_32_I1_400_3 46
+#define I_32_RN_400_3 23
+#define I_32_I0_400_3 24
+#define I_32_I1_400_3 25
 //TM1814 (RGBW)
-#define I_32_R0_TM1_4 47
-#define I_32_R1_TM1_4 48
-#define I_32_R2_TM1_4 49
-#define I_32_R3_TM1_4 50
-#define I_32_R4_TM1_4 51
-#define I_32_R5_TM1_4 52
-#define I_32_R6_TM1_4 53
-#define I_32_R7_TM1_4 54
-#define I_32_I0_TM1_4 55
-#define I_32_I1_TM1_4 56
+#define I_32_RN_TM1_4 26
+#define I_32_I0_TM1_4 27
+#define I_32_I1_TM1_4 28
 //Bit Bang theoratically possible, but very undesirable and not needed (no pin restrictions on RMT and I2S)
 
 //APA102
-#define I_HS_DOT_3 57 //hardware SPI
-#define I_SS_DOT_3 58 //soft SPI
+#define I_HS_DOT_3 29 //hardware SPI
+#define I_SS_DOT_3 30 //soft SPI
 
 //LPD8806
-#define I_HS_LPD_3 59
-#define I_SS_LPD_3 60
+#define I_HS_LPD_3 31
+#define I_SS_LPD_3 32
 
 //WS2801
-#define I_HS_WS1_3 61
-#define I_SS_WS1_3 62
+#define I_HS_WS1_3 33
+#define I_SS_WS1_3 34
 
 //P9813
-#define I_HS_P98_3 63
-#define I_SS_P98_3 64
+#define I_HS_P98_3 35
+#define I_SS_P98_3 36
 
 
 /*** ESP8266 Neopixel methods ***/
@@ -125,63 +97,46 @@
 /*** ESP32 Neopixel methods ***/
 #ifdef ARDUINO_ARCH_ESP32
 //RGB
-#define B_32_R0_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt0Ws2812xMethod>
-#define B_32_R1_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt1Ws2812xMethod>
-#define B_32_R2_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt2Ws2812xMethod>
-#define B_32_R3_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt3Ws2812xMethod>
-#define B_32_R4_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt4Ws2812xMethod>
-#define B_32_R5_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt5Ws2812xMethod>
-#define B_32_R6_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt6Ws2812xMethod>
-#define B_32_R7_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt7Ws2812xMethod>
+#define B_32_RN_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32RmtNWs2812xMethod>
 #define B_32_I0_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32I2s0800KbpsMethod>
+#ifndef CONFIG_IDF_TARGET_ESP32S2
 #define B_32_I1_NEO_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32I2s1800KbpsMethod>
+#endif
 //RGBW
-#define B_32_R0_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt0Ws2812xMethod>
-#define B_32_R1_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt1Ws2812xMethod>
-#define B_32_R2_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt2Ws2812xMethod>
-#define B_32_R3_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt3Ws2812xMethod>
-#define B_32_R4_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt4Ws2812xMethod>
-#define B_32_R5_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt5Ws2812xMethod>
-#define B_32_R6_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt6Ws2812xMethod>
-#define B_32_R7_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32Rmt7Ws2812xMethod>
+#define B_32_RN_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32RmtNWs2812xMethod>
 #define B_32_I0_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32I2s0800KbpsMethod>
+#ifndef CONFIG_IDF_TARGET_ESP32S2
 #define B_32_I1_NEO_4 NeoPixelBrightnessBus<NeoGrbwFeature, NeoEsp32I2s1800KbpsMethod>
+#endif
 //400Kbps
-#define B_32_R0_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt0400KbpsMethod>
-#define B_32_R1_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt1400KbpsMethod>
-#define B_32_R2_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt2400KbpsMethod>
-#define B_32_R3_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt3400KbpsMethod>
-#define B_32_R4_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt4400KbpsMethod>
-#define B_32_R5_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt5400KbpsMethod>
-#define B_32_R6_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt6400KbpsMethod>
-#define B_32_R7_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32Rmt7400KbpsMethod>
+#define B_32_RN_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32RmtN400KbpsMethod>
 #define B_32_I0_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32I2s0400KbpsMethod>
+#ifndef CONFIG_IDF_TARGET_ESP32S2
 #define B_32_I1_400_3 NeoPixelBrightnessBus<NeoGrbFeature, NeoEsp32I2s1400KbpsMethod>
+#endif
 //TM1814 (RGBW)
-#define B_32_R0_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt0Tm1814Method>
-#define B_32_R1_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt1Tm1814Method>
-#define B_32_R2_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt2Tm1814Method>
-#define B_32_R3_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt3Tm1814Method>
-#define B_32_R4_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt4Tm1814Method>
-#define B_32_R5_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt5Tm1814Method>
-#define B_32_R6_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt6Tm1814Method>
-#define B_32_R7_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32Rmt7Tm1814Method>
+#define B_32_RN_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32RmtNTm1814Method>
 #define B_32_I0_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32I2s0Tm1814Method>
+#ifndef CONFIG_IDF_TARGET_ESP32S2
 #define B_32_I1_TM1_4 NeoPixelBrightnessBus<NeoWrgbTm1814Feature, NeoEsp32I2s1Tm1814Method>
+#endif
 //Bit Bang theoratically possible, but very undesirable and not needed (no pin restrictions on RMT and I2S)
 
 #endif
 
 //APA102
 #define B_HS_DOT_3 NeoPixelBrightnessBus<DotStarBgrFeature, DotStarSpiMethod> //hardware SPI
-#define B_SS_DOT_3 NeoPixelBrightnessBus<DotStarBgrFeature, DotStarMethod> //soft SPI
+#define B_SS_DOT_3 NeoPixelBrightnessBus<DotStarBgrFeature, DotStarMethod>    //soft SPI
 
 //LPD8806
 #define B_HS_LPD_3 NeoPixelBrightnessBus<Lpd8806GrbFeature, Lpd8806SpiMethod>
 #define B_SS_LPD_3 NeoPixelBrightnessBus<Lpd8806GrbFeature, Lpd8806Method>
 
 //WS2801
-#define B_HS_WS1_3 NeoPixelBrightnessBus<NeoRbgFeature, NeoWs2801SpiMethod>
+//#define B_HS_WS1_3 NeoPixelBrightnessBus<NeoRbgFeature, NeoWs2801Spi40MhzMethod>
+//#define B_HS_WS1_3 NeoPixelBrightnessBus<NeoRbgFeature, NeoWs2801Spi20MhzMethod>
+//#define B_HS_WS1_3 NeoPixelBrightnessBus<NeoRbgFeature, NeoWs2801SpiMethod>     // 10MHz
+#define B_HS_WS1_3 NeoPixelBrightnessBus<NeoRbgFeature, NeoWs2801Spi2MhzMethod> //slower, more compatible
 #define B_SS_WS1_3 NeoPixelBrightnessBus<NeoRbgFeature, NeoWs2801Method>
 
 //P9813
@@ -225,46 +180,26 @@ class PolyBus {
       case I_HS_P98_3: (static_cast<B_HS_P98_3*>(busPtr))->Begin(); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: (static_cast<B_32_R0_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R1_NEO_3: (static_cast<B_32_R1_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R2_NEO_3: (static_cast<B_32_R2_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R3_NEO_3: (static_cast<B_32_R3_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R4_NEO_3: (static_cast<B_32_R4_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R5_NEO_3: (static_cast<B_32_R5_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R6_NEO_3: (static_cast<B_32_R6_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R7_NEO_3: (static_cast<B_32_R7_NEO_3*>(busPtr))->Begin(); break;
+      case I_32_RN_NEO_3: (static_cast<B_32_RN_NEO_3*>(busPtr))->Begin(); break;
       case I_32_I0_NEO_3: (static_cast<B_32_I0_NEO_3*>(busPtr))->Begin(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: (static_cast<B_32_I1_NEO_3*>(busPtr))->Begin(); break;
-      case I_32_R0_NEO_4: (static_cast<B_32_R0_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R1_NEO_4: (static_cast<B_32_R1_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R2_NEO_4: (static_cast<B_32_R2_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R3_NEO_4: (static_cast<B_32_R3_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R4_NEO_4: (static_cast<B_32_R4_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R5_NEO_4: (static_cast<B_32_R5_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R6_NEO_4: (static_cast<B_32_R6_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R7_NEO_4: (static_cast<B_32_R7_NEO_4*>(busPtr))->Begin(); break;
+      #endif
+      case I_32_RN_NEO_4: (static_cast<B_32_RN_NEO_4*>(busPtr))->Begin(); break;
       case I_32_I0_NEO_4: (static_cast<B_32_I0_NEO_4*>(busPtr))->Begin(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: (static_cast<B_32_I1_NEO_4*>(busPtr))->Begin(); break;
-      case I_32_R0_400_3: (static_cast<B_32_R0_400_3*>(busPtr))->Begin(); break;
-      case I_32_R1_400_3: (static_cast<B_32_R1_400_3*>(busPtr))->Begin(); break;
-      case I_32_R2_400_3: (static_cast<B_32_R2_400_3*>(busPtr))->Begin(); break;
-      case I_32_R3_400_3: (static_cast<B_32_R3_400_3*>(busPtr))->Begin(); break;
-      case I_32_R4_400_3: (static_cast<B_32_R4_400_3*>(busPtr))->Begin(); break;
-      case I_32_R5_400_3: (static_cast<B_32_R5_400_3*>(busPtr))->Begin(); break;
-      case I_32_R6_400_3: (static_cast<B_32_R6_400_3*>(busPtr))->Begin(); break;
-      case I_32_R7_400_3: (static_cast<B_32_R7_400_3*>(busPtr))->Begin(); break;
+      #endif
+      case I_32_RN_400_3: (static_cast<B_32_RN_400_3*>(busPtr))->Begin(); break;
       case I_32_I0_400_3: (static_cast<B_32_I0_400_3*>(busPtr))->Begin(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: (static_cast<B_32_I1_400_3*>(busPtr))->Begin(); break;
-      case I_32_R0_TM1_4: beginTM1814<B_32_R0_TM1_4*>(busPtr); break;
-      case I_32_R1_TM1_4: beginTM1814<B_32_R1_TM1_4*>(busPtr); break;
-      case I_32_R2_TM1_4: beginTM1814<B_32_R2_TM1_4*>(busPtr); break;
-      case I_32_R3_TM1_4: beginTM1814<B_32_R3_TM1_4*>(busPtr); break;
-      case I_32_R4_TM1_4: beginTM1814<B_32_R4_TM1_4*>(busPtr); break;
-      case I_32_R5_TM1_4: beginTM1814<B_32_R5_TM1_4*>(busPtr); break;
-      case I_32_R6_TM1_4: beginTM1814<B_32_R6_TM1_4*>(busPtr); break;
-      case I_32_R7_TM1_4: beginTM1814<B_32_R7_TM1_4*>(busPtr); break;
+      #endif
+      case I_32_RN_TM1_4: beginTM1814<B_32_RN_TM1_4*>(busPtr); break;
       case I_32_I0_TM1_4: beginTM1814<B_32_I0_TM1_4*>(busPtr); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: beginTM1814<B_32_I1_TM1_4*>(busPtr); break;
+      #endif
       // ESP32 can (and should, to avoid inadvertantly driving the chip select signal) specify the pins used for SPI, but only in begin()
       case I_HS_DOT_3: (static_cast<B_HS_DOT_3*>(busPtr))->Begin(pins[1], -1, pins[0], -1); break;
       case I_HS_LPD_3: (static_cast<B_HS_LPD_3*>(busPtr))->Begin(pins[1], -1, pins[0], -1); break;
@@ -277,7 +212,7 @@ class PolyBus {
       case I_SS_P98_3: (static_cast<B_SS_P98_3*>(busPtr))->Begin(); break;
     }
   };
-  static void* create(uint8_t busType, uint8_t* pins, uint16_t len) {
+  static void* create(uint8_t busType, uint8_t* pins, uint16_t len, uint8_t channel) {
     void* busPtr = nullptr;
     switch (busType) {
       case I_NONE: break;
@@ -300,46 +235,26 @@ class PolyBus {
       case I_8266_BB_TM1_4: busPtr = new B_8266_BB_TM1_4(len, pins[0]); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: busPtr = new B_32_R0_NEO_3(len, pins[0]); break;
-      case I_32_R1_NEO_3: busPtr = new B_32_R1_NEO_3(len, pins[0]); break;
-      case I_32_R2_NEO_3: busPtr = new B_32_R2_NEO_3(len, pins[0]); break;
-      case I_32_R3_NEO_3: busPtr = new B_32_R3_NEO_3(len, pins[0]); break;
-      case I_32_R4_NEO_3: busPtr = new B_32_R4_NEO_3(len, pins[0]); break;
-      case I_32_R5_NEO_3: busPtr = new B_32_R5_NEO_3(len, pins[0]); break;
-      case I_32_R6_NEO_3: busPtr = new B_32_R6_NEO_3(len, pins[0]); break;
-      case I_32_R7_NEO_3: busPtr = new B_32_R7_NEO_3(len, pins[0]); break;
+      case I_32_RN_NEO_3: busPtr = new B_32_RN_NEO_3(len, pins[0], (NeoBusChannel)channel); break;
       case I_32_I0_NEO_3: busPtr = new B_32_I0_NEO_3(len, pins[0]); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: busPtr = new B_32_I1_NEO_3(len, pins[0]); break;
-      case I_32_R0_NEO_4: busPtr = new B_32_R0_NEO_4(len, pins[0]); break;
-      case I_32_R1_NEO_4: busPtr = new B_32_R1_NEO_4(len, pins[0]); break;
-      case I_32_R2_NEO_4: busPtr = new B_32_R2_NEO_4(len, pins[0]); break;
-      case I_32_R3_NEO_4: busPtr = new B_32_R3_NEO_4(len, pins[0]); break;
-      case I_32_R4_NEO_4: busPtr = new B_32_R4_NEO_4(len, pins[0]); break;
-      case I_32_R5_NEO_4: busPtr = new B_32_R5_NEO_4(len, pins[0]); break;
-      case I_32_R6_NEO_4: busPtr = new B_32_R6_NEO_4(len, pins[0]); break;
-      case I_32_R7_NEO_4: busPtr = new B_32_R7_NEO_4(len, pins[0]); break;
+      #endif
+      case I_32_RN_NEO_4: busPtr = new B_32_RN_NEO_4(len, pins[0], (NeoBusChannel)channel); break;
       case I_32_I0_NEO_4: busPtr = new B_32_I0_NEO_4(len, pins[0]); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: busPtr = new B_32_I1_NEO_4(len, pins[0]); break;
-      case I_32_R0_400_3: busPtr = new B_32_R0_400_3(len, pins[0]); break;
-      case I_32_R1_400_3: busPtr = new B_32_R1_400_3(len, pins[0]); break;
-      case I_32_R2_400_3: busPtr = new B_32_R2_400_3(len, pins[0]); break;
-      case I_32_R3_400_3: busPtr = new B_32_R3_400_3(len, pins[0]); break;
-      case I_32_R4_400_3: busPtr = new B_32_R4_400_3(len, pins[0]); break;
-      case I_32_R5_400_3: busPtr = new B_32_R5_400_3(len, pins[0]); break;
-      case I_32_R6_400_3: busPtr = new B_32_R6_400_3(len, pins[0]); break;
-      case I_32_R7_400_3: busPtr = new B_32_R7_400_3(len, pins[0]); break;
+      #endif
+      case I_32_RN_400_3: busPtr = new B_32_RN_400_3(len, pins[0], (NeoBusChannel)channel); break;
       case I_32_I0_400_3: busPtr = new B_32_I0_400_3(len, pins[0]); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: busPtr = new B_32_I1_400_3(len, pins[0]); break;
-      case I_32_R0_TM1_4: busPtr = new B_32_R0_TM1_4(len, pins[0]); break;
-      case I_32_R1_TM1_4: busPtr = new B_32_R1_TM1_4(len, pins[0]); break;
-      case I_32_R2_TM1_4: busPtr = new B_32_R2_TM1_4(len, pins[0]); break;
-      case I_32_R3_TM1_4: busPtr = new B_32_R3_TM1_4(len, pins[0]); break;
-      case I_32_R4_TM1_4: busPtr = new B_32_R4_TM1_4(len, pins[0]); break;
-      case I_32_R5_TM1_4: busPtr = new B_32_R5_TM1_4(len, pins[0]); break;
-      case I_32_R6_TM1_4: busPtr = new B_32_R6_TM1_4(len, pins[0]); break;
-      case I_32_R7_TM1_4: busPtr = new B_32_R7_TM1_4(len, pins[0]); break;
+      #endif
+      case I_32_RN_TM1_4: busPtr = new B_32_RN_TM1_4(len, pins[0], (NeoBusChannel)channel); break;
       case I_32_I0_TM1_4: busPtr = new B_32_I0_TM1_4(len, pins[0]); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: busPtr = new B_32_I1_TM1_4(len, pins[0]); break;
+      #endif
     #endif
       // for 2-wire: pins[1] is clk, pins[0] is dat.  begin expects (len, clk, dat)
       case I_HS_DOT_3: busPtr = new B_HS_DOT_3(len, pins[1], pins[0]); break;
@@ -376,46 +291,26 @@ class PolyBus {
       case I_8266_BB_TM1_4: (static_cast<B_8266_BB_TM1_4*>(busPtr))->Show(); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: (static_cast<B_32_R0_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R1_NEO_3: (static_cast<B_32_R1_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R2_NEO_3: (static_cast<B_32_R2_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R3_NEO_3: (static_cast<B_32_R3_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R4_NEO_3: (static_cast<B_32_R4_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R5_NEO_3: (static_cast<B_32_R5_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R6_NEO_3: (static_cast<B_32_R6_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R7_NEO_3: (static_cast<B_32_R7_NEO_3*>(busPtr))->Show(); break;
+      case I_32_RN_NEO_3: (static_cast<B_32_RN_NEO_3*>(busPtr))->Show(); break;
       case I_32_I0_NEO_3: (static_cast<B_32_I0_NEO_3*>(busPtr))->Show(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: (static_cast<B_32_I1_NEO_3*>(busPtr))->Show(); break;
-      case I_32_R0_NEO_4: (static_cast<B_32_R0_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R1_NEO_4: (static_cast<B_32_R1_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R2_NEO_4: (static_cast<B_32_R2_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R3_NEO_4: (static_cast<B_32_R3_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R4_NEO_4: (static_cast<B_32_R4_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R5_NEO_4: (static_cast<B_32_R5_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R6_NEO_4: (static_cast<B_32_R6_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R7_NEO_4: (static_cast<B_32_R7_NEO_4*>(busPtr))->Show(); break;
+      #endif
+      case I_32_RN_NEO_4: (static_cast<B_32_RN_NEO_4*>(busPtr))->Show(); break;
       case I_32_I0_NEO_4: (static_cast<B_32_I0_NEO_4*>(busPtr))->Show(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: (static_cast<B_32_I1_NEO_4*>(busPtr))->Show(); break;
-      case I_32_R0_400_3: (static_cast<B_32_R0_400_3*>(busPtr))->Show(); break;
-      case I_32_R1_400_3: (static_cast<B_32_R1_400_3*>(busPtr))->Show(); break;
-      case I_32_R2_400_3: (static_cast<B_32_R2_400_3*>(busPtr))->Show(); break;
-      case I_32_R3_400_3: (static_cast<B_32_R3_400_3*>(busPtr))->Show(); break;
-      case I_32_R4_400_3: (static_cast<B_32_R4_400_3*>(busPtr))->Show(); break;
-      case I_32_R5_400_3: (static_cast<B_32_R5_400_3*>(busPtr))->Show(); break;
-      case I_32_R6_400_3: (static_cast<B_32_R6_400_3*>(busPtr))->Show(); break;
-      case I_32_R7_400_3: (static_cast<B_32_R7_400_3*>(busPtr))->Show(); break;
+      #endif
+      case I_32_RN_400_3: (static_cast<B_32_RN_400_3*>(busPtr))->Show(); break;
       case I_32_I0_400_3: (static_cast<B_32_I0_400_3*>(busPtr))->Show(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: (static_cast<B_32_I1_400_3*>(busPtr))->Show(); break;
-      case I_32_R0_TM1_4: (static_cast<B_32_R0_TM1_4*>(busPtr))->Show(); break;
-      case I_32_R1_TM1_4: (static_cast<B_32_R1_TM1_4*>(busPtr))->Show(); break;
-      case I_32_R2_TM1_4: (static_cast<B_32_R2_TM1_4*>(busPtr))->Show(); break;
-      case I_32_R3_TM1_4: (static_cast<B_32_R3_TM1_4*>(busPtr))->Show(); break;
-      case I_32_R4_TM1_4: (static_cast<B_32_R4_TM1_4*>(busPtr))->Show(); break;
-      case I_32_R5_TM1_4: (static_cast<B_32_R5_TM1_4*>(busPtr))->Show(); break;
-      case I_32_R6_TM1_4: (static_cast<B_32_R6_TM1_4*>(busPtr))->Show(); break;
-      case I_32_R7_TM1_4: (static_cast<B_32_R7_TM1_4*>(busPtr))->Show(); break;
+      #endif
+      case I_32_RN_TM1_4: (static_cast<B_32_RN_TM1_4*>(busPtr))->Show(); break;
       case I_32_I0_TM1_4: (static_cast<B_32_I0_TM1_4*>(busPtr))->Show(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: (static_cast<B_32_I1_TM1_4*>(busPtr))->Show(); break;
+      #endif
     #endif
       case I_HS_DOT_3: (static_cast<B_HS_DOT_3*>(busPtr))->Show(); break;
       case I_SS_DOT_3: (static_cast<B_SS_DOT_3*>(busPtr))->Show(); break;
@@ -449,46 +344,26 @@ class PolyBus {
       case I_8266_BB_TM1_4: return (static_cast<B_8266_BB_TM1_4*>(busPtr))->CanShow(); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: return (static_cast<B_32_R0_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R1_NEO_3: return (static_cast<B_32_R1_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R2_NEO_3: return (static_cast<B_32_R2_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R3_NEO_3: return (static_cast<B_32_R3_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R4_NEO_3: return (static_cast<B_32_R4_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R5_NEO_3: return (static_cast<B_32_R5_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R6_NEO_3: return (static_cast<B_32_R6_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R7_NEO_3: return (static_cast<B_32_R7_NEO_3*>(busPtr))->CanShow(); break;
+      case I_32_RN_NEO_3: return (static_cast<B_32_RN_NEO_3*>(busPtr))->CanShow(); break;
       case I_32_I0_NEO_3: return (static_cast<B_32_I0_NEO_3*>(busPtr))->CanShow(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: return (static_cast<B_32_I1_NEO_3*>(busPtr))->CanShow(); break;
-      case I_32_R0_NEO_4: return (static_cast<B_32_R0_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R1_NEO_4: return (static_cast<B_32_R1_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R2_NEO_4: return (static_cast<B_32_R2_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R3_NEO_4: return (static_cast<B_32_R3_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R4_NEO_4: return (static_cast<B_32_R4_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R5_NEO_4: return (static_cast<B_32_R5_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R6_NEO_4: return (static_cast<B_32_R6_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R7_NEO_4: return (static_cast<B_32_R7_NEO_4*>(busPtr))->CanShow(); break;
+      #endif
+      case I_32_RN_NEO_4: return (static_cast<B_32_RN_NEO_4*>(busPtr))->CanShow(); break;
       case I_32_I0_NEO_4: return (static_cast<B_32_I0_NEO_4*>(busPtr))->CanShow(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: return (static_cast<B_32_I1_NEO_4*>(busPtr))->CanShow(); break;
-      case I_32_R0_400_3: return (static_cast<B_32_R0_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R1_400_3: return (static_cast<B_32_R1_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R2_400_3: return (static_cast<B_32_R2_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R3_400_3: return (static_cast<B_32_R3_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R4_400_3: return (static_cast<B_32_R4_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R5_400_3: return (static_cast<B_32_R5_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R6_400_3: return (static_cast<B_32_R6_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R7_400_3: return (static_cast<B_32_R7_400_3*>(busPtr))->CanShow(); break;
+      #endif
+      case I_32_RN_400_3: return (static_cast<B_32_RN_400_3*>(busPtr))->CanShow(); break;
       case I_32_I0_400_3: return (static_cast<B_32_I0_400_3*>(busPtr))->CanShow(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: return (static_cast<B_32_I1_400_3*>(busPtr))->CanShow(); break;
-      case I_32_R0_TM1_4: return (static_cast<B_32_R0_TM1_4*>(busPtr))->CanShow(); break;
-      case I_32_R1_TM1_4: return (static_cast<B_32_R1_TM1_4*>(busPtr))->CanShow(); break;
-      case I_32_R2_TM1_4: return (static_cast<B_32_R2_TM1_4*>(busPtr))->CanShow(); break;
-      case I_32_R3_TM1_4: return (static_cast<B_32_R3_TM1_4*>(busPtr))->CanShow(); break;
-      case I_32_R4_TM1_4: return (static_cast<B_32_R4_TM1_4*>(busPtr))->CanShow(); break;
-      case I_32_R5_TM1_4: return (static_cast<B_32_R5_TM1_4*>(busPtr))->CanShow(); break;
-      case I_32_R6_TM1_4: return (static_cast<B_32_R6_TM1_4*>(busPtr))->CanShow(); break;
-      case I_32_R7_TM1_4: return (static_cast<B_32_R7_TM1_4*>(busPtr))->CanShow(); break;
+      #endif
+      case I_32_RN_TM1_4: return (static_cast<B_32_RN_TM1_4*>(busPtr))->CanShow(); break;
       case I_32_I0_TM1_4: return (static_cast<B_32_I0_TM1_4*>(busPtr))->CanShow(); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: return (static_cast<B_32_I1_TM1_4*>(busPtr))->CanShow(); break;
+      #endif
     #endif
       case I_HS_DOT_3: return (static_cast<B_HS_DOT_3*>(busPtr))->CanShow(); break;
       case I_SS_DOT_3: return (static_cast<B_SS_DOT_3*>(busPtr))->CanShow(); break;
@@ -546,46 +421,26 @@ class PolyBus {
       case I_8266_BB_TM1_4: (static_cast<B_8266_BB_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: (static_cast<B_32_R0_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R1_NEO_3: (static_cast<B_32_R1_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R2_NEO_3: (static_cast<B_32_R2_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R3_NEO_3: (static_cast<B_32_R3_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R4_NEO_3: (static_cast<B_32_R4_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R5_NEO_3: (static_cast<B_32_R5_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R6_NEO_3: (static_cast<B_32_R6_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R7_NEO_3: (static_cast<B_32_R7_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
+      case I_32_RN_NEO_3: (static_cast<B_32_RN_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
       case I_32_I0_NEO_3: (static_cast<B_32_I0_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: (static_cast<B_32_I1_NEO_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R0_NEO_4: (static_cast<B_32_R0_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R1_NEO_4: (static_cast<B_32_R1_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R2_NEO_4: (static_cast<B_32_R2_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R3_NEO_4: (static_cast<B_32_R3_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R4_NEO_4: (static_cast<B_32_R4_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R5_NEO_4: (static_cast<B_32_R5_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R6_NEO_4: (static_cast<B_32_R6_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R7_NEO_4: (static_cast<B_32_R7_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
+      #endif
+      case I_32_RN_NEO_4: (static_cast<B_32_RN_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
       case I_32_I0_NEO_4: (static_cast<B_32_I0_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: (static_cast<B_32_I1_NEO_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R0_400_3: (static_cast<B_32_R0_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R1_400_3: (static_cast<B_32_R1_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R2_400_3: (static_cast<B_32_R2_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R3_400_3: (static_cast<B_32_R3_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R4_400_3: (static_cast<B_32_R4_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R5_400_3: (static_cast<B_32_R5_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R6_400_3: (static_cast<B_32_R6_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R7_400_3: (static_cast<B_32_R7_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
+      #endif
+      case I_32_RN_400_3: (static_cast<B_32_RN_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
       case I_32_I0_400_3: (static_cast<B_32_I0_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: (static_cast<B_32_I1_400_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
-      case I_32_R0_TM1_4: (static_cast<B_32_R0_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R1_TM1_4: (static_cast<B_32_R1_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R2_TM1_4: (static_cast<B_32_R2_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R3_TM1_4: (static_cast<B_32_R3_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R4_TM1_4: (static_cast<B_32_R4_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R5_TM1_4: (static_cast<B_32_R5_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R6_TM1_4: (static_cast<B_32_R6_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
-      case I_32_R7_TM1_4: (static_cast<B_32_R7_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
+      #endif
+      case I_32_RN_TM1_4: (static_cast<B_32_RN_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
       case I_32_I0_TM1_4: (static_cast<B_32_I0_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: (static_cast<B_32_I1_TM1_4*>(busPtr))->SetPixelColor(pix, col); break;
+      #endif
     #endif
       case I_HS_DOT_3: (static_cast<B_HS_DOT_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
       case I_SS_DOT_3: (static_cast<B_SS_DOT_3*>(busPtr))->SetPixelColor(pix, RgbColor(col.R,col.G,col.B)); break;
@@ -619,46 +474,26 @@ class PolyBus {
       case I_8266_BB_TM1_4: (static_cast<B_8266_BB_TM1_4*>(busPtr))->SetBrightness(b); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: (static_cast<B_32_R0_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R1_NEO_3: (static_cast<B_32_R1_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R2_NEO_3: (static_cast<B_32_R2_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R3_NEO_3: (static_cast<B_32_R3_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R4_NEO_3: (static_cast<B_32_R4_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R5_NEO_3: (static_cast<B_32_R5_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R6_NEO_3: (static_cast<B_32_R6_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R7_NEO_3: (static_cast<B_32_R7_NEO_3*>(busPtr))->SetBrightness(b); break;
+      case I_32_RN_NEO_3: (static_cast<B_32_RN_NEO_3*>(busPtr))->SetBrightness(b); break;
       case I_32_I0_NEO_3: (static_cast<B_32_I0_NEO_3*>(busPtr))->SetBrightness(b); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: (static_cast<B_32_I1_NEO_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R0_NEO_4: (static_cast<B_32_R0_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R1_NEO_4: (static_cast<B_32_R1_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R2_NEO_4: (static_cast<B_32_R2_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R3_NEO_4: (static_cast<B_32_R3_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R4_NEO_4: (static_cast<B_32_R4_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R5_NEO_4: (static_cast<B_32_R5_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R6_NEO_4: (static_cast<B_32_R6_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R7_NEO_4: (static_cast<B_32_R7_NEO_4*>(busPtr))->SetBrightness(b); break;
+      #endif
+      case I_32_RN_NEO_4: (static_cast<B_32_RN_NEO_4*>(busPtr))->SetBrightness(b); break;
       case I_32_I0_NEO_4: (static_cast<B_32_I0_NEO_4*>(busPtr))->SetBrightness(b); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: (static_cast<B_32_I1_NEO_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R0_400_3: (static_cast<B_32_R0_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R1_400_3: (static_cast<B_32_R1_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R2_400_3: (static_cast<B_32_R2_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R3_400_3: (static_cast<B_32_R3_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R4_400_3: (static_cast<B_32_R4_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R5_400_3: (static_cast<B_32_R5_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R6_400_3: (static_cast<B_32_R6_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R7_400_3: (static_cast<B_32_R7_400_3*>(busPtr))->SetBrightness(b); break;
+      #endif
+      case I_32_RN_400_3: (static_cast<B_32_RN_400_3*>(busPtr))->SetBrightness(b); break;
       case I_32_I0_400_3: (static_cast<B_32_I0_400_3*>(busPtr))->SetBrightness(b); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: (static_cast<B_32_I1_400_3*>(busPtr))->SetBrightness(b); break;
-      case I_32_R0_TM1_4: (static_cast<B_32_R0_TM1_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R1_TM1_4: (static_cast<B_32_R1_TM1_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R2_TM1_4: (static_cast<B_32_R2_TM1_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R3_TM1_4: (static_cast<B_32_R3_TM1_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R4_TM1_4: (static_cast<B_32_R4_TM1_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R5_TM1_4: (static_cast<B_32_R5_TM1_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R6_TM1_4: (static_cast<B_32_R6_TM1_4*>(busPtr))->SetBrightness(b); break;
-      case I_32_R7_TM1_4: (static_cast<B_32_R7_TM1_4*>(busPtr))->SetBrightness(b); break;
+      #endif
+      case I_32_RN_TM1_4: (static_cast<B_32_RN_TM1_4*>(busPtr))->SetBrightness(b); break;
       case I_32_I0_TM1_4: (static_cast<B_32_I0_TM1_4*>(busPtr))->SetBrightness(b); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: (static_cast<B_32_I1_TM1_4*>(busPtr))->SetBrightness(b); break;
+      #endif
     #endif
       case I_HS_DOT_3: (static_cast<B_HS_DOT_3*>(busPtr))->SetBrightness(b); break;
       case I_SS_DOT_3: (static_cast<B_SS_DOT_3*>(busPtr))->SetBrightness(b); break;
@@ -693,46 +528,26 @@ class PolyBus {
       case I_8266_BB_TM1_4: col = (static_cast<B_8266_BB_TM1_4*>(busPtr))->GetPixelColor(pix); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: col = (static_cast<B_32_R0_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R1_NEO_3: col = (static_cast<B_32_R1_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R2_NEO_3: col = (static_cast<B_32_R2_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R3_NEO_3: col = (static_cast<B_32_R3_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R4_NEO_3: col = (static_cast<B_32_R4_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R5_NEO_3: col = (static_cast<B_32_R5_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R6_NEO_3: col = (static_cast<B_32_R6_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R7_NEO_3: col = (static_cast<B_32_R7_NEO_3*>(busPtr))->GetPixelColor(pix); break;
+      case I_32_RN_NEO_3: col = (static_cast<B_32_RN_NEO_3*>(busPtr))->GetPixelColor(pix); break;
       case I_32_I0_NEO_3: col = (static_cast<B_32_I0_NEO_3*>(busPtr))->GetPixelColor(pix); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: col = (static_cast<B_32_I1_NEO_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R0_NEO_4: col = (static_cast<B_32_R0_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R1_NEO_4: col = (static_cast<B_32_R1_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R2_NEO_4: col = (static_cast<B_32_R2_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R3_NEO_4: col = (static_cast<B_32_R3_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R4_NEO_4: col = (static_cast<B_32_R4_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R5_NEO_4: col = (static_cast<B_32_R5_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R6_NEO_4: col = (static_cast<B_32_R6_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R7_NEO_4: col = (static_cast<B_32_R7_NEO_4*>(busPtr))->GetPixelColor(pix); break;
+      #endif
+      case I_32_RN_NEO_4: col = (static_cast<B_32_RN_NEO_4*>(busPtr))->GetPixelColor(pix); break;
       case I_32_I0_NEO_4: col = (static_cast<B_32_I0_NEO_4*>(busPtr))->GetPixelColor(pix); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: col = (static_cast<B_32_I1_NEO_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R0_400_3: col = (static_cast<B_32_R0_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R1_400_3: col = (static_cast<B_32_R1_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R2_400_3: col = (static_cast<B_32_R2_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R3_400_3: col = (static_cast<B_32_R3_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R4_400_3: col = (static_cast<B_32_R4_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R5_400_3: col = (static_cast<B_32_R5_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R6_400_3: col = (static_cast<B_32_R6_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R7_400_3: col = (static_cast<B_32_R7_400_3*>(busPtr))->GetPixelColor(pix); break;
+      #endif
+      case I_32_RN_400_3: col = (static_cast<B_32_RN_400_3*>(busPtr))->GetPixelColor(pix); break;
       case I_32_I0_400_3: col = (static_cast<B_32_I0_400_3*>(busPtr))->GetPixelColor(pix); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: col = (static_cast<B_32_I1_400_3*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R0_TM1_4: col = (static_cast<B_32_R0_TM1_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R1_TM1_4: col = (static_cast<B_32_R1_TM1_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R2_TM1_4: col = (static_cast<B_32_R2_TM1_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R3_TM1_4: col = (static_cast<B_32_R3_TM1_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R4_TM1_4: col = (static_cast<B_32_R4_TM1_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R5_TM1_4: col = (static_cast<B_32_R5_TM1_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R6_TM1_4: col = (static_cast<B_32_R6_TM1_4*>(busPtr))->GetPixelColor(pix); break;
-      case I_32_R7_TM1_4: col = (static_cast<B_32_R7_TM1_4*>(busPtr))->GetPixelColor(pix); break;
+      #endif
+      case I_32_RN_TM1_4: col = (static_cast<B_32_RN_TM1_4*>(busPtr))->GetPixelColor(pix); break;
       case I_32_I0_TM1_4: col = (static_cast<B_32_I0_TM1_4*>(busPtr))->GetPixelColor(pix); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: col = (static_cast<B_32_I1_TM1_4*>(busPtr))->GetPixelColor(pix); break;
+      #endif
     #endif
       case I_HS_DOT_3: col = (static_cast<B_HS_DOT_3*>(busPtr))->GetPixelColor(pix); break;
       case I_SS_DOT_3: col = (static_cast<B_SS_DOT_3*>(busPtr))->GetPixelColor(pix); break;
@@ -784,46 +599,26 @@ class PolyBus {
       case I_8266_BB_TM1_4: delete (static_cast<B_8266_BB_TM1_4*>(busPtr)); break;
     #endif
     #ifdef ARDUINO_ARCH_ESP32
-      case I_32_R0_NEO_3: delete (static_cast<B_32_R0_NEO_3*>(busPtr)); break;
-      case I_32_R1_NEO_3: delete (static_cast<B_32_R1_NEO_3*>(busPtr)); break;
-      case I_32_R2_NEO_3: delete (static_cast<B_32_R2_NEO_3*>(busPtr)); break;
-      case I_32_R3_NEO_3: delete (static_cast<B_32_R3_NEO_3*>(busPtr)); break;
-      case I_32_R4_NEO_3: delete (static_cast<B_32_R4_NEO_3*>(busPtr)); break;
-      case I_32_R5_NEO_3: delete (static_cast<B_32_R5_NEO_3*>(busPtr)); break;
-      case I_32_R6_NEO_3: delete (static_cast<B_32_R6_NEO_3*>(busPtr)); break;
-      case I_32_R7_NEO_3: delete (static_cast<B_32_R7_NEO_3*>(busPtr)); break;
+      case I_32_RN_NEO_3: delete (static_cast<B_32_RN_NEO_3*>(busPtr)); break;
       case I_32_I0_NEO_3: delete (static_cast<B_32_I0_NEO_3*>(busPtr)); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_3: delete (static_cast<B_32_I1_NEO_3*>(busPtr)); break;
-      case I_32_R0_NEO_4: delete (static_cast<B_32_R0_NEO_4*>(busPtr)); break;
-      case I_32_R1_NEO_4: delete (static_cast<B_32_R1_NEO_4*>(busPtr)); break;
-      case I_32_R2_NEO_4: delete (static_cast<B_32_R2_NEO_4*>(busPtr)); break;
-      case I_32_R3_NEO_4: delete (static_cast<B_32_R3_NEO_4*>(busPtr)); break;
-      case I_32_R4_NEO_4: delete (static_cast<B_32_R4_NEO_4*>(busPtr)); break;
-      case I_32_R5_NEO_4: delete (static_cast<B_32_R5_NEO_4*>(busPtr)); break;
-      case I_32_R6_NEO_4: delete (static_cast<B_32_R6_NEO_4*>(busPtr)); break;
-      case I_32_R7_NEO_4: delete (static_cast<B_32_R7_NEO_4*>(busPtr)); break;
+      #endif
+      case I_32_RN_NEO_4: delete (static_cast<B_32_RN_NEO_4*>(busPtr)); break;
       case I_32_I0_NEO_4: delete (static_cast<B_32_I0_NEO_4*>(busPtr)); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_NEO_4: delete (static_cast<B_32_I1_NEO_4*>(busPtr)); break;
-      case I_32_R0_400_3: delete (static_cast<B_32_R0_400_3*>(busPtr)); break;
-      case I_32_R1_400_3: delete (static_cast<B_32_R1_400_3*>(busPtr)); break;
-      case I_32_R2_400_3: delete (static_cast<B_32_R2_400_3*>(busPtr)); break;
-      case I_32_R3_400_3: delete (static_cast<B_32_R3_400_3*>(busPtr)); break;
-      case I_32_R4_400_3: delete (static_cast<B_32_R4_400_3*>(busPtr)); break;
-      case I_32_R5_400_3: delete (static_cast<B_32_R5_400_3*>(busPtr)); break;
-      case I_32_R6_400_3: delete (static_cast<B_32_R6_400_3*>(busPtr)); break;
-      case I_32_R7_400_3: delete (static_cast<B_32_R7_400_3*>(busPtr)); break;
+      #endif
+      case I_32_RN_400_3: delete (static_cast<B_32_RN_400_3*>(busPtr)); break;
       case I_32_I0_400_3: delete (static_cast<B_32_I0_400_3*>(busPtr)); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_400_3: delete (static_cast<B_32_I1_400_3*>(busPtr)); break;
-      case I_32_R0_TM1_4: delete (static_cast<B_32_R0_TM1_4*>(busPtr)); break;
-      case I_32_R1_TM1_4: delete (static_cast<B_32_R1_TM1_4*>(busPtr)); break;
-      case I_32_R2_TM1_4: delete (static_cast<B_32_R2_TM1_4*>(busPtr)); break;
-      case I_32_R3_TM1_4: delete (static_cast<B_32_R3_TM1_4*>(busPtr)); break;
-      case I_32_R4_TM1_4: delete (static_cast<B_32_R4_TM1_4*>(busPtr)); break;
-      case I_32_R5_TM1_4: delete (static_cast<B_32_R5_TM1_4*>(busPtr)); break;
-      case I_32_R6_TM1_4: delete (static_cast<B_32_R6_TM1_4*>(busPtr)); break;
-      case I_32_R7_TM1_4: delete (static_cast<B_32_R7_TM1_4*>(busPtr)); break;
+      #endif
+      case I_32_RN_TM1_4: delete (static_cast<B_32_RN_TM1_4*>(busPtr)); break;
       case I_32_I0_TM1_4: delete (static_cast<B_32_I0_TM1_4*>(busPtr)); break;
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
       case I_32_I1_TM1_4: delete (static_cast<B_32_I1_TM1_4*>(busPtr)); break;
+      #endif
     #endif
       case I_HS_DOT_3: delete (static_cast<B_HS_DOT_3*>(busPtr)); break;
       case I_SS_DOT_3: delete (static_cast<B_SS_DOT_3*>(busPtr)); break;
@@ -872,18 +667,24 @@ class PolyBus {
           return I_8266_U0_TM1_4 + offset;
       }
       #else //ESP32
-      uint8_t offset = num; //RMT bus # == bus index in BusManager
-      if (offset > 9) return I_NONE;
+      uint8_t offset = 0; //0 = RMT (num 0-7) 8 = I2S0 9 = I2S1
+      #ifndef CONFIG_IDF_TARGET_ESP32S2
+      if (num > 9) return I_NONE;
+      if (num > 7) offset = num -7;
+      #else //ESP32 S2 only has 4 RMT channels
+      if (num > 5) return I_NONE;
+      if (num > 4) offset = num -4;
+      #endif
       switch (busType) {
         case TYPE_WS2812_RGB:
         case TYPE_WS2812_WWA:
-          return I_32_R0_NEO_3 + offset;
+          return I_32_RN_NEO_3 + offset;
         case TYPE_SK6812_RGBW:
-          return I_32_R0_NEO_4 + offset;
+          return I_32_RN_NEO_4 + offset;
         case TYPE_WS2811_400KHZ:
-          return I_32_R0_400_3 + offset;
+          return I_32_RN_400_3 + offset;
         case TYPE_TM1814:
-          return I_32_R0_TM1_4 + offset;
+          return I_32_RN_TM1_4 + offset;
       }
       #endif
     }

wled00/button.cpp

@@ -6,14 +6,23 @@
 
 #define WLED_DEBOUNCE_THRESHOLD 50 //only consider button input of at least 50ms as valid (debouncing)
 
+static const char _mqtt_topic_button[] PROGMEM = "%s/button/%d";  // optimize flash usage
+
 void shortPressAction(uint8_t b)
 {
   if (!macroButton[b])
   {
     toggleOnOff();
-    colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+    colorUpdated(CALL_MODE_BUTTON);
   } else {
-    applyPreset(macroButton[b]);
+    applyPreset(macroButton[b], CALL_MODE_BUTTON);
+  }
+
+  // publish MQTT message
+  if (buttonPublishMqtt && WLED_MQTT_CONNECTED) {
+    char subuf[64];
+    sprintf_P(subuf, _mqtt_topic_button, mqttDeviceTopic, (int)b);
+    mqtt->publish(subuf, 0, false, "short");
   }
 }
 
@@ -29,7 +38,7 @@ bool isButtonPressed(uint8_t i)
       if (digitalRead(btnPin[i]) == LOW) return true;
       break;
     case BTN_TYPE_PUSH_ACT_HIGH:
-    case BTN_TYPE_SWITCH_ACT_HIGH:
+    case BTN_TYPE_PIR_SENSOR:
       if (digitalRead(btnPin[i]) == HIGH) return true;
       break;
     case BTN_TYPE_TOUCH:
@@ -43,6 +52,7 @@ bool isButtonPressed(uint8_t i)
 
 void handleSwitch(uint8_t b)
 {
+  // isButtonPressed() handles inverted/noninverted logic
   if (buttonPressedBefore[b] != isButtonPressed(b)) {
     buttonPressedTime[b] = millis();
     buttonPressedBefore[b] = !buttonPressedBefore[b];
@@ -51,17 +61,26 @@ void handleSwitch(uint8_t b)
   if (buttonLongPressed[b] == buttonPressedBefore[b]) return;
     
   if (millis() - buttonPressedTime[b] > WLED_DEBOUNCE_THRESHOLD) { //fire edge event only after 50ms without change (debounce)
-    if (buttonPressedBefore[b]) { //LOW, falling edge, switch closed
-      if (macroButton[b]) applyPreset(macroButton[b]);
+    if (!buttonPressedBefore[b]) { // on -> off
+      if (macroButton[b]) applyPreset(macroButton[b], CALL_MODE_BUTTON);
       else { //turn on
-        if (!bri) {toggleOnOff(); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);}
+        if (!bri) {toggleOnOff(); colorUpdated(CALL_MODE_BUTTON);}
       } 
-    } else { //HIGH, rising edge, switch opened
-      if (macroLongPress[b]) applyPreset(macroLongPress[b]);
+    } else {  // off -> on
+      if (macroLongPress[b]) applyPreset(macroLongPress[b], CALL_MODE_BUTTON);
       else { //turn off
-        if (bri) {toggleOnOff(); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);}
+        if (bri) {toggleOnOff(); colorUpdated(CALL_MODE_BUTTON);}
       } 
     }
+
+    // publish MQTT message
+    if (buttonPublishMqtt && WLED_MQTT_CONNECTED) {
+      char subuf[64];
+      if (buttonType[b] == BTN_TYPE_PIR_SENSOR) sprintf_P(subuf, PSTR("%s/motion/%d"), mqttDeviceTopic, (int)b);
+      else sprintf_P(subuf, _mqtt_topic_button, mqttDeviceTopic, (int)b);
+      mqtt->publish(subuf, 0, false, !buttonPressedBefore[b] ? "off" : "on");
+    }
+
     buttonLongPressed[b] = buttonPressedBefore[b]; //save the last "long term" switch state
   }
 }
@@ -74,6 +93,9 @@ void handleAnalog(uint8_t b)
   #else
   uint16_t aRead = analogRead(btnPin[b]) >> 4; // convert 12bit read to 8bit
   #endif
+
+  if (buttonType[b] == BTN_TYPE_ANALOG_INVERTED) aRead = 255 - aRead;
+
   // remove noise & reduce frequency of UI updates
   aRead &= 0xFC;
 
@@ -132,18 +154,14 @@ void handleAnalog(uint8_t b)
         seg.setOption(SEG_OPTION_ON, 1);
       }
       // this will notify clients of update (websockets,mqtt,etc)
-      //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
-      // 6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
-      updateInterfaces(NOTIFIER_CALL_MODE_BUTTON);
+      updateInterfaces(CALL_MODE_BUTTON);
     }
   } else {
     //TODO:
     // we can either trigger a preset depending on the level (between short and long entries)
     // or use it for RGBW direct control
   }
-  //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
-  // 6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
-  colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+  colorUpdated(CALL_MODE_BUTTON);
 }
 
 void handleButton()
@@ -152,17 +170,18 @@ void handleButton()
 
   for (uint8_t b=0; b<WLED_MAX_BUTTONS; b++) {
     #ifdef ESP8266
-    if ((btnPin[b]<0 && buttonType[b] != BTN_TYPE_ANALOG) || buttonType[b] == BTN_TYPE_NONE) continue;
+    if ((btnPin[b]<0 && !(buttonType[b] == BTN_TYPE_ANALOG || buttonType[b] == BTN_TYPE_ANALOG_INVERTED)) || buttonType[b] == BTN_TYPE_NONE) continue;
     #else
     if (btnPin[b]<0 || buttonType[b] == BTN_TYPE_NONE) continue;
     #endif
 
-    if (buttonType[b] == BTN_TYPE_ANALOG && millis() - lastRead > 250) {   // button is not a button but a potentiometer
+    if ((buttonType[b] == BTN_TYPE_ANALOG || buttonType[b] == BTN_TYPE_ANALOG_INVERTED) && millis() - lastRead > 250) {   // button is not a button but a potentiometer
       if (b+1 == WLED_MAX_BUTTONS) lastRead = millis();
       handleAnalog(b); continue;
     }
 
-    if (buttonType[b] == BTN_TYPE_SWITCH || buttonType[b] == BTN_TYPE_SWITCH_ACT_HIGH) { //button is not momentary, but switch. This is only suitable on pins whose on-boot state does not matter (NOT gpio0)
+    //button is not momentary, but switch. This is only suitable on pins whose on-boot state does not matter (NOT gpio0)
+    if (buttonType[b] == BTN_TYPE_SWITCH || buttonType[b] == BTN_TYPE_PIR_SENSOR) {
       handleSwitch(b); continue;
     }
 
@@ -176,9 +195,16 @@ void handleButton()
       {
         if (!buttonLongPressed[b]) 
         {
-          if (macroLongPress[b]) {applyPreset(macroLongPress[b]);}
+          if (macroLongPress[b]) {applyPreset(macroLongPress[b], CALL_MODE_BUTTON);}
           else _setRandomColor(false,true);
 
+          // publish MQTT message
+          if (buttonPublishMqtt && WLED_MQTT_CONNECTED) {
+            char subuf[64];
+            sprintf_P(subuf, _mqtt_topic_button, mqttDeviceTopic, (int)b);
+            mqtt->publish(subuf, 0, false, "long");
+          }
+
           buttonLongPressed[b] = true;
         }
       }
@@ -197,8 +223,16 @@ void handleButton()
       else if (!buttonLongPressed[b]) { //short press
         if (macroDoublePress[b])
         {
-          if (doublePress) applyPreset(macroDoublePress[b]);
-          else buttonWaitTime[b] = millis();
+          if (doublePress) {
+            applyPreset(macroDoublePress[b], CALL_MODE_BUTTON);
+  
+            // publish MQTT message
+            if (buttonPublishMqtt && WLED_MQTT_CONNECTED) {
+              char subuf[64];
+              sprintf_P(subuf, _mqtt_topic_button, mqttDeviceTopic, (int)b);
+              mqtt->publish(subuf, 0, false, "double");
+            }
+          } else buttonWaitTime[b] = millis();
         } else shortPressAction(b);
       }
       buttonPressedBefore[b] = false;

wled00/cfg.cpp

@@ -85,6 +85,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   if (fromFS || !ins.isNull()) {
     uint8_t s = 0; //bus iterator
     strip.isRgbw = false;
+    strip.isOffRefreshRequred = false;
     busses.removeAll();
     uint32_t mem = 0;
     for (JsonObject elm : ins) {
@@ -99,32 +100,31 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
         if (i>4) break;
       }
 
-      uint16_t length = elm[F("len")];
-      if (length==0) continue;
+      uint16_t length = elm[F("len")] | 1;
       uint8_t colorOrder = (int)elm[F("order")];
-      //only use skip from the first strip (this shouldn't have been in ins obj. but remains here for compatibility)
       uint8_t skipFirst = elm[F("skip")];
       uint16_t start = elm[F("start")] | 0;
-      if (start >= ledCount) continue;
-      //limit length of strip if it would exceed total configured LEDs
-      if (start + length > ledCount) length = ledCount - start;
       uint8_t ledType = elm["type"] | TYPE_WS2812_RGB;
       bool reversed = elm["rev"];
-      //RGBW mode is enabled if at least one of the strips is RGBW
-      strip.isRgbw = (strip.isRgbw || BusManager::isRgbw(ledType));
-      //refresh is required to remain off if at least one of the strips requires the refresh.
-      strip.isOffRefreshRequred |= BusManager::isOffRefreshRequred(ledType);
-      s++;
+
       BusConfig bc = BusConfig(ledType, pins, start, length, colorOrder, reversed, skipFirst);
-      mem += busses.memUsage(bc);
-      if (mem <= MAX_LED_MEMORY) busses.add(bc);
+      if (bc.adjustBounds(ledCount)) {
+        //RGBW mode is enabled if at least one of the strips is RGBW
+        strip.isRgbw = (strip.isRgbw || BusManager::isRgbw(ledType));
+        //refresh is required to remain off if at least one of the strips requires the refresh.
+        strip.isOffRefreshRequred |= BusManager::isOffRefreshRequred(ledType);
+        s++;
+        mem += busses.memUsage(bc);
+        if (mem <= MAX_LED_MEMORY) busses.add(bc);
+      }
     }
     strip.finalizeInit(ledCount);
   }
   if (hw_led["rev"]) busses.getBus(0)->reversed = true; //set 0.11 global reversed setting for first bus
 
   // read multiple button configuration
-  JsonArray hw_btn_ins = hw[F("btn")][F("ins")];
+  JsonObject btn_obj = hw["btn"];
+  JsonArray hw_btn_ins = btn_obj[F("ins")];
   if (!hw_btn_ins.isNull()) {
     uint8_t s = 0;
     for (JsonObject btn : hw_btn_ins) {
@@ -136,7 +136,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
       } else {
         btnPin[s] = -1;
       }
-      JsonArray hw_btn_ins_0_macros = btn[F("macros")];
+      JsonArray hw_btn_ins_0_macros = btn["macros"];
       CJSON(macroButton[s], hw_btn_ins_0_macros[0]);
       CJSON(macroLongPress[s],hw_btn_ins_0_macros[1]);
       CJSON(macroDoublePress[s], hw_btn_ins_0_macros[2]);
@@ -152,16 +152,23 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
     }
   } else {
     // new install/missing configuration (button 0 has defaults)
-    if (fromFS)
-      for (uint8_t s=1; s<WLED_MAX_BUTTONS; s++) {
+    if (fromFS) {
+      // relies upon only being called once with fromFS == true, which is currently true.
+      uint8_t s = 0;
+      if (pinManager.allocatePin(btnPin[0],false)) { // initialized to #define value BTNPIN, or zero if not defined(!)
+        ++s; // do not clear default button if allocated successfully 
+      }
+      for (; s<WLED_MAX_BUTTONS; s++) {
         btnPin[s]           = -1;
         buttonType[s]       = BTN_TYPE_NONE;
         macroButton[s]      = 0;
         macroLongPress[s]   = 0;
         macroDoublePress[s] = 0;
       }
+    }
   }
-  CJSON(touchThreshold,hw[F("btn")][F("tt")]);
+  CJSON(touchThreshold,btn_obj[F("tt")]);
+  CJSON(buttonPublishMqtt,btn_obj["mqtt"]);
 
   int hw_ir_pin = hw["ir"]["pin"] | -2; // 4
   if (hw_ir_pin > -2) {
@@ -193,8 +200,8 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   CJSON(briMultiplier, light[F("scale-bri")]);
   CJSON(strip.paletteBlend, light[F("pal-mode")]);
 
-  float light_gc_bri = light[F("gc")]["bri"];
-  float light_gc_col = light[F("gc")]["col"]; // 2.8
+  float light_gc_bri = light["gc"]["bri"];
+  float light_gc_col = light["gc"]["col"]; // 2.8
   if (light_gc_bri > 1.5) strip.gammaCorrectBri = true;
   else if (light_gc_bri > 0.5) strip.gammaCorrectBri = false;
   if (light_gc_col > 1.5) strip.gammaCorrectCol = true;
@@ -213,7 +220,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   if (nightlightDelayMinsDefault != prev) nightlightDelayMins = nightlightDelayMinsDefault;
 
   CJSON(nightlightTargetBri, light_nl[F("tbri")]);
-  CJSON(macroNl, light_nl[F("macro")]);
+  CJSON(macroNl, light_nl["macro"]);
 
   JsonObject def = doc[F("def")];
   CJSON(bootPreset, def[F("ps")]);
@@ -229,7 +236,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   JsonObject if_sync_recv = if_sync["recv"];
   CJSON(receiveNotificationBrightness, if_sync_recv["bri"]);
   CJSON(receiveNotificationColor, if_sync_recv["col"]);
-  CJSON(receiveNotificationEffects, if_sync_recv[F("fx")]);
+  CJSON(receiveNotificationEffects, if_sync_recv["fx"]);
   //! following line might be a problem if called after boot
   receiveNotifications = (receiveNotificationBrightness || receiveNotificationColor || receiveNotificationEffects);
 
@@ -237,10 +244,10 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   prev = notifyDirectDefault;
   CJSON(notifyDirectDefault, if_sync_send[F("dir")]);
   if (notifyDirectDefault != prev) notifyDirect = notifyDirectDefault;
-  CJSON(notifyButton, if_sync_send[F("btn")]);
-  CJSON(notifyAlexa, if_sync_send[F("va")]);
-  CJSON(notifyHue, if_sync_send[F("hue")]);
-  CJSON(notifyMacro, if_sync_send[F("macro")]);
+  CJSON(notifyButton, if_sync_send["btn"]);
+  CJSON(notifyAlexa, if_sync_send["va"]);
+  CJSON(notifyHue, if_sync_send["hue"]);
+  CJSON(notifyMacro, if_sync_send["macro"]);
   CJSON(notifyTwice, if_sync_send[F("twice")]);
 
   JsonObject if_nodes = interfaces["nodes"];
@@ -264,10 +271,10 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   CJSON(arlsDisableGammaCorrection, if_live[F("no-gc")]); // false
   CJSON(arlsOffset, if_live[F("offset")]); // 0
 
-  CJSON(alexaEnabled, interfaces[F("va")][F("alexa")]); // false
+  CJSON(alexaEnabled, interfaces["va"][F("alexa")]); // false
 
-  CJSON(macroAlexaOn, interfaces[F("va")][F("macros")][0]);
-  CJSON(macroAlexaOff, interfaces[F("va")][F("macros")][1]);
+  CJSON(macroAlexaOn, interfaces["va"]["macros"][0]);
+  CJSON(macroAlexaOff, interfaces["va"]["macros"][1]);
 
 #ifndef WLED_DISABLE_BLYNK
   const char* apikey = interfaces["blynk"][F("token")] | "Hidden";
@@ -294,7 +301,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
 #endif
 
 #ifndef WLED_DISABLE_HUESYNC
-  JsonObject if_hue = interfaces[F("hue")];
+  JsonObject if_hue = interfaces["hue"];
   CJSON(huePollingEnabled, if_hue["en"]);
   CJSON(huePollLightId, if_hue["id"]);
   tdd = if_hue[F("iv")] | -1;
@@ -342,17 +349,17 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   CJSON(countdownHour,  cntdwn_goal[3]);
   CJSON(countdownMin,   cntdwn_goal[4]);
   CJSON(countdownSec,   cntdwn_goal[5]);
-  CJSON(macroCountdown, cntdwn[F("macro")]);
+  CJSON(macroCountdown, cntdwn["macro"]);
   setCountdown();
 
-  JsonArray timers = tm[F("ins")];
+  JsonArray timers = tm["ins"];
   uint8_t it = 0;
   for (JsonObject timer : timers) {
     if (it > 9) break;
     if (it<8 && timer[F("hour")]==255) it=8;  // hour==255 -> sunrise/sunset 
     CJSON(timerHours[it], timer[F("hour")]);
     CJSON(timerMinutes[it], timer["min"]);
-    CJSON(timerMacro[it], timer[F("macro")]);
+    CJSON(timerMacro[it], timer["macro"]);
 
     byte dowPrev =  timerWeekday[it];
     //note: act is currently only 0 or 1.
@@ -480,7 +487,7 @@ void serializeConfig() {
 
   JsonObject wifi = doc.createNestedObject("wifi");
   wifi[F("sleep")] = !noWifiSleep;
-  wifi[F("phy")] = 1;
+  //wifi[F("phy")] = 1;
 
   #ifdef WLED_USE_ETHERNET
   JsonObject ethernet = doc.createNestedObject("eth");
@@ -518,29 +525,20 @@ void serializeConfig() {
   hw_btn["max"] = WLED_MAX_BUTTONS; // just information about max number of buttons (not actually used)
   JsonArray hw_btn_ins = hw_btn.createNestedArray("ins");
 
-  // there is always at least one button
-  JsonObject hw_btn_ins_0 = hw_btn_ins.createNestedObject();
-  hw_btn_ins_0["type"] = buttonType[0];
-  JsonArray hw_btn_ins_0_pin = hw_btn_ins_0.createNestedArray("pin");
-  hw_btn_ins_0_pin.add(btnPin[0]);
-  JsonArray hw_btn_ins_0_macros = hw_btn_ins_0.createNestedArray("macros");
-  hw_btn_ins_0_macros.add(macroButton[0]);
-  hw_btn_ins_0_macros.add(macroLongPress[0]);
-  hw_btn_ins_0_macros.add(macroDoublePress[0]);
-
-  // additional buttons
-  for (uint8_t i=1; i<WLED_MAX_BUTTONS; i++) {
-    //if (btnPin[i]<0) continue;
-    hw_btn_ins_0 = hw_btn_ins.createNestedObject();
+  // configuration for all buttons
+  for (uint8_t i=0; i<WLED_MAX_BUTTONS; i++) {
+    JsonObject hw_btn_ins_0 = hw_btn_ins.createNestedObject();
     hw_btn_ins_0["type"] = buttonType[i];
-    hw_btn_ins_0_pin = hw_btn_ins_0.createNestedArray("pin");
+    JsonArray hw_btn_ins_0_pin = hw_btn_ins_0.createNestedArray("pin");
     hw_btn_ins_0_pin.add(btnPin[i]);
-    hw_btn_ins_0_macros = hw_btn_ins_0.createNestedArray("macros");
+    JsonArray hw_btn_ins_0_macros = hw_btn_ins_0.createNestedArray("macros");
     hw_btn_ins_0_macros.add(macroButton[i]);
     hw_btn_ins_0_macros.add(macroLongPress[i]);
     hw_btn_ins_0_macros.add(macroDoublePress[i]);
   }
+
   hw_btn[F("tt")] = touchThreshold;
+  hw_btn["mqtt"] = buttonPublishMqtt;
 
   JsonObject hw_ir = hw.createNestedObject("ir");
   hw_ir["pin"] = irPin;
@@ -570,7 +568,7 @@ void serializeConfig() {
   light_nl[F("mode")] = nightlightMode;
   light_nl["dur"] = nightlightDelayMinsDefault;
   light_nl[F("tbri")] = nightlightTargetBri;
-  light_nl[F("macro")] = macroNl;
+  light_nl["macro"] = macroNl;
 
   JsonObject def = doc.createNestedObject("def");
   def[F("ps")] = bootPreset;
@@ -590,10 +588,10 @@ void serializeConfig() {
 
   JsonObject if_sync_send = if_sync.createNestedObject("send");
   if_sync_send[F("dir")] = notifyDirect;
-  if_sync_send[F("btn")] = notifyButton;
-  if_sync_send[F("va")] = notifyAlexa;
-  if_sync_send[F("hue")] = notifyHue;
-  if_sync_send[F("macro")] = notifyMacro;
+  if_sync_send["btn"] = notifyButton;
+  if_sync_send["va"] = notifyAlexa;
+  if_sync_send["hue"] = notifyHue;
+  if_sync_send["macro"] = notifyMacro;
   if_sync_send[F("twice")] = notifyTwice;
 
   JsonObject if_nodes = interfaces.createNestedObject("nodes");
@@ -685,7 +683,7 @@ void serializeConfig() {
   JsonArray goal = cntdwn.createNestedArray(F("goal"));
   goal.add(countdownYear); goal.add(countdownMonth); goal.add(countdownDay);
   goal.add(countdownHour); goal.add(countdownMin); goal.add(countdownSec);
-  cntdwn[F("macro")] = macroCountdown;
+  cntdwn["macro"] = macroCountdown;
 
   JsonArray timers_ins = timers.createNestedArray("ins");
 
@@ -695,7 +693,7 @@ void serializeConfig() {
     timers_ins0["en"] = (timerWeekday[i] & 0x01);
     timers_ins0[F("hour")] = timerHours[i];
     timers_ins0["min"] = timerMinutes[i];
-    timers_ins0[F("macro")] = timerMacro[i];
+    timers_ins0["macro"] = timerMacro[i];
     timers_ins0[F("dow")] = timerWeekday[i] >> 1;
   }
 
@@ -755,7 +753,7 @@ bool deserializeConfigSec() {
 #endif
 
 #ifndef WLED_DISABLE_HUESYNC
-  getStringFromJson(hueApiKey, interfaces[F("hue")][F("key")], 47);
+  getStringFromJson(hueApiKey, interfaces["hue"][F("key")], 47);
 #endif
 
   JsonObject ota = doc["ota"];

wled00/const.h

@@ -66,17 +66,18 @@
 #define AP_BEHAVIOR_BUTTON_ONLY           3     //Only when button pressed for 6 sec
 
 //Notifier callMode
-#define NOTIFIER_CALL_MODE_INIT           0     //no updates on init, can be used to disable updates
-#define NOTIFIER_CALL_MODE_DIRECT_CHANGE  1
-#define NOTIFIER_CALL_MODE_BUTTON         2
-#define NOTIFIER_CALL_MODE_NOTIFICATION   3
-#define NOTIFIER_CALL_MODE_NIGHTLIGHT     4
-#define NOTIFIER_CALL_MODE_NO_NOTIFY      5
-#define NOTIFIER_CALL_MODE_FX_CHANGED     6     //no longer used
-#define NOTIFIER_CALL_MODE_HUE            7
-#define NOTIFIER_CALL_MODE_PRESET_CYCLE   8
-#define NOTIFIER_CALL_MODE_BLYNK          9
-#define NOTIFIER_CALL_MODE_ALEXA         10
+#define CALL_MODE_INIT           0     //no updates on init, can be used to disable updates
+#define CALL_MODE_DIRECT_CHANGE  1
+#define CALL_MODE_BUTTON         2
+#define CALL_MODE_NOTIFICATION   3
+#define CALL_MODE_NIGHTLIGHT     4
+#define CALL_MODE_NO_NOTIFY      5
+#define CALL_MODE_FX_CHANGED     6     //no longer used
+#define CALL_MODE_HUE            7
+#define CALL_MODE_PRESET_CYCLE   8
+#define CALL_MODE_BLYNK          9
+#define CALL_MODE_ALEXA         10
+#define CALL_MODE_WS_SEND       11     //special call mode, not for notifier, updates websocket only
 
 //RGB to RGBW conversion mode
 #define RGBW_MODE_MANUAL_ONLY     0            //No automatic white channel calculation. Manual white channel slider
@@ -161,9 +162,10 @@
 #define BTN_TYPE_PUSH             2
 #define BTN_TYPE_PUSH_ACT_HIGH    3
 #define BTN_TYPE_SWITCH           4
-#define BTN_TYPE_SWITCH_ACT_HIGH  5
+#define BTN_TYPE_PIR_SENSOR       5
 #define BTN_TYPE_TOUCH            6
 #define BTN_TYPE_ANALOG           7
+#define BTN_TYPE_ANALOG_INVERTED  8
 
 //Ethernet board types
 #define WLED_NUM_ETH_TYPES        7
@@ -194,6 +196,14 @@
 #define SEG_OPTION_FREEZE         5            //Segment contents will not be refreshed
 #define SEG_OPTION_TRANSITIONAL   7
 
+//Segment differs return byte
+#define SEG_DIFFERS_BRI        0x01
+#define SEG_DIFFERS_OPT        0x02
+#define SEG_DIFFERS_COL        0x04
+#define SEG_DIFFERS_FX         0x08
+#define SEG_DIFFERS_BOUNDS     0x10
+#define SEG_DIFFERS_GSO        0x20
+
 //Playlist option byte
 #define PL_OPTION_SHUFFLE      0x01
 

wled00/data/index.css

@@ -322,7 +322,7 @@ button {
 }
 
 .first {
-	margin-top: 18px !important;
+	margin-top: 10px;
 }
 
 #toast {
@@ -588,18 +588,13 @@ input[type=range]:active + .sliderbubble {
 }
 .btn-xs {
   width: 39px;
+	margin: 2px 0 0 0;
 }
 .btn-pl-add {
-  position: absolute;
-  bottom: -29px;
-  left: 94px;
-}
-.btn-pl-del {
-	position: absolute;
-	right: 2px;
-	bottom: -3px;
+	margin-left: 9px;
 }
 
+
 #qcs-w {
 	margin-top: 10px;
 }
@@ -617,14 +612,18 @@ input[type=range]:active + .sliderbubble {
 	margin-top: 5px;
 	display: none;
 }
+#tt {
+  text-align: center;
+}
 
 .cl {
 	width: 42px;
 }
 
 .sel-pl {
-  width: 200px;
-  background-position: 176px 16px;
+  width: 192px;
+  background-position: 168px 16px;
+  margin: 8px 7px 0 0;
 }
 
 .sel-ple {
@@ -657,7 +656,7 @@ input[type=number], input[type=text] {
 	background: var(--c-3);
 	color: var(--c-f);
 	border: 0px solid white;
-	border-radius: 5px;
+	border-radius: 25px;
 	padding: 8px;
 	margin: 6px 6px 6px 0;
 	font-size: 19px;
@@ -687,7 +686,6 @@ textarea {
 
 input[type=text] {
 	width: 100px;
-	border-radius: 25px;
 	text-align: center;
 }
 
@@ -696,11 +694,6 @@ input[type=text] {
 	margin: 26px 0 6px 12px !important;
 }
 
-.plentry {
-  margin-top: 16px;
-  position: relative;
-}
-
 .stxt {
 	width: 50px !important;
 }
@@ -714,7 +707,24 @@ input[type=number]::-webkit-outer-spin-button {
 	-webkit-appearance: none;
 }
 
+.pln {
+	width: 67px !important;
+	margin: 0 2px 8px 0 !important;
+	text-align: center;
+}
+.plnl {
+	width: 86px;
+	margin: 0 2px 0 0;
+	display: inline-block;
+}
+.pli {
+	width: 38px;
+	margin: 0 0 0 29px;
+	display: inline-block;
+}
+
 .segn {
+  border-radius: 5px !important;
 	margin: 3px 0 6px 0 !important;
 }
 
@@ -970,12 +980,12 @@ input[type=number]::-webkit-outer-spin-button {
 	z-index: 1;
 }
 
-#selectPalette .lstI.selected {
+#pallist .lstI.selected {
 	top: 27px;
 	bottom: -11px;
 }
 
-#selectPalette .lstI.sticky {
+#pallist .lstI.sticky {
 	top: -11px;
 }
 
@@ -1055,11 +1065,7 @@ input[type="text"].search:not(:placeholder-shown) {
 .hrz {
   width: auto;
   height: 2px;
-  background-color: var(--c-e);
-}
-.hrz-pl {
-  margin: 20px 0;
-	position: relative;
+  background-color: var(--c-b);
 }
 
 ::-webkit-scrollbar {

wled00/data/index.htm

@@ -93,7 +93,7 @@
 			Color palette
 		</p>
 		<div class="il">
-			<div id="selectPalette" class="list">
+			<div id="pallist" class="list">
 				<div class="lstI" data-id="0">
 					<label class="check schkl">
 						&nbsp;
@@ -153,6 +153,7 @@
 		<div id="segutil2">
 			<button class="btn btn-s" id="rsbtn" onclick="rSegs()">Reset segments</button>
 		</div>
+    <p>Transition: <input id="tt" class="noslide" type="number" min="0" max="65.5" step="0.1" value="0.7">s</p>
 	</div>
 
 	<div id="Favorites" class="tabcontent">
@@ -164,8 +165,7 @@
 		</div>
 		<div id="pcont">
 			Loading...
-		</div><br>
-		Transition <input id="tt" class="noslide" type="number" min="0" max="65.5" step="0.1" value="0.7">s
+		</div>
 	</div>
 </div>
 

wled00/data/index.js

@@ -7,7 +7,7 @@ var selColors;
 var expanded = [false];
 var powered = [true];
 var nlDur = 60, nlTar = 0;
-var nlFade = false;
+var nlMode = false;
 var selectedFx = 0;
 var csel = 0;
 var currentPreset = -1;
@@ -22,6 +22,8 @@ var pJson = {};
 var pN = "", pI = 0, pNum = 0;
 var pmt = 1, pmtLS = 0, pmtLast = 0;
 var lastinfo = {};
+var ws;
+var fxlist = d.getElementById('fxlist'), pallist = d.getElementById('pallist');
 var cfg = {
 	theme:{base:"dark", bg:{url:""}, alpha:{bg:0.6,tab:0.8}, color:{bg:""}},
 	comp :{colors:{picker: true, rgb: false, quick: true, hex: false}, labels:true, pcmbot:false, pid:true}
@@ -363,8 +365,22 @@ function presetError(empty)
 	if (hasBackup) d.getElementById('bck').value = bckstr;
 }
 
-function loadPresets()
+function loadPresets(callback = null)
 {
+	//1st boot (because there is a callback)
+	if (callback && pmt == pmtLS && pmt > 0) {
+		//we have a copy of the presets in local storage and don't need to fetch another one
+		populatePresets(true);
+		pmtLast = pmt;
+		callback();
+		return;
+	}
+
+	//afterwards
+	if (!callback && pmt == pmtLast) return;
+
+	pmtLast = pmt;
+
 	var url = '/presets.json';
 	if (loc) {
 		url = `http://${locip}/presets.json`;
@@ -388,6 +404,9 @@ function loadPresets()
 		showToast(error, true);
 		console.log(error);
 		presetError(false);
+	})
+	.finally(() => {
+		if (callback) setTimeout(callback,99);
 	});
 }
 
@@ -544,7 +563,7 @@ function populateSegments(s)
 					<tr>
 						<td class="segtd"><input class="noslide segn" id="seg${i}s" type="number" min="0" max="${ledCount-1}" value="${inst.start}" oninput="updateLen(${i})"></td>
 						<td class="segtd"><input class="noslide segn" id="seg${i}e" type="number" min="0" max="${ledCount}" value="${inst.stop}" oninput="updateLen(${i})"></td>
-						<td class="segtd"><input class="noslide segn" id="seg${i}of" type="number" min="0" max="${ledCount-1}" value="${inst.of}" oninput="updateLen(${i})"></td>
+						<td class="segtd"><input class="noslide segn" id="seg${i}of" type="number" value="${inst.of}" oninput="updateLen(${i})"></td>
 					</tr>
 				</table>
 				<table class="infot">
@@ -619,7 +638,7 @@ function populateEffects(effects)
 		);
 	}
 
-	d.getElementById('fxlist').innerHTML=html;
+	fxlist.innerHTML=html;
 }
 
 function populatePalettes(palettes)
@@ -653,12 +672,12 @@ function populatePalettes(palettes)
         );
 	}
 
-	d.getElementById('selectPalette').innerHTML=html;
+	pallist.innerHTML=html;
 }
 
 function redrawPalPrev()
 {
-	let palettes = d.querySelectorAll('#selectPalette .lstI');
+	let palettes = d.querySelectorAll('#pallist .lstI');
 	for (let i = 0; i < palettes.length; i++) {
 		let id = palettes[i].dataset.id;
 		let lstPrev = palettes[i].querySelector('.lstIprev');
@@ -803,8 +822,9 @@ function updateTrail(e, slidercol)
 {
 	if (e==null) return;
 	var max = e.hasAttribute('max') ? e.attributes.max.value : 255;
-	var progress = e.value * 100 / max;
-	progress = parseInt(progress);
+	var perc = e.value * 100 / max;
+	perc = parseInt(perc);
+  if (perc < 50) perc += 2;
 	var scol;
 	switch (slidercol) {
 	case 1: scol = "#f00"; break;
@@ -812,7 +832,7 @@ function updateTrail(e, slidercol)
 	case 3: scol = "#00f"; break;
 	default: scol = "var(--c-f)";
 	}
-	var val = `linear-gradient(90deg, ${scol} ${progress}%, var(--c-4) ${progress}%)`;
+	var val = `linear-gradient(90deg, ${scol} ${perc}%, var(--c-4) ${perc}%)`;
 	e.parentNode.getElementsByClassName('sliderdisplay')[0].style.background = val;
 }
 
@@ -908,31 +928,154 @@ function cmpP(a, b) {
   return a[1].n.localeCompare(b[1].n,undefined, {numeric: true});
 }
 
+function makeWS() {
+  if (ws) return;
+  ws = new WebSocket('ws://'+(loc?locip:window.location.hostname)+'/ws');
+  ws.onmessage = function(event) {
+    var json = JSON.parse(event.data);
+    if (json.leds) return; //liveview packet
+    clearTimeout(jsonTimeout);
+		jsonTimeout = null;
+		clearErrorToast();
+    d.getElementById('connind').style.backgroundColor = "#079";
+    var info = json.info;
+    d.getElementById('buttonNodes').style.display = (info.ndc > 0 && window.innerWidth > 770) ? "block":"none";
+    lastinfo = info;
+    if (isInfo) {
+      populateInfo(info);
+    }
+    s = json.state;
+    displayRover(info, s);
+		readState(json.state);
+	};
+  ws.onclose = function(event) {
+    d.getElementById('connind').style.backgroundColor = "#831";
+  }
+}
+
+function readState(s,command=false) {
+  isOn = s.on;
+  d.getElementById('sliderBri').value= s.bri;
+  nlA = s.nl.on;
+  nlDur = s.nl.dur;
+  nlTar = s.nl.tbri;
+  nlMode = s.nl.mode;
+  syncSend = s.udpn.send;
+  currentPreset = s.ps;
+  tr = s.transition;
+  d.getElementById('tt').value = tr/10;
+
+  var selc=0; var ind=0;
+  populateSegments(s);
+  for (let i = 0; i < (s.seg||[]).length; i++)
+  {
+    if(s.seg[i].sel) {selc = ind; break;} ind++;
+  }
+  var i=s.seg[selc];
+  if (!i) {
+    showToast('No Segments!', true);
+    updateUI();
+    return;
+  }
+  
+  selColors = i.col;
+  var cd = d.getElementById('csl').children;
+  for (let e = 2; e >= 0; e--)
+  {
+    cd[e].style.backgroundColor = "rgb(" + i.col[e][0] + "," + i.col[e][1] + "," + i.col[e][2] + ")";
+    if (isRgbw) whites[e] = parseInt(i.col[e][3]);
+    selectSlot(csel);
+  }
+  d.getElementById('sliderSpeed').value = whites[csel];
+
+  d.getElementById('sliderSpeed').value = i.sx;
+  d.getElementById('sliderIntensity').value = i.ix;
+
+  // Effects
+  var selFx = fxlist.querySelector(`input[name="fx"][value="${i.fx}"]`);
+  if (selFx) selFx.checked = true;
+  else location.reload(); //effect list is gone (e.g. if restoring tab). Reload.
+
+  var selElement = fxlist.querySelector('.selected');
+  if (selElement) {
+    selElement.classList.remove('selected')
+  }
+  var selectedEffect = fxlist.querySelector(`.lstI[data-id="${i.fx}"]`);
+  selectedEffect.classList.add('selected');
+  selectedFx = i.fx;
+
+  // Palettes
+  pallist.querySelector(`input[name="palette"][value="${i.pal}"]`).checked = true;
+  selElement = pallist.querySelector('.selected');
+  if (selElement) {
+    selElement.classList.remove('selected')
+  }
+  pallist.querySelector(`.lstI[data-id="${i.pal}"]`).classList.add('selected');
+
+  if (!command) {
+    selectedEffect.scrollIntoView({
+      behavior: 'smooth',
+      block: 'nearest',
+    });
+  }
+
+  if (s.error && s.error != 0) {
+    var errstr = "";
+    switch (s.error) {
+      case 10:
+        errstr = "Could not mount filesystem!";
+        break;
+      case 11:
+        errstr = "Not enough space to save preset!";
+        break;
+      case 12:
+        errstr = "Preset not found.";
+        break;
+      case 19:
+        errstr = "A filesystem error has occured.";
+        break;
+      }
+    showToast('Error ' + s.error + ": " + errstr, true);
+  }
+  updateUI();
+}
+
 var jsonTimeout;
 var reqsLegal = false;
 
-function requestJson(command, rinfo = true, verbose = true) {
+function requestJson(command, rinfo = true) {
 	d.getElementById('connind').style.backgroundColor = "#a90";
   if (command && !reqsLegal) return; //stop post requests from chrome onchange event on page restore
 	lastUpdate = new Date();
 	if (!jsonTimeout) jsonTimeout = setTimeout(showErrorToast, 3000);
 	var req = null;
-	var e1 = d.getElementById('fxlist');
-	var e2 = d.getElementById('selectPalette');
 
 	var url = rinfo ? '/json/si': (command ? '/json/state':'/json');
 	if (loc) {
 		url = `http://${locip}${url}`;
 	}
 
+  var useWs = ((command || rinfo) && ws && ws.readyState === WebSocket.OPEN);
+
 	var type = command ? 'post':'get';
 	if (command)
 	{
-    command.v = verbose;
+    command.v = true; //get complete API response
     command.time = Math.floor(Date.now() / 1000);
+    var t = d.getElementById('tt');
+    if (t.validity.valid) {
+      var tn = parseInt(t.value*10);
+      if (tn != tr) command.transition = tn;
+    }
 		req = JSON.stringify(command);
-		//console.log(req);
+    if (req.length > 1000) useWs = false; //do not send very long requests over websocket
 	}
+
+  if (useWs) {
+    ws.send(req?req:'{"v":true}');
+    return;
+  }
+
 	fetch
 	(url, {
 		method: type,
@@ -960,19 +1103,20 @@ function requestJson(command, rinfo = true, verbose = true) {
 		}
 		var s = json;
 		
-		if (!command || rinfo) {
-			if (!rinfo) {
-				pmt = json.info.fs.pmt;
-				if (pmt != pmtLS || pmt == 0) {
-					setTimeout(loadPresets,99);
-				}
-				else {
-					populatePresets(true);
-				}
-				pmtLast = pmt;
-
+		if (!command || rinfo) { //we have info object
+			if (!rinfo) { //entire JSON (on load)
 				populateEffects(json.effects);
 				populatePalettes(json.palettes);
+
+				//load palette previews, presets, and open websocket sequentially
+				setTimeout(function(){
+					loadPresets(function(){
+						loadPalettesData(function(){
+							if (!ws && json.info.ws > -1) makeWS();
+						});
+					});
+				},25);
+				
         reqsLegal = true;
 			}
 
@@ -995,10 +1139,8 @@ function requestJson(command, rinfo = true, verbose = true) {
       maxSeg = info.leds.maxseg;
 			pmt = info.fs.pmt;
 
-			if (!command && pmt != pmtLast) {
-				setTimeout(loadPresets,99);
-			}
-			pmtLast = pmt;
+			if (!command && rinfo) setTimeout(loadPresets, 99);
+
       d.getElementById('buttonNodes').style.display = (info.ndc > 0 && window.innerWidth > 770) ? "block":"none";
 			lastinfo = info;
 			if (isInfo) {
@@ -1006,94 +1148,9 @@ function requestJson(command, rinfo = true, verbose = true) {
 			}
 			s = json.state;
 			displayRover(info, s);
-
-      if (!rinfo) loadPalettesData();
 		}
 
-		isOn = s.on;
-		d.getElementById('sliderBri').value= s.bri;
-		nlA = s.nl.on;
-		nlDur = s.nl.dur;
-		nlTar = s.nl.tbri;
-		nlFade = s.nl.fade;
-		syncSend = s.udpn.send;
-		currentPreset = s.ps;
-		tr = s.transition;
-		d.getElementById('tt').value = tr/10;
-
-		var selc=0; var ind=0;
-		populateSegments(s);
-		for (let i = 0; i < (s.seg||[]).length; i++)
-		{
-			if(s.seg[i].sel) {selc = ind; break;} ind++;
-		}
-		var i=s.seg[selc];
-		if (!i) {
-			showToast('No Segments!', true);
-			updateUI();
-			return;
-		}
-		
-		selColors = i.col;
-		var cd = d.getElementById('csl').children;
-		for (let e = 2; e >= 0; e--)
-		{
-			cd[e].style.backgroundColor = "rgb(" + i.col[e][0] + "," + i.col[e][1] + "," + i.col[e][2] + ")";
-			if (isRgbw) whites[e] = parseInt(i.col[e][3]);
-			selectSlot(csel);
-		}
-		d.getElementById('sliderSpeed').value = whites[csel];
-
-		d.getElementById('sliderSpeed').value = i.sx;
-		d.getElementById('sliderIntensity').value = i.ix;
-
-		// Effects
-    var selFx = e1.querySelector(`input[name="fx"][value="${i.fx}"]`);
-    if (selFx) selFx.checked = true;
-    else location.reload(); //effect list is gone (e.g. if restoring tab). Reload.
-
-		var selElement = e1.querySelector('.selected');
-		if (selElement) {
-			selElement.classList.remove('selected')
-		}
-		var selectedEffect = e1.querySelector(`.lstI[data-id="${i.fx}"]`);
-		selectedEffect.classList.add('selected');
-		selectedFx = i.fx;
-
-		// Palettes
-		e2.querySelector(`input[name="palette"][value="${i.pal}"]`).checked = true;
-		selElement = e2.querySelector('.selected');
-		if (selElement) {
-			selElement.classList.remove('selected')
-		}
-		e2.querySelector(`.lstI[data-id="${i.pal}"]`).classList.add('selected');
-
-		if (!command) {
-			selectedEffect.scrollIntoView({
-				behavior: 'smooth',
-				block: 'nearest',
-			});
-		}
-
-		if (s.error && s.error != 0) {
-      		var errstr = "";
-      		switch (s.error) {
-				case 10:
-					errstr = "Could not mount filesystem!";
-					break;
-				case 11:
-					errstr = "Not enough space to save preset!";
-					break;
-				case 12:
-					errstr = "Preset not found.";
-					break;
-				case 19:
-					errstr = "A filesystem error has occured.";
-					break;
-      		}
-      		showToast('Error ' + s.error + ": " + errstr, true);
-    	}
-		updateUI();
+    readState(s,command);
 	})
 	.catch(function (error) {
 		showToast(error, true);
@@ -1104,7 +1161,6 @@ function requestJson(command, rinfo = true, verbose = true) {
 function togglePower() {
 	isOn = !isOn;
 	var obj = {"on": isOn};
-	obj.transition = parseInt(d.getElementById('tt').value*10);
 	requestJson(obj);
 }
 
@@ -1112,7 +1168,7 @@ function toggleNl() {
 	nlA = !nlA;
 	if (nlA)
 	{
-		showToast(`Timer active. Your light will turn ${nlTar > 0 ? "on":"off"} ${nlFade ? "over":"after"} ${nlDur} minutes.`);
+		showToast(`Timer active. Your light will turn ${nlTar > 0 ? "on":"off"} ${nlMode ? "over":"after"} ${nlDur} minutes.`);
 	} else {
 		showToast('Timer deactivated.');
 	}
@@ -1139,6 +1195,7 @@ function toggleLiveview() {
 	var url = loc ? `http://${locip}/liveview`:"/liveview";
 	d.getElementById('liveview').src = (isLv) ? url:"about:blank";
 	d.getElementById('buttonSr').className = (isLv) ? "active":"";
+  if (!isLv && ws && ws.readyState === WebSocket.OPEN) ws.send('{"lv":false}');
 	size();
 }
 
@@ -1280,6 +1337,7 @@ function makeP(i,pl) {
   if (pl) {
 		var rep = plJson[i].repeat ? plJson[i].repeat : 0;
 		content = `
+  <div class="first c">Playlist Entries</div>
   <div id="ple${i}"></div><label class="check revchkl">
     Shuffle
     <input type="checkbox" id="pl${i}rtgl" onchange="plR(${i})" ${plJson[i].r?"checked":""}>
@@ -1352,23 +1410,15 @@ function makePUtil() {
 function makePlEntry(p,i) {
   return `
   <div class="plentry">
-    ${i+1}:
     <select class="btn sel sel-pl" onchange="plePs(${p},${i},this)" data-val=${plJson[p].ps[i]} data-index=${i}>
 			${plSelContent}
     </select>
-		<table class="segt">
-			<tr>
-				<td class="segtd">Duration</td>
-				<td class="segtd">Transition</td>
-			</tr>
-			<tr>
-				<td class="segtd"><input class="noslide segn" type="number" max=6553.0 min=0.2 step=0.1 oninput="pleDur(${p},${i},this)" value=${plJson[p].dur[i]/10.0}></td>
-				<td class="segtd"><input class="noslide segn" type="number" max=65.0 min=0.0 step=0.1 oninput="pleTr(${p},${i},this)" value=${plJson[p].transition[i]/10.0}> s</td>
-			</tr>
-		</table>
-    <button class="btn btn-i btn-xs btn-pl-del" onclick="delPl(${p},${i})"><i class="icons btn-icon">&#xe037;</i></button></div>
-    <div class="hrz hrz-pl" />
-    <button class="btn btn-i btn-xs btn-pl-add" onclick="addPl(${p},${i})"><i class="icons btn-icon">&#xe18a;</i></button></div>
+		<button class="btn btn-i btn-xs btn-pl-del" onclick="delPl(${p},${i})"><i class="icons btn-icon">&#xe037;</i></button>
+		<div class="h plnl">Duration</div><div class="h plnl">Transition</div><div class="h pli">#${i+1}</div><br>
+		<input class="noslide pln" type="number" max=6553.0 min=0.2 step=0.1 oninput="pleDur(${p},${i},this)" value=${plJson[p].dur[i]/10.0}>
+		<input class="noslide pln" type="number" max=65.0 min=0.0 step=0.1 oninput="pleTr(${p},${i},this)" value=${plJson[p].transition[i]/10.0}> s
+		<button class="btn btn-i btn-xs btn-pl-add" onclick="addPl(${p},${i})"><i class="icons btn-icon">&#xe18a;</i></button>
+    <div class="hrz"></div>
   </div>`;
 }
 
@@ -1482,22 +1532,21 @@ function setX(ind = null) {
 function setPalette(paletteId = null)
 {
 	if (paletteId === null) {
-		paletteId = parseInt(d.querySelector('#selectPalette input[name="palette"]:checked').value);
+		paletteId = parseInt(d.querySelector('#pallist input[name="palette"]:checked').value);
 	} else {
-		d.querySelector(`#selectPalette input[name="palette"][value="${paletteId}`).checked = true;
+		d.querySelector(`#pallist input[name="palette"][value="${paletteId}`).checked = true;
 	}
-	var selElement = d.querySelector('#selectPalette .selected');
+	var selElement = d.querySelector('#pallist .selected');
 	if (selElement) {
 		selElement.classList.remove('selected')
 	}
-	d.querySelector(`#selectPalette .lstI[data-id="${paletteId}"]`).classList.add('selected');
+	d.querySelector(`#pallist .lstI[data-id="${paletteId}"]`).classList.add('selected');
 	var obj = {"seg": {"pal": paletteId}};
 	requestJson(obj);
 }
 
 function setBri() {
 	var obj = {"bri": parseInt(d.getElementById('sliderBri').value)};
-	obj.transition = parseInt(d.getElementById('tt').value*10);
 	requestJson(obj);
 }
 
@@ -1710,7 +1759,6 @@ function setColor(sr) {
 	}
 	updateHex();
 	updateRgb();
-	obj.transition = parseInt(d.getElementById('tt').value*10);
 	requestJson(obj);
 }
 
@@ -1756,7 +1804,7 @@ function rSegs()
 	requestJson(obj);
 }
 
-function loadPalettesData()
+function loadPalettesData(callback = null)
 {
 	if (palettesData) return;
 	const lsKey = "wledPalx";
@@ -1767,6 +1815,8 @@ function loadPalettesData()
 			var d = new Date();
 			if (palettesDataJson && palettesDataJson.vid == lastinfo.vid) {
 				palettesData = palettesDataJson.p;
+				//redrawPalPrev() //?
+				if (callback) callback();
 				return;
 			}
 		} catch (e) {}
@@ -1779,6 +1829,7 @@ function loadPalettesData()
 			vid: lastinfo.vid
 		}));
 		redrawPalPrev();
+		if (callback) setTimeout(callback, 99); //go on to connect websocket
 	});
 }
 
@@ -1812,7 +1863,6 @@ function getPalettesData(page, callback)
 	.catch(function (error) {
 		showToast(error, true);
 		console.log(error);
-		presetError(false);
 	});
 }
 

wled00/data/liveviewws.htm

@@ -21,18 +21,6 @@
 <body>
   <div id="canv" />
   <script>
-    console.info("Live-Preview websocket opening");
-    var socket = new WebSocket("ws://"+document.location.host+"/ws");
-
-    socket.onopen = function () {
-      console.info("Live-Preview websocket is opened");
-      socket.send("{'lv':true}");
-    }
-
-    socket.onclose = function () { console.info("Live-Preview websocket is closing"); }
-
-    socket.onerror = function (event) { console.error("Live-Preview websocket error:", event); }
-
     function updatePreview(leds) {
       var str = "linear-gradient(90deg,";
       var len = leds.length;        
@@ -46,7 +34,7 @@
       document.getElementById("canv").style.background = str;
     }
 
-    socket.onmessage = function (event) {
+    function getLiveJson(event) {
       try {
         var json = JSON.parse(event.data);
         if (json && json.leds) {
@@ -54,9 +42,23 @@
         } 
       }
       catch (err) {
-        console.error("Live-Preview websocket error:",err);
-      }      
+        console.error("Live-Preview ws error:",err);
+      } 
     }
+
+    var ws = top.window.ws;
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      console.info("Use top WS for peek");
+      ws.send("{'lv':true}");
+    } else {
+      console.info("Peek ws opening");
+      ws = new WebSocket("ws://"+document.location.host+"/ws");
+      ws.onopen = function () {
+        console.info("Peek WS opened");
+        ws.send("{'lv':true}");
+      }
+    }
+    ws.addEventListener('message',getLiveJson);
   </script>
 </body>
 </html>

wled00/data/settings_leds.htm

@@ -252,11 +252,11 @@ Color Order:
 <option value="4">BGR</option>
 <option value="5">GBR</option>
 </select><br>
-<span id="p0d${i}">Pin:</span> <input type="number" name="L0${i}" min="0" max="40" required style="width:35px" onchange="UI()"/>
-<span id="p1d${i}">Clock:</span> <input type="number" name="L1${i}" min="0" max="40" style="width:35px" onchange="UI()"/>
-<span id="p2d${i}"></span><input type="number" name="L2${i}" min="0" max="40" style="width:35px" onchange="UI()"/>
-<span id="p3d${i}"></span><input type="number" name="L3${i}" min="0" max="40" style="width:35px" onchange="UI()"/>
-<span id="p4d${i}"></span><input type="number" name="L4${i}" min="0" max="40" style="width:35px" onchange="UI()"/>
+<span id="p0d${i}">Pin:</span> <input type="number" class="xs" name="L0${i}" min="0" max="33" required onchange="UI()"/>
+<span id="p1d${i}">Clock:</span> <input type="number" class="xs" name="L1${i}" min="0" max="33" onchange="UI()"/>
+<span id="p2d${i}"></span><input type="number" class="xs" name="L2${i}" min="0" max="33" onchange="UI()"/>
+<span id="p3d${i}"></span><input type="number" class="xs" name="L3${i}" min="0" max="33" onchange="UI()"/>
+<span id="p4d${i}"></span><input type="number" class="xs" name="L4${i}" min="0" max="33" onchange="UI()"/>
 <br>
 <span id="psd${i}">Start:</span> <input type="number" name="LS${i}" id="ls${i}" min="0" max="8191" value="${lastEnd(i)}" required />&nbsp;
 <div id="dig${i}" style="display:inline">
@@ -280,15 +280,16 @@ Reverse (rotated 180°): <input type="checkbox" name="CV${i}">
       var c = gId("btns").innerHTML;
       var bt = "BT" + i;
       var be = "BE" + i;
-      c += `Button ${i} pin: <input type="number" min="-1" max="40" name="${bt}" onchange="UI()" style="width:35px" value="${p}">&nbsp;`;
+      c += `Button ${i} pin: <input type="number" class="xs" min="-1" max="40" name="${bt}" onchange="UI()" value="${p}">&nbsp;`;
       c += `<select name="${be}">`
       c += `<option value="0" ${t==0?"selected":""}>Disabled</option>`;
       c += `<option value="2" ${t==2?"selected":""}>Pushbutton</option>`;
       c += `<option value="3" ${t==3?"selected":""}>Push inverted</option>`;
       c += `<option value="4" ${t==4?"selected":""}>Switch</option>`;
-      c += `<option value="5" ${t==4?"selected":""}>Switch inverted</option>`;
+      c += `<option value="5" ${t==5?"selected":""}>PIR sensor</option>`;
       c += `<option value="6" ${t==6?"selected":""}>Touch</option>`;
       c += `<option value="7" ${t==7?"selected":""}>Analog</option>`;
+      c += `<option value="8" ${t==8?"selected":""}>Analog inverted</option>`;
       c += `</select>`;
       c += `<span style="cursor: pointer;" onclick="off('${bt}')">&nbsp;&#215;</span><br>`;
       gId("btns").innerHTML = c;
@@ -315,7 +316,7 @@ Reverse (rotated 180°): <input type="checkbox" name="CV${i}">
     <br>
     Enable automatic brightness limiter: <input type="checkbox" name="ABen" onchange="enABL()" id="able"><br>
     <div id="abl">
-      Maximum Current: <input name="MA" type="number" min="250" max="65000" oninput="UI()" required> mA<br>
+      Maximum Current: <input name="MA" type="number" class="l" min="250" max="65000" oninput="UI()" required> mA<br>
       <div id="ampwarning" style="color: orange; display: none;">
         &#9888; Your power supply provides high current.<br>
         To improve the safety of your setup,<br>
@@ -348,35 +349,36 @@ Reverse (rotated 180°): <input type="checkbox" name="CV${i}">
       Use less than <span id="wreason">800 LEDs per pin</span> for the best experience!<br>
     </div><hr style="width:260px">
     <div id="btns"></div>
-    Touch threshold: <input type="number" min="0" max="100" name="TT" required><br>
-    IR pin: <input type="number" min="-1" max="40" name="IR" onchange="UI()" style="width:35px">&nbsp;<select name="IT">
-    <option value="0">Remote disabled</option>
-    <option value="1">24-key RGB</option>
-    <option value="2">24-key with CT</option>
-    <option value="3">40-key blue</option>
-    <option value="4">44-key RGB</option>
-    <option value="5">21-key RGB</option>
-    <option value="6">6-key black</option>
-    <option value="7">9-key red</option>
+    Touch threshold: <input type="number" class="s" min="0" max="100" name="TT" required><br>
+    IR pin: <input type="number" class="xs" min="-1" max="40" name="IR" onchange="UI()">&nbsp;<select name="IT">
+    <option value=0>Remote disabled</option>
+    <option value=1>24-key RGB</option>
+    <option value=2>24-key with CT</option>
+    <option value=3>40-key blue</option>
+    <option value=4>44-key RGB</option>
+    <option value=5>21-key RGB</option>
+    <option value=6>6-key black</option>
+    <option value=7>9-key red</option>
+    <option value=8>JSON remote</option>
     </select><span style="cursor: pointer;" onclick="off('IR')">&nbsp;&#215;</span><br>
     <a href="https://github.com/Aircoookie/WLED/wiki/Infrared-Control" target="_blank">IR info</a><br>
-    Relay pin: <input type="number" min="-1" max="40" name="RL" onchange="UI()" style="width:35px"> Invert <input type="checkbox" name="RM"><span style="cursor: pointer;" onclick="off('RL')">&nbsp;&#215;</span><br>
+    Relay pin: <input type="number" class="xs" min="-1" max="33" name="RL" onchange="UI()"> Invert <input type="checkbox" name="RM"><span style="cursor: pointer;" onclick="off('RL')">&nbsp;&#215;</span><br>
     <hr style="width:260px">
 		<h3>Defaults</h3>
 		Turn LEDs on after power up/reset: <input type="checkbox" name="BO"><br>
-    Default brightness: <input name="CA" type="number" min="0" max="255" required> (0-255)<br><br>
-    Apply preset <input name="BP" type="number" min="0" max="250" required> at boot (0 uses defaults)
+    Default brightness: <input name="CA" type="number" class="s" min="0" max="255" required> (0-255)<br><br>
+    Apply preset <input name="BP" type="number" class="s" min="0" max="250" required> at boot (0 uses defaults)
     <br><br>
 		Use Gamma correction for color: <input type="checkbox" name="GC"> (strongly recommended)<br>
 		Use Gamma correction for brightness: <input type="checkbox" name="GB"> (not recommended)<br><br>
-		Brightness factor: <input name="BF" type="number" min="1" max="255" required> %
+		Brightness factor: <input name="BF" type="number" class="s" min="1" max="255" required> %
 		<h3>Transitions</h3>
 		Crossfade: <input type="checkbox" name="TF"><br>
-		Transition Time: <input name="TD" maxlength="5" size="2"> ms<br>
+		Transition Time: <input name="TD" type="number" class="l" min="0" max="65500"> ms<br>
 		Enable Palette transitions: <input type="checkbox" name="PF">
 		<h3>Timed light</h3>
-		Default Duration: <input name="TL" type="number" min="1" max="255" required> min<br>
-		Default Target brightness: <input name="TB" type="number" min="0" max="255" required><br>
+		Default Duration: <input name="TL" type="number" class="s" min="1" max="255" required> min<br>
+		Default Target brightness: <input name="TB" type="number" class="s" min="0" max="255" required><br>
 		Mode:
     <select name="TW">
 			<option value="0">Wait and set</option>

wled00/data/settings_sync.htm

@@ -83,6 +83,7 @@ Password: <input type="password" name="MQPASS" maxlength="64"><br>
 Client ID: <input name="MQCID" maxlength="40"><br>
 Device Topic: <input name="MD" maxlength="32"><br>
 Group Topic: <input name="MG" maxlength="32"><br>
+Publish on button press: <input type="checkbox" name="BM"><br>
 <i>Reboot required to apply changes. </i><a href="https://github.com/Aircoookie/WLED/wiki/MQTT" target="_blank">MQTT info</a>
 <h3>Philips Hue</h3>
 <i>You can find the bridge IP and the light number in the 'About' section of the hue app.</i><br>

wled00/data/settings_um.htm

@@ -84,7 +84,7 @@
                         c += ' max="39" min="-1" style="width:40px;"';
                         t = "int";
                     } else {
-                        c += ' step="0.00001" style="width:80px;"';
+                        c += ' step="any" style="width:100px;"';
                     }
                     break;
                 default:

wled00/data/settings_wifi.htm

@@ -31,20 +31,20 @@
 		Network name (SSID, empty to not connect): <br><input name="CS" maxlength="32"><br>
 		Network password: <br> <input type="password" name="CP" maxlength="63"><br>
 		Static IP (leave at 0.0.0.0 for DHCP):<br>
-		<input name="I0" type="number" min="0" max="255" required> .
-		<input name="I1" type="number" min="0" max="255" required> .
-		<input name="I2" type="number" min="0" max="255" required> .
-		<input name="I3" type="number" min="0" max="255" required><br>
+		<input name="I0" type="number" class="s" min="0" max="255" required> .
+		<input name="I1" type="number" class="s" min="0" max="255" required> .
+		<input name="I2" type="number" class="s" min="0" max="255" required> .
+		<input name="I3" type="number" class="s" min="0" max="255" required><br>
 		Static gateway:<br>
-		<input name="G0" type="number" min="0" max="255" required> .
-		<input name="G1" type="number" min="0" max="255" required> .
-		<input name="G2" type="number" min="0" max="255" required> .
-		<input name="G3" type="number" min="0" max="255" required><br>
+		<input name="G0" type="number" class="s" min="0" max="255" required> .
+		<input name="G1" type="number" class="s" min="0" max="255" required> .
+		<input name="G2" type="number" class="s" min="0" max="255" required> .
+		<input name="G3" type="number" class="s" min="0" max="255" required><br>
 		Static subnet mask:<br>
-		<input name="S0" type="number" min="0" max="255" required> .
-		<input name="S1" type="number" min="0" max="255" required> .
-		<input name="S2" type="number" min="0" max="255" required> .
-		<input name="S3" type="number" min="0" max="255" required><br>
+		<input name="S0" type="number" class="s" min="0" max="255" required> .
+		<input name="S1" type="number" class="s" min="0" max="255" required> .
+		<input name="S2" type="number" class="s" min="0" max="255" required> .
+		<input name="S3" type="number" class="s" min="0" max="255" required><br>
 		mDNS address (leave empty for no mDNS):<br/>
 		http:// <input name="CM" maxlength="32"> .local<br>
 		Client IP: <span class="sip"> Not connected </span> <br>
@@ -52,7 +52,7 @@
 		AP SSID (leave empty for no AP):<br> <input name="AS" maxlength="32"><br>
 		Hide AP name: <input type="checkbox" name="AH"><br>
 		AP password (leave empty for open):<br> <input type="password" name="AP" maxlength="63" pattern="(.{8,63})|()" title="Empty or min. 8 characters"><br>
-		Access Point WiFi channel: <input name="AC" type="number" min="1" max="13" required><br>
+		Access Point WiFi channel: <input name="AC" type="number" class="xs" min="1" max="13" required><br>
     AP opens:
     <select name="AB">
     <option value="0">No connection after boot</option>

wled00/data/style.css

@@ -38,14 +38,20 @@ input[type="number"] {
 input[type="number"].xxl {
   width: 100px;
 }
-input[type="number"].big {
+input[type="number"].xl {
   width: 85px;
 }
-input[type="number"].med {
+input[type="number"].l {
+  width: 60px;
+}
+input[type="number"].m {
   width: 55px;
 }
-input[type="number"].small {
-  width: 40px;
+input[type="number"].s {
+  width: 42px;
+}
+input[type="number"].xs {
+  width: 35px;
 }
 input[type="checkbox"] {
   transform: scale(1.5);

wled00/e131.cpp

@@ -156,9 +156,9 @@ void handleE131Packet(e131_packet_t* p, IPAddress clientIP, byte protocol){
         col[3]        = e131_data[DMXAddress+11]; //white
         colSec[3]     = e131_data[DMXAddress+12];
       }
-      transitionDelayTemp = 0;                        // act fast
-      colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);  // don't send UDP
-      return;                                         // don't activate realtime live mode
+      transitionDelayTemp = 0;               // act fast
+      colorUpdated(CALL_MODE_NOTIFICATION);  // don't send UDP
+      return;                                // don't activate realtime live mode
       break;
 
     case DMX_MODE_MULTIPLE_DRGB:

wled00/fcn_declare.h

@@ -32,6 +32,27 @@ bool deserializeConfigSec();
 void serializeConfig();
 void serializeConfigSec();
 
+template<typename DestType>
+bool getJsonValue(const JsonVariant& element, DestType& destination) {
+  if (element.isNull()) {
+    return false;
+  }
+
+  destination = element.as<DestType>();
+  return true;
+}
+
+template<typename DestType, typename DefaultType>
+bool getJsonValue(const JsonVariant& element, DestType& destination, const DefaultType defaultValue) {
+  if(!getJsonValue(element, destination)) {
+    destination = defaultValue;
+    return false;
+  }
+
+  return true;
+}
+
+
 //colors.cpp
 void colorFromUint32(uint32_t in, bool secondary = false);
 void colorFromUint24(uint32_t in, bool secondary = false);
@@ -87,6 +108,7 @@ void decodeIR44(uint32_t code);
 void decodeIR21(uint32_t code);
 void decodeIR6(uint32_t code);
 void decodeIR9(uint32_t code);
+void decodeIRJson(uint32_t code);
 
 void initIR();
 void handleIR();
@@ -98,7 +120,7 @@ void handleIR();
 #include "FX.h"
 
 void deserializeSegment(JsonObject elem, byte it, byte presetId = 0);
-bool deserializeState(JsonObject root, byte presetId = 0);
+bool deserializeState(JsonObject root, byte callMode = CALL_MODE_DIRECT_CHANGE, byte presetId = 0);
 void serializeSegment(JsonObject& root, WS2812FX::Segment& seg, byte id, bool forPreset = false, bool segmentBounds = true);
 void serializeState(JsonObject root, bool forPreset = false, bool includeBri = true, bool segmentBounds = true);
 void serializeInfo(JsonObject root);
@@ -155,11 +177,11 @@ void _drawOverlayCronixie();
 //playlist.cpp
 void shufflePlaylist();
 void unloadPlaylist();
-void loadPlaylist(JsonObject playlistObject, byte presetId = 0);
+int16_t loadPlaylist(JsonObject playlistObject, byte presetId = 0);
 void handlePlaylist();
 
 //presets.cpp
-bool applyPreset(byte index);
+bool applyPreset(byte index, byte callMode = CALL_MODE_DIRECT_CHANGE);
 void savePreset(byte index, bool persist = true, const char* pname = nullptr, JsonObject saveobj = JsonObject());
 void deletePreset(byte index);
 
@@ -189,7 +211,7 @@ class Usermod {
     virtual void addToJsonInfo(JsonObject& obj) {}
     virtual void readFromJsonState(JsonObject& obj) {}
     virtual void addToConfig(JsonObject& obj) {}
-    virtual bool readFromConfig(JsonObject& obj) { return true; } //Heads up! readFromConfig() now needs to return a bool
+    virtual bool readFromConfig(JsonObject& obj) { return true; } // Note as of 2021-06 readFromConfig() now needs to return a bool, see usermod_v2_example.h
     virtual void onMqttConnect(bool sessionPresent) {}
     virtual bool onMqttMessage(char* topic, char* payload) { return false; }
     virtual uint16_t getId() {return USERMOD_ID_UNSPECIFIED;}

wled00/html_other.h

@@ -42,7 +42,7 @@ function B(){window.history.back()}function U(){document.getElementById("uf").st
 .bt{background:#333;color:#fff;font-family:Verdana,sans-serif;border:.3ch solid #333;display:inline-block;font-size:20px;margin:8px;margin-top:12px}input[type=file]{font-size:16px}body{font-family:Verdana,sans-serif;text-align:center;background:#222;color:#fff;line-height:200%}#msg{display:none}
 </style></head><body><h2>WLED Software Update</h2><form method="POST" 
 action="/update" id="uf" enctype="multipart/form-data" onsubmit="U()">
-Installed version: 0.13.0-b0<br>Download the latest binary: <a 
+Installed version: 0.13.0-b2<br>Download the latest binary: <a 
 href="https://github.com/Aircoookie/WLED/releases" target="_blank"><img 
 src="https://img.shields.io/github/release/Aircoookie/WLED.svg?style=flat-square">
 </a><br><input type="file" class="bt" name="update" required><br><input 
@@ -85,7 +85,7 @@ charset="utf-8"><meta name="theme-color" content="#222222"><title>
 WLED Live Preview</title><style>
 body{margin:0}#canv{background:#000;filter:brightness(175%);width:100%;height:100%;position:absolute}
 </style></head><body><div id="canv"><script>
-console.info("Live-Preview websocket opening");var socket=new WebSocket("ws://"+document.location.host+"/ws");function updatePreview(e){var o="linear-gradient(90deg,",n=e.length;for(i=0;i<n;i++){var t=e[i];t.length>6&&(t=t.substring(2)),o+="#"+t,i<n-1&&(o+=",")}o+=")",document.getElementById("canv").style.background=o}socket.onopen=function(){console.info("Live-Preview websocket is opened"),socket.send("{'lv':true}")},socket.onclose=function(){console.info("Live-Preview websocket is closing")},socket.onerror=function(e){console.error("Live-Preview websocket error:",e)},socket.onmessage=function(e){try{var o=JSON.parse(e.data);o&&o.leds&&requestAnimationFrame((function(){updatePreview(o.leds)}))}catch(e){console.error("Live-Preview websocket error:",e)}}
+function updatePreview(e){var n="linear-gradient(90deg,",o=e.length;for(i=0;i<o;i++){var t=e[i];t.length>6&&(t=t.substring(2)),n+="#"+t,i<o-1&&(n+=",")}n+=")",document.getElementById("canv").style.background=n}function getLiveJson(e){try{var n=JSON.parse(e.data);n&&n.leds&&requestAnimationFrame((function(){updatePreview(n.leds)}))}catch(e){console.error("Live-Preview ws error:",e)}}var ws=top.window.ws;ws&&ws.readyState===WebSocket.OPEN?(console.info("Use top WS for peek"),ws.send("{'lv':true}")):(console.info("Peek ws opening"),(ws=new WebSocket("ws://"+document.location.host+"/ws")).onopen=function(){console.info("Peek WS opened"),ws.send("{'lv':true}")}),ws.addEventListener("message",getLiveJson)
 </script></body></html>)=====";
 
 

wled00/hue.cpp

@@ -10,7 +10,7 @@ void handleHue()
 {
   if (hueReceived)
   {
-    colorUpdated(NOTIFIER_CALL_MODE_HUE); hueReceived = false;
+    colorUpdated(CALL_MODE_HUE); hueReceived = false;
     if (hueStoreAllowed && hueNewKey)
     {
       serializeConfigSec(); //save api key
@@ -92,7 +92,7 @@ void onHueData(void* arg, AsyncClient* client, void *data, size_t len)
   if (str == nullptr) return;
   str += 4;
 
-  StaticJsonDocument<512> root;
+  StaticJsonDocument<1024> root;
   if (str[0] == '[') //is JSON array
   {
     auto error = deserializeJson(root, str);
@@ -161,7 +161,7 @@ void onHueData(void* arg, AsyncClient* client, void *data, size_t len)
           hueColormode = 1;
         } else //hs mode
         {
-          hueHue = root[F("hue")];
+          hueHue = root["hue"];
           hueSat = root[F("sat")];
           hueColormode = 2;
         }

wled00/ir.cpp

@@ -68,6 +68,14 @@ void decBrightness()
   }
 }
 
+// apply preset or fallback to a effect and palette if it doesn't exist
+void presetFallback(uint8_t presetID, uint8_t effectID, uint8_t paletteID) 
+{
+  if (!applyPreset(presetID, CALL_MODE_BUTTON)) { 
+    effectCurrent = effectID;      
+    effectPalette = paletteID;
+  }
+}
 
 //Add what your custom IR codes should trigger here. Guide: https://github.com/Aircoookie/WLED/wiki/Infrared-Control
 //IR codes themselves can be defined directly after "case" or in "ir_codes.h"
@@ -77,16 +85,14 @@ bool decodeIRCustom(uint32_t code)
   {
     //just examples, feel free to modify or remove
     case IRCUSTOM_ONOFF : toggleOnOff(); break;
-    case IRCUSTOM_MACRO1 : applyPreset(1); break;
+    case IRCUSTOM_MACRO1 : applyPreset(1, CALL_MODE_BUTTON); break;
 
     default: return false;
   }
-  if (code != IRCUSTOM_MACRO1) colorUpdated(NOTIFIER_CALL_MODE_BUTTON); //don't update color again if we apply macro, it already does it
+  if (code != IRCUSTOM_MACRO1) colorUpdated(CALL_MODE_BUTTON); //don't update color again if we apply macro, it already does it
   return true;
 }
 
-
-
 void relativeChange(byte* property, int8_t amount, byte lowerBoundary, byte higherBoundary)
 {
   int16_t new_val = (int16_t) *property + amount;
@@ -156,72 +162,79 @@ void decodeIR(uint32_t code)
   lastValidCode = 0; irTimesRepeated = 0;
   if (decodeIRCustom(code)) return;
   if      (code > 0xFFFFFF) return; //invalid code
-  else if (code > 0xF70000 && code < 0xF80000) decodeIR24(code); //is in 24-key remote range
-  else if (code > 0xFF0000) {
-    switch (irEnabled) {
-      case 1: decodeIR24OLD(code); break;  // white 24-key remote (old) - it sends 0xFF0000 values
-      case 2: decodeIR24CT(code);  break;  // white 24-key remote with CW, WW, CT+ and CT- keys
-      case 3: decodeIR40(code);    break;  // blue  40-key remote with 25%, 50%, 75% and 100% keys
-      case 4: decodeIR44(code);    break;  // white 44-key remote with color-up/down keys and DIY1 to 6 keys 
-      case 5: decodeIR21(code);    break;  // white 21-key remote  
-      case 6: decodeIR6(code);     break;  // black 6-key learning remote defaults: "CH" controls brightness,
-                                           // "VOL +" controls effect, "VOL -" controls colour/palette, "MUTE" 
-                                           // sets bright plain white
-      case 7: decodeIR9(code);    break;
-      default: return;
-    }
+  switch (irEnabled) {
+    case 1: 
+      if (code > 0xF80000) {
+        decodeIR24OLD(code);            // white 24-key remote (old) - it sends 0xFF0000 values
+      } else {
+        decodeIR24(code);               // 24-key remote - 0xF70000 to 0xF80000
+      }
+      break;
+    case 2: decodeIR24CT(code);  break;  // white 24-key remote with CW, WW, CT+ and CT- keys
+    case 3: decodeIR40(code);    break;  // blue  40-key remote with 25%, 50%, 75% and 100% keys
+    case 4: decodeIR44(code);    break;  // white 44-key remote with color-up/down keys and DIY1 to 6 keys 
+    case 5: decodeIR21(code);    break;  // white 21-key remote  
+    case 6: decodeIR6(code);     break;  // black 6-key learning remote defaults: "CH" controls brightness,
+                                          // "VOL +" controls effect, "VOL -" controls colour/palette, "MUTE" 
+                                          // sets bright plain white
+    case 7: decodeIR9(code);    break;
+    case 8: decodeIRJson(code); break;   // any remote configurable with ir.json file
+    default: return;
   }
+
   if (nightlightActive && bri == 0) nightlightActive = false;
-  colorUpdated(NOTIFIER_CALL_MODE_BUTTON); //for notifier, IR is considered a button input
-  //code <= 0xF70000 also invalid
+  colorUpdated(CALL_MODE_BUTTON); //for notifier, IR is considered a button input
 }
 
 void applyRepeatActions(){
   
     if (lastRepeatableAction == ACTION_BRIGHT_UP)
     { 
-      incBrightness(); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      incBrightness(); colorUpdated(CALL_MODE_BUTTON);
     }
     else if (lastRepeatableAction == ACTION_BRIGHT_DOWN )
     {
-      decBrightness(); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      decBrightness(); colorUpdated(CALL_MODE_BUTTON);
     }
 
     if (lastRepeatableAction == ACTION_SPEED_UP)
     { 
-      changeEffectSpeed(lastRepeatableValue); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      changeEffectSpeed(lastRepeatableValue); colorUpdated(CALL_MODE_BUTTON);
     }
     else if (lastRepeatableAction == ACTION_SPEED_DOWN )
     {
-      changeEffectSpeed(lastRepeatableValue); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      changeEffectSpeed(lastRepeatableValue); colorUpdated(CALL_MODE_BUTTON);
     }
 
     if (lastRepeatableAction == ACTION_INTENSITY_UP)
     { 
-      changeEffectIntensity(lastRepeatableValue); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      changeEffectIntensity(lastRepeatableValue); colorUpdated(CALL_MODE_BUTTON);
     }
     else if (lastRepeatableAction == ACTION_INTENSITY_DOWN )
     {
-      changeEffectIntensity(lastRepeatableValue); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      changeEffectIntensity(lastRepeatableValue); colorUpdated(CALL_MODE_BUTTON);
     }
 
     if (lastValidCode == IR40_WPLUS)
     { 
-      relativeChangeWhite(10); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      relativeChangeWhite(10); colorUpdated(CALL_MODE_BUTTON);
     }
     else if (lastValidCode == IR40_WMINUS)
     {
-      relativeChangeWhite(-10, 5); colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      relativeChangeWhite(-10, 5); colorUpdated(CALL_MODE_BUTTON);
     }
     else if ((lastValidCode == IR24_ON || lastValidCode == IR40_ON) && irTimesRepeated > 7 )
     {
       nightlightActive = true;
       nightlightStartTime = millis();
-      colorUpdated(NOTIFIER_CALL_MODE_BUTTON);
+      colorUpdated(CALL_MODE_BUTTON);
+    }
+    else if (irEnabled == 8) 
+    {
+      decodeIRJson(lastValidCode);
     }
 }
 
-
 void decodeIR24(uint32_t code)
 {
   switch (code) {
@@ -244,11 +257,11 @@ void decodeIR24(uint32_t code)
     case IR24_PURPLE    : colorFromUint32(COLOR_PURPLE);    break;
     case IR24_MAGENTA   : colorFromUint32(COLOR_MAGENTA);   break;
     case IR24_PINK      : colorFromUint32(COLOR_PINK);      break;
-    case IR24_WHITE     : colorFromUint32(COLOR_WHITE);           effectCurrent = 0;  break;
-    case IR24_FLASH     : if (!applyPreset(1)) effectCurrent = FX_MODE_COLORTWINKLE;  break;
-    case IR24_STROBE    : if (!applyPreset(2)) effectCurrent = FX_MODE_RAINBOW_CYCLE; break;
-    case IR24_FADE      : if (!applyPreset(3)) effectCurrent = FX_MODE_BREATH;        break;
-    case IR24_SMOOTH    : if (!applyPreset(4)) effectCurrent = FX_MODE_RAINBOW;       break;
+    case IR24_WHITE     : colorFromUint32(COLOR_WHITE);        effectCurrent = 0;  break;
+    case IR24_FLASH     : presetFallback(1, FX_MODE_COLORTWINKLE, effectPalette);  break;
+    case IR24_STROBE    : presetFallback(2, FX_MODE_RAINBOW_CYCLE, effectPalette); break;
+    case IR24_FADE      : presetFallback(3, FX_MODE_BREATH, effectPalette);        break;
+    case IR24_SMOOTH    : presetFallback(4, FX_MODE_RAINBOW, effectPalette);       break;
     default: return;
   }
   lastValidCode = code;
@@ -276,17 +289,16 @@ void decodeIR24OLD(uint32_t code)
     case IR24_OLD_PURPLE    : colorFromUint32(COLOR_PURPLE);       break;
     case IR24_OLD_MAGENTA   : colorFromUint32(COLOR_MAGENTA);      break;
     case IR24_OLD_PINK      : colorFromUint32(COLOR_PINK);         break;
-    case IR24_OLD_WHITE     : colorFromUint32(COLOR_WHITE);        effectCurrent = 0;     break;
-    case IR24_OLD_FLASH     : if (!applyPreset(1)) { effectCurrent = FX_MODE_COLORTWINKLE;  effectPalette = 0; } break;
-    case IR24_OLD_STROBE    : if (!applyPreset(2)) { effectCurrent = FX_MODE_RAINBOW_CYCLE; effectPalette = 0; } break;
-    case IR24_OLD_FADE      : if (!applyPreset(3)) { effectCurrent = FX_MODE_BREATH;        effectPalette = 0; } break;
-    case IR24_OLD_SMOOTH    : if (!applyPreset(4)) { effectCurrent = FX_MODE_RAINBOW;       effectPalette = 0; } break;
+    case IR24_OLD_WHITE     : colorFromUint32(COLOR_WHITE); effectCurrent = 0; break;
+    case IR24_OLD_FLASH     : presetFallback(1, FX_MODE_COLORTWINKLE, 0);      break;
+    case IR24_OLD_STROBE    : presetFallback(2, FX_MODE_RAINBOW_CYCLE, 0);     break;
+    case IR24_OLD_FADE      : presetFallback(3, FX_MODE_BREATH, 0);            break;
+    case IR24_OLD_SMOOTH    : presetFallback(4, FX_MODE_RAINBOW, 0);           break;
     default: return;
   }
   lastValidCode = code;
 }
 
-
 void decodeIR24CT(uint32_t code)
 {
   switch (code) {
@@ -321,7 +333,6 @@ void decodeIR24CT(uint32_t code)
   lastValidCode = code;
 }
 
-
 void decodeIR40(uint32_t code)
 {
   switch (code) {
@@ -371,10 +382,10 @@ void decodeIR40(uint32_t code)
     case IR40_SLOW         : changeEffectSpeed(-16);                                     break;
     case IR40_JUMP7        : changeEffectIntensity( 16);                                 break;
     case IR40_AUTO         : changeEffectIntensity(-16);                                 break;
-    case IR40_JUMP3        : if (!applyPreset(1)) { effectCurrent = FX_MODE_STATIC;        effectPalette = 0; } break;
-    case IR40_FADE3        : if (!applyPreset(2)) { effectCurrent = FX_MODE_BREATH;        effectPalette = 0; } break;
-    case IR40_FADE7        : if (!applyPreset(3)) { effectCurrent = FX_MODE_FIRE_FLICKER;  effectPalette = 0; } break;
-    case IR40_FLASH        : if (!applyPreset(4)) { effectCurrent = FX_MODE_RAINBOW;       effectPalette = 0; } break;
+    case IR40_JUMP3        : presetFallback(1, FX_MODE_STATIC,       0); break;
+    case IR40_FADE3        : presetFallback(2, FX_MODE_BREATH,       0); break;
+    case IR40_FADE7        : presetFallback(3, FX_MODE_FIRE_FLICKER, 0); break;
+    case IR40_FLASH        : presetFallback(4, FX_MODE_RAINBOW,      0); break;
   }
   lastValidCode = code;
 }
@@ -426,12 +437,12 @@ void decodeIR44(uint32_t code)
     case IR44_BLUEMINUS   : changeEffectIntensity(-16);                                 break;
     case IR44_QUICK       : changeEffectSpeed( 16);                                     break;
     case IR44_SLOW        : changeEffectSpeed(-16);                                     break;
-    case IR44_DIY1        : if (!applyPreset(1)) { effectCurrent = FX_MODE_STATIC;        effectPalette = 0; } break;
-    case IR44_DIY2        : if (!applyPreset(2)) { effectCurrent = FX_MODE_BREATH;        effectPalette = 0; } break;
-    case IR44_DIY3        : if (!applyPreset(3)) { effectCurrent = FX_MODE_FIRE_FLICKER;  effectPalette = 0; } break;
-    case IR44_DIY4        : if (!applyPreset(4)) { effectCurrent = FX_MODE_RAINBOW;       effectPalette = 0; } break;
-    case IR44_DIY5        : if (!applyPreset(5)) { effectCurrent = FX_MODE_METEOR_SMOOTH; effectPalette = 0; } break;
-    case IR44_DIY6        : if (!applyPreset(6)) { effectCurrent = FX_MODE_RAIN;          effectPalette = 0; } break;
+    case IR44_DIY1        : presetFallback(1, FX_MODE_STATIC,        0); break;
+    case IR44_DIY2        : presetFallback(2, FX_MODE_BREATH,        0); break;
+    case IR44_DIY3        : presetFallback(3, FX_MODE_FIRE_FLICKER,  0); break;
+    case IR44_DIY4        : presetFallback(4, FX_MODE_RAINBOW,       0); break;
+    case IR44_DIY5        : presetFallback(5, FX_MODE_METEOR_SMOOTH, 0); break;
+    case IR44_DIY6        : presetFallback(6, FX_MODE_RAIN,          0); break;
     case IR44_AUTO        : effectCurrent = FX_MODE_STATIC;                             break;
     case IR44_FLASH       : effectCurrent = FX_MODE_PALETTE;                            break;
     case IR44_JUMP3       : bri = 63;                                                   break;
@@ -462,10 +473,10 @@ void decodeIR21(uint32_t code)
     case IR21_PURPLE:    colorFromUint32(COLOR_PURPLE);    break;
     case IR21_PINK:      colorFromUint32(COLOR_PINK);      break;
     case IR21_WHITE:     colorFromUint32(COLOR_WHITE);           effectCurrent = 0;  break;
-    case IR21_FLASH:     if (!applyPreset(1)) { effectCurrent = FX_MODE_COLORTWINKLE;  effectPalette = 0; } break;
-    case IR21_STROBE:    if (!applyPreset(2)) { effectCurrent = FX_MODE_RAINBOW_CYCLE; effectPalette = 0; } break;
-    case IR21_FADE:      if (!applyPreset(3)) { effectCurrent = FX_MODE_BREATH;        effectPalette = 0; } break;
-    case IR21_SMOOTH:    if (!applyPreset(4)) { effectCurrent = FX_MODE_RAINBOW;       effectPalette = 0; } break;
+    case IR21_FLASH:     presetFallback(1, FX_MODE_COLORTWINKLE,  0); break;
+    case IR21_STROBE:    presetFallback(2, FX_MODE_RAINBOW_CYCLE, 0); break;
+    case IR21_FADE:      presetFallback(3, FX_MODE_BREATH,        0); break;
+    case IR21_SMOOTH:    presetFallback(4, FX_MODE_RAINBOW,       0); break;
     default: return;
     }
     lastValidCode = code;
@@ -507,9 +518,9 @@ void decodeIR9(uint32_t code)
 {
   switch (code) {
     case IR9_POWER      : toggleOnOff();  break;
-    case IR9_A          : if (!applyPreset(1)) effectCurrent = FX_MODE_COLORTWINKLE;  break;
-    case IR9_B          : if (!applyPreset(2)) effectCurrent = FX_MODE_RAINBOW_CYCLE; break;
-    case IR9_C          : if (!applyPreset(3)) effectCurrent = FX_MODE_BREATH;        break;
+    case IR9_A          : presetFallback(1, FX_MODE_COLORTWINKLE, effectPalette);  break;
+    case IR9_B          : presetFallback(2, FX_MODE_RAINBOW_CYCLE, effectPalette); break;
+    case IR9_C          : presetFallback(3, FX_MODE_BREATH, effectPalette);        break;
     case IR9_UP         : incBrightness();                                            break;
     case IR9_DOWN       : decBrightness();                                            break;
     //case IR9_UP         : changeEffectIntensity(16);         break;
@@ -522,6 +533,91 @@ void decodeIR9(uint32_t code)
   lastValidCode = code;
 }
 
+
+/*
+This allows users to customize IR actions without the need to edit C code and compile.
+From the https://github.com/Aircoookie/WLED/wiki/Infrared-Control page, download the starter 
+ir.json file that corresponds to the number of buttons on your remote.
+Many of the remotes with the same number of buttons emit the same codes, but will have
+different labels or colors. Once you edit the ir.json file, upload it to your controller
+using the /edit page.
+
+Each key should be the hex encoded IR code. The "cmd" property should be the HTTP API 
+or JSON API command to execute on button press. If the command contains a relative change (SI=~16),
+it will register as a repeatable command. If the command doesn't contain a "~" but is repeatable, add "rpt" property
+set to true. Other properties are ignored but having labels and positions can assist with editing
+the json file.
+
+Sample:
+{
+  "0xFF629D": {"cmd": "T=2", "rpt": true, "label": "Toggle on/off"},  // HTTP command
+  "0xFF9867": {"cmd": "A=~16", "label": "Inc brightness"},            // HTTP command with incrementing
+  "0xFF38C7": {"cmd": {"bri": 10}, "label": "Dim to 10"},             // JSON command
+  "0xFF22DD": {"cmd": "!presetFallback", "PL": 1, "FX": 16, "FP": 6,  // Custom command
+               "label": "Preset 1, fallback to Saw - Party if not found"},
+}
+*/
+void decodeIRJson(uint32_t code) 
+{
+  char objKey[10];
+  const char* cmd;
+  String cmdStr;
+  DynamicJsonDocument irDoc(JSON_BUFFER_SIZE);
+  JsonObject fdo;
+  JsonObject jsonCmdObj;
+
+  sprintf(objKey, "\"0x%X\":", code);
+
+  errorFlag = readObjectFromFile("/ir.json", objKey, &irDoc) ? ERR_NONE : ERR_FS_PLOAD;
+  fdo = irDoc.as<JsonObject>();
+  lastValidCode = 0;
+  if (!errorFlag) 
+  {
+    cmd = fdo["cmd"];
+    cmdStr = String(cmd);
+    jsonCmdObj = fdo["cmd"];
+    if (!cmdStr.isEmpty()) 
+    {
+      if (cmdStr.startsWith("!")) {
+        // call limited set of C functions
+        if (cmdStr.startsWith(F("!incBri"))) {
+          lastValidCode = code;
+          incBrightness();
+        } else if (cmdStr.startsWith(F("!decBri"))) {
+          lastValidCode = code;
+          decBrightness();
+        } else if (cmdStr.startsWith(F("!presetF"))) { //!presetFallback
+          uint8_t p1 = fdo["PL"] ? fdo["PL"] : 1;
+          uint8_t p2 = fdo["FX"] ? fdo["FX"] : random8(100);
+          uint8_t p3 = fdo["FP"] ? fdo["FP"] : 0;
+          presetFallback(p1, p2, p3);
+        }
+      } else {
+        // HTTP API command
+        if (cmdStr.indexOf("~") || fdo["rpt"]) 
+        {
+          // repeatable action
+          lastValidCode = code;
+        }
+        if (effectCurrent == 0 && cmdStr.indexOf("FP=") > -1) {
+          // setting palette but it wont show because effect is solid
+          effectCurrent = FX_MODE_GRADIENT;
+        }
+        if (!cmdStr.startsWith("win&")) {
+          cmdStr = "win&" + cmdStr;
+        }
+        handleSet(nullptr, cmdStr, false); 
+      }        
+    } else if (!jsonCmdObj.isNull()) {
+      // command is JSON object
+      //allow applyPreset() to reuse JSON buffer, or it would alloc. a second buffer and run out of mem.
+      fileDoc = &irDoc;
+      deserializeState(jsonCmdObj, CALL_MODE_BUTTON);
+      fileDoc = nullptr;
+    }
+  }
+}
+
 void initIR()
 {
   if (irEnabled > 0)
@@ -531,7 +627,6 @@ void initIR()
   }
 }
 
-
 void handleIR()
 {
   if (irEnabled > 0 && millis() - irCheckedTime > 120)

wled00/json.cpp

@@ -9,161 +9,176 @@
 void deserializeSegment(JsonObject elem, byte it, byte presetId)
 {
   byte id = elem["id"] | it;
-  if (id < strip.getMaxSegments())
-  {
-    WS2812FX::Segment& seg = strip.getSegment(id);
-    uint16_t start = elem[F("start")] | seg.start;
-    int stop = elem["stop"] | -1;
+  if (id >= strip.getMaxSegments()) return;
 
-    if (stop < 0) {
-      uint16_t len = elem[F("len")];
-      stop = (len > 0) ? start + len : seg.stop;
-    }
-    uint16_t grp = elem[F("grp")] | seg.grouping;
-    uint16_t spc = elem[F("spc")] | seg.spacing;
-    strip.setSegment(id, start, stop, grp, spc);
-    seg.offset = elem[F("of")] | seg.offset;
-    if (stop > start && seg.offset > stop - start -1) seg.offset = stop - start -1;
+  WS2812FX::Segment& seg = strip.getSegment(id);
+  //WS2812FX::Segment prev;
+  //prev = seg; //make a backup so we can tell if something changed
 
-    int segbri = elem["bri"] | -1;
-    if (segbri == 0) {
-      seg.setOption(SEG_OPTION_ON, 0, id);
-    } else if (segbri > 0) {
-      seg.setOpacity(segbri, id);
-      seg.setOption(SEG_OPTION_ON, 1, id);
-    }
-  
-    seg.setOption(SEG_OPTION_ON, elem["on"] | seg.getOption(SEG_OPTION_ON), id);
-    
-    JsonArray colarr = elem["col"];
-    if (!colarr.isNull())
-    {
-      for (uint8_t i = 0; i < 3; i++)
-      {
-        int rgbw[] = {0,0,0,0};
-        bool colValid = false;
-        JsonArray colX = colarr[i];
-        if (colX.isNull()) {
-          byte brgbw[] = {0,0,0,0};
-          const char* hexCol = colarr[i];
-          if (hexCol == nullptr) { //Kelvin color temperature (or invalid), e.g 2400
-            int kelvin = colarr[i] | -1;
-            if (kelvin <  0) continue;
-            if (kelvin == 0) seg.setColor(i, 0, id);
-            if (kelvin >  0) colorKtoRGB(kelvin, brgbw);
-            colValid = true;
-          } else { //HEX string, e.g. "FFAA00"
-            colValid = colorFromHexString(brgbw, hexCol);
-          }
-          for (uint8_t c = 0; c < 4; c++) rgbw[c] = brgbw[c];
-        } else { //Array of ints (RGB or RGBW color), e.g. [255,160,0]
-          byte sz = colX.size();
-          if (sz == 0) continue; //do nothing on empty array
-
-          byte cp = copyArray(colX, rgbw, 4);      
-          if (cp == 1 && rgbw[0] == 0) 
-            seg.setColor(i, 0, id);
-          colValid = true;
-        }
-
-        if (!colValid) continue;
-        if (id == strip.getMainSegmentId() && i < 2) //temporary, to make transition work on main segment
-        {
-          if (i == 0) {col[0] = rgbw[0]; col[1] = rgbw[1]; col[2] = rgbw[2]; col[3] = rgbw[3];}
-          if (i == 1) {colSec[0] = rgbw[0]; colSec[1] = rgbw[1]; colSec[2] = rgbw[2]; colSec[3] = rgbw[3];}
-        } else { //normal case, apply directly to segment
-          seg.setColor(i, ((rgbw[3] << 24) | ((rgbw[0]&0xFF) << 16) | ((rgbw[1]&0xFF) << 8) | ((rgbw[2]&0xFF))), id);
-          if (seg.mode == FX_MODE_STATIC) strip.trigger(); //instant refresh
-        }
-      }
-    }
-
-    // lx parser
-    #ifdef WLED_ENABLE_LOXONE
-    int lx = elem[F("lx")] | -1;
-    if (lx > 0) {
-      parseLxJson(lx, id, false);
-    }
-    int ly = elem[F("ly")] | -1;
-    if (ly > 0) {
-      parseLxJson(ly, id, true);
-    }
-    #endif
-
-    //if (pal != seg.palette && pal < strip.getPaletteCount()) strip.setPalette(pal);
-    seg.setOption(SEG_OPTION_SELECTED, elem[F("sel")] | seg.getOption(SEG_OPTION_SELECTED));
-    seg.setOption(SEG_OPTION_REVERSED, elem["rev"] | seg.getOption(SEG_OPTION_REVERSED));
-    seg.setOption(SEG_OPTION_MIRROR  , elem[F("mi")]  | seg.getOption(SEG_OPTION_MIRROR  ));
-
-    //temporary, strip object gets updated via colorUpdated()
-    if (id == strip.getMainSegmentId()) {
-      byte effectPrev = effectCurrent;
-      effectCurrent = elem[F("fx")] | effectCurrent;
-      if (!presetId && effectCurrent != effectPrev) unloadPlaylist(); //stop playlist if active and FX changed manually
-      effectSpeed = elem[F("sx")] | effectSpeed;
-      effectIntensity = elem[F("ix")] | effectIntensity;
-      effectPalette = elem["pal"] | effectPalette;
-    } else { //permanent
-      byte fx = elem[F("fx")] | seg.mode;
-      if (fx != seg.mode && fx < strip.getModeCount()) {
-        strip.setMode(id, fx);
-        if (!presetId) unloadPlaylist(); //stop playlist if active and FX changed manually
-      }
-      seg.speed = elem[F("sx")] | seg.speed;
-      seg.intensity = elem[F("ix")] | seg.intensity;
-      seg.palette = elem["pal"] | seg.palette;
-    }
-
-    JsonArray iarr = elem[F("i")]; //set individual LEDs
-    if (!iarr.isNull()) {
-      strip.setPixelSegment(id);
-
-      //freeze and init to black
-      if (!seg.getOption(SEG_OPTION_FREEZE)) {
-        seg.setOption(SEG_OPTION_FREEZE, true);
-        strip.fill(0);
-      }
-
-      uint16_t start = 0, stop = 0;
-      byte set = 0; //0 nothing set, 1 start set, 2 range set
-
-      for (uint16_t i = 0; i < iarr.size(); i++) {
-        if(iarr[i].is<JsonInteger>()) {
-          if (!set) {
-            start = iarr[i];
-            set = 1;
-          } else {
-            stop = iarr[i];
-            set = 2;
-          }
-        } else {
-          JsonArray icol = iarr[i];
-          if (icol.isNull()) break;
-
-          byte sz = icol.size();
-          if (sz == 0 || sz > 4) break;
-
-          int rgbw[] = {0,0,0,0};
-          copyArray(icol, rgbw);
-
-          if (set < 2) stop = start + 1;
-          for (uint16_t i = start; i < stop; i++) {
-            strip.setPixelColor(i, rgbw[0], rgbw[1], rgbw[2], rgbw[3]);
-          }
-          if (!set) start++;
-          set = 0;
-        }
-      }
-      strip.setPixelSegment(255);
-      strip.trigger();
-    } else { //return to regular effect
-      seg.setOption(SEG_OPTION_FREEZE, false);
-    }
+  uint16_t start = elem[F("start")] | seg.start;
+  int stop = elem["stop"] | -1;
 
+  if (stop < 0) {
+    uint16_t len = elem[F("len")];
+    stop = (len > 0) ? start + len : seg.stop;
   }
+  uint16_t grp = elem[F("grp")] | seg.grouping;
+  uint16_t spc = elem[F("spc")] | seg.spacing;
+  strip.setSegment(id, start, stop, grp, spc);
+
+  uint16_t len = 1;
+  if (stop > start) len = stop - start;
+  int offset = elem[F("of")] | INT32_MAX;
+  if (offset != INT32_MAX) {
+    int offsetAbs = abs(offset);
+    if (offsetAbs > len - 1) offsetAbs %= len;
+    if (offset < 0) offsetAbs = len - offsetAbs;
+    seg.offset = offsetAbs;
+  }
+  if (stop > start && seg.offset > len -1) seg.offset = len -1;
+
+  int segbri = elem["bri"] | -1;
+  if (segbri == 0) {
+    seg.setOption(SEG_OPTION_ON, 0, id);
+  } else if (segbri > 0) {
+    seg.setOpacity(segbri, id);
+    seg.setOption(SEG_OPTION_ON, 1, id);
+  }
+
+  seg.setOption(SEG_OPTION_ON, elem["on"] | seg.getOption(SEG_OPTION_ON), id);
+  
+  JsonArray colarr = elem["col"];
+  if (!colarr.isNull())
+  {
+    for (uint8_t i = 0; i < 3; i++)
+    {
+      int rgbw[] = {0,0,0,0};
+      bool colValid = false;
+      JsonArray colX = colarr[i];
+      if (colX.isNull()) {
+        byte brgbw[] = {0,0,0,0};
+        const char* hexCol = colarr[i];
+        if (hexCol == nullptr) { //Kelvin color temperature (or invalid), e.g 2400
+          int kelvin = colarr[i] | -1;
+          if (kelvin <  0) continue;
+          if (kelvin == 0) seg.setColor(i, 0, id);
+          if (kelvin >  0) colorKtoRGB(kelvin, brgbw);
+          colValid = true;
+        } else { //HEX string, e.g. "FFAA00"
+          colValid = colorFromHexString(brgbw, hexCol);
+        }
+        for (uint8_t c = 0; c < 4; c++) rgbw[c] = brgbw[c];
+      } else { //Array of ints (RGB or RGBW color), e.g. [255,160,0]
+        byte sz = colX.size();
+        if (sz == 0) continue; //do nothing on empty array
+
+        byte cp = copyArray(colX, rgbw, 4);      
+        if (cp == 1 && rgbw[0] == 0) 
+          seg.setColor(i, 0, id);
+        colValid = true;
+      }
+
+      if (!colValid) continue;
+      if (id == strip.getMainSegmentId() && i < 2) //temporary, to make transition work on main segment
+      {
+        if (i == 0) {col[0] = rgbw[0]; col[1] = rgbw[1]; col[2] = rgbw[2]; col[3] = rgbw[3];}
+        if (i == 1) {colSec[0] = rgbw[0]; colSec[1] = rgbw[1]; colSec[2] = rgbw[2]; colSec[3] = rgbw[3];}
+      } else { //normal case, apply directly to segment
+        seg.setColor(i, ((rgbw[3] << 24) | ((rgbw[0]&0xFF) << 16) | ((rgbw[1]&0xFF) << 8) | ((rgbw[2]&0xFF))), id);
+        if (seg.mode == FX_MODE_STATIC) strip.trigger(); //instant refresh
+      }
+    }
+  }
+
+  // lx parser
+  #ifdef WLED_ENABLE_LOXONE
+  int lx = elem[F("lx")] | -1;
+  if (lx > 0) {
+    parseLxJson(lx, id, false);
+  }
+  int ly = elem[F("ly")] | -1;
+  if (ly > 0) {
+    parseLxJson(ly, id, true);
+  }
+  #endif
+
+  //if (pal != seg.palette && pal < strip.getPaletteCount()) strip.setPalette(pal);
+  seg.setOption(SEG_OPTION_SELECTED, elem[F("sel")] | seg.getOption(SEG_OPTION_SELECTED));
+  seg.setOption(SEG_OPTION_REVERSED, elem["rev"] | seg.getOption(SEG_OPTION_REVERSED));
+  seg.setOption(SEG_OPTION_MIRROR  , elem[F("mi")]  | seg.getOption(SEG_OPTION_MIRROR  ));
+
+  //temporary, strip object gets updated via colorUpdated()
+  if (id == strip.getMainSegmentId()) {
+    byte effectPrev = effectCurrent;
+    effectCurrent = elem["fx"] | effectCurrent;
+    if (!presetId && effectCurrent != effectPrev) unloadPlaylist(); //stop playlist if active and FX changed manually
+    effectSpeed = elem[F("sx")] | effectSpeed;
+    effectIntensity = elem[F("ix")] | effectIntensity;
+    effectPalette = elem["pal"] | effectPalette;
+  } else { //permanent
+    byte fx = elem["fx"] | seg.mode;
+    if (fx != seg.mode && fx < strip.getModeCount()) {
+      strip.setMode(id, fx);
+      if (!presetId) unloadPlaylist(); //stop playlist if active and FX changed manually
+    }
+    seg.speed = elem[F("sx")] | seg.speed;
+    seg.intensity = elem[F("ix")] | seg.intensity;
+    seg.palette = elem["pal"] | seg.palette;
+  }
+
+  JsonArray iarr = elem[F("i")]; //set individual LEDs
+  if (!iarr.isNull()) {
+    strip.setPixelSegment(id);
+
+    //freeze and init to black
+    if (!seg.getOption(SEG_OPTION_FREEZE)) {
+      seg.setOption(SEG_OPTION_FREEZE, true);
+      strip.fill(0);
+    }
+
+    uint16_t start = 0, stop = 0;
+    byte set = 0; //0 nothing set, 1 start set, 2 range set
+
+    for (uint16_t i = 0; i < iarr.size(); i++) {
+      if(iarr[i].is<JsonInteger>()) {
+        if (!set) {
+          start = iarr[i];
+          set = 1;
+        } else {
+          stop = iarr[i];
+          set = 2;
+        }
+      } else { //color
+        int rgbw[] = {0,0,0,0};
+        JsonArray icol = iarr[i];
+        if (!icol.isNull()) { //array, e.g. [255,0,0]
+          byte sz = icol.size();
+          if (sz > 0 || sz < 5) copyArray(icol, rgbw);
+        } else { //hex string, e.g. "FF0000"
+          byte brgbw[] = {0,0,0,0};
+          const char* hexCol = iarr[i];
+          if (colorFromHexString(brgbw, hexCol)) {
+            for (uint8_t c = 0; c < 4; c++) rgbw[c] = brgbw[c];
+          }
+        }
+
+        if (set < 2) stop = start + 1;
+        for (uint16_t i = start; i < stop; i++) {
+          strip.setPixelColor(i, rgbw[0], rgbw[1], rgbw[2], rgbw[3]);
+        }
+        if (!set) start++;
+        set = 0;
+      }
+    }
+    strip.setPixelSegment(255);
+    strip.trigger();
+  } else { //return to regular effect
+    seg.setOption(SEG_OPTION_FREEZE, false);
+  }
+  return; // seg.differs(prev);
 }
 
-bool deserializeState(JsonObject root, byte presetId)
+bool deserializeState(JsonObject root, byte callMode, byte presetId)
 {
   strip.applyToAllSelected = false;
   bool stateResponse = root[F("v")] | false;
@@ -283,7 +298,7 @@ bool deserializeState(JsonObject root, byte presetId)
     ps = root["ps"] | -1; //load preset (clears state request!)
     if (ps >= 0) {
       if (!presetId) unloadPlaylist(); //stop playlist if preset changed manually
-      applyPreset(ps);
+      applyPreset(ps, callMode);
       return stateResponse;
     }
 
@@ -297,12 +312,14 @@ bool deserializeState(JsonObject root, byte presetId)
   }
 
   JsonObject playlist = root[F("playlist")];
-  if (!playlist.isNull()) {
-    loadPlaylist(playlist, presetId);
-    noNotification = true; //do not notify both for this request and the first playlist entry
+  if (!playlist.isNull() && loadPlaylist(playlist, presetId)) {
+    //do not notify here, because the first playlist entry will do
+    noNotification = true;
+  } else {
+    interfaceUpdateCallMode = CALL_MODE_WS_SEND;
   }
 
-  colorUpdated(noNotification ? NOTIFIER_CALL_MODE_NO_NOTIFY : NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+  colorUpdated(noNotification ? CALL_MODE_NO_NOTIFY : callMode);
 
   return stateResponse;
 }
@@ -345,7 +362,7 @@ void serializeSegment(JsonObject& root, WS2812FX::Segment& seg, byte id, bool fo
   strcat(colstr,"]");
   root["col"] = serialized(colstr);
 
-	root[F("fx")]  = seg.mode;
+	root["fx"]  = seg.mode;
 	root[F("sx")]  = seg.speed;
 	root[F("ix")]  = seg.intensity;
 	root["pal"] = seg.palette;

wled00/led.cpp

@@ -88,13 +88,13 @@ void colorUpdated(int callMode)
 {
   //call for notifier -> 0: init 1: direct change 2: button 3: notification 4: nightlight 5: other (No notification)
   //                     6: fx changed 7: hue 8: preset cycle 9: blynk 10: alexa
-  if (callMode != NOTIFIER_CALL_MODE_INIT && 
-      callMode != NOTIFIER_CALL_MODE_DIRECT_CHANGE && 
-      callMode != NOTIFIER_CALL_MODE_NO_NOTIFY) strip.applyToAllSelected = true; //if not from JSON api, which directly sets segments
+  if (callMode != CALL_MODE_INIT && 
+      callMode != CALL_MODE_DIRECT_CHANGE && 
+      callMode != CALL_MODE_NO_NOTIFY) strip.applyToAllSelected = true; //if not from JSON api, which directly sets segments
 
   bool someSel = false;
 
-  if (callMode == NOTIFIER_CALL_MODE_NOTIFICATION) {
+  if (callMode == CALL_MODE_NOTIFICATION) {
     someSel = (receiveNotificationBrightness || receiveNotificationColor || receiveNotificationEffects);
   }
   
@@ -115,21 +115,21 @@ void colorUpdated(int callMode)
         
     notify(callMode);
     
-    //set flag to update blynk and mqtt
+    //set flag to update blynk, ws and mqtt
     interfaceUpdateCallMode = callMode;
   } else {
     if (nightlightActive && !nightlightActiveOld && 
-        callMode != NOTIFIER_CALL_MODE_NOTIFICATION && 
-        callMode != NOTIFIER_CALL_MODE_NO_NOTIFY)
+        callMode != CALL_MODE_NOTIFICATION && 
+        callMode != CALL_MODE_NO_NOTIFY)
     {
-      notify(NOTIFIER_CALL_MODE_NIGHTLIGHT); 
-      interfaceUpdateCallMode = NOTIFIER_CALL_MODE_NIGHTLIGHT;
+      notify(CALL_MODE_NIGHTLIGHT); 
+      interfaceUpdateCallMode = CALL_MODE_NIGHTLIGHT;
     }
   }
   
   if (!colChanged) return; //following code is for e.g. initiating transitions
   
-  if (callMode != NOTIFIER_CALL_MODE_NO_NOTIFY && nightlightActive && (nightlightMode == NL_MODE_FADE || nightlightMode == NL_MODE_COLORFADE))
+  if (callMode != CALL_MODE_NO_NOTIFY && nightlightActive && (nightlightMode == NL_MODE_FADE || nightlightMode == NL_MODE_COLORFADE))
   {
     briNlT = bri;
     nightlightDelayMs -= (millis() - nightlightStartTime);
@@ -143,19 +143,19 @@ void colorUpdated(int callMode)
   if (briT == 0)
   {
     //setLedsStandard(true); //do not color transition if starting from off!
-    if (callMode != NOTIFIER_CALL_MODE_NOTIFICATION) resetTimebase(); //effect start from beginning
+    if (callMode != CALL_MODE_NOTIFICATION) resetTimebase(); //effect start from beginning
   }
 
   briIT = bri;
   if (bri > 0) briLast = bri;
 
   //deactivate nightlight if target brightness is reached
-  if (bri == nightlightTargetBri && callMode != NOTIFIER_CALL_MODE_NO_NOTIFY && nightlightMode != NL_MODE_SUN) nightlightActive = false;
+  if (bri == nightlightTargetBri && callMode != CALL_MODE_NO_NOTIFY && nightlightMode != NL_MODE_SUN) nightlightActive = false;
   
   if (fadeTransition)
   {
     //set correct delay if not using notification delay
-    if (callMode != NOTIFIER_CALL_MODE_NOTIFICATION && !jsonTransitionOnce) transitionDelayTemp = transitionDelay;
+    if (callMode != CALL_MODE_NOTIFICATION && !jsonTransitionOnce) transitionDelayTemp = transitionDelay;
     jsonTransitionOnce = false;
     strip.setTransition(transitionDelayTemp);
     if (transitionDelayTemp == 0) {setLedsStandard(); strip.trigger(); return;}
@@ -180,14 +180,19 @@ void colorUpdated(int callMode)
 void updateInterfaces(uint8_t callMode)
 {
   sendDataWs();
+  if (callMode == CALL_MODE_WS_SEND) {
+    lastInterfaceUpdate = millis();
+    return;
+  }
+  
   #ifndef WLED_DISABLE_ALEXA
-  if (espalexaDevice != nullptr && callMode != NOTIFIER_CALL_MODE_ALEXA) {
+  if (espalexaDevice != nullptr && callMode != CALL_MODE_ALEXA) {
     espalexaDevice->setValue(bri);
     espalexaDevice->setColor(col[0], col[1], col[2]);
   }
   #endif
-  if (callMode != NOTIFIER_CALL_MODE_BLYNK && 
-      callMode != NOTIFIER_CALL_MODE_NO_NOTIFY) updateBlynk();
+  if (callMode != CALL_MODE_BLYNK && 
+      callMode != CALL_MODE_NO_NOTIFY) updateBlynk();
   doPublishMqtt = true;
   lastInterfaceUpdate = millis();
 }
@@ -249,7 +254,7 @@ void handleNightlight()
         if (bri) effectSpeed += 60; //sunset if currently on
         briNlT = !bri; //true == sunrise, false == sunset
         if (!bri) bri = briLast;
-        colorUpdated(NOTIFIER_CALL_MODE_NO_NOTIFY);
+        colorUpdated(CALL_MODE_NO_NOTIFY);
       }
     }
     float nper = (millis() - nightlightStartTime)/((float)nightlightDelayMs);
@@ -260,7 +265,7 @@ void handleNightlight()
       {
         for (byte i=0; i<4; i++) col[i] = colNlT[i]+ ((colSec[i] - colNlT[i])*nper);   // fading from actual color to secondary color
       }
-      colorUpdated(NOTIFIER_CALL_MODE_NO_NOTIFY);
+      colorUpdated(CALL_MODE_NO_NOTIFY);
     }
     if (nper >= 1) //nightlight duration over
     {
@@ -268,7 +273,7 @@ void handleNightlight()
       if (nightlightMode == NL_MODE_SET)
       {
         bri = nightlightTargetBri;
-        colorUpdated(NOTIFIER_CALL_MODE_NO_NOTIFY);
+        colorUpdated(CALL_MODE_NO_NOTIFY);
       }
       if (bri == 0) briLast = briNlT;
       if (nightlightMode == NL_MODE_SUN)
@@ -292,7 +297,7 @@ void handleNightlight()
       effectCurrent = colNlT[0];
       effectSpeed = colNlT[1];
       effectPalette = colNlT[2];
-      colorUpdated(NOTIFIER_CALL_MODE_NO_NOTIFY);
+      colorUpdated(CALL_MODE_NO_NOTIFY);
     }
     nightlightActiveOld = false;
   }

wled00/mqtt.cpp

@@ -15,7 +15,7 @@ void parseMQTTBriPayload(char* payload)
     uint8_t in = strtoul(payload, NULL, 10);
     if (in == 0 && bri > 0) briLast = bri;
     bri = in;
-    colorUpdated(NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+    colorUpdated(CALL_MODE_DIRECT_CHANGE);
   }
 }
 
@@ -88,12 +88,14 @@ void onMqttMessage(char* topic, char* payload, AsyncMqttClientMessageProperties
 
   if (strcmp_P(topic, PSTR("/col")) == 0) {
     colorFromDecOrHexString(col, (char*)payloadStr);
-    colorUpdated(NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+    colorUpdated(CALL_MODE_DIRECT_CHANGE);
   } else if (strcmp_P(topic, PSTR("/api")) == 0) {
     if (payload[0] == '{') { //JSON API
       DynamicJsonDocument doc(JSON_BUFFER_SIZE);
       deserializeJson(doc, payloadStr);
+      fileDoc = &doc;
       deserializeState(doc.as<JsonObject>());
+      fileDoc = nullptr;
     } else { //HTTP API
       String apireq = "win&";
       apireq += (char*)payloadStr;

wled00/playlist.cpp

@@ -53,16 +53,16 @@ void unloadPlaylist() {
 }
 
 
-void loadPlaylist(JsonObject playlistObj, byte presetId) {
+int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   unloadPlaylist();
   
   JsonArray presets = playlistObj["ps"];
   playlistLen = presets.size();
-  if (playlistLen == 0) return;
+  if (playlistLen == 0) return -1;
   if (playlistLen > 100) playlistLen = 100;
 
   playlistEntries = new PlaylistEntry[playlistLen];
-  if (playlistEntries == nullptr) return;
+  if (playlistEntries == nullptr) return -1;
 
   byte it = 0;
   for (int ps : presets) {
@@ -113,6 +113,7 @@ void loadPlaylist(JsonObject playlistObj, byte presetId) {
 
   currentPlaylist = presetId;
   DEBUG_PRINTLN(F("Playlist loaded."));
+  return currentPlaylist;
 }
 
 

wled00/presets.cpp

@@ -4,7 +4,7 @@
  * Methods to handle saving and loading presets to/from the filesystem
  */
 
-bool applyPreset(byte index)
+bool applyPreset(byte index, byte callMode)
 {
   if (index == 0) return false;
   if (fileDoc) {
@@ -14,7 +14,7 @@ bool applyPreset(byte index)
     #ifdef WLED_DEBUG_FS
       serializeJson(*fileDoc, Serial);
     #endif
-    deserializeState(fdo, index);
+    deserializeState(fdo, callMode, index);
   } else {
     DEBUGFS_PRINTLN(F("Make read buf"));
     DynamicJsonDocument fDoc(JSON_BUFFER_SIZE);
@@ -24,7 +24,7 @@ bool applyPreset(byte index)
     #ifdef WLED_DEBUG_FS
       serializeJson(fDoc, Serial);
     #endif
-    deserializeState(fdo, index);
+    deserializeState(fdo, callMode, index);
   }
 
   if (!errorFlag) {

wled00/set.cpp

@@ -259,6 +259,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
     strlcpy(mqttClientID, request->arg(F("MQCID")).c_str(), 41);
     strlcpy(mqttDeviceTopic, request->arg(F("MD")).c_str(), 33);
     strlcpy(mqttGroupTopic, request->arg(F("MG")).c_str(), 33);
+    buttonPublishMqtt = request->hasArg(F("BM"));
     #endif
 
     #ifndef WLED_DISABLE_HUESYNC
@@ -551,13 +552,6 @@ bool handleSet(AsyncWebServerRequest *request, const String& req, bool apply)
   DEBUG_PRINTLN(req);
 
   strip.applyToAllSelected = false;
-  //snapshot to check if request changed values later, temporary.
-  byte prevCol[4] = {col[0], col[1], col[2], col[3]};
-  byte prevColSec[4] = {colSec[0], colSec[1], colSec[2], colSec[3]};
-  byte prevEffect = effectCurrent;
-  byte prevSpeed = effectSpeed;
-  byte prevIntensity = effectIntensity;
-  byte prevPalette = effectPalette;
 
   //segment select (sets main segment)
   byte prevMain = strip.getMainSegmentId();
@@ -613,9 +607,24 @@ bool handleSet(AsyncWebServerRequest *request, const String& req, bool apply)
   pos = req.indexOf(F("PS=")); //saves current in preset
   if (pos > 0) savePreset(getNumVal(&req, pos));
 
+  pos = req.indexOf(F("P1=")); //sets first preset for cycle
+  if (pos > 0) presetCycleMin = getNumVal(&req, pos);
+
+  pos = req.indexOf(F("P2=")); //sets last preset for cycle
+  if (pos > 0) presetCycleMax = getNumVal(&req, pos);
+
   //apply preset
-  pos = req.indexOf(F("PL="));
-  if (pos > 0) applyPreset(getNumVal(&req, pos));
+  if (updateVal(&req, "PL=", &presetCycCurr, presetCycleMin, presetCycleMax)) {
+    applyPreset(presetCycCurr);
+  }
+
+  //snapshot to check if request changed values later, temporary.
+  byte prevCol[4] = {col[0], col[1], col[2], col[3]};
+  byte prevColSec[4] = {colSec[0], colSec[1], colSec[2], colSec[3]};
+  byte prevEffect = effectCurrent;
+  byte prevSpeed = effectSpeed;
+  byte prevIntensity = effectIntensity;
+  byte prevPalette = effectPalette;
 
   //set brightness
   updateVal(&req, "&A=", &bri);
@@ -910,7 +919,7 @@ bool handleSet(AsyncWebServerRequest *request, const String& req, bool apply)
   strip.applyToAllSelected = false;
 
   pos = req.indexOf(F("&NN")); //do not send UDP notifications this time
-  colorUpdated((pos > 0) ? NOTIFIER_CALL_MODE_NO_NOTIFY : NOTIFIER_CALL_MODE_DIRECT_CHANGE);
+  colorUpdated((pos > 0) ? CALL_MODE_NO_NOTIFY : CALL_MODE_DIRECT_CHANGE);
 
   return true;
 }

wled00/udp.cpp

@@ -13,14 +13,14 @@ void notify(byte callMode, bool followUp)
   if (!udpConnected) return;
   switch (callMode)
   {
-    case NOTIFIER_CALL_MODE_INIT:          return;
-    case NOTIFIER_CALL_MODE_DIRECT_CHANGE: if (!notifyDirect) return; break;
-    case NOTIFIER_CALL_MODE_BUTTON:        if (!notifyButton) return; break;
-    case NOTIFIER_CALL_MODE_NIGHTLIGHT:    if (!notifyDirect) return; break;
-    case NOTIFIER_CALL_MODE_HUE:           if (!notifyHue)    return; break;
-    case NOTIFIER_CALL_MODE_PRESET_CYCLE:  if (!notifyDirect) return; break;
-    case NOTIFIER_CALL_MODE_BLYNK:         if (!notifyDirect) return; break;
-    case NOTIFIER_CALL_MODE_ALEXA:         if (!notifyAlexa)  return; break;
+    case CALL_MODE_INIT:          return;
+    case CALL_MODE_DIRECT_CHANGE: if (!notifyDirect) return; break;
+    case CALL_MODE_BUTTON:        if (!notifyButton) return; break;
+    case CALL_MODE_NIGHTLIGHT:    if (!notifyDirect) return; break;
+    case CALL_MODE_HUE:           if (!notifyHue)    return; break;
+    case CALL_MODE_PRESET_CYCLE:  if (!notifyDirect) return; break;
+    case CALL_MODE_BLYNK:         if (!notifyDirect) return; break;
+    case CALL_MODE_ALEXA:         if (!notifyAlexa)  return; break;
     default: return;
   }
   byte udpOut[WLEDPACKETSIZE];
@@ -296,7 +296,7 @@ void handleNotifications()
     if (nightlightActive) nightlightDelayMins = udpIn[7];
     
     if (receiveNotificationBrightness || !someSel) bri = udpIn[2];
-    colorUpdated(NOTIFIER_CALL_MODE_NOTIFICATION);
+    colorUpdated(CALL_MODE_NOTIFICATION);
     return;
   }
 

wled00/usermods_list.cpp

@@ -74,6 +74,14 @@
 #include "../usermods/EleksTube_IPS/usermod_elekstube_ips.h"
 #endif
 
+#ifdef USERMOD_ROTARY_ENCODER_BRIGHTNESS_COLOR
+#include "../usermods/usermod_rotary_brightness_color/usermod_rotary_brightness_color.h"
+#endif
+
+#ifdef RGB_ROTARY_ENCODER
+#include "../usermods/rgb-rotary-encoder/rgb-rotary-encoder.h"
+#endif
+
 void registerUsermods()
 {
 /*
@@ -143,4 +151,12 @@ void registerUsermods()
   #ifdef USERMOD_ELEKSTUBE_IPS
   usermods.add(new ElekstubeIPSUsermod());
   #endif
+
+  #ifdef USERMOD_ROTARY_ENCODER_BRIGHTNESS_COLOR
+  usermods.add(new RotaryEncoderBrightnessColor());
+  #endif
+
+  #ifdef RGB_ROTARY_ENCODER
+  usermods.add(new RgbRotaryEncoderUsermod());
+  #endif
 }

wled00/wled.cpp

@@ -195,10 +195,17 @@ void WLED::loop()
     strip.isRgbw = false;
     for (uint8_t i = 0; i < WLED_MAX_BUSSES; i++) {
       if (busConfigs[i] == nullptr) break;
-      mem += busses.memUsage(*busConfigs[i]);
-      if (mem <= MAX_LED_MEMORY) busses.add(*busConfigs[i]);
-      //if (BusManager::isRgbw(busConfigs[i]->type)) strip.isRgbw = true;
-      strip.isRgbw = (strip.isRgbw || BusManager::isRgbw(busConfigs[i]->type));
+      
+      if (busConfigs[i]->adjustBounds(ledCount)) {
+        mem += busses.memUsage(*busConfigs[i]);
+        if (mem <= MAX_LED_MEMORY) {
+          busses.add(*busConfigs[i]);
+          //RGBW mode is enabled if at least one of the strips is RGBW
+          strip.isRgbw = (strip.isRgbw || BusManager::isRgbw(busConfigs[i]->type));
+          //refresh is required to remain off if at least one of the strips requires the refresh.
+          strip.isOffRefreshRequred |= BusManager::isOffRefreshRequred(busConfigs[i]->type);
+        }
+      }
       delete busConfigs[i]; busConfigs[i] = nullptr;
     }
     strip.finalizeInit(ledCount);
@@ -284,6 +291,8 @@ void WLED::setup()
   pinManager.allocatePin(2);
 #endif
 
+  for (uint8_t i=1; i<WLED_MAX_BUTTONS; i++) btnPin[i] = -1;
+
   bool fsinit = false;
   DEBUGFS_PRINTLN(F("Mount FS"));
 #ifdef ARDUINO_ARCH_ESP32
@@ -378,14 +387,14 @@ void WLED::beginStrip()
   strip.setShowCallback(handleOverlayDraw);
 
   if (bootPreset > 0) {
-    applyPreset(bootPreset);
+    applyPreset(bootPreset, CALL_MODE_INIT);
   } else if (turnOnAtBoot) {
     if (briS > 0) bri = briS;
     else if (bri == 0) bri = 128;
   } else {
     briLast = briS; bri = 0;
   }
-  colorUpdated(NOTIFIER_CALL_MODE_INIT);
+  colorUpdated(CALL_MODE_INIT);
 
   // init relay pin
   if (rlyPin>=0)
@@ -437,14 +446,60 @@ void WLED::initConnection()
   // Only initialize ethernet board if not NONE
   if (ethernetType != WLED_ETH_NONE && ethernetType < WLED_NUM_ETH_TYPES) {
     ethernet_settings es = ethernetBoards[ethernetType];
-    ETH.begin(
-      (uint8_t) es.eth_address, 
-      (int)     es.eth_power, 
-      (int)     es.eth_mdc, 
-      (int)     es.eth_mdio, 
-      (eth_phy_type_t)   es.eth_type,
-      (eth_clock_mode_t) es.eth_clk_mode
-    );
+    // Use PinManager to ensure pins are available for
+    // ethernet AND to prevent other uses of these pins.
+    bool s = true;
+    byte pinsAllocated[4] { 255, 255, 255, 255 };
+
+    if (s && (s = pinManager.allocatePin((byte)es.eth_power))) {
+      pinsAllocated[0] = (byte)es.eth_power;
+    }
+    if (s && (s = pinManager.allocatePin((byte)es.eth_mdc))) {
+      pinsAllocated[1] = (byte)es.eth_mdc;
+    }
+    if (s && (s = pinManager.allocatePin((byte)es.eth_mdio))) {
+      pinsAllocated[2] = (byte)es.eth_mdio;
+    }
+    switch(es.eth_clk_mode) {
+      case ETH_CLOCK_GPIO0_IN:
+        s = pinManager.allocatePin(0, false);
+        pinsAllocated[3] = 0;
+        break;
+      case ETH_CLOCK_GPIO0_OUT:
+        s = pinManager.allocatePin(0);
+        pinsAllocated[3] = 0;
+        break;
+      case ETH_CLOCK_GPIO16_OUT:
+        s = pinManager.allocatePin(16);
+        pinsAllocated[3] = 16;
+        break;
+      case ETH_CLOCK_GPIO17_OUT:
+        s = pinManager.allocatePin(17);
+        pinsAllocated[3] = 17;
+        break;
+      default:
+        s = false;
+        break;
+    }
+
+    if (s) {
+      s = ETH.begin(
+        (uint8_t) es.eth_address, 
+        (int)     es.eth_power, 
+        (int)     es.eth_mdc, 
+        (int)     es.eth_mdio, 
+        (eth_phy_type_t)   es.eth_type,
+        (eth_clock_mode_t) es.eth_clk_mode
+      );
+    }
+    
+    if (!s) {
+      DEBUG_PRINTLN(F("Ethernet init failed"));
+      // de-allocate only those pins allocated before the failure
+      for (byte p : pinsAllocated) {
+        pinManager.deallocatePin(p);
+      }
+    }
   }
 #endif
 

wled00/wled.h

@@ -3,12 +3,12 @@
 /*
    Main sketch, global variable declarations
    @title WLED project sketch
-   @version 0.13.0-b0
+   @version 0.13.0-b2
    @author Christian Schwinne
  */
 
 // version code in format yymmddb (b = daily build)
-#define VERSION 2106302
+#define VERSION 2107100
 
 //uncomment this if you have a "my_config.h" file you'd like to use
 //#define WLED_USE_MY_CONFIG
@@ -442,6 +442,7 @@ WLED_GLOBAL byte briLast _INIT(128);          // brightness before turned off. U
 WLED_GLOBAL byte whiteLast _INIT(128);        // white channel before turned off. Used for toggle function
 
 // button
+WLED_GLOBAL bool buttonPublishMqtt                            _INIT(false);
 WLED_GLOBAL bool buttonPressedBefore[WLED_MAX_BUTTONS]        _INIT({false});
 WLED_GLOBAL bool buttonLongPressed[WLED_MAX_BUTTONS]          _INIT({false});
 WLED_GLOBAL unsigned long buttonPressedTime[WLED_MAX_BUTTONS] _INIT({0});
@@ -452,7 +453,7 @@ WLED_GLOBAL byte touchThreshold                               _INIT(TOUCH_THRESH
 WLED_GLOBAL bool notifyDirectDefault _INIT(notifyDirect);
 WLED_GLOBAL bool receiveNotifications _INIT(true);
 WLED_GLOBAL unsigned long notificationSentTime _INIT(0);
-WLED_GLOBAL byte notificationSentCallMode _INIT(NOTIFIER_CALL_MODE_INIT);
+WLED_GLOBAL byte notificationSentCallMode _INIT(CALL_MODE_INIT);
 WLED_GLOBAL bool notificationTwoRequired _INIT(false);
 
 // effects
@@ -502,7 +503,10 @@ WLED_GLOBAL bool blynkEnabled _INIT(false);
 
 //playlists
 WLED_GLOBAL unsigned long presetCycledTime _INIT(0);
-WLED_GLOBAL int16_t currentPlaylist _INIT(0);
+WLED_GLOBAL int16_t currentPlaylist _INIT(-1);
+//still used for "PL=~" HTTP API command
+WLED_GLOBAL byte presetCycleMin _INIT(1), presetCycleMax _INIT(5);
+WLED_GLOBAL byte presetCycCurr _INIT(presetCycleMin);
 
 // realtime
 WLED_GLOBAL byte realtimeMode _INIT(REALTIME_MODE_INACTIVE);
@@ -515,7 +519,7 @@ WLED_GLOBAL uint16_t tpmPayloadFrameSize _INIT(0);
 // mqtt
 WLED_GLOBAL unsigned long lastMqttReconnectAttempt _INIT(0);
 WLED_GLOBAL unsigned long lastInterfaceUpdate _INIT(0);
-WLED_GLOBAL byte interfaceUpdateCallMode _INIT(NOTIFIER_CALL_MODE_INIT);
+WLED_GLOBAL byte interfaceUpdateCallMode _INIT(CALL_MODE_INIT);
 WLED_GLOBAL char mqttStatusTopic[40] _INIT("");        // this must be global because of async handlers
 
 // alexa udp

wled00/wled_ethernet.h

@@ -20,8 +20,16 @@ ethernet_settings ethernetBoards[] = {
   // WT32-EHT01
   // Please note, from my testing only these pins work for LED outputs:
   //   IO2, IO4, IO12, IO14, IO15
-  // These pins do not appear to work from my testing:
-  //   IO35, IO36, IO39
+  // Pins IO34 through IO39 are input-only on ESP32, so
+  // the following exposed pins won't work to drive WLEDs
+  //   IO35(*), IO36, IO39
+  // The following pins are also exposed via the headers,
+  // and likely can be used as general purpose IO:
+  //   IO05(*), IO32 (CFG), IO33 (485_EN), IO33 (TXD)
+  //
+  //   (*) silkscreen on board revision v1.2 may be wrong:
+  //       IO5 silkscreen on v1.2 says IO35
+  //       IO35 silkscreen on v1.2 says RXD
   {
     1,                 // eth_address, 
     16,                // eth_power, 

wled00/ws.cpp

@@ -16,7 +16,6 @@ void wsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventTyp
   if(type == WS_EVT_CONNECT){
     //client connected
     sendDataWs(client);
-    //client->ping();
   } else if(type == WS_EVT_DISCONNECT){
     //client disconnected
     if (client->id() == wsLiveClientId) wsLiveClientId = 0;
@@ -24,7 +23,7 @@ void wsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventTyp
     //data packet
     AwsFrameInfo * info = (AwsFrameInfo*)arg;
     if(info->final && info->index == 0 && info->len == len){
-      //the whole message is in a single frame and we got all of it's data (max. 1450byte)
+      //the whole message is in a single frame and we got all of its data (max. 1450byte)
       if(info->opcode == WS_TEXT)
       {
         bool verboseResponse = false;
@@ -34,14 +33,24 @@ void wsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventTyp
           JsonObject root = jsonBuffer.as<JsonObject>();
           if (error || root.isNull()) return;
 
-          if (root.containsKey("lv"))
+          if (root["v"] && root.size() == 1) {
+            //if the received value is just "{"v":true}", send only to this client
+            verboseResponse = true;
+          } else if (root.containsKey("lv"))
           {
             wsLiveClientId = root["lv"] ? client->id() : 0;
+          } else {
+            fileDoc = &jsonBuffer;
+            verboseResponse = deserializeState(root);
+            fileDoc = nullptr;
+            if (!interfaceUpdateCallMode) {
+              //special case, only on playlist load, avoid sending twice in rapid succession
+              if (millis() - lastInterfaceUpdate > 1700) verboseResponse = false;
+            }
           }
-
-          verboseResponse = deserializeState(root);
         }
-        if (verboseResponse || millis() - lastInterfaceUpdate < 1900) sendDataWs(client); //update if it takes longer than 100ms until next "broadcast"
+        //update if it takes longer than 300ms until next "broadcast"
+        if (verboseResponse && (millis() - lastInterfaceUpdate < 1700 || !interfaceUpdateCallMode)) sendDataWs(client);
       }
     } else {
       //message is comprised of multiple frames or the frame is split into multiple packets

wled00/xml.cpp

@@ -441,6 +441,7 @@ void getSettingsJS(byte subPage, char* dest)
     sappends('s',SET_F("MQCID"),mqttClientID);
     sappends('s',SET_F("MD"),mqttDeviceTopic);
     sappends('s',SET_F("MG"),mqttGroupTopic);
+    sappend('c',SET_F("BM"),buttonPublishMqtt);
     #endif
 
     #ifndef WLED_DISABLE_HUESYNC