From 6f3267aee98095bab3381956fa1949f5c09cb2db Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Thu, 22 Aug 2024 17:15:12 +0200
Subject: [PATCH 01/45] Dynamic bus config - provide LED types from BusManager
 for settings Credit: @netmindz for the idea.

---
 wled00/bus_manager.cpp        | 157 +++++++++++++++----------
 wled00/bus_manager.h          | 214 +++++++++++++++++-----------------
 wled00/cfg.cpp                |   7 +-
 wled00/data/settings_leds.htm | 149 ++++++++++++-----------
 wled00/set.cpp                |   4 +-
 wled00/xml.cpp                |   2 +
 6 files changed, 279 insertions(+), 254 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index d0e32b2116..aef6b2ee9b 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -48,38 +48,25 @@ uint8_t realtimeBroadcast(uint8_t type, IPAddress client, uint16_t length, byte
 #define W(c) (byte((c) >> 24))
 
 
-void ColorOrderMap::add(uint16_t start, uint16_t len, uint8_t colorOrder) {
-  if (_count >= WLED_MAX_COLOR_ORDER_MAPPINGS) {
-    return;
-  }
-  if (len == 0) {
-    return;
-  }
-  // upper nibble contains W swap information
-  if ((colorOrder & 0x0F) > COL_ORDER_MAX) {
-    return;
-  }
-  _mappings[_count].start = start;
-  _mappings[_count].len = len;
-  _mappings[_count].colorOrder = colorOrder;
-  _count++;
+bool ColorOrderMap::add(uint16_t start, uint16_t len, uint8_t colorOrder) {
+  if (count() >= WLED_MAX_COLOR_ORDER_MAPPINGS || len == 0 || (colorOrder & 0x0F) > COL_ORDER_MAX) return false; // upper nibble contains W swap information
+  _mappings.push_back({start,len,colorOrder});
+  return true;
 }
 
 uint8_t IRAM_ATTR ColorOrderMap::getPixelColorOrder(uint16_t pix, uint8_t defaultColorOrder) const {
-  if (_count > 0) {
-    // upper nibble contains W swap information
-    // when ColorOrderMap's upper nibble contains value >0 then swap information is used from it, otherwise global swap is used
-    for (unsigned i = 0; i < _count; i++) {
-      if (pix >= _mappings[i].start && pix < (_mappings[i].start + _mappings[i].len)) {
-        return _mappings[i].colorOrder | ((_mappings[i].colorOrder >> 4) ? 0 : (defaultColorOrder & 0xF0));
-      }
+  // upper nibble contains W swap information
+  // when ColorOrderMap's upper nibble contains value >0 then swap information is used from it, otherwise global swap is used
+  for (unsigned i = 0; i < count(); i++) {
+    if (pix >= _mappings[i].start && pix < (_mappings[i].start + _mappings[i].len)) {
+      return _mappings[i].colorOrder | ((_mappings[i].colorOrder >> 4) ? 0 : (defaultColorOrder & 0xF0));
     }
   }
   return defaultColorOrder;
 }
 
 
-uint32_t Bus::autoWhiteCalc(uint32_t c) {
+uint32_t Bus::autoWhiteCalc(uint32_t c) const {
   unsigned aWM = _autoWhiteMode;
   if (_gAWM < AW_GLOBAL_DISABLED) aWM = _gAWM;
   if (aWM == RGBW_MODE_MANUAL_ONLY) return c;
@@ -95,7 +82,7 @@ uint32_t Bus::autoWhiteCalc(uint32_t c) {
   return RGBW32(r, g, b, w);
 }
 
-uint8_t *Bus::allocData(size_t size) {
+uint8_t *Bus::allocateData(size_t size) {
   if (_data) free(_data); // should not happen, but for safety
   return _data = (uint8_t *)(size>0 ? calloc(size, sizeof(uint8_t)) : nullptr);
 }
@@ -123,7 +110,7 @@ BusDigital::BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com)
   }
   _iType = PolyBus::getI(bc.type, _pins, nr);
   if (_iType == I_NONE) return;
-  if (bc.doubleBuffer && !allocData(bc.count * Bus::getNumberOfChannels(bc.type))) return;
+  if (bc.doubleBuffer && !allocateData(bc.count * Bus::getNumberOfChannels(bc.type))) return;
   //_buffering = bc.doubleBuffer;
   uint16_t lenToCreate = bc.count;
   if (bc.type == TYPE_WS2812_1CH_X3) lenToCreate = NUM_ICS_WS2812_1CH_3X(bc.count); // only needs a third of "RGB" LEDs for NeoPixelBus
@@ -150,7 +137,7 @@ BusDigital::BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com)
 //I am NOT to be held liable for burned down garages or houses!
 
 // To disable brightness limiter we either set output max current to 0 or single LED current to 0
-uint8_t BusDigital::estimateCurrentAndLimitBri() {
+uint8_t BusDigital::estimateCurrentAndLimitBri(void) {
   bool useWackyWS2815PowerModel = false;
   byte actualMilliampsPerLed = _milliAmpsPerLed;
 
@@ -202,7 +189,7 @@ uint8_t BusDigital::estimateCurrentAndLimitBri() {
   return newBri;
 }
 
-void BusDigital::show() {
+void BusDigital::show(void) {
   _milliAmpsTotal = 0;
   if (!_valid) return;
 
@@ -263,7 +250,7 @@ void BusDigital::show() {
   if (newBri < _bri) PolyBus::setBrightness(_busPtr, _iType, _bri);
 }
 
-bool BusDigital::canShow() {
+bool BusDigital::canShow(void) const {
   if (!_valid) return true;
   return PolyBus::canShow(_busPtr, _iType);
 }
@@ -319,7 +306,7 @@ void IRAM_ATTR BusDigital::setPixelColor(uint16_t pix, uint32_t c) {
 }
 
 // returns original color if global buffering is enabled, else returns lossly restored color from bus
-uint32_t IRAM_ATTR BusDigital::getPixelColor(uint16_t pix) {
+uint32_t IRAM_ATTR BusDigital::getPixelColor(uint16_t pix) const {
   if (!_valid) return 0;
   if (_data) {
     size_t offset = pix * getNumberOfChannels();
@@ -349,9 +336,9 @@ uint32_t IRAM_ATTR BusDigital::getPixelColor(uint16_t pix) {
   }
 }
 
-uint8_t BusDigital::getPins(uint8_t* pinArray) {
+uint8_t BusDigital::getPins(uint8_t* pinArray) const {
   unsigned numPins = IS_2PIN(_type) ? 2 : 1;
-  for (unsigned i = 0; i < numPins; i++) pinArray[i] = _pins[i];
+  if (pinArray) for (unsigned i = 0; i < numPins; i++) pinArray[i] = _pins[i];
   return numPins;
 }
 
@@ -361,12 +348,12 @@ void BusDigital::setColorOrder(uint8_t colorOrder) {
   _colorOrder = colorOrder;
 }
 
-void BusDigital::reinit() {
+void BusDigital::reinit(void) {
   if (!_valid) return;
   PolyBus::begin(_busPtr, _iType, _pins);
 }
 
-void BusDigital::cleanup() {
+void BusDigital::cleanup(void) {
   DEBUG_PRINTLN(F("Digital Cleanup."));
   PolyBus::cleanup(_busPtr, _iType);
   _iType = I_NONE;
@@ -477,7 +464,7 @@ void BusPwm::setPixelColor(uint16_t pix, uint32_t c) {
 }
 
 //does no index check
-uint32_t BusPwm::getPixelColor(uint16_t pix) {
+uint32_t BusPwm::getPixelColor(uint16_t pix) const {
   if (!_valid) return 0;
   // TODO getting the reverse from CCT is involved (a quick approximation when CCT blending is ste to 0 implemented)
   switch (_type) {
@@ -528,7 +515,7 @@ static const uint16_t cieLUT[256] = {
 };
 #endif
 
-void BusPwm::show() {
+void BusPwm::show(void) {
   if (!_valid) return;
   unsigned numPins = NUM_PWM_PINS(_type);
   unsigned maxBri = (1<<_depth) - 1;
@@ -548,16 +535,14 @@ void BusPwm::show() {
   }
 }
 
-uint8_t BusPwm::getPins(uint8_t* pinArray) {
+uint8_t BusPwm::getPins(uint8_t* pinArray) const {
   if (!_valid) return 0;
   unsigned numPins = NUM_PWM_PINS(_type);
-  for (unsigned i = 0; i < numPins; i++) {
-    pinArray[i] = _pins[i];
-  }
+  if (pinArray) for (unsigned i = 0; i < numPins; i++) pinArray[i] = _pins[i];
   return numPins;
 }
 
-void BusPwm::deallocatePins() {
+void BusPwm::deallocatePins(void) {
   unsigned numPins = NUM_PWM_PINS(_type);
   for (unsigned i = 0; i < numPins; i++) {
     pinManager.deallocatePin(_pins[i], PinOwner::BusPwm);
@@ -601,19 +586,19 @@ void BusOnOff::setPixelColor(uint16_t pix, uint32_t c) {
   _data[0] = bool(r|g|b|w) && bool(_bri) ? 0xFF : 0;
 }
 
-uint32_t BusOnOff::getPixelColor(uint16_t pix) {
+uint32_t BusOnOff::getPixelColor(uint16_t pix) const {
   if (!_valid) return 0;
   return RGBW32(_data[0], _data[0], _data[0], _data[0]);
 }
 
-void BusOnOff::show() {
+void BusOnOff::show(void) {
   if (!_valid) return;
   digitalWrite(_pin, _reversed ? !(bool)_data[0] : (bool)_data[0]);
 }
 
-uint8_t BusOnOff::getPins(uint8_t* pinArray) {
+uint8_t BusOnOff::getPins(uint8_t* pinArray) const {
   if (!_valid) return 0;
-  pinArray[0] = _pin;
+  if (pinArray) pinArray[0] = _pin;
   return 1;
 }
 
@@ -642,7 +627,7 @@ BusNetwork::BusNetwork(BusConfig &bc)
   }
   _UDPchannels = _rgbw ? 4 : 3;
   _client = IPAddress(bc.pins[0],bc.pins[1],bc.pins[2],bc.pins[3]);
-  _valid = (allocData(_len * _UDPchannels) != nullptr);
+  _valid = (allocateData(_len * _UDPchannels) != nullptr);
   DEBUG_PRINTF_P(PSTR("%successfully inited virtual strip with type %u and IP %u.%u.%u.%u\n"), _valid?"S":"Uns", bc.type, bc.pins[0], bc.pins[1], bc.pins[2], bc.pins[3]);
 }
 
@@ -657,27 +642,25 @@ void BusNetwork::setPixelColor(uint16_t pix, uint32_t c) {
   if (_rgbw) _data[offset+3] = W(c);
 }
 
-uint32_t BusNetwork::getPixelColor(uint16_t pix) {
+uint32_t BusNetwork::getPixelColor(uint16_t pix) const {
   if (!_valid || pix >= _len) return 0;
   unsigned offset = pix * _UDPchannels;
   return RGBW32(_data[offset], _data[offset+1], _data[offset+2], (_rgbw ? _data[offset+3] : 0));
 }
 
-void BusNetwork::show() {
+void BusNetwork::show(void) {
   if (!_valid || !canShow()) return;
   _broadcastLock = true;
   realtimeBroadcast(_UDPtype, _client, _len, _data, _bri, _rgbw);
   _broadcastLock = false;
 }
 
-uint8_t BusNetwork::getPins(uint8_t* pinArray) {
-  for (unsigned i = 0; i < 4; i++) {
-    pinArray[i] = _client[i];
-  }
+uint8_t BusNetwork::getPins(uint8_t* pinArray) const {
+  if (pinArray) for (unsigned i = 0; i < 4; i++) pinArray[i] = _client[i];
   return 4;
 }
 
-void BusNetwork::cleanup() {
+void BusNetwork::cleanup(void) {
   _type = I_NONE;
   _valid = false;
   freeData();
@@ -724,13 +707,67 @@ int BusManager::add(BusConfig &bc) {
   return numBusses++;
 }
 
+// idea by @netmindz https://github.com/Aircoookie/WLED/pull/4056
+String BusManager::getLEDTypesJSONString(void) {
+  struct LEDType {
+    uint8_t id;
+    const char *type;
+    const char *name;
+  } types[] = {
+    {TYPE_WS2812_RGB,      "D",      PSTR("WS281x")},
+    {TYPE_SK6812_RGBW,     "D",      PSTR("SK6812/WS2814 RGBW")},
+    {TYPE_TM1814,          "D",      PSTR("TM1814")},
+    {TYPE_WS2811_400KHZ,   "D",      PSTR("400kHz")},
+    {TYPE_TM1829,          "D",      PSTR("TM1829")},
+    {TYPE_UCS8903,         "D",      PSTR("UCS8903")},
+    {TYPE_APA106,          "D",      PSTR("APA106/PL9823")},
+    {TYPE_TM1914,          "D",      PSTR("TM1914")},
+    {TYPE_FW1906,          "D",      PSTR("FW1906 GRBCW")},
+    {TYPE_UCS8904,         "D",      PSTR("UCS8904 RGBW")},
+    {TYPE_WS2805,          "D",      PSTR("WS2805 RGBCW")},
+    {TYPE_SM16825,         "D",      PSTR("SM16825 RGBCW")},
+    {TYPE_WS2812_1CH_X3,   "D",      PSTR("WS2811 White")},
+    //{TYPE_WS2812_2CH_X3,   "D",      PSTR("WS2811 CCT")},
+    //{TYPE_WS2812_WWA,      "D",      PSTR("WS2811 WWA")},
+    {TYPE_WS2801,          "2P",     PSTR("WS2801")},
+    {TYPE_APA102,          "2P",     PSTR("APA102")},
+    {TYPE_LPD8806,         "2P",     PSTR("LPD8806")},
+    {TYPE_LPD6803,         "2P",     PSTR("LPD6803")},
+    {TYPE_P9813,           "2P",     PSTR("PP9813")},
+    {TYPE_ONOFF,           "",       PSTR("On/Off")},
+    {TYPE_ANALOG_1CH,      "A",      PSTR("PWM White")},
+    {TYPE_ANALOG_2CH,      "AA",     PSTR("PWM CCT")},
+    {TYPE_ANALOG_3CH,      "AAA",    PSTR("PWM RGB")},
+    {TYPE_ANALOG_4CH,      "AAAA",   PSTR("PWM RGBW")},
+    {TYPE_ANALOG_5CH,      "AAAAA",  PSTR("PWM RGB+CCT")},
+    //{TYPE_ANALOG_6CH,      "AAAAAA", PSTR("PWM RGB+DCCT")},
+    {TYPE_NET_DDP_RGB,     "V",      PSTR("DDP RGB (network)")},
+    {TYPE_NET_ARTNET_RGB,  "V",      PSTR("Art-Net RGB (network)")},
+    {TYPE_NET_DDP_RGBW,    "V",      PSTR("DDP RGBW (network)")},
+    {TYPE_NET_ARTNET_RGBW, "V",      PSTR("Art-Net RGBW (network)")}
+  };
+  String json = "[";
+  for (const auto &type : types) {
+    String id = String(type.id);
+    json += "{i:" + id
+      + F(",w:") + String((int)Bus::hasWhite(type.id))
+      + F(",c:") + String((int)Bus::hasCCT(type.id))
+      + F(",s:") + String((int)Bus::is16bit(type.id))
+      + F(",t:\"") + FPSTR(type.type)
+      + F("\",n:\"") + FPSTR(type.name) + F("\"},");
+  }
+  json.setCharAt(json.length()-1, ']'); // replace last comma with bracket
+  return json;
+}
+
+
 void BusManager::useParallelOutput(void) {
   _parallelOutputs = 8; // hardcoded since we use NPB I2S x8 methods
   PolyBus::setParallelI2S1Output();
 }
 
 //do not call this method from system context (network callback)
-void BusManager::removeAll() {
+void BusManager::removeAll(void) {
   DEBUG_PRINTLN(F("Removing all."));
   //prevents crashes due to deleting busses while in use.
   while (!canAllShow()) yield();
@@ -744,7 +781,7 @@ void BusManager::removeAll() {
 // #2478
 // If enabled, RMT idle level is set to HIGH when off
 // to prevent leakage current when using an N-channel MOSFET to toggle LED power
-void BusManager::esp32RMTInvertIdle() {
+void BusManager::esp32RMTInvertIdle(void) {
   bool idle_out;
   unsigned rmt = 0;
   for (unsigned u = 0; u < numBusses(); u++) {
@@ -775,7 +812,7 @@ void BusManager::esp32RMTInvertIdle() {
 }
 #endif
 
-void BusManager::on() {
+void BusManager::on(void) {
   #ifdef ESP8266
   //Fix for turning off onboard LED breaking bus
   if (pinManager.getPinOwner(LED_BUILTIN) == PinOwner::BusDigital) {
@@ -796,7 +833,7 @@ void BusManager::on() {
   #endif
 }
 
-void BusManager::off() {
+void BusManager::off(void) {
   #ifdef ESP8266
   // turn off built-in LED if strip is turned off
   // this will break digital bus so will need to be re-initialised on On
@@ -811,7 +848,7 @@ void BusManager::off() {
   #endif
 }
 
-void BusManager::show() {
+void BusManager::show(void) {
   _milliAmpsUsed = 0;
   for (unsigned i = 0; i < numBusses; i++) {
     busses[i]->show();
@@ -852,13 +889,13 @@ void BusManager::setSegmentCCT(int16_t cct, bool allowWBCorrection) {
 uint32_t BusManager::getPixelColor(uint16_t pix) {
   for (unsigned i = 0; i < numBusses; i++) {
     unsigned bstart = busses[i]->getStart();
-    if (pix < bstart || pix >= bstart + busses[i]->getLength()) continue;
+    if (!busses[i]->containsPixel(pix)) continue;
     return busses[i]->getPixelColor(pix - bstart);
   }
   return 0;
 }
 
-bool BusManager::canAllShow() {
+bool BusManager::canAllShow(void) {
   for (unsigned i = 0; i < numBusses; i++) {
     if (!busses[i]->canShow()) return false;
   }
@@ -871,7 +908,7 @@ Bus* BusManager::getBus(uint8_t busNr) {
 }
 
 //semi-duplicate of strip.getLengthTotal() (though that just returns strip._length, calculated in finalizeInit())
-uint16_t BusManager::getTotalLength() {
+uint16_t BusManager::getTotalLength(void) {
   unsigned len = 0;
   for (unsigned i=0; i<numBusses; i++) len += busses[i]->getLength();
   return len;
diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index 5e516d2e16..8d23f11272 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -6,6 +6,8 @@
  */
 
 #include "const.h"
+#include <array>
+#include <vector>
 
 //colors.cpp
 uint16_t approximateKelvinFromRGB(uint32_t rgb);
@@ -73,34 +75,31 @@ struct BusConfig {
 
 
 // Defines an LED Strip and its color ordering.
-struct ColorOrderMapEntry {
+typedef struct {
   uint16_t start;
   uint16_t len;
   uint8_t colorOrder;
-};
+} ColorOrderMapEntry;
 
 struct ColorOrderMap {
-    void add(uint16_t start, uint16_t len, uint8_t colorOrder);
+    bool add(uint16_t start, uint16_t len, uint8_t colorOrder);
 
-    uint8_t count() const { return _count; }
+    inline uint8_t count() const { return _mappings.size(); }
 
     void reset() {
-      _count = 0;
-      memset(_mappings, 0, sizeof(_mappings));
+      _mappings.clear();
+      _mappings.shrink_to_fit();
     }
 
     const ColorOrderMapEntry* get(uint8_t n) const {
-      if (n > _count) {
-        return nullptr;
-      }
+      if (n >= count()) return nullptr;
       return &(_mappings[n]);
     }
 
     uint8_t getPixelColorOrder(uint16_t pix, uint8_t defaultColorOrder) const;
 
   private:
-    uint8_t _count;
-    ColorOrderMapEntry _mappings[WLED_MAX_COLOR_ORDER_MAPPINGS];
+    std::vector<ColorOrderMapEntry> _mappings;
 };
 
 
@@ -122,59 +121,61 @@ class Bus {
 
     virtual ~Bus() {} //throw the bus under the bus
 
-    virtual void     show() = 0;
-    virtual bool     canShow()                   { return true; }
-    virtual void     setStatusPixel(uint32_t c)  {}
+    virtual void     show(void) = 0;
+    virtual bool     canShow(void) const                          { return true; }
+    virtual void     setStatusPixel(uint32_t c)                   {}
     virtual void     setPixelColor(uint16_t pix, uint32_t c) = 0;
-    virtual uint32_t getPixelColor(uint16_t pix) { return 0; }
-    virtual void     setBrightness(uint8_t b)    { _bri = b; };
-    virtual uint8_t  getPins(uint8_t* pinArray)  { return 0; }
-    virtual uint16_t getLength()                 { return isOk() ? _len : 0; }
-    virtual void     setColorOrder(uint8_t co)   {}
-    virtual uint8_t  getColorOrder()             { return COL_ORDER_RGB; }
-    virtual uint8_t  skippedLeds()               { return 0; }
-    virtual uint16_t getFrequency()              { return 0U; }
-    virtual uint16_t getLEDCurrent()             { return 0; }
-    virtual uint16_t getUsedCurrent()            { return 0; }
-    virtual uint16_t getMaxCurrent()             { return 0; }
-    virtual uint8_t  getNumberOfChannels()       { return hasWhite(_type) + 3*hasRGB(_type) + hasCCT(_type); }
-    static inline uint8_t getNumberOfChannels(uint8_t type) { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
-    inline  void     setReversed(bool reversed)  { _reversed = reversed; }
-    inline  uint16_t getStart()                  { return _start; }
-    inline  void     setStart(uint16_t start)    { _start = start; }
-    inline  uint8_t  getType()                   { return _type; }
-    inline  bool     isOk()                      { return _valid; }
-    inline  bool     isReversed()                { return _reversed; }
-    inline  bool     isOffRefreshRequired()      { return _needsRefresh; }
-            bool     containsPixel(uint16_t pix) { return pix >= _start && pix < _start+_len; }
-
-    virtual bool hasRGB(void) { return Bus::hasRGB(_type); }
-    static  bool hasRGB(uint8_t type) {
-      if ((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) || type == TYPE_ANALOG_1CH || type == TYPE_ANALOG_2CH || type == TYPE_ONOFF) return false;
-      return true;
+    virtual void     setBrightness(uint8_t b)                     { _bri = b; };
+    inline  void     setStart(uint16_t start)                     { _start = start; }
+    virtual void     setColorOrder(uint8_t co)                    {}
+    virtual bool     hasRGB(void) const                           { return Bus::hasRGB(_type); }
+    virtual bool     hasWhite(void) const                         { return Bus::hasWhite(_type); }
+    virtual bool     hasCCT(void) const                           { return Bus::hasCCT(_type); }
+    virtual bool     is16bit(void) const                          { return Bus::is16bit(_type); }
+    virtual uint32_t getPixelColor(uint16_t pix) const            { return 0; }
+    virtual uint8_t  getPins(uint8_t* pinArray = nullptr) const   { return 0; }
+    virtual uint16_t getLength(void) const                        { return isOk() ? _len : 0; }
+    virtual uint8_t  getColorOrder(void) const                    { return COL_ORDER_RGB; }
+    virtual uint8_t  skippedLeds(void) const                      { return 0; }
+    virtual uint16_t getFrequency(void) const                     { return 0U; }
+    virtual uint16_t getLEDCurrent(void) const                    { return 0; }
+    virtual uint16_t getUsedCurrent(void) const                   { return 0; }
+    virtual uint16_t getMaxCurrent(void) const                    { return 0; }
+    virtual uint8_t  getNumberOfChannels(void) const              { return hasWhite(_type) + 3*hasRGB(_type) + hasCCT(_type); }
+
+    inline  void     setReversed(bool reversed)                   { _reversed = reversed; }
+    inline  void     setAutoWhiteMode(uint8_t m)                  { if (m < 5) _autoWhiteMode = m; }
+    inline  uint8_t  getAutoWhiteMode(void) const                 { return _autoWhiteMode; }
+    inline  uint16_t getStart(void) const                         { return _start; }
+    inline  uint8_t  getType(void) const                          { return _type; }
+    inline  bool     isOk(void) const                             { return _valid; }
+    inline  bool     isReversed(void) const                       { return _reversed; }
+    inline  bool     isOffRefreshRequired(void) const             { return _needsRefresh; }
+    inline  bool     containsPixel(uint16_t pix) const            { return pix >= _start && pix < _start + _len; }
+
+    static inline uint8_t getNumberOfChannels(uint8_t type)       { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
+    static constexpr bool hasRGB(uint8_t type) {
+      return !((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) || type == TYPE_ANALOG_1CH || type == TYPE_ANALOG_2CH || type == TYPE_ONOFF);
     }
-    virtual bool hasWhite(void) { return Bus::hasWhite(_type); }
-    static  bool hasWhite(uint8_t type) {
-      if ((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) ||
-          type == TYPE_SK6812_RGBW || type == TYPE_TM1814 || type == TYPE_UCS8904 ||
-          type == TYPE_FW1906 || type == TYPE_WS2805 || type == TYPE_SM16825) return true; // digital types with white channel
-      if (type > TYPE_ONOFF && type <= TYPE_ANALOG_5CH && type != TYPE_ANALOG_3CH) return true; // analog types with white channel
-      if (type == TYPE_NET_DDP_RGBW || type == TYPE_NET_ARTNET_RGBW) return true; // network types with white channel
-      return false;
+    static constexpr bool hasWhite(uint8_t type) {
+      return  (type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) ||
+              type == TYPE_SK6812_RGBW || type == TYPE_TM1814 || type == TYPE_UCS8904 ||
+              type == TYPE_FW1906 || type == TYPE_WS2805 || type == TYPE_SM16825 ||        // digital types with white channel
+              (type > TYPE_ONOFF && type <= TYPE_ANALOG_5CH && type != TYPE_ANALOG_3CH) || // analog types with white channel
+              type == TYPE_NET_DDP_RGBW || type == TYPE_NET_ARTNET_RGBW;                   // network types with white channel
     }
-    virtual bool hasCCT(void) { return Bus::hasCCT(_type); }
-    static  bool hasCCT(uint8_t type) {
-      if (type == TYPE_WS2812_2CH_X3 || type == TYPE_WS2812_WWA ||
-          type == TYPE_ANALOG_2CH    || type == TYPE_ANALOG_5CH ||
-          type == TYPE_FW1906        || type == TYPE_WS2805     ||
-          type == TYPE_SM16825) return true;
-      return false;
+    static constexpr bool hasCCT(uint8_t type) {
+      return  type == TYPE_WS2812_2CH_X3 || type == TYPE_WS2812_WWA ||
+              type == TYPE_ANALOG_2CH    || type == TYPE_ANALOG_5CH ||
+              type == TYPE_FW1906        || type == TYPE_WS2805     ||
+              type == TYPE_SM16825;
     }
-    static inline int16_t getCCT() { return _cct; }
-    static void setCCT(int16_t cct) {
-      _cct = cct;
-    }
-    static inline uint8_t getCCTBlend() { return _cctBlend; }
+    static constexpr bool is16bit(uint8_t type)      { return type == TYPE_UCS8903 || type == TYPE_UCS8904 || type == TYPE_SM16825; }
+    static inline int16_t getCCT(void)               { return _cct; }
+    static inline void    setGlobalAWMode(uint8_t m) { if (m < 5) _gAWM = m; else _gAWM = AW_GLOBAL_DISABLED; }
+    static inline uint8_t getGlobalAWMode(void)      { return _gAWM; }
+    static void setCCT(int16_t cct)                  { _cct = cct; }
+    static inline uint8_t getCCTBlend(void)          { return _cctBlend; }
     static void setCCTBlend(uint8_t b) {
       if (b > 100) b = 100;
       _cctBlend = (b * 127) / 100;
@@ -203,10 +204,6 @@ class Bus {
       ww = (w * ww) / 255; //brightness scaling
       cw = (w * cw) / 255;
     }
-    inline        void    setAutoWhiteMode(uint8_t m) { if (m < 5) _autoWhiteMode = m; }
-    inline        uint8_t getAutoWhiteMode()          { return _autoWhiteMode; }
-    inline static void    setGlobalAWMode(uint8_t m)  { if (m < 5) _gAWM = m; else _gAWM = AW_GLOBAL_DISABLED; }
-    inline static uint8_t getGlobalAWMode()           { return _gAWM; }
 
   protected:
     uint8_t  _type;
@@ -231,8 +228,8 @@ class Bus {
     //  127 - additive CCT blending (CCT 127 => 100% warm, 100% cold)
     static uint8_t _cctBlend;
 
-    uint32_t autoWhiteCalc(uint32_t c);
-    uint8_t *allocData(size_t size = 1);
+    uint32_t autoWhiteCalc(uint32_t c) const;
+    uint8_t *allocateData(size_t size = 1);
     void     freeData() { if (_data != nullptr) free(_data); _data = nullptr; }
 };
 
@@ -242,23 +239,22 @@ class BusDigital : public Bus {
     BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com);
     ~BusDigital() { cleanup(); }
 
-    void show() override;
-    bool canShow() override;
+    void show(void) override;
+    bool canShow(void) const override;
     void setBrightness(uint8_t b) override;
     void setStatusPixel(uint32_t c) override;
     void setPixelColor(uint16_t pix, uint32_t c) override;
     void setColorOrder(uint8_t colorOrder) override;
-    uint32_t getPixelColor(uint16_t pix) override;
-    uint8_t  getColorOrder() override  { return _colorOrder; }
-    uint8_t  getPins(uint8_t* pinArray) override;
-    uint8_t  skippedLeds() override    { return _skip; }
-    uint16_t getFrequency() override   { return _frequencykHz; }
-    uint8_t  estimateCurrentAndLimitBri();
-    uint16_t getLEDCurrent() override  { return _milliAmpsPerLed; }
-    uint16_t getUsedCurrent() override { return _milliAmpsTotal; }
-    uint16_t getMaxCurrent() override  { return _milliAmpsMax; }
-    void reinit();
-    void cleanup();
+    uint32_t getPixelColor(uint16_t pix) const override;
+    uint8_t  getColorOrder(void) const override  { return _colorOrder; }
+    uint8_t  getPins(uint8_t* pinArray) const override;
+    uint8_t  skippedLeds(void) const override    { return _skip; }
+    uint16_t getFrequency(void) const override   { return _frequencykHz; }
+    uint16_t getLEDCurrent(void) const override  { return _milliAmpsPerLed; }
+    uint16_t getUsedCurrent(void) const override { return _milliAmpsTotal; }
+    uint16_t getMaxCurrent(void) const override  { return _milliAmpsMax; }
+    void reinit(void);
+    void cleanup(void);
 
   private:
     uint8_t _skip;
@@ -273,7 +269,7 @@ class BusDigital : public Bus {
 
     static uint16_t _milliAmpsTotal; // is overwitten/recalculated on each show()
 
-    inline uint32_t restoreColorLossy(uint32_t c, uint8_t restoreBri) {
+    inline uint32_t restoreColorLossy(uint32_t c, uint8_t restoreBri) const {
       if (restoreBri < 255) {
         uint8_t* chan = (uint8_t*) &c;
         for (uint_fast8_t i=0; i<4; i++) {
@@ -283,6 +279,8 @@ class BusDigital : public Bus {
       }
       return c;
     }
+
+    uint8_t  estimateCurrentAndLimitBri(void);
 };
 
 
@@ -292,11 +290,11 @@ class BusPwm : public Bus {
     ~BusPwm() { cleanup(); }
 
     void setPixelColor(uint16_t pix, uint32_t c) override;
-    uint32_t getPixelColor(uint16_t pix) override; //does no index check
-    uint8_t  getPins(uint8_t* pinArray) override;
-    uint16_t getFrequency() override { return _frequency; }
-    void show() override;
-    void cleanup() { deallocatePins(); }
+    uint32_t getPixelColor(uint16_t pix) const override; //does no index check
+    uint8_t  getPins(uint8_t* pinArray) const override;
+    uint16_t getFrequency(void) const override { return _frequency; }
+    void show(void) override;
+    void cleanup(void) { deallocatePins(); }
 
   private:
     uint8_t _pins[5];
@@ -307,7 +305,7 @@ class BusPwm : public Bus {
     uint8_t _depth;
     uint16_t _frequency;
 
-    void deallocatePins();
+    void deallocatePins(void);
 };
 
 
@@ -317,10 +315,10 @@ class BusOnOff : public Bus {
     ~BusOnOff() { cleanup(); }
 
     void setPixelColor(uint16_t pix, uint32_t c) override;
-    uint32_t getPixelColor(uint16_t pix) override;
-    uint8_t  getPins(uint8_t* pinArray) override;
-    void show() override;
-    void cleanup() { pinManager.deallocatePin(_pin, PinOwner::BusOnOff); }
+    uint32_t getPixelColor(uint16_t pix) const override;
+    uint8_t  getPins(uint8_t* pinArray) const override;
+    void show(void) override;
+    void cleanup(void) { pinManager.deallocatePin(_pin, PinOwner::BusOnOff); }
 
   private:
     uint8_t _pin;
@@ -333,14 +331,14 @@ class BusNetwork : public Bus {
     BusNetwork(BusConfig &bc);
     ~BusNetwork() { cleanup(); }
 
-    bool hasRGB() override   { return true; }
-    bool hasWhite() override { return _rgbw; }
-    bool canShow() override  { return !_broadcastLock; } // this should be a return value from UDP routine if it is still sending data out
+    bool hasRGB(void) const override   { return true; }
+    bool hasWhite(void) const override { return _rgbw; }
+    bool canShow(void) const override  { return !_broadcastLock; } // this should be a return value from UDP routine if it is still sending data out
     void setPixelColor(uint16_t pix, uint32_t c) override;
-    uint32_t getPixelColor(uint16_t pix) override;
-    uint8_t  getPins(uint8_t* pinArray) override;
-    void show() override;
-    void cleanup();
+    uint32_t getPixelColor(uint16_t pix) const override;
+    uint8_t  getPins(uint8_t* pinArray) const override;
+    void show(void) override;
+    void cleanup(void);
 
   private:
     IPAddress _client;
@@ -365,31 +363,31 @@ class BusManager {
     static void useParallelOutput(void); // workaround for inaccessible PolyBus
 
     //do not call this method from system context (network callback)
-    static void removeAll();
+    static void removeAll(void);
 
     static void on(void);
     static void off(void);
 
-    static void show();
-    static bool canAllShow();
+    static void show(void);
+    static bool canAllShow(void);
     static void setStatusPixel(uint32_t c);
     static void setPixelColor(uint16_t pix, uint32_t c);
     static void setBrightness(uint8_t b);
     // for setSegmentCCT(), cct can only be in [-1,255] range; allowWBCorrection will convert it to K
     // WARNING: setSegmentCCT() is a misleading name!!! much better would be setGlobalCCT() or just setCCT()
     static void setSegmentCCT(int16_t cct, bool allowWBCorrection = false);
-    static void setMilliampsMax(uint16_t max) { _milliAmpsMax = max;}
+    static inline void setMilliampsMax(uint16_t max) { _milliAmpsMax = max;}
     static uint32_t getPixelColor(uint16_t pix);
-    static inline int16_t getSegmentCCT() { return Bus::getCCT(); }
+    static inline int16_t getSegmentCCT(void) { return Bus::getCCT(); }
 
     static Bus* getBus(uint8_t busNr);
 
     //semi-duplicate of strip.getLengthTotal() (though that just returns strip._length, calculated in finalizeInit())
-    static uint16_t getTotalLength();
-    static uint8_t getNumBusses() { return numBusses; }
+    static uint16_t getTotalLength(void);
+    static inline uint8_t getNumBusses(void) { return numBusses; }
+    static String getLEDTypesJSONString(void);
 
-    static void                 updateColorOrderMap(const ColorOrderMap &com) { memcpy(&colorOrderMap, &com, sizeof(ColorOrderMap)); }
-    static const ColorOrderMap& getColorOrderMap() { return colorOrderMap; }
+    static inline ColorOrderMap& getColorOrderMap(void) { return colorOrderMap; }
 
   private:
     static uint8_t numBusses;
@@ -400,9 +398,9 @@ class BusManager {
     static uint8_t _parallelOutputs;
 
     #ifdef ESP32_DATA_IDLE_HIGH
-    static void    esp32RMTInvertIdle();
+    static void    esp32RMTInvertIdle(void);
     #endif
-    static uint8_t getNumVirtualBusses() {
+    static uint8_t getNumVirtualBusses(void) {
       int j = 0;
       for (int i=0; i<numBusses; i++) if (busses[i]->getType() >= TYPE_NET_DDP_RGB && busses[i]->getType() < 96) j++;
       return j;
diff --git a/wled00/cfg.cpp b/wled00/cfg.cpp
index 89076efab6..76ff4d20eb 100644
--- a/wled00/cfg.cpp
+++ b/wled00/cfg.cpp
@@ -244,17 +244,12 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   // read color order map configuration
   JsonArray hw_com = hw[F("com")];
   if (!hw_com.isNull()) {
-    ColorOrderMap com = {};
-    unsigned s = 0;
     for (JsonObject entry : hw_com) {
-      if (s > WLED_MAX_COLOR_ORDER_MAPPINGS) break;
       uint16_t start = entry["start"] | 0;
       uint16_t len = entry["len"] | 0;
       uint8_t colorOrder = (int)entry[F("order")];
-      com.add(start, len, colorOrder);
-      s++;
+      if (!BusManager::getColorOrderMap().add(start, len, colorOrder)) break;
     }
-    BusManager::updateColorOrderMap(com);
   }
 
   // read multiple button configuration
diff --git a/wled00/data/settings_leds.htm b/wled00/data/settings_leds.htm
index b7d2d18a7d..54c16b9d96 100644
--- a/wled00/data/settings_leds.htm
+++ b/wled00/data/settings_leds.htm
@@ -7,6 +7,7 @@
 	<script>
 		var d=document,laprev=55,maxB=1,maxD=1,maxA=1,maxV=0,maxM=4000,maxPB=4096,maxL=1333,maxCO=10,maxLbquot=0; //maximum bytes for LED allocation: 4kB for 8266, 32kB for 32
 		var oMaxB=1;
+		d.ledTypes = []; // filled from GetV()
 		d.um_p = [];
 		d.rsvd = [];
 		d.ro_gpio = [];
@@ -18,14 +19,15 @@
 		function gId(n){return d.getElementById(n);}
 		function off(n){d.getElementsByName(n)[0].value = -1;}
 		// these functions correspond to C macros found in const.h
-		function isPWM(t) { return t > 40 && t < 46; }                      // is PWM type
-		function isAna(t) { return t == 40 || isPWM(t); }                   // is analog type
-		function isDig(t) { return (t > 15 && t < 40) || isD2P(t); }        // is digital type
-		function isD2P(t) { return t > 47 && t < 64; }                      // is digital 2 pin type
-		function is16b(t) { return t == 26 || t == 29 || t == 34; }         // is digital 16 bit type
-		function isVir(t) { return t >= 80 && t < 96; }                     // is virtual type
-		function hasW(t)  { return (t >= 18 && t <= 21) || (t >= 28 && t <= 32) || t == 34 || (t >= 44 && t <= 45) || (t >= 88 && t <= 89); }
-		function hasCCT(t) { return t == 20 || t == 21 || t == 42 || t == 45 || t == 28 || t == 32 || t == 34; }
+		function gT(t)     { for (let type of d.ledTypes) if (t == type.i) return type; } // getType from available ledTypes
+		function isPWM(t)  { return gT(t).t.charAt(0) === "A"; }    // is PWM type
+		function isAna(t)  { return gT(t).t === "" || isPWM(t); }   // is analog type
+		function isDig(t)  { return gT(t).t === "D" || isD2P(t); }  // is digital type
+		function isD2P(t)  { return gT(t).t === "2P"; }             // is digital 2 pin type
+		function isVir(t)  { return gT(t).t === "V"; }              // is virtual type
+		function hasW(t)   { return gT(t).w == 1; }                 // has white channel
+		function hasCCT(t) { return gT(t).c == 1; }                 // is white CCT enabled
+		function is16b(t)  { return gT(t).s == 1; }                 // is digital 16 bit type
 		// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
 		function loadJS(FILE_URL, async = true) {
 			let scE = d.createElement("script");
@@ -224,6 +226,35 @@
 			let sLC = 0, sPC = 0, sDI = 0, maxLC = 0;
 			const ablEN = d.Sf.ABL.checked;
 			maxB = oMaxB; // TODO make sure we start with all possible buses
+			let setPinConfig = (n,t) => {
+				let p0d = "GPIO:";
+				let p1d = "";
+				switch (gT(t).t.charAt(0)) {
+					case '2':
+						p1d = "Clk "+p0d;
+					case 'D':
+						p0d = "Data "+p0d;
+						break;
+					case 'A':
+						if (gT(t).t.length > 1) p0d = "GPIOs:";
+						break;
+					case 'V':
+						p0d = "IP address:";
+						break;
+				}
+				gId("p0d"+n).innerHTML = p0d;
+				gId("p1d"+n).innerHTML = p1d;
+				// secondary pins show/hide (type string length is equivalent to number of pins used; except for virtual and on/off)
+				let pins = gT(t).t.length + 3*isVir(t); // fixes virtual pins to 4
+				if (pins == 0) pins = 1;                  // fixes on/off pin
+				for (let p=1; p<5; p++) {
+					var LK = d.Sf["L"+p+n];
+					if (!LK) continue;
+					LK.style.display = (p < pins) ? "inline" : "none";
+					LK.required = (p < pins);
+					if (p >= pins) LK.value="";
+				}
+			}
 
 			// enable/disable LED fields
 			let LTs = d.Sf.querySelectorAll("#mLC select[name^=LT]");
@@ -232,49 +263,29 @@
 				// is the field a LED type?
 				var n = s.name.substring(2);
 				var t = parseInt(s.value);
-				gId("p0d"+n).innerHTML = isVir(t) ? "IP address:" : isD2P(t) ? "Data GPIO:" : (t > 41) ? "GPIOs:" : "GPIO:";
-				gId("p1d"+n).innerHTML = isD2P(t) ? "Clk GPIO:" : "";
-				gId("abl"+n).style.display = (!ablEN || isVir(t) || isAna(t)) ? "none" : "inline";
-				//var LK = d.getElementsByName("L1"+n)[0]; // clock pin
-
 				memu += getMem(t, n); // calc memory
-
-				// enumerate pins
-				for (p=1; p<5; p++) {
-					var LK = d.Sf["L"+p+n]; // secondary pins
-					if (!LK) continue;
-					if ((isVir(t) && p<4) || (isD2P(t) && p==1) || (isPWM(t) && (p+40 < t))) // TYPE_xxxx values from const.h
-					{
-						// display pin field
-						LK.style.display = "inline";
-						LK.required = true;
-					} else {
-						// hide pin field
-						LK.style.display = "none";
-						LK.required = false;
-						LK.value="";
-					}
-				}
+				setPinConfig(n,t);
+				gId("abl"+n).style.display = (!ablEN || isVir(t) || isAna(t)) ? "none" : "inline";
 				if (change) {
-					gId("rf"+n).checked = (gId("rf"+n).checked || t == 31); // LEDs require data in off state
-					if (isAna(t)) d.Sf["LC"+n].value = 1; // for sanity change analog count just to 1 LED
+					gId("rf"+n).checked = (gId("rf"+n).checked || t == 31); // LEDs require data in off state (mandatory for TM1814)
+					if (isAna(t)) d.Sf["LC"+n].value = 1;                   // for sanity change analog count just to 1 LED
 					d.Sf["LA"+n].min = (isVir(t) || isAna(t)) ? 0 : 1;
 					d.Sf["MA"+n].min = (isVir(t) || isAna(t)) ? 0 : 250;
 				}
-				gId("rf"+n).onclick = (t == 31) ? (()=>{return false}) : (()=>{});  // prevent change for TM1814
-				gRGBW |= hasW(t); // RGBW checkbox, TYPE_xxxx values from const.h
-				gId("co"+n).style.display = (isVir(t) || isAna(t)) ? "none":"inline";  // hide color order for PWM
-				gId("dig"+n+"w").style.display = (isDig(t) && hasW(t)) ? "inline":"none"; // show swap channels dropdown
-				gId("dig"+n+"w").querySelector("[data-opt=CCT]").disabled = !hasCCT(t);   // disable WW/CW swapping	
-				if (!(isDig(t) && hasW(t))) d.Sf["WO"+n].value = 0; // reset swapping
-				gId("dig"+n+"c").style.display = (isAna(t)) ? "none":"inline";  // hide count for analog
-				gId("dig"+n+"r").style.display = (isVir(t)) ? "none":"inline";  // hide reversed for virtual
+				gId("rf"+n).onclick = (t == 31) ? (()=>{return false}) : (()=>{});          // prevent change for TM1814
+				gRGBW |= hasW(t);                                                           // RGBW checkbox
+				gId("co"+n).style.display = (isVir(t) || isAna(t)) ? "none":"inline";       // hide color order for PWM
+				gId("dig"+n+"w").style.display = (isDig(t) && hasW(t)) ? "inline":"none";   // show swap channels dropdown
+				gId("dig"+n+"w").querySelector("[data-opt=CCT]").disabled = !hasCCT(t);     // disable WW/CW swapping	
+				if (!(isDig(t) && hasW(t))) d.Sf["WO"+n].value = 0;                         // reset swapping
+				gId("dig"+n+"c").style.display = (isAna(t)) ? "none":"inline";              // hide count for analog
+				gId("dig"+n+"r").style.display = (isVir(t)) ? "none":"inline";              // hide reversed for virtual
 				gId("dig"+n+"s").style.display = (isVir(t) || isAna(t)) ? "none":"inline";  // hide skip 1st for virtual & analog
-				gId("dig"+n+"f").style.display = (isDig(t)) ? "inline":"none";  // hide refresh
-				gId("dig"+n+"a").style.display = (hasW(t)) ? "inline":"none";   // auto calculate white
+				gId("dig"+n+"f").style.display = (isDig(t)) ? "inline":"none";              // hide refresh
+				gId("dig"+n+"a").style.display = (hasW(t)) ? "inline":"none";               // auto calculate white
 				gId("dig"+n+"l").style.display = (isD2P(t) || isPWM(t)) ? "inline":"none";  // bus clock speed / PWM speed (relative) (not On/Off)
-				gId("rev"+n).innerHTML = isAna(t) ? "Inverted output":"Reversed (rotated 180°)";  // change reverse text for analog
-				//gId("psd"+n).innerHTML = isAna(t) ? "Index:":"Start:";    // change analog start description
+				gId("rev"+n).innerHTML = isAna(t) ? "Inverted output":"Reversed";           // change reverse text for analog else (rotated 180°)
+				//gId("psd"+n).innerHTML = isAna(t) ? "Index:":"Start:";                      // change analog start description
 			});
 			// display global white channel overrides
 			gId("wc").style.display = (gRGBW) ? 'inline':'none';
@@ -408,38 +419,7 @@
 				var cn = `<div class="iST">
 <hr class="sml">
 ${i+1}:
-<select name="LT${s}" onchange="UI(true)">${i>=maxB && false ? '' :
-'<option value="22" data-type="D">WS281x</option>\
-<option value="30" data-type="D">SK6812/WS2814 RGBW</option>\
-<option value="31" data-type="D">TM1814</option>\
-<option value="24" data-type="D">400kHz</option>\
-<option value="25" data-type="D">TM1829</option>\
-<option value="26" data-type="D">UCS8903</option>\
-<option value="27" data-type="D">APA106/PL9823</option>\
-<option value="33" data-type="D">TM1914</option>\
-<option value="28" data-type="D">FW1906 GRBCW</option>\
-<option value="29" data-type="D">UCS8904 RGBW</option>\
-<option value="32" data-type="D">WS2805 RGBCW</option>\
-<option value="34" data-type="D">SM16825 RGBCW</option>\
-<option value="50" data-type="2P">WS2801</option>\
-<option value="51" data-type="2P">APA102</option>\
-<option value="52" data-type="2P">LPD8806</option>\
-<option value="54" data-type="2P">LPD6803</option>\
-<option value="53" data-type="2P">P9813</option>\
-<option value="19" data-type="D">WS2811 White</option>\
-<option value="40">On/Off</option>\
-<option value="41" data-type="A">PWM White</option>\
-<option value="42" data-type="AA">PWM CCT</option>\
-<option value="43" data-type="AAA">PWM RGB</option>\
-<option value="44" data-type="AAAA">PWM RGBW</option>\
-<option value="45" data-type="AAAAA">PWM RGB+CCT</option>\
-<!--option value="46" data-type="AAAAAA">PWM RGB+DCCT</option-->'}
-<option value="80" data-type="V">DDP RGB (network)</option>
-<!--option value="81" data-type="V">E1.31 RGB (network)</option-->
-<option value="82" data-type="V">Art-Net RGB (network)</option>
-<option value="88" data-type="V">DDP RGBW (network)</option>
-<option value="89" data-type="V">Art-Net RGBW (network)</option>
-</select><br>
+<select name="LT${s}" onchange="UI(true)"></select><br>
 <div id="abl${s}">
 mA/LED: <select name="LAsel${s}" onchange="enLA(this,'${s}');UI();">
 <option value="55" selected>55mA (typ. 5V WS281x)</option>
@@ -478,6 +458,21 @@
 <div id="dig${s}a" style="display:inline"><br>Auto-calculate white channel from RGB:<br><select name="AW${s}"><option value=0>None</option><option value=1>Brighter</option><option value=2>Accurate</option><option value=3>Dual</option><option value=4>Max</option></select>&nbsp;</div>
 </div>`;
 				f.insertAdjacentHTML("beforeend", cn);
+				// fill led types (credit @netmindz)
+				d.Sf.querySelectorAll("#mLC select[name^=LT]").forEach((sel,n)=>{
+					if (sel.length == 0) { // ignore already updated
+						for (let type of d.ledTypes) {
+							let opt = d.createElement("option");
+							opt.value = type.i;
+							opt.text = type.n;
+							if (type.t != undefined && type.t != "") {
+								opt.setAttribute('data-type', type.t);
+							}
+							sel.appendChild(opt);			
+						}
+					}
+				});
+				// disable inappropriate LED types
 				let sel = d.getElementsByName("LT"+s)[0]
 				if (i >= maxB || digitalB >= maxD) disable(sel,'option[data-type="D"]');
 				if (i >= maxB || twopinB >= 1)     disable(sel,'option[data-type="2P"]');
@@ -810,7 +805,7 @@ <h2>LED &amp; Hardware setup</h2>
 			Use per-output limiter: <input type="checkbox" name="PPL" onchange="UI()"><br>
 			<div id="ppldis" style="display:none;">
 				<i>Make sure you enter correct values in each LED output.<br>
-				If using multiple outputs with only one PSU, distribute its power proportionally amongst ouputs.</i><br>
+				If using multiple outputs with only one PSU, distribute its power proportionally amongst outputs.</i><br>
 			</div>
 			<div id="ampwarning" class="warn" style="display: none;">
 				&#9888; Your power supply provides high current.<br>
diff --git a/wled00/set.cpp b/wled00/set.cpp
index 2811d70885..d295d36ee1 100644
--- a/wled00/set.cpp
+++ b/wled00/set.cpp
@@ -215,7 +215,6 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
     }
     //doInitBusses = busesChanged; // we will do that below to ensure all input data is processed
 
-    ColorOrderMap com = {};
     for (int s = 0; s < WLED_MAX_COLOR_ORDER_MAPPINGS; s++) {
       int offset = s < 10 ? 48 : 55;
       char xs[4] = "XS"; xs[2] = offset+s; xs[3] = 0; //start LED
@@ -227,10 +226,9 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
         length = request->arg(xc).toInt();
         colorOrder = request->arg(xo).toInt() & 0x0F;
         colorOrder |= (request->arg(xw).toInt() & 0x0F) << 4; // add W swap information
-        com.add(start, length, colorOrder);
+        if (!BusManager::getColorOrderMap().add(start, length, colorOrder)) break;
       }
     }
-    BusManager::updateColorOrderMap(com);
 
     // update other pins
     #ifndef WLED_DISABLE_INFRARED
diff --git a/wled00/xml.cpp b/wled00/xml.cpp
index 25c0c6298d..df14752498 100644
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -349,6 +349,8 @@ void getSettingsJS(byte subPage, char* dest)
 
     appendGPIOinfo();
 
+    oappend(SET_F("d.ledTypes=")); oappend(BusManager::getLEDTypesJSONString().c_str()); oappend(";");
+
     // set limits
     oappend(SET_F("bLimits("));
     oappend(itoa(WLED_MAX_BUSSES,nS,10));  oappend(",");

From dbb47d506ce59c4b88bdcff6693e17e092587172 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sat, 24 Aug 2024 11:35:32 +0200
Subject: [PATCH 02/45] Bus manager rework - move macros to constexpr methods -
 introduce type capabilities for UI - add phase shifting (POC) to PWM -
 replace PWM CIE LUT with calculated curve CIE & phase shifting credit
 @dedehai

---
 wled00/FX_fcn.cpp             |   4 +-
 wled00/bus_manager.cpp        | 100 ++++++++++++++-------
 wled00/bus_manager.h          | 164 +++++++++++++++++++---------------
 wled00/bus_wrapper.h          |   4 +-
 wled00/cfg.cpp                |   6 +-
 wled00/const.h                |  12 +++
 wled00/data/settings_leds.htm |  28 +++---
 wled00/set.cpp                |   6 +-
 wled00/wled.cpp               |   4 +-
 wled00/xml.cpp                |   6 +-
 10 files changed, 205 insertions(+), 129 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index bc5c8b0519..a06d4f843b 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -1249,12 +1249,12 @@ void WS2812FX::finalizeInit(void) {
     //RGBW mode is enabled if at least one of the strips is RGBW
     _hasWhiteChannel |= bus->hasWhite();
     //refresh is required to remain off if at least one of the strips requires the refresh.
-    _isOffRefreshRequired |= bus->isOffRefreshRequired();
+    _isOffRefreshRequired |= bus->isOffRefreshRequired() && !bus->isPWM(); // use refresh bit for phase shift with analog
     unsigned busEnd = bus->getStart() + bus->getLength();
     if (busEnd > _length) _length = busEnd;
     #ifdef ESP8266
     // why do we need to reinitialise GPIO3???
-    //if ((!IS_DIGITAL(bus->getType()) || IS_2PIN(bus->getType()))) continue;
+    //if (!bus->isDigital() || bus->is2Pin()) continue;
     //uint8_t pins[5];
     //if (!bus->getPins(pins)) continue;
     //BusDigital* bd = static_cast<BusDigital*>(bus);
diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index aef6b2ee9b..854de8fb71 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -4,6 +4,9 @@
 
 #include <Arduino.h>
 #include <IPAddress.h>
+#ifdef ARDUINO_ARCH_ESP32
+#include "driver/ledc.h"
+#endif
 #include "const.h"
 #include "pin_manager.h"
 #include "bus_wrapper.h"
@@ -96,11 +99,11 @@ BusDigital::BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com)
 , _milliAmpsMax(bc.milliAmpsMax)
 , _colorOrderMap(com)
 {
-  if (!IS_DIGITAL(bc.type) || !bc.count) return;
+  if (!isDigital(bc.type) || !bc.count) return;
   if (!pinManager.allocatePin(bc.pins[0], true, PinOwner::BusDigital)) return;
   _frequencykHz = 0U;
   _pins[0] = bc.pins[0];
-  if (IS_2PIN(bc.type)) {
+  if (is2Pin(bc.type)) {
     if (!pinManager.allocatePin(bc.pins[1], true, PinOwner::BusDigital)) {
       cleanup();
       return;
@@ -110,13 +113,16 @@ BusDigital::BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com)
   }
   _iType = PolyBus::getI(bc.type, _pins, nr);
   if (_iType == I_NONE) return;
+  _hasRgb = hasRGB(bc.type);
+  _hasWhite = hasWhite(bc.type);
+  _hasCCT = hasCCT(bc.type);
   if (bc.doubleBuffer && !allocateData(bc.count * Bus::getNumberOfChannels(bc.type))) return;
   //_buffering = bc.doubleBuffer;
   uint16_t lenToCreate = bc.count;
   if (bc.type == TYPE_WS2812_1CH_X3) lenToCreate = NUM_ICS_WS2812_1CH_3X(bc.count); // only needs a third of "RGB" LEDs for NeoPixelBus
   _busPtr = PolyBus::create(_iType, _pins, lenToCreate + _skip, nr, _frequencykHz);
   _valid = (_busPtr != nullptr);
-  DEBUG_PRINTF_P(PSTR("%successfully inited strip %u (len %u) with type %u and pins %u,%u (itype %u). mA=%d/%d\n"), _valid?"S":"Uns", nr, bc.count, bc.type, _pins[0], IS_2PIN(bc.type)?_pins[1]:255, _iType, _milliAmpsPerLed, _milliAmpsMax);
+  DEBUG_PRINTF_P(PSTR("%successfully inited strip %u (len %u) with type %u and pins %u,%u (itype %u). mA=%d/%d\n"), _valid?"S":"Uns", nr, bc.count, bc.type, _pins[0], is2Pin(bc.type)?_pins[1]:255, _iType, _milliAmpsPerLed, _milliAmpsMax);
 }
 
 //fine tune power estimation constants for your setup
@@ -337,7 +343,7 @@ uint32_t IRAM_ATTR BusDigital::getPixelColor(uint16_t pix) const {
 }
 
 uint8_t BusDigital::getPins(uint8_t* pinArray) const {
-  unsigned numPins = IS_2PIN(_type) ? 2 : 1;
+  unsigned numPins = is2Pin(_type) + 1;
   if (pinArray) for (unsigned i = 0; i < numPins; i++) pinArray[i] = _pins[i];
   return numPins;
 }
@@ -391,10 +397,10 @@ void BusDigital::cleanup(void) {
 #endif
 
 BusPwm::BusPwm(BusConfig &bc)
-: Bus(bc.type, bc.start, bc.autoWhite, 1, bc.reversed)
+: Bus(bc.type, bc.start, bc.autoWhite, 1, bc.reversed, bc.refreshReq) // hijack Off refresh flag to indicate usage of phase shifting
 {
-  if (!IS_PWM(bc.type)) return;
-  unsigned numPins = NUM_PWM_PINS(bc.type);
+  if (!isPWM(bc.type)) return;
+  unsigned numPins = numPWMPins(bc.type);
   _frequency = bc.frequency ? bc.frequency : WLED_PWM_FREQ;
   // duty cycle resolution (_depth) can be extracted from this formula: CLOCK_FREQUENCY > _frequency * 2^_depth
   for (_depth = MAX_BIT_WIDTH; _depth > 8; _depth--) if (((CLOCK_FREQUENCY/_frequency) >> _depth) > 0) break;
@@ -422,6 +428,9 @@ BusPwm::BusPwm(BusConfig &bc)
     ledcAttachPin(_pins[i], _ledcStart + i);
     #endif
   }
+  _hasRgb = hasRGB(bc.type);
+  _hasWhite = hasWhite(bc.type);
+  _hasCCT = hasCCT(bc.type);
   _data = _pwmdata; // avoid malloc() and use stack
   _valid = true;
   DEBUG_PRINTF_P(PSTR("%successfully inited PWM strip with type %u, frequency %u, bit depth %u and pins %u,%u,%u,%u,%u\n"), _valid?"S":"Uns", bc.type, _frequency, _depth, _pins[0], _pins[1], _pins[2], _pins[3], _pins[4]);
@@ -484,6 +493,7 @@ uint32_t BusPwm::getPixelColor(uint16_t pix) const {
   return RGBW32(_data[0], _data[0], _data[0], _data[0]);
 }
 
+/*
 #ifndef ESP8266
 static const uint16_t cieLUT[256] = {
 	0, 2, 4, 5, 7, 9, 11, 13, 15, 16, 
@@ -514,11 +524,13 @@ static const uint16_t cieLUT[256] = {
 	3890, 3930, 3971, 4012, 4053, 4095
 };
 #endif
+*/
 
 void BusPwm::show(void) {
   if (!_valid) return;
-  unsigned numPins = NUM_PWM_PINS(_type);
+  unsigned numPins = getPins();
   unsigned maxBri = (1<<_depth) - 1;
+/*
   #ifdef ESP8266
   unsigned pwmBri = (unsigned)(roundf(powf((float)_bri / 255.0f, 1.7f) * (float)maxBri)); // using gamma 1.7 to extrapolate PWM duty cycle
   #else
@@ -533,17 +545,43 @@ void BusPwm::show(void) {
     ledcWrite(_ledcStart + i, scaled);
     #endif
   }
+*/
+  // use CIE brightness formula (credit @dedehai)
+  unsigned pwmBri = (unsigned)_bri * 100;  
+  if (pwmBri < 2040) pwmBri = ((pwmBri << _depth) + 115043U) / 230087U; //adding '0.5' before division for correct rounding
+  else {
+    pwmBri += 4080;
+    float temp = (float)pwmBri / 29580.0f;
+    temp = temp * temp * temp * (1<<_depth) - 1;
+    pwmBri = (unsigned)temp;
+  }
+  // determine phase shift POC (credit @dedehai)
+  [[maybe_unused]] uint32_t phaseOffset = maxBri / numPins;
+  for (unsigned i = 0; i < numPins; i++) {
+    unsigned scaled = (_data[i] * pwmBri) / 255;
+    if (_reversed) scaled = maxBri - scaled;
+    #ifdef ESP8266
+    analogWrite(_pins[i], scaled);
+    #else
+    if (_needsRefresh) { // hacked to determine if phase shifted PWM is requested
+      uint8_t group = ((_ledcStart + i) / 8), channel = ((_ledcStart + i) % 8); // _ledcStart + i is always less than MAX_LED_CHANNELS/LEDC_CHANNELS
+      ledc_set_duty_with_hpoint((ledc_mode_t)group, (ledc_channel_t)channel, scaled, phaseOffset*i);
+      ledc_update_duty((ledc_mode_t)group, (ledc_channel_t)channel);
+    } else
+      ledcWrite(_ledcStart + i, scaled);
+    #endif
+  }
 }
 
 uint8_t BusPwm::getPins(uint8_t* pinArray) const {
   if (!_valid) return 0;
-  unsigned numPins = NUM_PWM_PINS(_type);
+  unsigned numPins = numPWMPins(_type);
   if (pinArray) for (unsigned i = 0; i < numPins; i++) pinArray[i] = _pins[i];
   return numPins;
 }
 
 void BusPwm::deallocatePins(void) {
-  unsigned numPins = NUM_PWM_PINS(_type);
+  unsigned numPins = getPins();
   for (unsigned i = 0; i < numPins; i++) {
     pinManager.deallocatePin(_pins[i], PinOwner::BusPwm);
     if (!pinManager.isPinOk(_pins[i])) continue;
@@ -571,6 +609,9 @@ BusOnOff::BusOnOff(BusConfig &bc)
   }
   _pin = currentPin; //store only after allocatePin() succeeds
   pinMode(_pin, OUTPUT);
+  _hasRgb = false;
+  _hasWhite = false;
+  _hasCCT = false;
   _data = &_onoffdata; // avoid malloc() and use stack
   _valid = true;
   DEBUG_PRINTF_P(PSTR("%successfully inited On/Off strip with pin %u\n"), _valid?"S":"Uns", _pin);
@@ -609,23 +650,22 @@ BusNetwork::BusNetwork(BusConfig &bc)
 {
   switch (bc.type) {
     case TYPE_NET_ARTNET_RGB:
-      _rgbw = false;
       _UDPtype = 2;
       break;
     case TYPE_NET_ARTNET_RGBW:
-      _rgbw = true;
       _UDPtype = 2;
       break;
     case TYPE_NET_E131_RGB:
-      _rgbw = false;
       _UDPtype = 1;
       break;
     default: // TYPE_NET_DDP_RGB / TYPE_NET_DDP_RGBW
-      _rgbw = bc.type == TYPE_NET_DDP_RGBW;
       _UDPtype = 0;
       break;
   }
-  _UDPchannels = _rgbw ? 4 : 3;
+  _hasRgb = hasRGB(bc.type);
+  _hasWhite = hasWhite(bc.type);
+  _hasCCT = false;
+  _UDPchannels = _hasWhite + 3;
   _client = IPAddress(bc.pins[0],bc.pins[1],bc.pins[2],bc.pins[3]);
   _valid = (allocateData(_len * _UDPchannels) != nullptr);
   DEBUG_PRINTF_P(PSTR("%successfully inited virtual strip with type %u and IP %u.%u.%u.%u\n"), _valid?"S":"Uns", bc.type, bc.pins[0], bc.pins[1], bc.pins[2], bc.pins[3]);
@@ -633,25 +673,25 @@ BusNetwork::BusNetwork(BusConfig &bc)
 
 void BusNetwork::setPixelColor(uint16_t pix, uint32_t c) {
   if (!_valid || pix >= _len) return;
-  if (_rgbw) c = autoWhiteCalc(c);
+  if (_hasWhite) c = autoWhiteCalc(c);
   if (Bus::_cct >= 1900) c = colorBalanceFromKelvin(Bus::_cct, c); //color correction from CCT
   unsigned offset = pix * _UDPchannels;
   _data[offset]   = R(c);
   _data[offset+1] = G(c);
   _data[offset+2] = B(c);
-  if (_rgbw) _data[offset+3] = W(c);
+  if (_hasWhite) _data[offset+3] = W(c);
 }
 
 uint32_t BusNetwork::getPixelColor(uint16_t pix) const {
   if (!_valid || pix >= _len) return 0;
   unsigned offset = pix * _UDPchannels;
-  return RGBW32(_data[offset], _data[offset+1], _data[offset+2], (_rgbw ? _data[offset+3] : 0));
+  return RGBW32(_data[offset], _data[offset+1], _data[offset+2], (hasWhite() ? _data[offset+3] : 0));
 }
 
 void BusNetwork::show(void) {
   if (!_valid || !canShow()) return;
   _broadcastLock = true;
-  realtimeBroadcast(_UDPtype, _client, _len, _data, _bri, _rgbw);
+  realtimeBroadcast(_UDPtype, _client, _len, _data, _bri, hasWhite());
   _broadcastLock = false;
 }
 
@@ -669,13 +709,13 @@ void BusNetwork::cleanup(void) {
 
 //utility to get the approx. memory usage of a given BusConfig
 uint32_t BusManager::memUsage(BusConfig &bc) {
-  if (bc.type == TYPE_ONOFF || IS_PWM(bc.type)) return 5;
+  if (Bus::isOnOff(bc.type) || Bus::isPWM(bc.type)) return 5;
 
   unsigned len = bc.count + bc.skipAmount;
   unsigned channels = Bus::getNumberOfChannels(bc.type);
   unsigned multiplier = 1;
-  if (IS_DIGITAL(bc.type)) { // digital types
-    if (IS_16BIT(bc.type)) len *= 2; // 16-bit LEDs
+  if (Bus::isDigital(bc.type)) { // digital types
+    if (Bus::is16bit(bc.type)) len *= 2; // 16-bit LEDs
     #ifdef ESP8266
       if (bc.pins[0] == 3) { //8266 DMA uses 5x the mem
         multiplier = 5;
@@ -695,11 +735,11 @@ uint32_t BusManager::memUsage(unsigned maxChannels, unsigned maxCount, unsigned
 
 int BusManager::add(BusConfig &bc) {
   if (getNumBusses() - getNumVirtualBusses() >= WLED_MAX_BUSSES) return -1;
-  if (IS_VIRTUAL(bc.type)) {
+  if (Bus::isVirtual(bc.type)) {
     busses[numBusses] = new BusNetwork(bc);
-  } else if (IS_DIGITAL(bc.type)) {
+  } else if (Bus::isDigital(bc.type)) {
     busses[numBusses] = new BusDigital(bc, numBusses, colorOrderMap);
-  } else if (bc.type == TYPE_ONOFF) {
+  } else if (Bus::isOnOff(bc.type)) {
     busses[numBusses] = new BusOnOff(bc);
   } else {
     busses[numBusses] = new BusPwm(bc);
@@ -749,10 +789,10 @@ String BusManager::getLEDTypesJSONString(void) {
   String json = "[";
   for (const auto &type : types) {
     String id = String(type.id);
+    // capabilities follows similar pattern as JSON API 
+    int capabilities = Bus::hasRGB(type.id) | Bus::hasWhite(type.id)<<1 | Bus::hasCCT(type.id)<<2 | Bus::is16bit(type.id)<<4;
     json += "{i:" + id
-      + F(",w:") + String((int)Bus::hasWhite(type.id))
-      + F(",c:") + String((int)Bus::hasCCT(type.id))
-      + F(",s:") + String((int)Bus::is16bit(type.id))
+      + F(",c:") + String(capabilities)
       + F(",t:\"") + FPSTR(type.type)
       + F("\",n:\"") + FPSTR(type.name) + F("\"},");
   }
@@ -799,7 +839,7 @@ void BusManager::esp32RMTInvertIdle(void) {
       if (u >= _parallelOutputs + 8) return; // only 8 RMT channels
       rmt = u - _parallelOutputs;
     #endif
-    if (busses[u]->getLength()==0 || !IS_DIGITAL(busses[u]->getType()) || IS_2PIN(busses[u]->getType())) continue;
+    if (busses[u]->getLength()==0 || !Bus::isDigital(busses[u]->getType()) || IS_2PIN(busses[u]->getType())) continue;
     //assumes that bus number to rmt channel mapping stays 1:1
     rmt_channel_t ch = static_cast<rmt_channel_t>(rmt);
     rmt_idle_level_t lvl;
@@ -818,7 +858,7 @@ void BusManager::on(void) {
   if (pinManager.getPinOwner(LED_BUILTIN) == PinOwner::BusDigital) {
     for (unsigned i = 0; i < numBusses; i++) {
       uint8_t pins[2] = {255,255};
-      if (IS_DIGITAL(busses[i]->getType()) && busses[i]->getPins(pins)) {
+      if (Bus::isDigital(busses[i]->getType()) && busses[i]->getPins(pins)) {
         if (pins[0] == LED_BUILTIN || pins[1] == LED_BUILTIN) {
           BusDigital *bus = static_cast<BusDigital*>(busses[i]);
           bus->reinit();
diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index 8d23f11272..df96e59440 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -23,56 +23,7 @@ uint16_t approximateKelvinFromRGB(uint32_t rgb);
 #define IC_INDEX_WS2812_2CH_3X(i)  ((i)*2/3)
 #define WS2812_2CH_3X_SPANS_2_ICS(i) ((i)&0x01)    // every other LED zone is on two different ICs
 
-//temporary struct for passing bus configuration to bus
-struct BusConfig {
-  uint8_t type;
-  uint16_t count;
-  uint16_t start;
-  uint8_t colorOrder;
-  bool reversed;
-  uint8_t skipAmount;
-  bool refreshReq;
-  uint8_t autoWhite;
-  uint8_t pins[5] = {255, 255, 255, 255, 255};
-  uint16_t frequency;
-  bool doubleBuffer;
-  uint8_t milliAmpsPerLed;
-  uint16_t milliAmpsMax;
-
-  BusConfig(uint8_t busType, uint8_t* ppins, uint16_t pstart, uint16_t len = 1, uint8_t pcolorOrder = COL_ORDER_GRB, bool rev = false, uint8_t skip = 0, byte aw=RGBW_MODE_MANUAL_ONLY, uint16_t clock_kHz=0U, bool dblBfr=false, uint8_t maPerLed=LED_MILLIAMPS_DEFAULT, uint16_t maMax=ABL_MILLIAMPS_DEFAULT)
-  : count(len)
-  , start(pstart)
-  , colorOrder(pcolorOrder)
-  , reversed(rev)
-  , skipAmount(skip)
-  , autoWhite(aw)
-  , frequency(clock_kHz)
-  , doubleBuffer(dblBfr)
-  , milliAmpsPerLed(maPerLed)
-  , milliAmpsMax(maMax)
-  {
-    refreshReq = (bool) GET_BIT(busType,7);
-    type = busType & 0x7F;  // bit 7 may be/is hacked to include refresh info (1=refresh in off state, 0=no refresh)
-    size_t nPins = 1;
-    if (IS_VIRTUAL(type))   nPins = 4; //virtual network bus. 4 "pins" store IP address
-    else if (IS_2PIN(type)) nPins = 2;
-    else if (IS_PWM(type))  nPins = NUM_PWM_PINS(type);
-    for (size_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;
-  }
-};
-
+struct BusConfig; // forward declaration
 
 // Defines an LED Strip and its color ordering.
 typedef struct {
@@ -126,12 +77,7 @@ class Bus {
     virtual void     setStatusPixel(uint32_t c)                   {}
     virtual void     setPixelColor(uint16_t pix, uint32_t c) = 0;
     virtual void     setBrightness(uint8_t b)                     { _bri = b; };
-    inline  void     setStart(uint16_t start)                     { _start = start; }
     virtual void     setColorOrder(uint8_t co)                    {}
-    virtual bool     hasRGB(void) const                           { return Bus::hasRGB(_type); }
-    virtual bool     hasWhite(void) const                         { return Bus::hasWhite(_type); }
-    virtual bool     hasCCT(void) const                           { return Bus::hasCCT(_type); }
-    virtual bool     is16bit(void) const                          { return Bus::is16bit(_type); }
     virtual uint32_t getPixelColor(uint16_t pix) const            { return 0; }
     virtual uint8_t  getPins(uint8_t* pinArray = nullptr) const   { return 0; }
     virtual uint16_t getLength(void) const                        { return isOk() ? _len : 0; }
@@ -141,11 +87,21 @@ class Bus {
     virtual uint16_t getLEDCurrent(void) const                    { return 0; }
     virtual uint16_t getUsedCurrent(void) const                   { return 0; }
     virtual uint16_t getMaxCurrent(void) const                    { return 0; }
-    virtual uint8_t  getNumberOfChannels(void) const              { return hasWhite(_type) + 3*hasRGB(_type) + hasCCT(_type); }
 
+    inline  bool     hasRGB(void) const                           { return _hasRgb; }
+    inline  bool     hasWhite(void) const                         { return _hasWhite; }
+    inline  bool     hasCCT(void) const                           { return _hasCCT; }
+    inline  bool     isDigital(void) const                        { return isDigital(_type); }
+    inline  bool     is2Pin(void) const                           { return is2Pin(_type); }
+    inline  bool     isOnOff(void) const                          { return isOnOff(_type); }
+    inline  bool     isPWM(void) const                            { return isPWM(_type); }
+    inline  bool     isVirtual(void) const                        { return isVirtual(_type); }
+    inline  bool     is16bit(void) const                          { return is16bit(_type); }
     inline  void     setReversed(bool reversed)                   { _reversed = reversed; }
+    inline  void     setStart(uint16_t start)                     { _start = start; }
     inline  void     setAutoWhiteMode(uint8_t m)                  { if (m < 5) _autoWhiteMode = m; }
     inline  uint8_t  getAutoWhiteMode(void) const                 { return _autoWhiteMode; }
+    inline  uint8_t  getNumberOfChannels(void) const              { return hasWhite() + 3*hasRGB() + hasCCT(); }
     inline  uint16_t getStart(void) const                         { return _start; }
     inline  uint8_t  getType(void) const                          { return _type; }
     inline  bool     isOk(void) const                             { return _valid; }
@@ -153,7 +109,7 @@ class Bus {
     inline  bool     isOffRefreshRequired(void) const             { return _needsRefresh; }
     inline  bool     containsPixel(uint16_t pix) const            { return pix >= _start && pix < _start + _len; }
 
-    static inline uint8_t getNumberOfChannels(uint8_t type)       { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
+    static constexpr uint8_t getNumberOfChannels(uint8_t type)    { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
     static constexpr bool hasRGB(uint8_t type) {
       return !((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) || type == TYPE_ANALOG_1CH || type == TYPE_ANALOG_2CH || type == TYPE_ONOFF);
     }
@@ -170,12 +126,20 @@ class Bus {
               type == TYPE_FW1906        || type == TYPE_WS2805     ||
               type == TYPE_SM16825;
     }
-    static constexpr bool is16bit(uint8_t type)      { return type == TYPE_UCS8903 || type == TYPE_UCS8904 || type == TYPE_SM16825; }
-    static inline int16_t getCCT(void)               { return _cct; }
-    static inline void    setGlobalAWMode(uint8_t m) { if (m < 5) _gAWM = m; else _gAWM = AW_GLOBAL_DISABLED; }
-    static inline uint8_t getGlobalAWMode(void)      { return _gAWM; }
-    static void setCCT(int16_t cct)                  { _cct = cct; }
-    static inline uint8_t getCCTBlend(void)          { return _cctBlend; }
+    static constexpr bool  isTypeValid(uint8_t type)  { return (type > 15 && type < 128); }
+    static constexpr bool  isDigital(uint8_t type)    { return (type >= TYPE_DIGITAL_MIN && type <= TYPE_DIGITAL_MAX) || is2Pin(type); }
+    static constexpr bool  is2Pin(uint8_t type)       { return (type >= TYPE_2PIN_MIN && type <= TYPE_2PIN_MAX); }
+    static constexpr bool  isOnOff(uint8_t type)      { return (type == TYPE_ONOFF); }
+    static constexpr bool  isPWM(uint8_t type)        { return (type >= TYPE_ANALOG_MIN && type <= TYPE_ANALOG_MAX); }
+    static constexpr bool  isVirtual(uint8_t type)    { return (type >= TYPE_VIRTUAL_MIN && type <= TYPE_VIRTUAL_MAX); }
+    static constexpr bool  is16bit(uint8_t type)      { return type == TYPE_UCS8903 || type == TYPE_UCS8904 || type == TYPE_SM16825; }
+    static constexpr int   numPWMPins(uint8_t type)   { return (type - 40); }
+
+    static inline int16_t  getCCT(void)               { return _cct; }
+    static inline void     setGlobalAWMode(uint8_t m) { if (m < 5) _gAWM = m; else _gAWM = AW_GLOBAL_DISABLED; }
+    static inline uint8_t  getGlobalAWMode(void)      { return _gAWM; }
+    static inline void     setCCT(int16_t cct)        { _cct = cct; }
+    static inline uint8_t  getCCTBlend(void)          { return _cctBlend; }
     static void setCCTBlend(uint8_t b) {
       if (b > 100) b = 100;
       _cctBlend = (b * 127) / 100;
@@ -210,9 +174,14 @@ class Bus {
     uint8_t  _bri;
     uint16_t _start;
     uint16_t _len;
-    bool     _reversed;
-    bool     _valid;
-    bool     _needsRefresh;
+    //struct { //using bitfield struct adds abour 250 bytes to binary size
+      bool _reversed;//     : 1;
+      bool _valid;//        : 1;
+      bool _needsRefresh;// : 1;
+      bool _hasRgb;//       : 1;
+      bool _hasWhite;//     : 1;
+      bool _hasCCT;//       : 1;
+    //} __attribute__ ((packed));
     uint8_t  _autoWhiteMode;
     uint8_t  *_data;
     // global Auto White Calculation override
@@ -247,7 +216,7 @@ class BusDigital : public Bus {
     void setColorOrder(uint8_t colorOrder) override;
     uint32_t getPixelColor(uint16_t pix) const override;
     uint8_t  getColorOrder(void) const override  { return _colorOrder; }
-    uint8_t  getPins(uint8_t* pinArray) const override;
+    uint8_t  getPins(uint8_t* pinArray = nullptr) const override;
     uint8_t  skippedLeds(void) const override    { return _skip; }
     uint16_t getFrequency(void) const override   { return _frequencykHz; }
     uint16_t getLEDCurrent(void) const override  { return _milliAmpsPerLed; }
@@ -291,7 +260,7 @@ class BusPwm : public Bus {
 
     void setPixelColor(uint16_t pix, uint32_t c) override;
     uint32_t getPixelColor(uint16_t pix) const override; //does no index check
-    uint8_t  getPins(uint8_t* pinArray) const override;
+    uint8_t  getPins(uint8_t* pinArray = nullptr) const override;
     uint16_t getFrequency(void) const override { return _frequency; }
     void show(void) override;
     void cleanup(void) { deallocatePins(); }
@@ -331,12 +300,10 @@ class BusNetwork : public Bus {
     BusNetwork(BusConfig &bc);
     ~BusNetwork() { cleanup(); }
 
-    bool hasRGB(void) const override   { return true; }
-    bool hasWhite(void) const override { return _rgbw; }
     bool canShow(void) const override  { return !_broadcastLock; } // this should be a return value from UDP routine if it is still sending data out
     void setPixelColor(uint16_t pix, uint32_t c) override;
     uint32_t getPixelColor(uint16_t pix) const override;
-    uint8_t  getPins(uint8_t* pinArray) const override;
+    uint8_t  getPins(uint8_t* pinArray = nullptr) const override;
     void show(void) override;
     void cleanup(void);
 
@@ -344,11 +311,62 @@ class BusNetwork : public Bus {
     IPAddress _client;
     uint8_t   _UDPtype;
     uint8_t   _UDPchannels;
-    bool      _rgbw;
     bool      _broadcastLock;
 };
 
 
+//temporary struct for passing bus configuration to bus
+struct BusConfig {
+  uint8_t type;
+  uint16_t count;
+  uint16_t start;
+  uint8_t colorOrder;
+  bool reversed;
+  uint8_t skipAmount;
+  bool refreshReq;
+  uint8_t autoWhite;
+  uint8_t pins[5] = {255, 255, 255, 255, 255};
+  uint16_t frequency;
+  bool doubleBuffer;
+  uint8_t milliAmpsPerLed;
+  uint16_t milliAmpsMax;
+
+  BusConfig(uint8_t busType, uint8_t* ppins, uint16_t pstart, uint16_t len = 1, uint8_t pcolorOrder = COL_ORDER_GRB, bool rev = false, uint8_t skip = 0, byte aw=RGBW_MODE_MANUAL_ONLY, uint16_t clock_kHz=0U, bool dblBfr=false, uint8_t maPerLed=LED_MILLIAMPS_DEFAULT, uint16_t maMax=ABL_MILLIAMPS_DEFAULT)
+  : count(len)
+  , start(pstart)
+  , colorOrder(pcolorOrder)
+  , reversed(rev)
+  , skipAmount(skip)
+  , autoWhite(aw)
+  , frequency(clock_kHz)
+  , doubleBuffer(dblBfr)
+  , milliAmpsPerLed(maPerLed)
+  , milliAmpsMax(maMax)
+  {
+    refreshReq = (bool) GET_BIT(busType,7);
+    type = busType & 0x7F;  // bit 7 may be/is hacked to include refresh info (1=refresh in off state, 0=no refresh)
+    size_t nPins = 1;
+    if (Bus::isVirtual(type))   nPins = 4; //virtual network bus. 4 "pins" store IP address
+    else if (Bus::is2Pin(type)) nPins = 2;
+    else if (Bus::isPWM(type))  nPins = Bus::numPWMPins(type);
+    for (size_t i = 0; i < nPins; i++) pins[i] = ppins[i];
+    DEBUGBUS_PRINTF_P(PSTR("BusConfig type %d pins: %u\r\n"), (int)type, (int)Bus::isVirtual(type), nPins);
+  }
+
+  //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;
+  }
+};
+
+
 class BusManager {
   public:
     BusManager() {};
@@ -398,7 +416,7 @@ class BusManager {
     static uint8_t _parallelOutputs;
 
     #ifdef ESP32_DATA_IDLE_HIGH
-    static void    esp32RMTInvertIdle(void);
+    static void    esp32RMTInvertIdle(void) ;
     #endif
     static uint8_t getNumVirtualBusses(void) {
       int j = 0;
diff --git a/wled00/bus_wrapper.h b/wled00/bus_wrapper.h
index ae39adc146..bf2d30c0e6 100644
--- a/wled00/bus_wrapper.h
+++ b/wled00/bus_wrapper.h
@@ -1314,8 +1314,8 @@ class PolyBus {
 
   //gives back the internal type index (I_XX_XXX_X above) for the input
   static uint8_t getI(uint8_t busType, uint8_t* pins, uint8_t num = 0) {
-    if (!IS_DIGITAL(busType)) return I_NONE;
-    if (IS_2PIN(busType)) { //SPI LED chips
+    if (!Bus::isDigital(busType)) return I_NONE;
+    if (Bus::is2Pin(busType)) { //SPI LED chips
       bool isHSPI = false;
       #ifdef ESP8266
       if (pins[0] == P_8266_HS_MOSI && pins[1] == P_8266_HS_CLK) isHSPI = true;
diff --git a/wled00/cfg.cpp b/wled00/cfg.cpp
index 76ff4d20eb..5f0c8593f1 100644
--- a/wled00/cfg.cpp
+++ b/wled00/cfg.cpp
@@ -173,8 +173,8 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
     for (JsonObject elm : ins) {
       unsigned type = elm["type"] | TYPE_WS2812_RGB;
       unsigned len = elm["len"] | DEFAULT_LED_COUNT;
-      if (!IS_DIGITAL(type)) continue;
-      if (!IS_2PIN(type)) {
+      if (!Bus::isDigital(type)) continue;
+      if (!Bus::is2Pin(type)) {
         digitalCount++;
         unsigned channels = Bus::getNumberOfChannels(type);
         if (len > maxLedsOnBus)     maxLedsOnBus = len;
@@ -215,7 +215,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
       uint8_t maPerLed = elm[F("ledma")] | LED_MILLIAMPS_DEFAULT;
       uint16_t maMax = elm[F("maxpwr")] | (ablMilliampsMax * length) / total; // rough (incorrect?) per strip ABL calculation when no config exists
       // To disable brightness limiter we either set output max current to 0 or single LED current to 0 (we choose output max current)
-      if (IS_PWM(ledType) || IS_ONOFF(ledType) || IS_VIRTUAL(ledType)) { // analog and virtual
+      if (Bus::isPWM(ledType) || Bus::isOnOff(ledType) || Bus::isVirtual(ledType)) { // analog and virtual
         maPerLed = 0;
         maMax = 0;
       }
diff --git a/wled00/const.h b/wled00/const.h
index d5cd049d5e..a87c6ff30e 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -281,6 +281,7 @@
 #define TYPE_NONE                 0            //light is not configured
 #define TYPE_RESERVED             1            //unused. Might indicate a "virtual" light
 //Digital types (data pin only) (16-39)
+#define TYPE_DIGITAL_MIN         16            // first usable digital type
 #define TYPE_WS2812_1CH          18            //white-only chips (1 channel per IC) (unused)
 #define TYPE_WS2812_1CH_X3       19            //white-only chips (3 channels per IC)
 #define TYPE_WS2812_2CH_X3       20            //CCT chips (1st IC controls WW + CW of 1st zone and CW of 2nd zone, 2nd IC controls WW of 2nd zone and WW + CW of 3rd zone)
@@ -298,26 +299,36 @@
 #define TYPE_WS2805              32            //RGB + WW + CW
 #define TYPE_TM1914              33            //RGB
 #define TYPE_SM16825             34            //RGB + WW + CW
+#define TYPE_DIGITAL_MAX         39            // last usable digital type
 //"Analog" types (40-47)
 #define TYPE_ONOFF               40            //binary output (relays etc.; NOT PWM)
+#define TYPE_ANALOG_MIN          41            // first usable analog type
 #define TYPE_ANALOG_1CH          41            //single channel PWM. Uses value of brightest RGBW channel
 #define TYPE_ANALOG_2CH          42            //analog WW + CW
 #define TYPE_ANALOG_3CH          43            //analog RGB
 #define TYPE_ANALOG_4CH          44            //analog RGBW
 #define TYPE_ANALOG_5CH          45            //analog RGB + WW + CW
+#define TYPE_ANALOG_6CH          46            //analog RGB + A + WW + CW
+#define TYPE_ANALOG_MAX          47            // last usable analog type
 //Digital types (data + clock / SPI) (48-63)
+#define TYPE_2PIN_MIN            48
 #define TYPE_WS2801              50
 #define TYPE_APA102              51
 #define TYPE_LPD8806             52
 #define TYPE_P9813               53
 #define TYPE_LPD6803             54
+#define TYPE_2PIN_MAX            63
 //Network types (master broadcast) (80-95)
+#define TYPE_VIRTUAL_MIN         80
 #define TYPE_NET_DDP_RGB         80            //network DDP RGB bus (master broadcast bus)
 #define TYPE_NET_E131_RGB        81            //network E131 RGB bus (master broadcast bus, unused)
 #define TYPE_NET_ARTNET_RGB      82            //network ArtNet RGB bus (master broadcast bus, unused)
 #define TYPE_NET_DDP_RGBW        88            //network DDP RGBW bus (master broadcast bus)
 #define TYPE_NET_ARTNET_RGBW     89            //network ArtNet RGB bus (master broadcast bus, unused)
+#define TYPE_VIRTUAL_MAX         95
 
+/*
+// old macros that have been moved to Bus class
 #define IS_TYPE_VALID(t) ((t) > 15 && (t) < 128)
 #define IS_DIGITAL(t)    (((t) > 15 && (t) < 40) || ((t) > 47 && (t) < 64)) //digital are 16-39 and 48-63
 #define IS_2PIN(t)       ((t) > 47 && (t) < 64)
@@ -326,6 +337,7 @@
 #define IS_PWM(t)        ((t) > 40 && (t) < 46)     //does not include on/Off type
 #define NUM_PWM_PINS(t)  ((t) - 40)                 //for analog PWM 41-45 only
 #define IS_VIRTUAL(t)    ((t) >= 80 && (t) < 96)    //this was a poor choice a better would be 96-111
+*/
 
 //Color orders
 #define COL_ORDER_GRB             0           //GRB(w),defaut
diff --git a/wled00/data/settings_leds.htm b/wled00/data/settings_leds.htm
index 54c16b9d96..57d94f31aa 100644
--- a/wled00/data/settings_leds.htm
+++ b/wled00/data/settings_leds.htm
@@ -25,9 +25,10 @@
 		function isDig(t)  { return gT(t).t === "D" || isD2P(t); }  // is digital type
 		function isD2P(t)  { return gT(t).t === "2P"; }             // is digital 2 pin type
 		function isVir(t)  { return gT(t).t === "V"; }              // is virtual type
-		function hasW(t)   { return gT(t).w == 1; }                 // has white channel
-		function hasCCT(t) { return gT(t).c == 1; }                 // is white CCT enabled
-		function is16b(t)  { return gT(t).s == 1; }                 // is digital 16 bit type
+		function hasRGB(t) { return !!(gT(t).c & 0x01); }           // has RGB
+		function hasW(t)   { return !!(gT(t).c & 0x02); }           // has white channel
+		function hasCCT(t) { return !!(gT(t).c & 0x04); }           // is white CCT enabled
+		function is16b(t)  { return !!(gT(t).c & 0x10); }           // is digital 16 bit type
 		// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
 		function loadJS(FILE_URL, async = true) {
 			let scE = d.createElement("script");
@@ -229,24 +230,29 @@
 			let setPinConfig = (n,t) => {
 				let p0d = "GPIO:";
 				let p1d = "";
+				let off = "Off Refresh";
 				switch (gT(t).t.charAt(0)) {
 					case '2':
-						p1d = "Clk "+p0d;
+						p1d = "Clock "+p0d;
 					case 'D':
 						p0d = "Data "+p0d;
 						break;
 					case 'A':
-						if (gT(t).t.length > 1) p0d = "GPIOs:";
+						if (gT(t).t.length > 1) {
+							p0d = "GPIOs:";
+							off = "Phase shift";
+						} else gId(`dig${n}f`).style.display = "none";
 						break;
 					case 'V':
 						p0d = "IP address:";
 						break;
 				}
-				gId("p0d"+n).innerHTML = p0d;
-				gId("p1d"+n).innerHTML = p1d;
+				gId("p0d"+n).innerText = p0d;
+				gId("p1d"+n).innerText = p1d;
+				gId("off"+n).innerText = off;
 				// secondary pins show/hide (type string length is equivalent to number of pins used; except for virtual and on/off)
 				let pins = gT(t).t.length + 3*isVir(t); // fixes virtual pins to 4
-				if (pins == 0) pins = 1;                  // fixes on/off pin
+				if (pins == 0) pins = 1;                // fixes on/off pin
 				for (let p=1; p<5; p++) {
 					var LK = d.Sf["L"+p+n];
 					if (!LK) continue;
@@ -281,7 +287,7 @@
 				gId("dig"+n+"c").style.display = (isAna(t)) ? "none":"inline";              // hide count for analog
 				gId("dig"+n+"r").style.display = (isVir(t)) ? "none":"inline";              // hide reversed for virtual
 				gId("dig"+n+"s").style.display = (isVir(t) || isAna(t)) ? "none":"inline";  // hide skip 1st for virtual & analog
-				gId("dig"+n+"f").style.display = (isDig(t)) ? "inline":"none";              // hide refresh
+				gId("dig"+n+"f").style.display = (isDig(t) || isPWM(t)) ? "inline":"none";  // hide refresh (PWM hijacks reffresh for phase shifting)
 				gId("dig"+n+"a").style.display = (hasW(t)) ? "inline":"none";               // auto calculate white
 				gId("dig"+n+"l").style.display = (isD2P(t) || isPWM(t)) ? "inline":"none";  // bus clock speed / PWM speed (relative) (not On/Off)
 				gId("rev"+n).innerHTML = isAna(t) ? "Inverted output":"Reversed";           // change reverse text for analog else (rotated 180°)
@@ -454,8 +460,8 @@
 <span id="p4d${s}"></span><input type="number" name="L4${s}" class="s" onchange="UI();pinUpd(this);"/>
 <div id="dig${s}r" style="display:inline"><br><span id="rev${s}">Reversed</span>: <input type="checkbox" name="CV${s}"></div>
 <div id="dig${s}s" style="display:inline"><br>Skip first LEDs: <input type="number" name="SL${s}" min="0" max="255" value="0" oninput="UI()"></div>
-<div id="dig${s}f" style="display:inline"><br>Off Refresh: <input id="rf${s}" type="checkbox" name="RF${s}"></div>
-<div id="dig${s}a" style="display:inline"><br>Auto-calculate white channel from RGB:<br><select name="AW${s}"><option value=0>None</option><option value=1>Brighter</option><option value=2>Accurate</option><option value=3>Dual</option><option value=4>Max</option></select>&nbsp;</div>
+<div id="dig${s}f" style="display:inline"><br><span id="off${s}">Off Refresh</span>: <input id="rf${s}" type="checkbox" name="RF${s}"></div>
+<div id="dig${s}a" style="display:inline"><br>Auto-calculate W channel from RGB:<br><select name="AW${s}"><option value=0>None</option><option value=1>Brighter</option><option value=2>Accurate</option><option value=3>Dual</option><option value=4>Max</option></select>&nbsp;</div>
 </div>`;
 				f.insertAdjacentHTML("beforeend", cn);
 				// fill led types (credit @netmindz)
diff --git a/wled00/set.cpp b/wled00/set.cpp
index d295d36ee1..7be27ed206 100644
--- a/wled00/set.cpp
+++ b/wled00/set.cpp
@@ -177,7 +177,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
       }
       awmode = request->arg(aw).toInt();
       uint16_t freq = request->arg(sp).toInt();
-      if (IS_PWM(type)) {
+      if (Bus::isPWM(type)) {
         switch (freq) {
           case 0 : freq = WLED_PWM_FREQ/2;    break;
           case 1 : freq = WLED_PWM_FREQ*2/3;  break;
@@ -186,7 +186,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
           case 3 : freq = WLED_PWM_FREQ*2;    break;
           case 4 : freq = WLED_PWM_FREQ*10/3; break; // uint16_t max (19531 * 3.333)
         }
-      } else if (IS_DIGITAL(type) && IS_2PIN(type)) {
+      } else if (Bus::is2Pin(type)) {
         switch (freq) {
           default:
           case 0 : freq =  1000; break;
@@ -199,7 +199,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
         freq = 0;
       }
       channelSwap = Bus::hasWhite(type) ? request->arg(wo).toInt() : 0;
-      if (type == TYPE_ONOFF || IS_PWM(type) || IS_VIRTUAL(type)) { // analog and virtual
+      if (Bus::isOnOff(type) || Bus::isPWM(type) || Bus::isVirtual(type)) { // analog and virtual
         maPerLed = 0;
         maMax = 0;
       } else {
diff --git a/wled00/wled.cpp b/wled00/wled.cpp
index a6143eee6f..90498f52bb 100644
--- a/wled00/wled.cpp
+++ b/wled00/wled.cpp
@@ -186,8 +186,8 @@ void WLED::loop()
     unsigned maxChannels = 0;
     for (unsigned i = 0; i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) {
       if (busConfigs[i] == nullptr) break;
-      if (!IS_DIGITAL(busConfigs[i]->type)) continue;
-      if (!IS_2PIN(busConfigs[i]->type)) {
+      if (!Bus::isDigital(busConfigs[i]->type)) continue;
+      if (!Bus::is2Pin(busConfigs[i]->type)) {
         digitalCount++;
         unsigned channels = Bus::getNumberOfChannels(busConfigs[i]->type);
         if (busConfigs[i]->count > maxLedsOnBus) maxLedsOnBus = busConfigs[i]->count;
diff --git a/wled00/xml.cpp b/wled00/xml.cpp
index df14752498..c06b027686 100644
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -395,7 +395,7 @@ void getSettingsJS(byte subPage, char* dest)
       int nPins = bus->getPins(pins);
       for (int i = 0; i < nPins; i++) {
         lp[1] = offset+i;
-        if (pinManager.isPinOk(pins[i]) || IS_VIRTUAL(bus->getType())) sappend('v',lp,pins[i]);
+        if (pinManager.isPinOk(pins[i]) || bus->isVirtual()) sappend('v',lp,pins[i]);
       }
       sappend('v',lc,bus->getLength());
       sappend('v',lt,bus->getType());
@@ -407,7 +407,7 @@ void getSettingsJS(byte subPage, char* dest)
       sappend('v',aw,bus->getAutoWhiteMode());
       sappend('v',wo,bus->getColorOrder() >> 4);
       unsigned speed = bus->getFrequency();
-      if (IS_PWM(bus->getType())) {
+      if (bus->isPWM()) {
         switch (speed) {
           case WLED_PWM_FREQ/2    : speed = 0; break;
           case WLED_PWM_FREQ*2/3  : speed = 1; break;
@@ -416,7 +416,7 @@ void getSettingsJS(byte subPage, char* dest)
           case WLED_PWM_FREQ*2    : speed = 3; break;
           case WLED_PWM_FREQ*10/3 : speed = 4; break; // uint16_t max (19531 * 3.333)
         }
-      } else if (IS_DIGITAL(bus->getType()) && IS_2PIN(bus->getType())) {
+      } else if (bus->is2Pin()) {
         switch (speed) {
           case  1000 : speed = 0; break;
           case  2000 : speed = 1; break;

From 8818a9e82acdcea5b65f79f8482e6392a502a9c7 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sat, 24 Aug 2024 11:41:23 +0200
Subject: [PATCH 03/45] Remove erroneous debug

---
 wled00/bus_manager.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index df96e59440..c16eca40f8 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -350,7 +350,6 @@ struct BusConfig {
     else if (Bus::is2Pin(type)) nPins = 2;
     else if (Bus::isPWM(type))  nPins = Bus::numPWMPins(type);
     for (size_t i = 0; i < nPins; i++) pins[i] = ppins[i];
-    DEBUGBUS_PRINTF_P(PSTR("BusConfig type %d pins: %u\r\n"), (int)type, (int)Bus::isVirtual(type), nPins);
   }
 
   //validates start and length and extends total if needed

From 865e3dcd0c8946c6987929e1d9981a8b30c0196e Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sun, 25 Aug 2024 12:53:23 +0200
Subject: [PATCH 04/45] getNumberOfPins

---
 wled00/bus_manager.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index c16eca40f8..1d1136fd83 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -109,6 +109,7 @@ class Bus {
     inline  bool     isOffRefreshRequired(void) const             { return _needsRefresh; }
     inline  bool     containsPixel(uint16_t pix) const            { return pix >= _start && pix < _start + _len; }
 
+    static constexpr uint8_t getNumberOfPins(uint8_t type)        { return isVirtual(type) ? 4 : isPWM(type) ? numPWMPins(type) : is2Pin(type) + 1; } // credit @PaoloTK
     static constexpr uint8_t getNumberOfChannels(uint8_t type)    { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
     static constexpr bool hasRGB(uint8_t type) {
       return !((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) || type == TYPE_ANALOG_1CH || type == TYPE_ANALOG_2CH || type == TYPE_ONOFF);

From 820df0c596d7573fab4f59f90b86015876607df6 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Tue, 27 Aug 2024 00:21:24 +0200
Subject: [PATCH 05/45] PinManager update - LEDC: allocate same timer for CCT
 PWM - use SOC constants BusManager update - use allocateMultiplePins for
 BusPwm

---
 wled00/bus_manager.cpp | 15 +++++-----
 wled00/const.h         |  9 +++---
 wled00/pin_manager.cpp | 63 +++++++++++++++---------------------------
 wled00/pin_manager.h   | 39 ++++++++++++--------------
 4 files changed, 53 insertions(+), 73 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 0314321aee..795096c050 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -405,22 +405,23 @@ BusPwm::BusPwm(BusConfig &bc)
   // duty cycle resolution (_depth) can be extracted from this formula: CLOCK_FREQUENCY > _frequency * 2^_depth
   for (_depth = MAX_BIT_WIDTH; _depth > 8; _depth--) if (((CLOCK_FREQUENCY/_frequency) >> _depth) > 0) break;
 
+  managed_pin_type pins[numPins];
+  for (unsigned i = 0; i < numPins; i++) pins[i] = {(int8_t)bc.pins[i], true};
+  if (!pinManager.allocateMultiplePins(pins, numPins, PinOwner::BusPwm)) return;
+
 #ifdef ESP8266
   analogWriteRange((1<<_depth)-1);
   analogWriteFreq(_frequency);
 #else
   _ledcStart = pinManager.allocateLedc(numPins);
   if (_ledcStart == 255) { //no more free LEDC channels
-    deallocatePins(); return;
+    pinManager.deallocateMultiplePins(pins, numPins, PinOwner::BusPwm);
+    return;
   }
 #endif
 
   for (unsigned i = 0; i < numPins; i++) {
-    uint8_t currentPin = bc.pins[i];
-    if (!pinManager.allocatePin(currentPin, true, PinOwner::BusPwm)) {
-      deallocatePins(); return;
-    }
-    _pins[i] = currentPin; //store only after allocatePin() succeeds
+    _pins[i] = bc.pins[i]; // store only after allocateMultiplePins() succeeded
     #ifdef ESP8266
     pinMode(_pins[i], OUTPUT);
     #else
@@ -539,7 +540,7 @@ void BusPwm::deallocatePins(void) {
     #ifdef ESP8266
     digitalWrite(_pins[i], LOW); //turn off PWM interrupt
     #else
-    if (_ledcStart < 16) ledcDetachPin(_pins[i]);
+    if (_ledcStart < WLED_MAX_ANALOG_CHANNELS) ledcDetachPin(_pins[i]);
     #endif
   }
   #ifdef ARDUINO_ARCH_ESP32
diff --git a/wled00/const.h b/wled00/const.h
index a87c6ff30e..bdc80aab93 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -51,27 +51,28 @@
     #define WLED_MAX_BUSSES 4                 // will allow 3 digital & 1 analog RGB
     #define WLED_MIN_VIRTUAL_BUSSES 2
   #else
+    #define WLED_MAX_ANALOG_CHANNELS (LEDC_CHANNEL_MAX*LEDC_SPEED_MODE_MAX)
     #if defined(CONFIG_IDF_TARGET_ESP32C3)    // 2 RMT, 6 LEDC, only has 1 I2S but NPB does not support it ATM
       #define WLED_MAX_BUSSES 4               // will allow 2 digital & 2 analog RGB
       #define WLED_MAX_DIGITAL_CHANNELS 2
-      #define WLED_MAX_ANALOG_CHANNELS 6
+      //#define WLED_MAX_ANALOG_CHANNELS 6
       #define WLED_MIN_VIRTUAL_BUSSES 3
     #elif defined(CONFIG_IDF_TARGET_ESP32S2)  // 4 RMT, 8 LEDC, only has 1 I2S bus, supported in NPB
       // the 5th bus (I2S) will prevent Audioreactive usermod from functioning (it is last used though)
       #define WLED_MAX_BUSSES 7               // will allow 5 digital & 2 analog RGB
       #define WLED_MAX_DIGITAL_CHANNELS 5
-      #define WLED_MAX_ANALOG_CHANNELS 8
+      //#define WLED_MAX_ANALOG_CHANNELS 8
       #define WLED_MIN_VIRTUAL_BUSSES 3
     #elif defined(CONFIG_IDF_TARGET_ESP32S3)  // 4 RMT, 8 LEDC, has 2 I2S but NPB does not support them ATM
       #define WLED_MAX_BUSSES 6               // will allow 4 digital & 2 analog RGB
       #define WLED_MAX_DIGITAL_CHANNELS 4
-      #define WLED_MAX_ANALOG_CHANNELS 8
+      //#define WLED_MAX_ANALOG_CHANNELS 8
       #define WLED_MIN_VIRTUAL_BUSSES 4
     #else
       // the last digital bus (I2S0) will prevent Audioreactive usermod from functioning
       #define WLED_MAX_BUSSES 20              // will allow 17 digital & 3 analog RGB
       #define WLED_MAX_DIGITAL_CHANNELS 17
-      #define WLED_MAX_ANALOG_CHANNELS 10
+      //#define WLED_MAX_ANALOG_CHANNELS 16
       #define WLED_MIN_VIRTUAL_BUSSES 4
     #endif
   #endif
diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 84101e7cf1..0a0f391554 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -32,9 +32,7 @@ bool PinManagerClass::deallocatePin(byte gpio, PinOwner tag)
     return false;
   }
 
-  byte by = gpio >> 3;
-  byte bi = gpio - 8*by;
-  bitWrite(pinAlloc[by], bi, false);
+  bitWrite(pinAlloc, gpio, false);
   ownerTag[gpio] = PinOwner::None;
   return true;
 }
@@ -99,7 +97,7 @@ bool PinManagerClass::allocateMultiplePins(const managed_pin_type * mptArray, by
   bool shouldFail = false;
   // first verify the pins are OK and not already allocated
   for (int i = 0; i < arrayElementCount; i++) {
-    byte gpio = mptArray[i].pin;
+    unsigned gpio = mptArray[i].pin;
     if (gpio == 0xFF) {
       // explicit support for io -1 as a no-op (no allocation of pin),
       // as this can greatly simplify configuration arrays
@@ -137,7 +135,7 @@ bool PinManagerClass::allocateMultiplePins(const managed_pin_type * mptArray, by
 
   // all pins are available .. track each one
   for (int i = 0; i < arrayElementCount; i++) {
-    byte gpio = mptArray[i].pin;
+    unsigned gpio = mptArray[i].pin;
     if (gpio == 0xFF) {
       // allow callers to include -1 value as non-requested pin
       // as this can greatly simplify configuration arrays
@@ -146,9 +144,7 @@ bool PinManagerClass::allocateMultiplePins(const managed_pin_type * mptArray, by
     if (gpio >= WLED_NUM_PINS)
       continue; // other unexpected GPIO => avoid array bounds violation
 
-    byte by = gpio >> 3;
-    byte bi = gpio - 8*by;
-    bitWrite(pinAlloc[by], bi, true);
+    bitWrite(pinAlloc, gpio, true);
     ownerTag[gpio] = tag;
     #ifdef WLED_DEBUG
     DEBUG_PRINT(F("PIN ALLOC: Pin "));
@@ -192,9 +188,7 @@ bool PinManagerClass::allocatePin(byte gpio, bool output, PinOwner tag)
     return false;
   }
 
-  byte by = gpio >> 3;
-  byte bi = gpio - 8*by;
-  bitWrite(pinAlloc[by], bi, true);
+  bitWrite(pinAlloc, gpio, true);
   ownerTag[gpio] = tag;
   #ifdef WLED_DEBUG
   DEBUG_PRINT(F("PIN ALLOC: Pin "));
@@ -213,9 +207,7 @@ bool PinManagerClass::isPinAllocated(byte gpio, PinOwner tag) const
 {
   if (!isPinOk(gpio, false)) return true;
   if ((tag != PinOwner::None) && (ownerTag[gpio] != tag)) return false;
-  byte by = gpio >> 3;
-  byte bi = gpio - (by<<3);
-  return bitRead(pinAlloc[by], bi);
+  return bitRead(pinAlloc, gpio);
 }
 
 /* see https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-reference/peripherals/gpio.html
@@ -237,7 +229,7 @@ bool PinManagerClass::isPinAllocated(byte gpio, PinOwner tag) const
 // Check if supplied GPIO is ok to use
 bool PinManagerClass::isPinOk(byte gpio, bool output) const
 {
-  if (gpio >= WLED_NUM_PINS) return false;        // catch error case, to avoid array out-of-bounds access
+  if (gpio >= WLED_NUM_PINS) return false;     // catch error case, to avoid array out-of-bounds access
 #ifdef ARDUINO_ARCH_ESP32
   if (digitalPinIsValid(gpio)) {
   #if defined(CONFIG_IDF_TARGET_ESP32C3)
@@ -282,34 +274,26 @@ PinOwner PinManagerClass::getPinOwner(byte gpio) const
 }
 
 #ifdef ARDUINO_ARCH_ESP32
-#if defined(CONFIG_IDF_TARGET_ESP32C3)
-  #define MAX_LED_CHANNELS 6
-#else
-  #if defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3)
-    #define MAX_LED_CHANNELS 8
-  #else
-    #define MAX_LED_CHANNELS 16
-  #endif
-#endif
 byte PinManagerClass::allocateLedc(byte channels)
 {
-  if (channels > MAX_LED_CHANNELS || channels == 0) return 255;
-  byte ca = 0;
-  for (unsigned i = 0; i < MAX_LED_CHANNELS; i++) {
-    byte by = i >> 3;
-    byte bi = i - 8*by;
-    if (bitRead(ledcAlloc[by], bi)) { //found occupied pin
+  if (channels > WLED_MAX_ANALOG_CHANNELS || channels == 0) return 255;
+  unsigned ca = 0;
+  for (unsigned i = 0; i < WLED_MAX_ANALOG_CHANNELS; i++) {
+    if (bitRead(ledcAlloc, i)) { //found occupied pin
       ca = 0;
     } else {
-      ca++;
+      // if we have PWM CCT bus allocation (2 channels) we need to make sure both channels share the same timer
+      // for phase shifting purposes (otherwise phase shifts may not be accurate)
+      if (channels == 2) { // will skip odd channel for first channel for phase shifting
+        if (ca == 0 && i % 2 == 0) ca++;  // even LEDC channels is 1st PWM channel
+        if (ca == 1 && i % 2 == 1) ca++;  // odd LEDC channel is 2nd PWM channel
+      } else
+        ca++;
     }
     if (ca >= channels) { //enough free channels
-      byte in = (i + 1) - ca;
+      unsigned in = (i + 1) - ca;
       for (unsigned j = 0; j < ca; j++) {
-        byte bChan = in + j;
-        byte byChan = bChan >> 3;
-        byte biChan = bChan - 8*byChan;
-        bitWrite(ledcAlloc[byChan], biChan, true);
+        bitWrite(ledcAlloc, in+j, true);
       }
       return in;
     }
@@ -319,11 +303,8 @@ byte PinManagerClass::allocateLedc(byte channels)
 
 void PinManagerClass::deallocateLedc(byte pos, byte channels)
 {
-  for (unsigned j = pos; j < pos + channels; j++) {
-    if (j > MAX_LED_CHANNELS) return;
-    byte by = j >> 3;
-    byte bi = j - 8*by;
-    bitWrite(ledcAlloc[by], bi, false);
+  for (unsigned j = pos; j < pos + channels && j < WLED_MAX_ANALOG_CHANNELS; j++) {
+    bitWrite(ledcAlloc, j, false);
   }
 }
 #endif
diff --git a/wled00/pin_manager.h b/wled00/pin_manager.h
index 2fc0038803..986964a7f5 100644
--- a/wled00/pin_manager.h
+++ b/wled00/pin_manager.h
@@ -4,6 +4,9 @@
  * Registers pins so there is no attempt for two interfaces to use the same pin
  */
 #include <Arduino.h>
+#ifdef ARDUINO_ARCH_ESP32
+#include "driver/ledc.h" // needed for analog/LEDC channel counts
+#endif
 #include "const.h" // for USERMOD_* values
 
 typedef struct PinManagerPinType {
@@ -46,7 +49,6 @@ enum struct PinOwner : uint8_t {
   UM_RotaryEncoderUI   = USERMOD_ID_ROTARY_ENC_UI,      // 0x08 // Usermod "usermod_v2_rotary_encoder_ui.h"
   // #define USERMOD_ID_AUTO_SAVE                       // 0x09 // Usermod "usermod_v2_auto_save.h" -- Does not allocate pins
   // #define USERMOD_ID_DHT                             // 0x0A // Usermod "usermod_dht.h" -- Statically allocates pins, not compatible with pinManager?
-  // #define USERMOD_ID_MODE_SORT                       // 0x0B // Usermod "usermod_v2_mode_sort.h" -- Does not allocate pins
   // #define USERMOD_ID_VL53L0X                         // 0x0C // Usermod "usermod_vl53l0x_gestures.h" -- Uses "standard" HW_I2C pins
   UM_MultiRelay        = USERMOD_ID_MULTI_RELAY,        // 0x0D // Usermod "usermod_multi_relay.h"
   UM_AnimatedStaircase = USERMOD_ID_ANIMATED_STAIRCASE, // 0x0E // Usermod "Animated_Staircase.h"
@@ -64,29 +66,28 @@ enum struct PinOwner : uint8_t {
   UM_LDR_DUSK_DAWN     = USERMOD_ID_LDR_DUSK_DAWN,      // 0x2B // Usermod "usermod_LDR_Dusk_Dawn_v2.h"
   UM_MAX17048          = USERMOD_ID_MAX17048,           // 0x2F // Usermod "usermod_max17048.h"
   UM_BME68X            = USERMOD_ID_BME68X,             // 0x31 // Usermod "usermod_bme68x.h -- Uses "standard" HW_I2C pins
-  UM_PIXELS_DICE_TRAY  = USERMOD_ID_PIXELS_DICE_TRAY,   // 0x35 // Usermod "pixels_dice_tray.h" -- Needs compile time specified 6 pins for display including SPI.
+  UM_PIXELS_DICE_TRAY  = USERMOD_ID_PIXELS_DICE_TRAY    // 0x35 // Usermod "pixels_dice_tray.h" -- Needs compile time specified 6 pins for display including SPI.
 };
 static_assert(0u == static_cast<uint8_t>(PinOwner::None), "PinOwner::None must be zero, so default array initialization works as expected");
 
 class PinManagerClass {
   private:
-  #ifdef ESP8266
-  #define WLED_NUM_PINS 17
-  uint8_t pinAlloc[3] = {0x00, 0x00, 0x00}; //24bit, 1 bit per pin, we use first 17bits
-  PinOwner ownerTag[WLED_NUM_PINS] = { PinOwner::None };
-  #else
-  #define WLED_NUM_PINS 50
-  uint8_t pinAlloc[7] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; // 56bit, 1 bit per pin, we use 50 bits on ESP32-S3
-  uint8_t ledcAlloc[2] = {0x00, 0x00}; //16 LEDC channels
-  PinOwner ownerTag[WLED_NUM_PINS] = { PinOwner::None }; // new MCU's have up to 50 GPIO
-  #endif
-  struct {
-    uint8_t i2cAllocCount : 4; // allow multiple allocation of I2C bus pins but keep track of allocations
-    uint8_t spiAllocCount : 4; // allow multiple allocation of SPI bus pins but keep track of allocations
-  };
+    struct {
+    #ifdef ESP8266
+      #define WLED_NUM_PINS (GPIO_PIN_COUNT+1) // somehow they forgot GPIO 16 (0-16==17)
+      uint32_t pinAlloc     : 24; // 24bit, 1 bit per pin, we use first 17bits
+    #else
+      #define WLED_NUM_PINS (GPIO_PIN_COUNT)
+      uint64_t pinAlloc     : 56; // 56 bits, 1 bit per pin, we use 50 bits on ESP32-S3
+      uint16_t ledcAlloc    : 16; // up to 16 LEDC channels (WLED_MAX_ANALOG_CHANNELS)
+    #endif
+      uint8_t i2cAllocCount :  4; // allow multiple allocation of I2C bus pins but keep track of allocations
+      uint8_t spiAllocCount :  4; // allow multiple allocation of SPI bus pins but keep track of allocations
+    } __attribute__ ((packed));
+    PinOwner ownerTag[WLED_NUM_PINS] = { PinOwner::None };
 
   public:
-  PinManagerClass() : i2cAllocCount(0), spiAllocCount(0) {}
+  PinManagerClass() : pinAlloc(0), i2cAllocCount(0), spiAllocCount(0) {}
   // De-allocates a single pin
   bool deallocatePin(byte gpio, PinOwner tag);
   // De-allocates multiple pins but only if all can be deallocated (PinOwner has to be specified)
@@ -101,13 +102,9 @@ class PinManagerClass {
   // ethernet, etc..
   bool allocateMultiplePins(const managed_pin_type * mptArray, byte arrayElementCount, PinOwner tag );
 
-  #if !defined(ESP8266) // ESP8266 compiler doesn't understand deprecated attribute
   [[deprecated("Replaced by three-parameter allocatePin(gpio, output, ownerTag), for improved debugging")]]
-  #endif
   inline bool allocatePin(byte gpio, bool output = true) { return allocatePin(gpio, output, PinOwner::None); }
-  #if !defined(ESP8266) // ESP8266 compiler doesn't understand deprecated attribute
   [[deprecated("Replaced by two-parameter deallocatePin(gpio, ownerTag), for improved debugging")]]
-  #endif
   inline void deallocatePin(byte gpio) { deallocatePin(gpio, PinOwner::None); }
 
   // will return true for reserved pins

From b2e00eb868d3a53388f2105d360ffdfad66e3528 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Tue, 27 Aug 2024 14:11:56 +0200
Subject: [PATCH 06/45] Introduce network type (previous virtual) - phase
 shifting correction (limit to PWM CCT)

---
 wled00/bus_manager.cpp        | 38 +++++++++++++++++++-------------
 wled00/data/settings_leds.htm | 41 ++++++++++++++++++++---------------
 2 files changed, 47 insertions(+), 32 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 795096c050..9a35059f33 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -427,6 +427,9 @@ BusPwm::BusPwm(BusConfig &bc)
     #else
     ledcSetup(_ledcStart + i, _frequency, _depth);
     ledcAttachPin(_pins[i], _ledcStart + i);
+    // LEDC timer reset credit @dedehai
+    uint8_t group = ((_ledcStart + i) / 8), channel = ((_ledcStart + i) % 8); // _ledcStart + i is always less than MAX_LED_CHANNELS/LEDC_CHANNELS
+    ledc_timer_rst((ledc_mode_t)group, (ledc_channel_t)channel); // reset timer so all timers are almost in sync (for phase shift)
     #endif
   }
   _hasRgb = hasRGB(bc.type);
@@ -496,29 +499,30 @@ uint32_t BusPwm::getPixelColor(uint16_t pix) const {
 
 void BusPwm::show() {
   if (!_valid) return;
-  unsigned numPins = getPins();
-  unsigned maxBri = (1<<_depth) - 1;
+  const unsigned numPins = getPins();
+  const unsigned maxBri = (1<<_depth);
   // use CIE brightness formula
   unsigned pwmBri = (unsigned)_bri * 100;  
-  if(pwmBri < 2040) pwmBri = ((pwmBri << _depth) + 115043) / 230087; //adding '0.5' before division for correct rounding
+  if (pwmBri < 2040)
+    pwmBri = ((pwmBri << _depth) + 115043) / 230087; //adding '0.5' before division for correct rounding
   else {  
     pwmBri += 4080;
     float temp = (float)pwmBri / 29580;
-    temp = temp * temp * temp * (1<<_depth) - 1; 
+    temp = temp * temp * temp * maxBri; 
     pwmBri = (unsigned)temp;
   }
   // determine phase shift POC (credit @dedehai)
-  [[maybe_unused]] uint32_t phaseOffset = maxBri / numPins;
   for (unsigned i = 0; i < numPins; i++) {
     unsigned scaled = (_data[i] * pwmBri) / 255;
     if (_reversed) scaled = maxBri - scaled;
     #ifdef ESP8266
     analogWrite(_pins[i], scaled);
     #else
-    if (_needsRefresh) { // hacked to determine if phase shifted PWM is requested
+    // CCT blending has to be 0 for phse shift to work (WW & CW must not overlap)
+    if (_type == TYPE_ANALOG_2CH && _needsRefresh && Bus::getCCTBlend() == 0) { // hacked to determine if phase shifted PWM is requested
+      if (scaled >= maxBri/2) scaled = maxBri/2 - 1; // safety check & add dead time of 1 pulse
       uint8_t group = ((_ledcStart + i) / 8), channel = ((_ledcStart + i) % 8); // _ledcStart + i is always less than MAX_LED_CHANNELS/LEDC_CHANNELS
-      ledc_set_duty_with_hpoint((ledc_mode_t)group, (ledc_channel_t)channel, scaled, phaseOffset*i);
-      ledc_update_duty((ledc_mode_t)group, (ledc_channel_t)channel);
+      ledc_set_duty_and_update((ledc_mode_t)group, (ledc_channel_t)channel, scaled, (maxBri / numPins)*i);
     } else
       ledcWrite(_ledcStart + i, scaled);
     #endif
@@ -719,8 +723,8 @@ String BusManager::getLEDTypesJSONString(void) {
     {TYPE_WS2805,          "D",      PSTR("WS2805 RGBCW")},
     {TYPE_SM16825,         "D",      PSTR("SM16825 RGBCW")},
     {TYPE_WS2812_1CH_X3,   "D",      PSTR("WS2811 White")},
-    //{TYPE_WS2812_2CH_X3,   "D",      PSTR("WS2811 CCT")},
-    //{TYPE_WS2812_WWA,      "D",      PSTR("WS2811 WWA")},
+    //{TYPE_WS2812_2CH_X3,   "D",      PSTR("WS2811 CCT")}, // not implemented
+    //{TYPE_WS2812_WWA,      "D",      PSTR("WS2811 WWA")}, // not implemented
     {TYPE_WS2801,          "2P",     PSTR("WS2801")},
     {TYPE_APA102,          "2P",     PSTR("APA102")},
     {TYPE_LPD8806,         "2P",     PSTR("LPD8806")},
@@ -732,11 +736,15 @@ String BusManager::getLEDTypesJSONString(void) {
     {TYPE_ANALOG_3CH,      "AAA",    PSTR("PWM RGB")},
     {TYPE_ANALOG_4CH,      "AAAA",   PSTR("PWM RGBW")},
     {TYPE_ANALOG_5CH,      "AAAAA",  PSTR("PWM RGB+CCT")},
-    //{TYPE_ANALOG_6CH,      "AAAAAA", PSTR("PWM RGB+DCCT")},
-    {TYPE_NET_DDP_RGB,     "V",      PSTR("DDP RGB (network)")},
-    {TYPE_NET_ARTNET_RGB,  "V",      PSTR("Art-Net RGB (network)")},
-    {TYPE_NET_DDP_RGBW,    "V",      PSTR("DDP RGBW (network)")},
-    {TYPE_NET_ARTNET_RGBW, "V",      PSTR("Art-Net RGBW (network)")}
+    //{TYPE_ANALOG_6CH,      "AAAAAA", PSTR("PWM RGB+DCCT")}, // unimplementable ATM
+    {TYPE_NET_DDP_RGB,     "N",      PSTR("DDP RGB (network)")},
+    {TYPE_NET_ARTNET_RGB,  "N",      PSTR("Art-Net RGB (network)")},
+    {TYPE_NET_DDP_RGBW,    "N",      PSTR("DDP RGBW (network)")},
+    {TYPE_NET_ARTNET_RGBW, "N",      PSTR("Art-Net RGBW (network)")},
+    // hypothetical extensions
+    //{TYPE_VIRTUAL_I2C_W,   "V",     PSTR("I2C White (virtual)")}, // allows setting I2C address in _pin[0]
+    //{TYPE_VIRTUAL_I2C_CCT, "V",     PSTR("I2C CCT (virtual)")}, // allows setting I2C address in _pin[0]
+    //{TYPE_VIRTUAL_I2C_RGB, "V",     PSTR("I2C RGB (virtual)")}, // allows setting I2C address in _pin[0]
   };
   String json = "[";
   for (const auto &type : types) {
diff --git a/wled00/data/settings_leds.htm b/wled00/data/settings_leds.htm
index 57d94f31aa..30709e12d1 100644
--- a/wled00/data/settings_leds.htm
+++ b/wled00/data/settings_leds.htm
@@ -24,7 +24,8 @@
 		function isAna(t)  { return gT(t).t === "" || isPWM(t); }   // is analog type
 		function isDig(t)  { return gT(t).t === "D" || isD2P(t); }  // is digital type
 		function isD2P(t)  { return gT(t).t === "2P"; }             // is digital 2 pin type
-		function isVir(t)  { return gT(t).t === "V"; }              // is virtual type
+		function isNet(t)  { return gT(t).t === "N"; }              // is network type
+		function isVir(t)  { return gT(t).t === "V" || isNet(t); }  // is virtual type
 		function hasRGB(t) { return !!(gT(t).c & 0x01); }           // has RGB
 		function hasW(t)   { return !!(gT(t).c & 0x02); }           // has white channel
 		function hasCCT(t) { return !!(gT(t).c & 0x04); }           // is white CCT enabled
@@ -202,12 +203,10 @@
 			let len = parseInt(d.getElementsByName("LC"+n)[0].value);
 			len += parseInt(d.getElementsByName("SL"+n)[0].value); // skipped LEDs are allocated too
 			let dbl = 0;
-			let ch = 3;
+			let ch = 3*hasRGB(t) + hasW(t) + hasCCT(t);
 			let mul = 1;
 			if (isDig(t)) {
 				if (is16b(t)) len *= 2; // 16 bit LEDs
-				if (t > 28 && t < 40) ch = 4; //RGBW
-				if (t == 28) ch = 5; //GRBCW
 				if (maxM < 10000 && d.getElementsByName("L0"+n)[0].value == 3) { //8266 DMA uses 5x the mem
 					mul = 5;
 				}
@@ -216,7 +215,6 @@
 				}
 				if (d.Sf.LD.checked) dbl = len * ch; // double buffering
 			}
-			if (isVir(t) && t == 88) ch = 4;
 			return len * ch * mul + dbl;
 		}
 
@@ -232,27 +230,36 @@
 				let p1d = "";
 				let off = "Off Refresh";
 				switch (gT(t).t.charAt(0)) {
-					case '2':
+					case '2': // 2 pin digital
 						p1d = "Clock "+p0d;
-					case 'D':
+						// fallthrough
+					case 'D': // digital
 						p0d = "Data "+p0d;
 						break;
-					case 'A':
-						if (gT(t).t.length > 1) {
-							p0d = "GPIOs:";
-							off = "Phase shift";
-						} else gId(`dig${n}f`).style.display = "none";
+					case 'A': // PWM analog
+						switch (gT(t).t.length) { // type length determines number of GPIO used
+							case  1: break;
+							case  2: off = "Phase shift";
+								if (d.Sf["CB"].value != 0) gId(`rf${n}`).checked = 0; // disable phase shifting
+								gId(`rf${n}`).disabled = (d.Sf["CB"].value != 0);     // prevent changes
+								// fallthrough
+							default: p0d = "GPIOs:"; break;
+						}
+						// PWM CCT allows phase shifting
+						gId(`dig${n}f`).style.display = (gT(t).t.length != 2) ? "none" : "inline";
 						break;
-					case 'V':
+					case 'N': // network
 						p0d = "IP address:";
 						break;
+					case 'V': // virtual/non-GPIO based
+						p0d = "Config:"
+						break;
 				}
 				gId("p0d"+n).innerText = p0d;
 				gId("p1d"+n).innerText = p1d;
 				gId("off"+n).innerText = off;
-				// secondary pins show/hide (type string length is equivalent to number of pins used; except for virtual and on/off)
-				let pins = gT(t).t.length + 3*isVir(t); // fixes virtual pins to 4
-				if (pins == 0) pins = 1;                // fixes on/off pin
+				// secondary pins show/hide (type string length is equivalent to number of pins used; except for network and on/off)
+				let pins = Math.min(gT(t).t.length,1) + 3*isNet(t); // fixes network pins to 4
 				for (let p=1; p<5; p++) {
 					var LK = d.Sf["L"+p+n];
 					if (!LK) continue;
@@ -909,7 +916,7 @@ <h3>White management</h3>
 			<br>
 			Calculate CCT from RGB: <input type="checkbox" name="CR"><br>
 			CCT IC used (Athom 15W): <input type="checkbox" name="IC"><br>
-			CCT additive blending: <input type="number" class="s" min="0" max="100" name="CB" required> %
+			CCT additive blending: <input type="number" class="s" min="0" max="100" name="CB" onchange="UI()" required> %
 		</div>
 		<h3>Advanced</h3>
 		Palette blending:

From c51ce2eec79e4202ebb76ce0c0a3e404d5799053 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Tue, 27 Aug 2024 21:57:00 +0200
Subject: [PATCH 07/45] Fix C/P error Clarifications

---
 wled00/bus_manager.cpp | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 9a35059f33..e5918ce95f 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -425,11 +425,12 @@ BusPwm::BusPwm(BusConfig &bc)
     #ifdef ESP8266
     pinMode(_pins[i], OUTPUT);
     #else
-    ledcSetup(_ledcStart + i, _frequency, _depth);
-    ledcAttachPin(_pins[i], _ledcStart + i);
+    unsigned channel = _ledcStart + i;
+    ledcSetup(channel, _frequency, _depth);
+    ledcAttachPin(_pins[i], channel);
     // LEDC timer reset credit @dedehai
-    uint8_t group = ((_ledcStart + i) / 8), channel = ((_ledcStart + i) % 8); // _ledcStart + i is always less than MAX_LED_CHANNELS/LEDC_CHANNELS
-    ledc_timer_rst((ledc_mode_t)group, (ledc_channel_t)channel); // reset timer so all timers are almost in sync (for phase shift)
+    uint8_t group = (channel / 8), timer = ((channel / 2) % 4); // same fromula as in ledcSetup()
+    ledc_timer_rst((ledc_mode_t)group, (ledc_timer_t)timer); // reset timer so all timers are almost in sync (for phase shift)
     #endif
   }
   _hasRgb = hasRGB(bc.type);
@@ -501,30 +502,37 @@ void BusPwm::show() {
   if (!_valid) return;
   const unsigned numPins = getPins();
   const unsigned maxBri = (1<<_depth);
+
   // use CIE brightness formula
   unsigned pwmBri = (unsigned)_bri * 100;  
   if (pwmBri < 2040)
     pwmBri = ((pwmBri << _depth) + 115043) / 230087; //adding '0.5' before division for correct rounding
   else {  
     pwmBri += 4080;
-    float temp = (float)pwmBri / 29580;
+    float temp = (float)pwmBri / 29580.0f;
     temp = temp * temp * temp * maxBri; 
     pwmBri = (unsigned)temp;
   }
-  // determine phase shift POC (credit @dedehai)
+
   for (unsigned i = 0; i < numPins; i++) {
     unsigned scaled = (_data[i] * pwmBri) / 255;
     if (_reversed) scaled = maxBri - scaled;
     #ifdef ESP8266
     analogWrite(_pins[i], scaled);
     #else
-    // CCT blending has to be 0 for phse shift to work (WW & CW must not overlap)
+    unsigned channel = _ledcStart + i;
+    // determine phase shift POC for PWM CCT (credit @dedehai)
+    // phase shifting (180°) is only available for PWM CCT LED type if _needsRefresh is true (UI hack)
+    // and CCT blending is 0 (WW & CW must not overlap)
+    // this will allow using H-bridge to drive reverse-polarity CCT LED strip (2 wires)
+    // NOTE/TODO: if this has no side effects we may forego UI hack and the need for _needsRefresh
+    // we may even use phase shift to evenly distribute power across different pins
     if (_type == TYPE_ANALOG_2CH && _needsRefresh && Bus::getCCTBlend() == 0) { // hacked to determine if phase shifted PWM is requested
-      if (scaled >= maxBri/2) scaled = maxBri/2 - 1; // safety check & add dead time of 1 pulse
-      uint8_t group = ((_ledcStart + i) / 8), channel = ((_ledcStart + i) % 8); // _ledcStart + i is always less than MAX_LED_CHANNELS/LEDC_CHANNELS
-      ledc_set_duty_and_update((ledc_mode_t)group, (ledc_channel_t)channel, scaled, (maxBri / numPins)*i);
+      unsigned maxDuty = (maxBri / numPins);        // numPins is 2
+      if (scaled >= maxDuty) scaled = maxDuty - 1;  // safety check & add dead time of 1 pulse when brightness is at 50%
+      ledc_set_duty_and_update((ledc_mode_t)(channel / 8), (ledc_channel_t)(channel % 8), scaled, maxDuty*i);
     } else
-      ledcWrite(_ledcStart + i, scaled);
+      ledcWrite(channel, scaled);
     #endif
   }
 }

From 6655e2664e81e59a5ffbedf3a4121ab0f7c61d95 Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Thu, 29 Aug 2024 13:18:48 +0200
Subject: [PATCH 08/45] rebase to bus-config

---
 wled00/FX_fcn.cpp      | 39 +++++++++++++++++++++++++++------------
 wled00/bus_manager.cpp |  2 +-
 wled00/bus_manager.h   |  9 +++------
 wled00/const.h         |  7 +++++++
 4 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index a06d4f843b..69a742c3de 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -44,8 +44,8 @@
 */
 
 //factory defaults LED setup
-//#define PIXEL_COUNTS 30, 30, 30, 30
-//#define DATA_PINS 16, 1, 3, 4
+//#define PIXEL_COUNTS 30
+//#define DATA_PINS 2 (8266/C3) or 16 
 //#define DEFAULT_LED_TYPE TYPE_WS2812_RGB
 
 #ifndef PIXEL_COUNTS
@@ -56,8 +56,8 @@
   #define DATA_PINS LEDPIN
 #endif
 
-#ifndef DEFAULT_LED_TYPE
-  #define DEFAULT_LED_TYPE TYPE_WS2812_RGB
+#ifndef LED_TYPES
+  #define LED_TYPES DEFAULT_LED_TYPE
 #endif
 
 #ifndef DEFAULT_LED_COLOR_ORDER
@@ -1215,17 +1215,30 @@ void WS2812FX::finalizeInit(void) {
   //if busses failed to load, add default (fresh install, FS issue, ...)
   if (BusManager::getNumBusses() == 0) {
     DEBUG_PRINTLN(F("No busses, init default"));
+    constexpr unsigned defDataTypes[] = {LED_TYPES};
     const unsigned defDataPins[] = {DATA_PINS};
     const unsigned defCounts[] = {PIXEL_COUNTS};
-    const unsigned defNumPins = ((sizeof defDataPins) / (sizeof defDataPins[0]));
+    const unsigned defNumTypes = ((sizeof defDataTypes) / (sizeof defDataTypes[0]));
+    constexpr unsigned defNumPins = ((sizeof defDataPins) / (sizeof defDataPins[0]));
     const unsigned defNumCounts = ((sizeof defCounts) / (sizeof defCounts[0]));
-    // if number of pins is divisible by counts, use number of counts to determine number of buses, otherwise use pins
-    const unsigned defNumBusses = defNumPins > defNumCounts && defNumPins%defNumCounts == 0 ? defNumCounts : defNumPins;
-    const unsigned pinsPerBus = defNumPins / defNumBusses;
+
+    static_assert(Bus::getNumberOfPins(defDataTypes[0]) <= defNumPins,
+                  "The first LED type configured requires more pins than have been defined!");
+
     unsigned prevLen = 0;
-    for (unsigned i = 0; i < defNumBusses && i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) {
-      uint8_t defPin[5]; // max 5 pins
-      for (unsigned j = 0; j < pinsPerBus; j++) defPin[j] = defDataPins[i*pinsPerBus + j];
+    unsigned pinsIndex = 0;
+    for (unsigned i = 0; i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) {
+      uint8_t defPin[OUTPUT_MAX_PINS]; // max 5 pins
+      // if we have less types than requested outputs and they do not align, use last known type to set current type
+      unsigned dataType = defDataTypes[(i < defNumTypes) ? i : defNumTypes -1];
+      unsigned busPins = Bus::getNumberOfPins(dataType);
+      // check if we have enough pins left to configure an output of this type
+      if (pinsIndex + busPins > defNumPins) {
+        DEBUG_PRINTLN(F("LED outputs misaligned with defined pins. Some pins will remain unused."));
+        break;
+      }
+      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) defPin[j] = defDataPins[pinsIndex + j];
+      pinsIndex += busPins;
       // when booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
       // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), etc
       if (pinManager.isPinAllocated(defPin[0])) {
@@ -1235,8 +1248,10 @@ void WS2812FX::finalizeInit(void) {
       unsigned start = prevLen;
       // if we have less counts than pins and they do not align, use last known count to set current count
       unsigned count = defCounts[(i < defNumCounts) ? i : defNumCounts -1];
+      // analog always has length 1
+      if (Bus::isPWM(dataType)) count = 1;
       prevLen += count;
-      BusConfig defCfg = BusConfig(DEFAULT_LED_TYPE, defPin, start, count, DEFAULT_LED_COLOR_ORDER, false, 0, RGBW_MODE_MANUAL_ONLY, 0, useGlobalLedBuffer);
+      BusConfig defCfg = BusConfig(dataType, defPin, start, count, DEFAULT_LED_COLOR_ORDER, false, 0, RGBW_MODE_MANUAL_ONLY, 0, useGlobalLedBuffer);
       if (BusManager::add(defCfg) == -1) break;
     }
   }
diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index e5918ce95f..77e60ba4fa 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -673,7 +673,7 @@ void BusNetwork::cleanup(void) {
 
 //utility to get the approx. memory usage of a given BusConfig
 uint32_t BusManager::memUsage(BusConfig &bc) {
-  if (Bus::isOnOff(bc.type) || Bus::isPWM(bc.type)) return 5;
+  if (Bus::isOnOff(bc.type) || Bus::isPWM(bc.type)) return OUTPUT_MAX_PINS;
 
   unsigned len = bc.count + bc.skipAmount;
   unsigned channels = Bus::getNumberOfChannels(bc.type);
diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index 1d1136fd83..f6aa4b5790 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -267,8 +267,8 @@ class BusPwm : public Bus {
     void cleanup(void) { deallocatePins(); }
 
   private:
-    uint8_t _pins[5];
-    uint8_t _pwmdata[5];
+    uint8_t _pins[OUTPUT_MAX_PINS];
+    uint8_t _pwmdata[OUTPUT_MAX_PINS];
     #ifdef ARDUINO_ARCH_ESP32
     uint8_t _ledcStart;
     #endif
@@ -346,10 +346,7 @@ struct BusConfig {
   {
     refreshReq = (bool) GET_BIT(busType,7);
     type = busType & 0x7F;  // bit 7 may be/is hacked to include refresh info (1=refresh in off state, 0=no refresh)
-    size_t nPins = 1;
-    if (Bus::isVirtual(type))   nPins = 4; //virtual network bus. 4 "pins" store IP address
-    else if (Bus::is2Pin(type)) nPins = 2;
-    else if (Bus::isPWM(type))  nPins = Bus::numPWMPins(type);
+    size_t nPins = Bus::getNumberOfPins(type);
     for (size_t i = 0; i < nPins; i++) pins[i] = ppins[i];
   }
 
diff --git a/wled00/const.h b/wled00/const.h
index bdc80aab93..cb50a108fa 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -466,6 +466,9 @@
 #define NTP_PACKET_SIZE 48       // size of NTP receive buffer
 #define NTP_MIN_PACKET_SIZE 48   // min expected size - NTP v4 allows for "extended information" appended to the standard fields
 
+// Maximum number of pins per output. 5 for RGBCCT analog LEDs.
+#define OUTPUT_MAX_PINS 5
+
 //maximum number of rendered LEDs - this does not have to match max. physical LEDs, e.g. if there are virtual busses
 #ifndef MAX_LEDS
 #ifdef ESP8266
@@ -577,6 +580,10 @@
 #endif
 #endif
 
+#ifndef DEFAULT_LED_TYPE
+  #define DEFAULT_LED_TYPE TYPE_WS2812_RGB
+#endif
+
 #ifndef DEFAULT_LED_COUNT
   #define DEFAULT_LED_COUNT 30
 #endif

From 0d035a08d6e5813599de1e861465329b82e974a7 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Fri, 30 Aug 2024 15:21:16 +0200
Subject: [PATCH 09/45] Dithering support & bugfix in UI Thanks to @dedehai &
 @zalatnaicsongor

---
 wled00/bus_manager.cpp        | 71 ++++++++++++++++++++++++-----------
 wled00/const.h                |  6 ++-
 wled00/data/settings_leds.htm | 27 +++++--------
 3 files changed, 64 insertions(+), 40 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index e5918ce95f..89e53e60f5 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -6,6 +6,7 @@
 #include <IPAddress.h>
 #ifdef ARDUINO_ARCH_ESP32
 #include "driver/ledc.h"
+#include "soc/ledc_struct.h"
 #endif
 #include "const.h"
 #include "pin_manager.h"
@@ -392,7 +393,7 @@ void BusDigital::cleanup(void) {
     #define MAX_BIT_WIDTH SOC_LEDC_TIMER_BIT_WIDE_NUM 
   #else
     // ESP32: 20 bit (but in reality we would never go beyond 16 bit as the frequency would be to low)
-    #define MAX_BIT_WIDTH 20
+    #define MAX_BIT_WIDTH 14
   #endif
 #endif
 
@@ -413,11 +414,13 @@ BusPwm::BusPwm(BusConfig &bc)
   analogWriteRange((1<<_depth)-1);
   analogWriteFreq(_frequency);
 #else
+  // for 2 pin PWM CCT strip pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer
   _ledcStart = pinManager.allocateLedc(numPins);
   if (_ledcStart == 255) { //no more free LEDC channels
     pinManager.deallocateMultiplePins(pins, numPins, PinOwner::BusPwm);
     return;
   }
+  if (_needsRefresh) _depth = 8; // fixed 8 bit depth with 4 bit dithering (ESP8266 has no hardware to support dithering)
 #endif
 
   for (unsigned i = 0; i < numPins; i++) {
@@ -501,38 +504,62 @@ uint32_t BusPwm::getPixelColor(uint16_t pix) const {
 void BusPwm::show() {
   if (!_valid) return;
   const unsigned numPins = getPins();
-  const unsigned maxBri = (1<<_depth);
-
-  // use CIE brightness formula
-  unsigned pwmBri = (unsigned)_bri * 100;  
-  if (pwmBri < 2040)
-    pwmBri = ((pwmBri << _depth) + 115043) / 230087; //adding '0.5' before division for correct rounding
-  else {  
+  const unsigned maxBri = (1<<_depth); // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8)
+
+  // use CIE brightness formula to fit (or approximate linearity of) human eye perceived brightness
+  // the formula is based on 12 bit resolution as there is no need for greater precision
+  unsigned pwmBri = (unsigned)_bri * 100;  // enlarge to use integer math for linear response
+  if (pwmBri < 2040) {
+    // linear response for values [0-20]
+    pwmBri = ((pwmBri << 12) + 115043) / 230087; //adding '0.5' before division for correct rounding
+  } else {
+    // cubic response for values [21-255]
     pwmBri += 4080;
     float temp = (float)pwmBri / 29580.0f;
-    temp = temp * temp * temp * maxBri; 
+    temp = temp * temp * temp * 4095.0f; 
     pwmBri = (unsigned)temp;
   }
+  // pwmBri is in range [0-4095]
+
+  // determine phase shift
+  [[maybe_unused]] unsigned phaseOffset = maxBri / numPins; // (maxBri is at _depth resolution)
+  // we will be phase shifting every channel by fixed amount (i times /2 or /3 or /4 or /5)
+  // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type (with 180° phase)
+  // CCT additive blending must be 0 (WW & CW must not overlap) in such case
+  // for all other cases it will just try to "spread" the load on PSU
 
   for (unsigned i = 0; i < numPins; i++) {
     unsigned scaled = (_data[i] * pwmBri) / 255;
-    if (_reversed) scaled = maxBri - scaled;
+    // adjust "scaled" value (to fit resolution bounds)
+    if (_depth < 12 && !_needsRefresh) scaled >>= 12 - _depth; // normalize scaled value (if not using dithering)
+    else if (_depth > 12)              scaled <<= _depth - 12; // scale to _depth if using >12 bit
+    if (_reversed)                     scaled = maxBri - scaled;
+
     #ifdef ESP8266
     analogWrite(_pins[i], scaled);
     #else
     unsigned channel = _ledcStart + i;
-    // determine phase shift POC for PWM CCT (credit @dedehai)
-    // phase shifting (180°) is only available for PWM CCT LED type if _needsRefresh is true (UI hack)
-    // and CCT blending is 0 (WW & CW must not overlap)
-    // this will allow using H-bridge to drive reverse-polarity CCT LED strip (2 wires)
-    // NOTE/TODO: if this has no side effects we may forego UI hack and the need for _needsRefresh
-    // we may even use phase shift to evenly distribute power across different pins
-    if (_type == TYPE_ANALOG_2CH && _needsRefresh && Bus::getCCTBlend() == 0) { // hacked to determine if phase shifted PWM is requested
-      unsigned maxDuty = (maxBri / numPins);        // numPins is 2
-      if (scaled >= maxDuty) scaled = maxDuty - 1;  // safety check & add dead time of 1 pulse when brightness is at 50%
-      ledc_set_duty_and_update((ledc_mode_t)(channel / 8), (ledc_channel_t)(channel % 8), scaled, maxDuty*i);
-    } else
-      ledcWrite(channel, scaled);
+    if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {
+      // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer
+      unsigned briLimit = phaseOffset << (_needsRefresh*4); // expand limit if using dithering (_depth==8, scaled is at 12 bit)
+      if (scaled >= briLimit) scaled = briLimit - 1;        // safety check & 1 pulse dead time when brightness is at 50%
+    }
+    unsigned gr = channel/8;  // high/low speed group
+    unsigned ch = channel%8;  // group channel
+    if (_needsRefresh) {
+      // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
+      // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)
+      // directly write to LEDC struct as there is no HAL exposed function for dithering
+      // duty has 20 bit resolution with 4 fractional bits (24 bits in total)
+      // _depth is 8 bit in this case (and maxBri==256), scaled is still at 12 bit
+      LEDC.channel_group[gr].channel[ch].duty.duty = scaled; // write full 12 bit value (4 dithering bits)
+      LEDC.channel_group[gr].channel[ch].hpoint.hpoint = phaseOffset*i; // phaseOffset is at _depth resolution (8 bit)
+      ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
+    } else {
+      // scaled will be [0-((1<<_depth)-1)] and hpoint evenly distributed
+      ledc_set_duty_and_update((ledc_mode_t)gr, (ledc_channel_t)ch, scaled, phaseOffset*i);
+      //ledcWrite(channel, scaled);
+    }
     #endif
   }
 }
diff --git a/wled00/const.h b/wled00/const.h
index bdc80aab93..af6ef5ed27 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -533,7 +533,11 @@
 #ifdef ESP8266
   #define WLED_PWM_FREQ    880 //PWM frequency proven as good for LEDs
 #else
-  #define WLED_PWM_FREQ  19531
+  #ifdef SOC_LEDC_SUPPORT_XTAL_CLOCK
+    #define WLED_PWM_FREQ 9765    // XTAL clock is 40MHz (this will allow 12 bit resolution)
+  #else
+    #define WLED_PWM_FREQ  19531  // APB clock is 80MHz
+  #endif
 #endif
 #endif
 
diff --git a/wled00/data/settings_leds.htm b/wled00/data/settings_leds.htm
index 30709e12d1..58bd842058 100644
--- a/wled00/data/settings_leds.htm
+++ b/wled00/data/settings_leds.htm
@@ -5,9 +5,9 @@
 	<meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
 	<title>LED Settings</title>
 	<script>
-		var d=document,laprev=55,maxB=1,maxD=1,maxA=1,maxV=0,maxM=4000,maxPB=4096,maxL=1333,maxCO=10,maxLbquot=0; //maximum bytes for LED allocation: 4kB for 8266, 32kB for 32
+		var d=document,laprev=55,maxB=1,maxD=1,maxA=1,maxV=0,maxM=4000,maxPB=2048,maxL=1664,maxCO=5,maxLbquot=0; //maximum bytes for LED allocation: 4kB for 8266, 32kB for 32
 		var oMaxB=1;
-		d.ledTypes = []; // filled from GetV()
+		d.ledTypes = [/*{i:22,c:1,t:"D",n:"WS2812"},{i:42,c:6,t:"AA",n:"PWM CCT"}*/]; // filled from GetV()
 		d.um_p = [];
 		d.rsvd = [];
 		d.ro_gpio = [];
@@ -60,7 +60,7 @@
 			x.className = error ? "error":"show";
 			clearTimeout(timeout);
 			x.style.animation = 'none';
-			timeout = setTimeout(function(){ x.className = x.className.replace("show", ""); }, 2900);
+			timeout = setTimeout(()=>{ x.className = x.className.replace("show", ""); }, 2900);
 		}
 		function bLimits(b,v,p,m,l,o=5,d=2,a=6) {
 			// maxB - max buses (can be changed if using ESP32 parallel I2S)
@@ -69,7 +69,7 @@
 			// maxV - min virtual buses
 			// maxPB - max LEDs per bus
 			// maxM - max LED memory
-			// maxL - max LEDs
+			// maxL - max LEDs (will serve to determine ESP >1664 == ESP32)
 			// maxCO - max Color Order mappings
 			oMaxB = maxB = b; maxD = d, maxA = a, maxV = v; maxM = m; maxPB = p; maxL = l; maxCO = o;
 		}
@@ -237,16 +237,8 @@
 						p0d = "Data "+p0d;
 						break;
 					case 'A': // PWM analog
-						switch (gT(t).t.length) { // type length determines number of GPIO used
-							case  1: break;
-							case  2: off = "Phase shift";
-								if (d.Sf["CB"].value != 0) gId(`rf${n}`).checked = 0; // disable phase shifting
-								gId(`rf${n}`).disabled = (d.Sf["CB"].value != 0);     // prevent changes
-								// fallthrough
-							default: p0d = "GPIOs:"; break;
-						}
-						// PWM CCT allows phase shifting
-						gId(`dig${n}f`).style.display = (gT(t).t.length != 2) ? "none" : "inline";
+						if (gT(t).t.length > 1) p0d = "GPIOs:";
+						off = "Dithering";
 						break;
 					case 'N': // network
 						p0d = "IP address:";
@@ -259,7 +251,7 @@
 				gId("p1d"+n).innerText = p1d;
 				gId("off"+n).innerText = off;
 				// secondary pins show/hide (type string length is equivalent to number of pins used; except for network and on/off)
-				let pins = Math.min(gT(t).t.length,1) + 3*isNet(t); // fixes network pins to 4
+				let pins = Math.max(gT(t).t.length,1) + 3*isNet(t); // fixes network pins to 4
 				for (let p=1; p<5; p++) {
 					var LK = d.Sf["L"+p+n];
 					if (!LK) continue;
@@ -294,7 +286,7 @@
 				gId("dig"+n+"c").style.display = (isAna(t)) ? "none":"inline";              // hide count for analog
 				gId("dig"+n+"r").style.display = (isVir(t)) ? "none":"inline";              // hide reversed for virtual
 				gId("dig"+n+"s").style.display = (isVir(t) || isAna(t)) ? "none":"inline";  // hide skip 1st for virtual & analog
-				gId("dig"+n+"f").style.display = (isDig(t) || isPWM(t)) ? "inline":"none";  // hide refresh (PWM hijacks reffresh for phase shifting)
+				gId("dig"+n+"f").style.display = (isDig(t) || (isPWM(t) && maxL>2048)) ? "inline":"none"; // hide refresh (PWM hijacks reffresh for dithering on ESP32)
 				gId("dig"+n+"a").style.display = (hasW(t)) ? "inline":"none";               // auto calculate white
 				gId("dig"+n+"l").style.display = (isD2P(t) || isPWM(t)) ? "inline":"none";  // bus clock speed / PWM speed (relative) (not On/Off)
 				gId("rev"+n).innerHTML = isAna(t) ? "Inverted output":"Reversed";           // change reverse text for analog else (rotated 180°)
@@ -916,7 +908,8 @@ <h3>White management</h3>
 			<br>
 			Calculate CCT from RGB: <input type="checkbox" name="CR"><br>
 			CCT IC used (Athom 15W): <input type="checkbox" name="IC"><br>
-			CCT additive blending: <input type="number" class="s" min="0" max="100" name="CB" onchange="UI()" required> %
+			CCT additive blending: <input type="number" class="s" min="0" max="100" name="CB" onchange="UI()" required> %<br>
+			<i class="warn">WARNING: When using H-bridge for reverse polarity (2-wire) CCT LED strip<br><b>make sure this value is 0</b>.<br>(ESP32 variants only, ESP8266 does not support H-bridges)</i>
 		</div>
 		<h3>Advanced</h3>
 		Palette blending:

From 2ca034bfa84e22bafc840027487ff58c24c600d2 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sun, 1 Sep 2024 11:43:22 +0200
Subject: [PATCH 10/45] Remove ledc_set_duty_and_update Add semaphoring
 Determine CCT overlap

---
 wled00/bus_manager.cpp | 54 +++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 24 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 89e53e60f5..2f5c7f27af 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -7,6 +7,9 @@
 #ifdef ARDUINO_ARCH_ESP32
 #include "driver/ledc.h"
 #include "soc/ledc_struct.h"
+#define LEDC_MUTEX_LOCK()    do {} while (xSemaphoreTake(_ledc_sys_lock, portMAX_DELAY) != pdPASS)
+#define LEDC_MUTEX_UNLOCK()  xSemaphoreGive(_ledc_sys_lock)
+extern xSemaphoreHandle _ledc_sys_lock;
 #endif
 #include "const.h"
 #include "pin_manager.h"
@@ -506,8 +509,9 @@ void BusPwm::show() {
   const unsigned numPins = getPins();
   const unsigned maxBri = (1<<_depth); // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8)
 
-  // use CIE brightness formula to fit (or approximate linearity of) human eye perceived brightness
+  // use CIE brightness formula (cubic) to fit (or approximate linearity of) human eye perceived brightness
   // the formula is based on 12 bit resolution as there is no need for greater precision
+  // see: https://en.wikipedia.org/wiki/Lightness
   unsigned pwmBri = (unsigned)_bri * 100;  // enlarge to use integer math for linear response
   if (pwmBri < 2040) {
     // linear response for values [0-20]
@@ -527,39 +531,41 @@ void BusPwm::show() {
   // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type (with 180° phase)
   // CCT additive blending must be 0 (WW & CW must not overlap) in such case
   // for all other cases it will just try to "spread" the load on PSU
+  bool cctOverlap = (_type == TYPE_ANALOG_2CH) && (_data[0]+_data[1] >= 254);
+
+  // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
+  // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)
+  bool dithering = _needsRefresh;                           // avoid working with bitfield
 
   for (unsigned i = 0; i < numPins; i++) {
-    unsigned scaled = (_data[i] * pwmBri) / 255;
+    unsigned scaled = (_data[i] * pwmBri) / 255;            // scaled is at 12 bit depth (same as pwmBri)
     // adjust "scaled" value (to fit resolution bounds)
-    if (_depth < 12 && !_needsRefresh) scaled >>= 12 - _depth; // normalize scaled value (if not using dithering)
-    else if (_depth > 12)              scaled <<= _depth - 12; // scale to _depth if using >12 bit
-    if (_reversed)                     scaled = maxBri - scaled;
-
+    if (_depth < 12 && !dithering) scaled >>= 12 - _depth;  // normalize scaled value (if not using dithering)
+    else if (_depth > 12)          scaled <<= _depth - 12;  // scale to _depth if using >12 bit
+    if (_reversed)                 scaled = maxBri - scaled;
+    // scaled is now at _depth resolution (8-14 bits) except when using dithering, 12 bit in such case
     #ifdef ESP8266
     analogWrite(_pins[i], scaled);
     #else
     unsigned channel = _ledcStart + i;
-    if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {
-      // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer
-      unsigned briLimit = phaseOffset << (_needsRefresh*4); // expand limit if using dithering (_depth==8, scaled is at 12 bit)
-      if (scaled >= briLimit) scaled = briLimit - 1;        // safety check & 1 pulse dead time when brightness is at 50%
+    // prevent overlapping PWM signals for H-bridge
+    // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer
+    // so we only need to take care of shortening the signal at 50% distribution for 1 pulse
+    if (cctOverlap && Bus::getCCTBlend() == 0) {
+      unsigned shift = (dithering*4);
+      unsigned briLimit = phaseOffset << shift;               // expand limit if using dithering
+      if (scaled >= briLimit) scaled = briLimit - (1<<shift); // safety check & 1 pulse dead time when brightness is at 50%
     }
     unsigned gr = channel/8;  // high/low speed group
     unsigned ch = channel%8;  // group channel
-    if (_needsRefresh) {
-      // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
-      // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)
-      // directly write to LEDC struct as there is no HAL exposed function for dithering
-      // duty has 20 bit resolution with 4 fractional bits (24 bits in total)
-      // _depth is 8 bit in this case (and maxBri==256), scaled is still at 12 bit
-      LEDC.channel_group[gr].channel[ch].duty.duty = scaled; // write full 12 bit value (4 dithering bits)
-      LEDC.channel_group[gr].channel[ch].hpoint.hpoint = phaseOffset*i; // phaseOffset is at _depth resolution (8 bit)
-      ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
-    } else {
-      // scaled will be [0-((1<<_depth)-1)] and hpoint evenly distributed
-      ledc_set_duty_and_update((ledc_mode_t)gr, (ledc_channel_t)ch, scaled, phaseOffset*i);
-      //ledcWrite(channel, scaled);
-    }
+    // directly write to LEDC struct as there is no HAL exposed function for dithering
+    // duty has 20 bit resolution with 4 fractional bits (24 bits in total)
+    // _depth is 8 bit in this case (and maxBri==256), scaled is still at 12 bit
+    LEDC_MUTEX_LOCK();
+    LEDC.channel_group[gr].channel[ch].duty.duty = scaled << ((!dithering)*4); // write full 12 bit value (4 dithering bits)
+    LEDC.channel_group[gr].channel[ch].hpoint.hpoint = phaseOffset*i; // phaseOffset is at _depth resolution (8 bit)
+    LEDC_MUTEX_UNLOCK();
+    ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
     #endif
   }
 }

From a3b28871c61ec930edf664b5201751a6c7fd5e8f Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sun, 1 Sep 2024 12:27:41 +0200
Subject: [PATCH 11/45] Dirty fix for newer framework

---
 wled00/bus_manager.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 2f5c7f27af..4d12c93b6d 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -7,9 +7,14 @@
 #ifdef ARDUINO_ARCH_ESP32
 #include "driver/ledc.h"
 #include "soc/ledc_struct.h"
-#define LEDC_MUTEX_LOCK()    do {} while (xSemaphoreTake(_ledc_sys_lock, portMAX_DELAY) != pdPASS)
-#define LEDC_MUTEX_UNLOCK()  xSemaphoreGive(_ledc_sys_lock)
-extern xSemaphoreHandle _ledc_sys_lock;
+  #if !(defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2) || defined(CONFIG_IDF_TARGET_ESP32S3))
+    #define LEDC_MUTEX_LOCK()    do {} while (xSemaphoreTake(_ledc_sys_lock, portMAX_DELAY) != pdPASS)
+    #define LEDC_MUTEX_UNLOCK()  xSemaphoreGive(_ledc_sys_lock)
+    extern xSemaphoreHandle _ledc_sys_lock;
+  #else
+    #define LEDC_MUTEX_LOCK()
+    #define LEDC_MUTEX_UNLOCK()
+  #endif
 #endif
 #include "const.h"
 #include "pin_manager.h"
@@ -531,7 +536,7 @@ void BusPwm::show() {
   // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type (with 180° phase)
   // CCT additive blending must be 0 (WW & CW must not overlap) in such case
   // for all other cases it will just try to "spread" the load on PSU
-  bool cctOverlap = (_type == TYPE_ANALOG_2CH) && (_data[0]+_data[1] >= 254);
+  [[maybe_unused]] bool cctOverlap = (_type == TYPE_ANALOG_2CH) && (_data[0]+_data[1] >= 254);
 
   // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
   // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)

From fcc344ba995b6c39d8004d440057046fb5ecefa6 Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Sun, 1 Sep 2024 21:31:19 +0200
Subject: [PATCH 12/45] add read/only pin logic and check

---
 wled00/FX_fcn.cpp      | 26 +++++++++++++++-----------
 wled00/const.h         | 13 +++++++++++++
 wled00/pin_manager.cpp | 23 +++++++++++++++++++++++
 wled00/pin_manager.h   |  3 +++
 wled00/xml.cpp         | 20 +++++++++-----------
 5 files changed, 63 insertions(+), 22 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 69a742c3de..331ceb0774 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -1216,11 +1216,11 @@ void WS2812FX::finalizeInit(void) {
   if (BusManager::getNumBusses() == 0) {
     DEBUG_PRINTLN(F("No busses, init default"));
     constexpr unsigned defDataTypes[] = {LED_TYPES};
-    const unsigned defDataPins[] = {DATA_PINS};
-    const unsigned defCounts[] = {PIXEL_COUNTS};
-    const unsigned defNumTypes = ((sizeof defDataTypes) / (sizeof defDataTypes[0]));
+    constexpr unsigned defDataPins[] = {DATA_PINS};
+    constexpr unsigned defCounts[] = {PIXEL_COUNTS};
+    constexpr unsigned defNumTypes = ((sizeof defDataTypes) / (sizeof defDataTypes[0]));
     constexpr unsigned defNumPins = ((sizeof defDataPins) / (sizeof defDataPins[0]));
-    const unsigned defNumCounts = ((sizeof defCounts) / (sizeof defCounts[0]));
+    constexpr unsigned defNumCounts = ((sizeof defCounts) / (sizeof defCounts[0]));
 
     static_assert(Bus::getNumberOfPins(defDataTypes[0]) <= defNumPins,
                   "The first LED type configured requires more pins than have been defined!");
@@ -1237,14 +1237,18 @@ void WS2812FX::finalizeInit(void) {
         DEBUG_PRINTLN(F("LED outputs misaligned with defined pins. Some pins will remain unused."));
         break;
       }
-      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) defPin[j] = defDataPins[pinsIndex + j];
-      pinsIndex += busPins;
-      // when booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
-      // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), etc
-      if (pinManager.isPinAllocated(defPin[0])) {
-        defPin[0] = 1; // start with GPIO1 and work upwards
-        while (pinManager.isPinAllocated(defPin[0]) && defPin[0] < WLED_NUM_PINS) defPin[0]++;
+      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) {
+        defPin[j] = defDataPins[pinsIndex + j];
+
+        // when booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
+        // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
+        if (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) {
+          defPin[j] = 1; // start with GPIO1 and work upwards
+          while (pinManager.isPinAllocated(defPin[j]) && pinManager.isReadOnlyPin(defPin[j]) && defPin[j] < WLED_NUM_PINS) defPin[j]++;
+        }
       }
+      pinsIndex += busPins;
+
       unsigned start = prevLen;
       // if we have less counts than pins and they do not align, use last known count to set current count
       unsigned count = defCounts[(i < defNumCounts) ? i : defNumCounts -1];
diff --git a/wled00/const.h b/wled00/const.h
index cb50a108fa..ffefb3ca5e 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -572,6 +572,19 @@
 #endif
 #endif
 
+// List of read only pins. Cannot be used for LED outputs.
+#if defined(CONFIG_IDF_TARGET_ESP32S2)
+  #define READ_ONLY_PINS 46
+#elif defined(CONFIG_IDF_TARGET_ESP32S3)
+// none for S3
+#elif defined(CONFIG_IDF_TARGET_ESP32C3)
+// none for C3
+#elif defined(ESP32)
+  #define READ_ONLY_PINS 34,35,36,37,38,39
+#else
+// none for ESP8266
+#endif
+
 #ifdef WLED_ENABLE_DMX
 #if (LEDPIN == 2)
   #undef LEDPIN
diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 0a0f391554..507ce81cd1 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -267,6 +267,29 @@ bool PinManagerClass::isPinOk(byte gpio, bool output) const
   return false;
 }
 
+unsigned *PinManagerClass::getReadOnlyPins()
+{
+  #ifdef READ_ONLY_PINS
+    static unsigned readOnlyPins[] = {READ_ONLY_PINS};
+  #elif
+    static unsigned readOnlyPins[] = 255;
+  #endif
+  return readOnlyPins;
+}
+
+bool PinManagerClass::isReadOnlyPin(byte gpio)
+{
+  const unsigned* pins = PinManagerClass::getReadOnlyPins();
+  const unsigned numPins = sizeof(pins) / sizeof(pins[0]);
+
+  for (unsigned i = 0; i < numPins; i++) {
+    if (pins[i] == gpio) {
+      return true;
+    }
+  }
+  return false;
+}
+
 PinOwner PinManagerClass::getPinOwner(byte gpio) const
 {
   if (!isPinOk(gpio, false)) return PinOwner::None;
diff --git a/wled00/pin_manager.h b/wled00/pin_manager.h
index 986964a7f5..b441b89af2 100644
--- a/wled00/pin_manager.h
+++ b/wled00/pin_manager.h
@@ -112,6 +112,9 @@ class PinManagerClass {
   // will return false for reserved pins
   bool isPinOk(byte gpio, bool output = true) const;
 
+  static unsigned* getReadOnlyPins();
+  static bool isReadOnlyPin(byte gpio);
+
   PinOwner getPinOwner(byte gpio) const;
 
   #ifdef ARDUINO_ARCH_ESP32
diff --git a/wled00/xml.cpp b/wled00/xml.cpp
index c06b027686..8f8dd9e7d4 100644
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -191,17 +191,15 @@ void appendGPIOinfo() {
 
   // add info for read-only GPIO
   oappend(SET_F("d.ro_gpio=["));
-  #if defined(CONFIG_IDF_TARGET_ESP32S2)
-  oappendi(46);
-  #elif defined(CONFIG_IDF_TARGET_ESP32S3)
-  // none for S3
-  #elif defined(CONFIG_IDF_TARGET_ESP32C3)
-  // none for C3
-  #elif defined(ESP32)
-  oappend(SET_F("34,35,36,37,38,39"));
-  #else
-  // none for ESP8266
-  #endif
+  const unsigned* readOnlyPins = pinManager.getReadOnlyPins();
+  const unsigned numReadOnlyPins = ((sizeof readOnlyPins) / (sizeof readOnlyPins[0]));
+  for (unsigned i = 0; i < numReadOnlyPins; i++) {
+    // Ignore 255
+    if (readOnlyPins[i] <= WLED_NUM_PINS) {
+      oappendi(readOnlyPins[i]);
+      if (i != numReadOnlyPins) oappend(SET_F(","));
+    } 
+  }
   oappend(SET_F("];"));
 
   // add info about max. # of pins

From c9423454531999027d6b7e50444a51d036cd5794 Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Sun, 1 Sep 2024 21:35:09 +0200
Subject: [PATCH 13/45] bug fix

---
 wled00/pin_manager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 507ce81cd1..3ba48ead42 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -271,7 +271,7 @@ unsigned *PinManagerClass::getReadOnlyPins()
 {
   #ifdef READ_ONLY_PINS
     static unsigned readOnlyPins[] = {READ_ONLY_PINS};
-  #elif
+  #else
     static unsigned readOnlyPins[] = 255;
   #endif
   return readOnlyPins;

From 9bb979f2e8cab910ad0a2ec8a7d3026b1f93413c Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Sun, 1 Sep 2024 21:46:30 +0200
Subject: [PATCH 14/45] bug fix

---
 wled00/pin_manager.cpp | 4 ++--
 wled00/xml.cpp         | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 3ba48ead42..527e4470c4 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -272,7 +272,7 @@ unsigned *PinManagerClass::getReadOnlyPins()
   #ifdef READ_ONLY_PINS
     static unsigned readOnlyPins[] = {READ_ONLY_PINS};
   #else
-    static unsigned readOnlyPins[] = 255;
+    static unsigned readOnlyPins[] = {255};
   #endif
   return readOnlyPins;
 }
@@ -280,7 +280,7 @@ unsigned *PinManagerClass::getReadOnlyPins()
 bool PinManagerClass::isReadOnlyPin(byte gpio)
 {
   const unsigned* pins = PinManagerClass::getReadOnlyPins();
-  const unsigned numPins = sizeof(pins) / sizeof(pins[0]);
+  const unsigned numPins = (sizeof *pins) / (sizeof pins[0]);
 
   for (unsigned i = 0; i < numPins; i++) {
     if (pins[i] == gpio) {
diff --git a/wled00/xml.cpp b/wled00/xml.cpp
index 8f8dd9e7d4..dfb3d67df2 100644
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -192,7 +192,7 @@ void appendGPIOinfo() {
   // add info for read-only GPIO
   oappend(SET_F("d.ro_gpio=["));
   const unsigned* readOnlyPins = pinManager.getReadOnlyPins();
-  const unsigned numReadOnlyPins = ((sizeof readOnlyPins) / (sizeof readOnlyPins[0]));
+  const unsigned numReadOnlyPins = (sizeof *readOnlyPins) / (sizeof readOnlyPins[0]);
   for (unsigned i = 0; i < numReadOnlyPins; i++) {
     // Ignore 255
     if (readOnlyPins[i] <= WLED_NUM_PINS) {

From 85e2f7eb34458aeda38e02e8bcf9a10e12260d9f Mon Sep 17 00:00:00 2001
From: Damian Schneider <daedae@gmx.ch>
Date: Mon, 2 Sep 2024 17:53:15 +0200
Subject: [PATCH 15/45] fixed offsets and inverted signal plus dead time

---
 wled00/bus_manager.cpp | 63 ++++++++++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 20 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 4d12c93b6d..8428e12666 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -410,6 +410,7 @@ BusPwm::BusPwm(BusConfig &bc)
 {
   if (!isPWM(bc.type)) return;
   unsigned numPins = numPWMPins(bc.type);
+  unsigned dithering = 0;
   _frequency = bc.frequency ? bc.frequency : WLED_PWM_FREQ;
   // duty cycle resolution (_depth) can be extracted from this formula: CLOCK_FREQUENCY > _frequency * 2^_depth
   for (_depth = MAX_BIT_WIDTH; _depth > 8; _depth--) if (((CLOCK_FREQUENCY/_frequency) >> _depth) > 0) break;
@@ -428,7 +429,10 @@ BusPwm::BusPwm(BusConfig &bc)
     pinManager.deallocateMultiplePins(pins, numPins, PinOwner::BusPwm);
     return;
   }
-  if (_needsRefresh) _depth = 8; // fixed 8 bit depth with 4 bit dithering (ESP8266 has no hardware to support dithering)
+  if (_needsRefresh) {
+    _depth = 12; // fixed 8 bit depth PWM with 4 bit dithering (ESP8266 has no hardware to support dithering)
+    dithering = 4;
+  }
 #endif
 
   for (unsigned i = 0; i < numPins; i++) {
@@ -437,7 +441,7 @@ BusPwm::BusPwm(BusConfig &bc)
     pinMode(_pins[i], OUTPUT);
     #else
     unsigned channel = _ledcStart + i;
-    ledcSetup(channel, _frequency, _depth);
+    ledcSetup(channel, _frequency, _depth - dithering);
     ledcAttachPin(_pins[i], channel);
     // LEDC timer reset credit @dedehai
     uint8_t group = (channel / 8), timer = ((channel / 2) % 4); // same fromula as in ledcSetup()
@@ -511,8 +515,11 @@ uint32_t BusPwm::getPixelColor(uint16_t pix) const {
 
 void BusPwm::show() {
   if (!_valid) return;
+  bool dithering = _needsRefresh;      // avoid working with bitfield
   const unsigned numPins = getPins();
-  const unsigned maxBri = (1<<_depth); // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8)
+  const unsigned maxBri = (1<<_depth) + 1; // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8) note: +1 ensures 'full on' (else there is one low pulse period at 100% dutycycle)
+  const unsigned bithsift = dithering * 4; 
+  //const unsigned maxBri = (1<<_depth) << (dithering*4); // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8)
 
   // use CIE brightness formula (cubic) to fit (or approximate linearity of) human eye perceived brightness
   // the formula is based on 12 bit resolution as there is no need for greater precision
@@ -525,41 +532,37 @@ void BusPwm::show() {
     // cubic response for values [21-255]
     pwmBri += 4080;
     float temp = (float)pwmBri / 29580.0f;
-    temp = temp * temp * temp * 4095.0f; 
+    temp = temp * temp * temp * (float)maxBri; 
     pwmBri = (unsigned)temp;
   }
   // pwmBri is in range [0-4095]
 
   // determine phase shift
   [[maybe_unused]] unsigned phaseOffset = maxBri / numPins; // (maxBri is at _depth resolution)
-  // we will be phase shifting every channel by fixed amount (i times /2 or /3 or /4 or /5)
-  // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type (with 180° phase)
+
+  unsigned phaseOffset = 0; 
+  // we will be phase shifting every channel by previous pulse length (plus dead time if required)
+  // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type 
   // CCT additive blending must be 0 (WW & CW must not overlap) in such case
   // for all other cases it will just try to "spread" the load on PSU
-  [[maybe_unused]] bool cctOverlap = (_type == TYPE_ANALOG_2CH) && (_data[0]+_data[1] >= 254);
 
   // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
   // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)
-  bool dithering = _needsRefresh;                           // avoid working with bitfield
 
   for (unsigned i = 0; i < numPins; i++) {
-    unsigned scaled = (_data[i] * pwmBri) / 255;            // scaled is at 12 bit depth (same as pwmBri)
-    // adjust "scaled" value (to fit resolution bounds)
-    if (_depth < 12 && !dithering) scaled >>= 12 - _depth;  // normalize scaled value (if not using dithering)
-    else if (_depth > 12)          scaled <<= _depth - 12;  // scale to _depth if using >12 bit
-    if (_reversed)                 scaled = maxBri - scaled;
+    unsigned scaled = (_data[i] * pwmBri) / 255;   
+    if (_reversed)                 scaled = maxBri - scaled; 
     // scaled is now at _depth resolution (8-14 bits) except when using dithering, 12 bit in such case
     #ifdef ESP8266
     analogWrite(_pins[i], scaled);
     #else
     unsigned channel = _ledcStart + i;
-    // prevent overlapping PWM signals for H-bridge
-    // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer
-    // so we only need to take care of shortening the signal at 50% distribution for 1 pulse
-    if (cctOverlap && Bus::getCCTBlend() == 0) {
-      unsigned shift = (dithering*4);
-      unsigned briLimit = phaseOffset << shift;               // expand limit if using dithering
-      if (scaled >= briLimit) scaled = briLimit - (1<<shift); // safety check & 1 pulse dead time when brightness is at 50%
+    // prevent overlapping PWM signals (required for H-bridge driven CCT strips)
+    // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer (i.e. they are in sync)
+    // we only need to take care of shortening the signal at full brightness, otherwise the pulses cannot overlap with CCTBlend() == 0
+    if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {    
+      if (_bri==255) scaled -= 2 << bithsift;  // add dead time when brightness is 100% (when using dithering, two full 8bit pulses are required, in non-dithering one extra pulse does not hurt at all    note: actually could add dead time only if global brightness is also at 255
+      //another way (maybe more elegant?) of doing this would be to limit bus brightness to 254 if CCT is enabled with zero blending (
     }
     unsigned gr = channel/8;  // high/low speed group
     unsigned ch = channel%8;  // group channel
@@ -571,8 +574,28 @@ void BusPwm::show() {
     LEDC.channel_group[gr].channel[ch].hpoint.hpoint = phaseOffset*i; // phaseOffset is at _depth resolution (8 bit)
     LEDC_MUTEX_UNLOCK();
     ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
+
+    
+    phaseOffset += ((scaled + (maxBri - scaled) / 2) >> bithsift) + 1; // fixed 180°, add 1 pulse for dead time (min pulse with dithering is 8bit)
+    phaseOffset += 2 + (scaled >> bithsift); // offset to cascade the signals, dithering requires two pulses and in non-dithering the extra pulse does not hurt
+    if(phaseOffset >= maxBri >> bithsift) phaseOffset = 0; // offset it out of bounds, reset
+      
+    Serial.print(" maxbri = ");
+    Serial.print(maxBri);
+    Serial.print(" offset = ");
+    Serial.print(phaseOffset);
+    Serial.print(" bit depth = ");
+    Serial.print(_depth);
+    Serial.print(" freq = ");
+    Serial.print(_frequency);
+    Serial.print(" scaled= ");
+    Serial.println(scaled);
+    Serial.print(" duty = ");
+    Serial.println(LEDC.channel_group[gr].channel[ch].duty.duty);
+
     #endif
   }
+  Serial.println("*********");
 }
 
 uint8_t BusPwm::getPins(uint8_t* pinArray) const {

From be7475fe669def0a0ad4b25080de59f18dd50bf7 Mon Sep 17 00:00:00 2001
From: Damian Schneider <daedae@gmx.ch>
Date: Mon, 2 Sep 2024 22:06:46 +0200
Subject: [PATCH 16/45] bugfixes, removed debug printout

---
 wled00/bus_manager.cpp | 26 ++------------------------
 1 file changed, 2 insertions(+), 24 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 8428e12666..ba36eb12ba 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -533,13 +533,8 @@ void BusPwm::show() {
     pwmBri += 4080;
     float temp = (float)pwmBri / 29580.0f;
     temp = temp * temp * temp * (float)maxBri; 
-    pwmBri = (unsigned)temp;
+    pwmBri = (unsigned)temp;  // pwmBri is in range [0-maxBri] 
   }
-  // pwmBri is in range [0-4095]
-
-  // determine phase shift
-  [[maybe_unused]] unsigned phaseOffset = maxBri / numPins; // (maxBri is at _depth resolution)
-
   unsigned phaseOffset = 0; 
   // we will be phase shifting every channel by previous pulse length (plus dead time if required)
   // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type 
@@ -575,27 +570,10 @@ void BusPwm::show() {
     LEDC_MUTEX_UNLOCK();
     ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
 
-    
-    phaseOffset += ((scaled + (maxBri - scaled) / 2) >> bithsift) + 1; // fixed 180°, add 1 pulse for dead time (min pulse with dithering is 8bit)
     phaseOffset += 2 + (scaled >> bithsift); // offset to cascade the signals, dithering requires two pulses and in non-dithering the extra pulse does not hurt
-    if(phaseOffset >= maxBri >> bithsift) phaseOffset = 0; // offset it out of bounds, reset
-      
-    Serial.print(" maxbri = ");
-    Serial.print(maxBri);
-    Serial.print(" offset = ");
-    Serial.print(phaseOffset);
-    Serial.print(" bit depth = ");
-    Serial.print(_depth);
-    Serial.print(" freq = ");
-    Serial.print(_frequency);
-    Serial.print(" scaled= ");
-    Serial.println(scaled);
-    Serial.print(" duty = ");
-    Serial.println(LEDC.channel_group[gr].channel[ch].duty.duty);
-
+    if(phaseOffset >= maxBri >> bithsift) phaseOffset = 0; // offset it out of bounds, reset TODO: maybe this should be (maxBri-1), need to test
     #endif
   }
-  Serial.println("*********");
 }
 
 uint8_t BusPwm::getPins(uint8_t* pinArray) const {

From d79d5dbadd99925d792f907464e8279808438c0a Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Tue, 3 Sep 2024 17:29:38 +0200
Subject: [PATCH 17/45] remove getReadOnlyPins() function

---
 wled00/pin_manager.cpp | 23 +++++++----------------
 wled00/pin_manager.h   |  3 +--
 wled00/xml.cpp         | 16 ++++++++--------
 3 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 527e4470c4..2bd82115f6 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -267,26 +267,17 @@ bool PinManagerClass::isPinOk(byte gpio, bool output) const
   return false;
 }
 
-unsigned *PinManagerClass::getReadOnlyPins()
-{
-  #ifdef READ_ONLY_PINS
-    static unsigned readOnlyPins[] = {READ_ONLY_PINS};
-  #else
-    static unsigned readOnlyPins[] = {255};
-  #endif
-  return readOnlyPins;
-}
-
 bool PinManagerClass::isReadOnlyPin(byte gpio)
 {
-  const unsigned* pins = PinManagerClass::getReadOnlyPins();
-  const unsigned numPins = (sizeof *pins) / (sizeof pins[0]);
+  #ifdef READ_ONLY_PINS
+  const unsigned pins[] = {READ_ONLY_PINS};
+  const unsigned numPins = ((sizeof pins) / (sizeof pins[0]));
 
-  for (unsigned i = 0; i < numPins; i++) {
-    if (pins[i] == gpio) {
-      return true;
-    }
+  if (gpio <= WLED_NUM_PINS) {
+    for (unsigned i = 0; i < numPins; i++) if (gpio == pins[i]) return true;
   }
+  #endif
+
   return false;
 }
 
diff --git a/wled00/pin_manager.h b/wled00/pin_manager.h
index b441b89af2..a8ddf5f751 100644
--- a/wled00/pin_manager.h
+++ b/wled00/pin_manager.h
@@ -111,8 +111,7 @@ class PinManagerClass {
   bool isPinAllocated(byte gpio, PinOwner tag = PinOwner::None) const;
   // will return false for reserved pins
   bool isPinOk(byte gpio, bool output = true) const;
-
-  static unsigned* getReadOnlyPins();
+  
   static bool isReadOnlyPin(byte gpio);
 
   PinOwner getPinOwner(byte gpio) const;
diff --git a/wled00/xml.cpp b/wled00/xml.cpp
index dfb3d67df2..fce453cfc1 100644
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -191,14 +191,14 @@ void appendGPIOinfo() {
 
   // add info for read-only GPIO
   oappend(SET_F("d.ro_gpio=["));
-  const unsigned* readOnlyPins = pinManager.getReadOnlyPins();
-  const unsigned numReadOnlyPins = (sizeof *readOnlyPins) / (sizeof readOnlyPins[0]);
-  for (unsigned i = 0; i < numReadOnlyPins; i++) {
-    // Ignore 255
-    if (readOnlyPins[i] <= WLED_NUM_PINS) {
-      oappendi(readOnlyPins[i]);
-      if (i != numReadOnlyPins) oappend(SET_F(","));
-    } 
+  bool firstPin = true;
+  for (unsigned i = 0; i < WLED_NUM_PINS; i++) {
+    if (pinManager.isReadOnlyPin(i)) {
+      // No comma before the first pin
+      if (!firstPin) oappend(SET_F(","));
+      oappendi(i);
+      firstPin = false;
+    }
   }
   oappend(SET_F("];"));
 

From 2cc0aceac7ad08d45cbb1e981c9ae203cf349470 Mon Sep 17 00:00:00 2001
From: Damian Schneider <daedae@gmx.ch>
Date: Tue, 3 Sep 2024 19:14:50 +0200
Subject: [PATCH 18/45] Bugfixes

- fixed maxBri value
- fixed overflow in dead time subtraction
- deadtime and offset now also work if signals are inverted (_reversed)
---
 wled00/bus_manager.cpp | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index ba36eb12ba..2756cc946f 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -517,10 +517,8 @@ void BusPwm::show() {
   if (!_valid) return;
   bool dithering = _needsRefresh;      // avoid working with bitfield
   const unsigned numPins = getPins();
-  const unsigned maxBri = (1<<_depth) + 1; // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8) note: +1 ensures 'full on' (else there is one low pulse period at 100% dutycycle)
+  const unsigned maxBri = (1<<_depth); // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8) 
   const unsigned bithsift = dithering * 4; 
-  //const unsigned maxBri = (1<<_depth) << (dithering*4); // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8)
-
   // use CIE brightness formula (cubic) to fit (or approximate linearity of) human eye perceived brightness
   // the formula is based on 12 bit resolution as there is no need for greater precision
   // see: https://en.wikipedia.org/wiki/Lightness
@@ -540,38 +538,37 @@ void BusPwm::show() {
   // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type 
   // CCT additive blending must be 0 (WW & CW must not overlap) in such case
   // for all other cases it will just try to "spread" the load on PSU
-
   // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
   // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)
-
   for (unsigned i = 0; i < numPins; i++) {
     unsigned scaled = (_data[i] * pwmBri) / 255;   
-    if (_reversed)                 scaled = maxBri - scaled; 
+    // prevent overlapping PWM signals (required for H-bridge driven CCT strips)
+    // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer (i.e. they are in sync)
+    // we only need to take care of shortening the signal at full brightness, otherwise the pulses overlap with CCTBlend() == 0
+    signed deadtime = 0; // add dead time when brightness is 100% (when using dithering, two full 8bit pulses are required, in non-dithering one extra pulse does not hurt at all    note: actually could add dead time only if global brightness is also at 255    
+    if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {      
+      deadtime = 2 << bithsift;  
+      if (_bri == 255 && scaled >= deadtime) scaled -= deadtime;  
+      //another way (maybe more elegant?) of doing this would be to limit bus brightness to 254 if CCT is enabled with zero blending 
+      if(_reversed) deadtime = -deadtime; // need to invert dead time at this point: phaseshift needs to go the opposite way so low signals dont overlap
+    }
+    if (_reversed) scaled = maxBri - scaled; 
     // scaled is now at _depth resolution (8-14 bits) except when using dithering, 12 bit in such case
     #ifdef ESP8266
     analogWrite(_pins[i], scaled);
     #else
-    unsigned channel = _ledcStart + i;
-    // prevent overlapping PWM signals (required for H-bridge driven CCT strips)
-    // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer (i.e. they are in sync)
-    // we only need to take care of shortening the signal at full brightness, otherwise the pulses cannot overlap with CCTBlend() == 0
-    if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {    
-      if (_bri==255) scaled -= 2 << bithsift;  // add dead time when brightness is 100% (when using dithering, two full 8bit pulses are required, in non-dithering one extra pulse does not hurt at all    note: actually could add dead time only if global brightness is also at 255
-      //another way (maybe more elegant?) of doing this would be to limit bus brightness to 254 if CCT is enabled with zero blending (
-    }
+    unsigned channel = _ledcStart + i;    
     unsigned gr = channel/8;  // high/low speed group
     unsigned ch = channel%8;  // group channel
     // directly write to LEDC struct as there is no HAL exposed function for dithering
     // duty has 20 bit resolution with 4 fractional bits (24 bits in total)
-    // _depth is 8 bit in this case (and maxBri==256), scaled is still at 12 bit
     LEDC_MUTEX_LOCK();
-    LEDC.channel_group[gr].channel[ch].duty.duty = scaled << ((!dithering)*4); // write full 12 bit value (4 dithering bits)
-    LEDC.channel_group[gr].channel[ch].hpoint.hpoint = phaseOffset*i; // phaseOffset is at _depth resolution (8 bit)
+    LEDC.channel_group[gr].channel[ch].duty.duty = scaled << ((!dithering)*4); // lowest 4 bits are used for dithering, shift by 4 bits if not using dithering
+    LEDC.channel_group[gr].channel[ch].hpoint.hpoint = phaseOffset; 
     LEDC_MUTEX_UNLOCK();
     ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
-
-    phaseOffset += 2 + (scaled >> bithsift); // offset to cascade the signals, dithering requires two pulses and in non-dithering the extra pulse does not hurt
-    if(phaseOffset >= maxBri >> bithsift) phaseOffset = 0; // offset it out of bounds, reset TODO: maybe this should be (maxBri-1), need to test
+    phaseOffset += ((scaled + deadtime) >> bithsift); // offset to cascade the signals, add dead time if required (to ensure pulses do not overlap)
+    if(phaseOffset >= maxBri >> bithsift) phaseOffset = 0; // offset it out of bounds, reset    
     #endif
   }
 }

From b1e58dd10dd326f619b3c983174d4cf8e50aa3b9 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Tue, 3 Sep 2024 22:28:21 +0200
Subject: [PATCH 19/45] Optimisations - renamed variables - some tuning

---
 wled00/bus_manager.cpp | 55 +++++++++++++++++++++---------------------
 1 file changed, 27 insertions(+), 28 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index 2756cc946f..f9dd847d75 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -429,6 +429,7 @@ BusPwm::BusPwm(BusConfig &bc)
     pinManager.deallocateMultiplePins(pins, numPins, PinOwner::BusPwm);
     return;
   }
+  // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
   if (_needsRefresh) {
     _depth = 12; // fixed 8 bit depth PWM with 4 bit dithering (ESP8266 has no hardware to support dithering)
     dithering = 4;
@@ -515,10 +516,13 @@ uint32_t BusPwm::getPixelColor(uint16_t pix) const {
 
 void BusPwm::show() {
   if (!_valid) return;
-  bool dithering = _needsRefresh;      // avoid working with bitfield
+  // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
+  // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)
+  const bool     dithering = _needsRefresh; // avoid working with bitfield
   const unsigned numPins = getPins();
-  const unsigned maxBri = (1<<_depth); // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8) 
-  const unsigned bithsift = dithering * 4; 
+  const unsigned maxBri = (1<<_depth);      // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8) 
+  const unsigned bitShift = dithering * 4;  // if dithering, _depth is 12 bit but LEDC channel is set to 8 bit (using 4 fractional bits)
+
   // use CIE brightness formula (cubic) to fit (or approximate linearity of) human eye perceived brightness
   // the formula is based on 12 bit resolution as there is no need for greater precision
   // see: https://en.wikipedia.org/wiki/Lightness
@@ -533,42 +537,37 @@ void BusPwm::show() {
     temp = temp * temp * temp * (float)maxBri; 
     pwmBri = (unsigned)temp;  // pwmBri is in range [0-maxBri] 
   }
-  unsigned phaseOffset = 0; 
+
+  [[maybe_unused]] unsigned hPoint = 0;  // phase shift (0 - maxBri)
   // we will be phase shifting every channel by previous pulse length (plus dead time if required)
   // phase shifting is only mandatory when using H-bridge to drive reverse-polarity PWM CCT (2 wire) LED type 
-  // CCT additive blending must be 0 (WW & CW must not overlap) in such case
+  // CCT additive blending must be 0 (WW & CW will not overlap) otherwise signals *will* overlap
   // for all other cases it will just try to "spread" the load on PSU
-  // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
-  // https://github.com/Aircoookie/WLED/pull/4115 and https://github.com/zalatnaicsongor/WLED/pull/1)
+  // Phase shifting requires that LEDC timers are synchronised (see setup()). For PWM CCT (and H-bridge) it is
+  // also mandatory that both channels use the same timer (pinManager takes care of that).
   for (unsigned i = 0; i < numPins; i++) {
-    unsigned scaled = (_data[i] * pwmBri) / 255;   
-    // prevent overlapping PWM signals (required for H-bridge driven CCT strips)
-    // pinManager will make sure both LEDC channels are in the same speed group and sharing the same timer (i.e. they are in sync)
-    // we only need to take care of shortening the signal at full brightness, otherwise the pulses overlap with CCTBlend() == 0
-    signed deadtime = 0; // add dead time when brightness is 100% (when using dithering, two full 8bit pulses are required, in non-dithering one extra pulse does not hurt at all    note: actually could add dead time only if global brightness is also at 255    
-    if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {      
-      deadtime = 2 << bithsift;  
-      if (_bri == 255 && scaled >= deadtime) scaled -= deadtime;  
-      //another way (maybe more elegant?) of doing this would be to limit bus brightness to 254 if CCT is enabled with zero blending 
-      if(_reversed) deadtime = -deadtime; // need to invert dead time at this point: phaseshift needs to go the opposite way so low signals dont overlap
-    }
-    if (_reversed) scaled = maxBri - scaled; 
-    // scaled is now at _depth resolution (8-14 bits) except when using dithering, 12 bit in such case
+    unsigned duty = (_data[i] * pwmBri) / 255;
+    if (_reversed) duty = maxBri - duty;
     #ifdef ESP8266
-    analogWrite(_pins[i], scaled);
+    analogWrite(_pins[i], duty);
     #else
-    unsigned channel = _ledcStart + i;    
+    unsigned deadTime = 0;
+    if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {
+      // add dead time between signals (when using dithering, two full 8bit pulses are required)
+      deadTime = (1+dithering) << bitShift;
+      // we only need to take care of shortening the signal at (almost) full brightness otherwise pulses may overflow hPoint
+      if (_bri >= 254 && duty + deadTime + hPoint >= maxBri) duty = maxBri - hPoint - deadTime; // shorten duty if overflowing
+    }
+    unsigned channel = _ledcStart + i;
     unsigned gr = channel/8;  // high/low speed group
     unsigned ch = channel%8;  // group channel
     // directly write to LEDC struct as there is no HAL exposed function for dithering
     // duty has 20 bit resolution with 4 fractional bits (24 bits in total)
-    LEDC_MUTEX_LOCK();
-    LEDC.channel_group[gr].channel[ch].duty.duty = scaled << ((!dithering)*4); // lowest 4 bits are used for dithering, shift by 4 bits if not using dithering
-    LEDC.channel_group[gr].channel[ch].hpoint.hpoint = phaseOffset; 
-    LEDC_MUTEX_UNLOCK();
+    LEDC.channel_group[gr].channel[ch].duty.duty = duty << ((!dithering)*4);  // lowest 4 bits are used for dithering, shift by 4 bits if not using dithering
+    LEDC.channel_group[gr].channel[ch].hpoint.hpoint = hPoint >> bitShift;    // hPoint is at _depth resolution (needs shifting if dithering)
     ledc_update_duty((ledc_mode_t)gr, (ledc_channel_t)ch);
-    phaseOffset += ((scaled + deadtime) >> bithsift); // offset to cascade the signals, add dead time if required (to ensure pulses do not overlap)
-    if(phaseOffset >= maxBri >> bithsift) phaseOffset = 0; // offset it out of bounds, reset    
+    hPoint += duty + deadTime;        // offset to cascade the signals
+    if (hPoint >= maxBri) hPoint = 0; // offset it out of bounds, reset
     #endif
   }
 }

From 8e4f8fcbc8eb069306a7eca3c7750061734da8fc Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Wed, 4 Sep 2024 13:27:04 +0200
Subject: [PATCH 20/45] fix bug in reassignment logic

---
 wled00/FX_fcn.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 331ceb0774..a737fb5490 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -1237,6 +1237,7 @@ void WS2812FX::finalizeInit(void) {
         DEBUG_PRINTLN(F("LED outputs misaligned with defined pins. Some pins will remain unused."));
         break;
       }
+      
       for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) {
         defPin[j] = defDataPins[pinsIndex + j];
 
@@ -1244,7 +1245,7 @@ void WS2812FX::finalizeInit(void) {
         // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
         if (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) {
           defPin[j] = 1; // start with GPIO1 and work upwards
-          while (pinManager.isPinAllocated(defPin[j]) && pinManager.isReadOnlyPin(defPin[j]) && defPin[j] < WLED_NUM_PINS) defPin[j]++;
+          while ((pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) && defPin[j] < WLED_NUM_PINS) defPin[j]++;
         }
       }
       pinsIndex += busPins;

From 329173e1452846a419feb426bcbc041e9163cc93 Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Wed, 4 Sep 2024 13:28:43 +0200
Subject: [PATCH 21/45] added complete validation logic for pins and types

---
 wled00/FX_fcn.cpp | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index a737fb5490..74d6125643 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -69,6 +69,18 @@
   #error "Max segments must be at least max number of busses!"
 #endif
 
+static constexpr unsigned sumPinsRequired(const unsigned* current, size_t count) {
+ return (count > 0) ? (Bus::getNumberOfPins(*current) + sumPinsRequired(current+1,count-1)) : 0;
+}
+
+static constexpr bool validatePinsAndTypes(const unsigned* types, unsigned numTypes, unsigned numPins ) {
+  // Pins provided < pins required -> always invalid
+  // Pins provided = pins required -> always valid
+  // Pins provided > pins required -> last type will repeat until we run out of pins, make sure excess pins modulo last type pins == 0
+  return (sumPinsRequired(types, numTypes) > numPins) ? false :
+          (numPins - sumPinsRequired(types, numTypes)) % Bus::getNumberOfPins(types[numTypes-1]) == 0;
+}
+
 
 ///////////////////////////////////////////////////////////////////////////////
 // Segment class implementation
@@ -1222,9 +1234,9 @@ void WS2812FX::finalizeInit(void) {
     constexpr unsigned defNumPins = ((sizeof defDataPins) / (sizeof defDataPins[0]));
     constexpr unsigned defNumCounts = ((sizeof defCounts) / (sizeof defCounts[0]));
 
-    static_assert(Bus::getNumberOfPins(defDataTypes[0]) <= defNumPins,
-                  "The first LED type configured requires more pins than have been defined!");
-
+    static_assert(validatePinsAndTypes(defDataTypes, defNumTypes, defNumPins),
+                  "The default pin list defined in DATA_PINS does not match the pin requirements for the default buses defined in LED_TYPES");
+    
     unsigned prevLen = 0;
     unsigned pinsIndex = 0;
     for (unsigned i = 0; i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) {
@@ -1232,7 +1244,9 @@ void WS2812FX::finalizeInit(void) {
       // if we have less types than requested outputs and they do not align, use last known type to set current type
       unsigned dataType = defDataTypes[(i < defNumTypes) ? i : defNumTypes -1];
       unsigned busPins = Bus::getNumberOfPins(dataType);
+
       // check if we have enough pins left to configure an output of this type
+      // should never happen due to static assert above
       if (pinsIndex + busPins > defNumPins) {
         DEBUG_PRINTLN(F("LED outputs misaligned with defined pins. Some pins will remain unused."));
         break;
@@ -1245,6 +1259,7 @@ void WS2812FX::finalizeInit(void) {
         // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
         if (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) {
           defPin[j] = 1; // start with GPIO1 and work upwards
+          // @FIX pins are allocated after the loop, so if we reassign to a pin that's already in the array for this output 2 fields will have the same pin
           while ((pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) && defPin[j] < WLED_NUM_PINS) defPin[j]++;
         }
       }

From d3c31c52a27faaefb6bd1aca5bdc3b76ea4431fd Mon Sep 17 00:00:00 2001
From: Damian Schneider <daedae@gmx.ch>
Date: Wed, 4 Sep 2024 18:03:52 +0200
Subject: [PATCH 22/45] found a better way of deadTime subtraction, fixed
 inverted signals

---
 wled00/bus_manager.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index f9dd847d75..e18d1023c0 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -546,18 +546,20 @@ void BusPwm::show() {
   // Phase shifting requires that LEDC timers are synchronised (see setup()). For PWM CCT (and H-bridge) it is
   // also mandatory that both channels use the same timer (pinManager takes care of that).
   for (unsigned i = 0; i < numPins; i++) {
-    unsigned duty = (_data[i] * pwmBri) / 255;
-    if (_reversed) duty = maxBri - duty;
+    unsigned duty = (_data[i] * pwmBri) / 255;    
     #ifdef ESP8266
+    if (_reversed) duty = maxBri - duty;
     analogWrite(_pins[i], duty);
     #else
     unsigned deadTime = 0;
     if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {
       // add dead time between signals (when using dithering, two full 8bit pulses are required)
       deadTime = (1+dithering) << bitShift;
-      // we only need to take care of shortening the signal at (almost) full brightness otherwise pulses may overflow hPoint
-      if (_bri >= 254 && duty + deadTime + hPoint >= maxBri) duty = maxBri - hPoint - deadTime; // shorten duty if overflowing
+      // we only need to take care of shortening the signal at (almost) full brightness otherwise pulses may overlap
+      if (_bri >= 254 && duty >= maxBri / 2 && duty < maxBri) duty -= deadTime << 1; // shorten duty of larger signal except if full on
+      if(_reversed) deadTime = -deadTime; // need to invert dead time to make phaseshift go the opposite way so low signals dont overlap
     }
+    if (_reversed) duty = maxBri - duty;
     unsigned channel = _ledcStart + i;
     unsigned gr = channel/8;  // high/low speed group
     unsigned ch = channel%8;  // group channel

From 092a5a1ca34c2c17c353c6c0c87550cf831a9e80 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Wed, 4 Sep 2024 20:54:44 +0200
Subject: [PATCH 23/45] Unsigned fix

---
 wled00/bus_manager.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index e18d1023c0..ef7df007df 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -551,13 +551,13 @@ void BusPwm::show() {
     if (_reversed) duty = maxBri - duty;
     analogWrite(_pins[i], duty);
     #else
-    unsigned deadTime = 0;
+    int deadTime = 0;
     if (_type == TYPE_ANALOG_2CH && Bus::getCCTBlend() == 0) {
       // add dead time between signals (when using dithering, two full 8bit pulses are required)
       deadTime = (1+dithering) << bitShift;
       // we only need to take care of shortening the signal at (almost) full brightness otherwise pulses may overlap
       if (_bri >= 254 && duty >= maxBri / 2 && duty < maxBri) duty -= deadTime << 1; // shorten duty of larger signal except if full on
-      if(_reversed) deadTime = -deadTime; // need to invert dead time to make phaseshift go the opposite way so low signals dont overlap
+      if (_reversed) deadTime = -deadTime; // need to invert dead time to make phaseshift go the opposite way so low signals dont overlap
     }
     if (_reversed) duty = maxBri - duty;
     unsigned channel = _ledcStart + i;

From 9cc333b2bdc7dab0d654b1bbfdf01e147bf8acbe Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Thu, 5 Sep 2024 21:49:27 +0200
Subject: [PATCH 24/45] Move LED types to individual bus type - (credit
 @netmindz & @willmmiles) Tuning.

---
 wled00/bus_manager.cpp | 147 ++++++++++++++++++++++++-----------------
 wled00/bus_manager.h   |  23 +++++--
 2 files changed, 103 insertions(+), 67 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index ef7df007df..e214604fcc 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -363,6 +363,32 @@ void BusDigital::setColorOrder(uint8_t colorOrder) {
   _colorOrder = colorOrder;
 }
 
+// credit @willmmiles & @netmindz https://github.com/Aircoookie/WLED/pull/4056
+std::vector<LEDType> BusDigital::getLEDTypes() {
+  return {
+    {TYPE_WS2812_RGB,    "D",  PSTR("WS281x")},
+    {TYPE_SK6812_RGBW,   "D",  PSTR("SK6812/WS2814 RGBW")},
+    {TYPE_TM1814,        "D",  PSTR("TM1814")},
+    {TYPE_WS2811_400KHZ, "D",  PSTR("400kHz")},
+    {TYPE_TM1829,        "D",  PSTR("TM1829")},
+    {TYPE_UCS8903,       "D",  PSTR("UCS8903")},
+    {TYPE_APA106,        "D",  PSTR("APA106/PL9823")},
+    {TYPE_TM1914,        "D",  PSTR("TM1914")},
+    {TYPE_FW1906,        "D",  PSTR("FW1906 GRBCW")},
+    {TYPE_UCS8904,       "D",  PSTR("UCS8904 RGBW")},
+    {TYPE_WS2805,        "D",  PSTR("WS2805 RGBCW")},
+    {TYPE_SM16825,       "D",  PSTR("SM16825 RGBCW")},
+    {TYPE_WS2812_1CH_X3, "D",  PSTR("WS2811 White")},
+    //{TYPE_WS2812_2CH_X3, "D",  PSTR("WS2811 CCT")}, // not implemented
+    //{TYPE_WS2812_WWA,    "D",  PSTR("WS2811 WWA")}, // not implemented
+    {TYPE_WS2801,        "2P", PSTR("WS2801")},
+    {TYPE_APA102,        "2P", PSTR("APA102")},
+    {TYPE_LPD8806,       "2P", PSTR("LPD8806")},
+    {TYPE_LPD6803,       "2P", PSTR("LPD6803")},
+    {TYPE_P9813,         "2P", PSTR("PP9813")},
+  };
+}
+
 void BusDigital::reinit(void) {
   if (!_valid) return;
   PolyBus::begin(_busPtr, _iType, _pins);
@@ -406,11 +432,11 @@ void BusDigital::cleanup(void) {
 #endif
 
 BusPwm::BusPwm(BusConfig &bc)
-: Bus(bc.type, bc.start, bc.autoWhite, 1, bc.reversed, bc.refreshReq) // hijack Off refresh flag to indicate usage of phase shifting
+: Bus(bc.type, bc.start, bc.autoWhite, 1, bc.reversed, bc.refreshReq) // hijack Off refresh flag to indicate usage of dithering
 {
   if (!isPWM(bc.type)) return;
   unsigned numPins = numPWMPins(bc.type);
-  unsigned dithering = 0;
+  [[maybe_unused]] const bool dithering = _needsRefresh;
   _frequency = bc.frequency ? bc.frequency : WLED_PWM_FREQ;
   // duty cycle resolution (_depth) can be extracted from this formula: CLOCK_FREQUENCY > _frequency * 2^_depth
   for (_depth = MAX_BIT_WIDTH; _depth > 8; _depth--) if (((CLOCK_FREQUENCY/_frequency) >> _depth) > 0) break;
@@ -430,10 +456,7 @@ BusPwm::BusPwm(BusConfig &bc)
     return;
   }
   // if _needsRefresh is true (UI hack) we are using dithering (credit @dedehai & @zalatnaicsongor)
-  if (_needsRefresh) {
-    _depth = 12; // fixed 8 bit depth PWM with 4 bit dithering (ESP8266 has no hardware to support dithering)
-    dithering = 4;
-  }
+  if (dithering) _depth = 12; // fixed 8 bit depth PWM with 4 bit dithering (ESP8266 has no hardware to support dithering)
 #endif
 
   for (unsigned i = 0; i < numPins; i++) {
@@ -442,7 +465,7 @@ BusPwm::BusPwm(BusConfig &bc)
     pinMode(_pins[i], OUTPUT);
     #else
     unsigned channel = _ledcStart + i;
-    ledcSetup(channel, _frequency, _depth - dithering);
+    ledcSetup(channel, _frequency, _depth - (dithering*4)); // with dithering _frequency doesn't really matter as resolution is 8 bit
     ledcAttachPin(_pins[i], channel);
     // LEDC timer reset credit @dedehai
     uint8_t group = (channel / 8), timer = ((channel / 2) % 4); // same fromula as in ledcSetup()
@@ -521,7 +544,7 @@ void BusPwm::show() {
   const bool     dithering = _needsRefresh; // avoid working with bitfield
   const unsigned numPins = getPins();
   const unsigned maxBri = (1<<_depth);      // possible values: 16384 (14), 8192 (13), 4096 (12), 2048 (11), 1024 (10), 512 (9) and 256 (8) 
-  const unsigned bitShift = dithering * 4;  // if dithering, _depth is 12 bit but LEDC channel is set to 8 bit (using 4 fractional bits)
+  [[maybe_unused]] const unsigned bitShift = dithering * 4;  // if dithering, _depth is 12 bit but LEDC channel is set to 8 bit (using 4 fractional bits)
 
   // use CIE brightness formula (cubic) to fit (or approximate linearity of) human eye perceived brightness
   // the formula is based on 12 bit resolution as there is no need for greater precision
@@ -581,6 +604,18 @@ uint8_t BusPwm::getPins(uint8_t* pinArray) const {
   return numPins;
 }
 
+// credit @willmmiles & @netmindz https://github.com/Aircoookie/WLED/pull/4056
+std::vector<LEDType> BusPwm::getLEDTypes() {
+  return {
+    {TYPE_ANALOG_1CH, "A",      PSTR("PWM White")},
+    {TYPE_ANALOG_2CH, "AA",     PSTR("PWM CCT")},
+    {TYPE_ANALOG_3CH, "AAA",    PSTR("PWM RGB")},
+    {TYPE_ANALOG_4CH, "AAAA",   PSTR("PWM RGBW")},
+    {TYPE_ANALOG_5CH, "AAAAA",  PSTR("PWM RGB+CCT")},
+    //{TYPE_ANALOG_6CH, "AAAAAA", PSTR("PWM RGB+DCCT")}, // unimplementable ATM
+  };
+}
+
 void BusPwm::deallocatePins(void) {
   unsigned numPins = getPins();
   for (unsigned i = 0; i < numPins; i++) {
@@ -602,7 +637,7 @@ BusOnOff::BusOnOff(BusConfig &bc)
 : Bus(bc.type, bc.start, bc.autoWhite, 1, bc.reversed)
 , _onoffdata(0)
 {
-  if (bc.type != TYPE_ONOFF) return;
+  if (!Bus::isOnOff(bc.type)) return;
 
   uint8_t currentPin = bc.pins[0];
   if (!pinManager.allocatePin(currentPin, true, PinOwner::BusOnOff)) {
@@ -644,6 +679,12 @@ uint8_t BusOnOff::getPins(uint8_t* pinArray) const {
   return 1;
 }
 
+// credit @willmmiles & @netmindz https://github.com/Aircoookie/WLED/pull/4056
+std::vector<LEDType> BusOnOff::getLEDTypes() {
+  return {
+    {TYPE_ONOFF, "", PSTR("On/Off")},
+  };
+}
 
 BusNetwork::BusNetwork(BusConfig &bc)
 : Bus(bc.type, bc.start, bc.autoWhite, bc.count)
@@ -701,6 +742,21 @@ uint8_t BusNetwork::getPins(uint8_t* pinArray) const {
   return 4;
 }
 
+// credit @willmmiles & @netmindz https://github.com/Aircoookie/WLED/pull/4056
+std::vector<LEDType> BusNetwork::getLEDTypes() {
+  return {
+    {TYPE_NET_DDP_RGB,     "N",     PSTR("DDP RGB (network)")},      // should be "NNNN" to determine 4 "pin" fields
+    {TYPE_NET_ARTNET_RGB,  "N",     PSTR("Art-Net RGB (network)")},
+    {TYPE_NET_DDP_RGBW,    "N",     PSTR("DDP RGBW (network)")},
+    {TYPE_NET_ARTNET_RGBW, "N",     PSTR("Art-Net RGBW (network)")},
+    // hypothetical extensions
+    //{TYPE_VIRTUAL_I2C_W,   "V",     PSTR("I2C White (virtual)")}, // allows setting I2C address in _pin[0]
+    //{TYPE_VIRTUAL_I2C_CCT, "V",     PSTR("I2C CCT (virtual)")}, // allows setting I2C address in _pin[0]
+    //{TYPE_VIRTUAL_I2C_RGB, "VVV",   PSTR("I2C RGB (virtual)")}, // allows setting I2C address in _pin[0] and 2 additional values in _pin[1] & _pin[2]
+    //{TYPE_USERMOD,         "VVVVV", PSTR("Usermod (virtual)")}, // 5 data fields (see https://github.com/Aircoookie/WLED/pull/4123)
+  };
+}
+
 void BusNetwork::cleanup(void) {
   _type = I_NONE;
   _valid = false;
@@ -748,63 +804,30 @@ int BusManager::add(BusConfig &bc) {
   return numBusses++;
 }
 
-// idea by @netmindz https://github.com/Aircoookie/WLED/pull/4056
-String BusManager::getLEDTypesJSONString(void) {
-  struct LEDType {
-    uint8_t id;
-    const char *type;
-    const char *name;
-  } types[] = {
-    {TYPE_WS2812_RGB,      "D",      PSTR("WS281x")},
-    {TYPE_SK6812_RGBW,     "D",      PSTR("SK6812/WS2814 RGBW")},
-    {TYPE_TM1814,          "D",      PSTR("TM1814")},
-    {TYPE_WS2811_400KHZ,   "D",      PSTR("400kHz")},
-    {TYPE_TM1829,          "D",      PSTR("TM1829")},
-    {TYPE_UCS8903,         "D",      PSTR("UCS8903")},
-    {TYPE_APA106,          "D",      PSTR("APA106/PL9823")},
-    {TYPE_TM1914,          "D",      PSTR("TM1914")},
-    {TYPE_FW1906,          "D",      PSTR("FW1906 GRBCW")},
-    {TYPE_UCS8904,         "D",      PSTR("UCS8904 RGBW")},
-    {TYPE_WS2805,          "D",      PSTR("WS2805 RGBCW")},
-    {TYPE_SM16825,         "D",      PSTR("SM16825 RGBCW")},
-    {TYPE_WS2812_1CH_X3,   "D",      PSTR("WS2811 White")},
-    //{TYPE_WS2812_2CH_X3,   "D",      PSTR("WS2811 CCT")}, // not implemented
-    //{TYPE_WS2812_WWA,      "D",      PSTR("WS2811 WWA")}, // not implemented
-    {TYPE_WS2801,          "2P",     PSTR("WS2801")},
-    {TYPE_APA102,          "2P",     PSTR("APA102")},
-    {TYPE_LPD8806,         "2P",     PSTR("LPD8806")},
-    {TYPE_LPD6803,         "2P",     PSTR("LPD6803")},
-    {TYPE_P9813,           "2P",     PSTR("PP9813")},
-    {TYPE_ONOFF,           "",       PSTR("On/Off")},
-    {TYPE_ANALOG_1CH,      "A",      PSTR("PWM White")},
-    {TYPE_ANALOG_2CH,      "AA",     PSTR("PWM CCT")},
-    {TYPE_ANALOG_3CH,      "AAA",    PSTR("PWM RGB")},
-    {TYPE_ANALOG_4CH,      "AAAA",   PSTR("PWM RGBW")},
-    {TYPE_ANALOG_5CH,      "AAAAA",  PSTR("PWM RGB+CCT")},
-    //{TYPE_ANALOG_6CH,      "AAAAAA", PSTR("PWM RGB+DCCT")}, // unimplementable ATM
-    {TYPE_NET_DDP_RGB,     "N",      PSTR("DDP RGB (network)")},
-    {TYPE_NET_ARTNET_RGB,  "N",      PSTR("Art-Net RGB (network)")},
-    {TYPE_NET_DDP_RGBW,    "N",      PSTR("DDP RGBW (network)")},
-    {TYPE_NET_ARTNET_RGBW, "N",      PSTR("Art-Net RGBW (network)")},
-    // hypothetical extensions
-    //{TYPE_VIRTUAL_I2C_W,   "V",     PSTR("I2C White (virtual)")}, // allows setting I2C address in _pin[0]
-    //{TYPE_VIRTUAL_I2C_CCT, "V",     PSTR("I2C CCT (virtual)")}, // allows setting I2C address in _pin[0]
-    //{TYPE_VIRTUAL_I2C_RGB, "V",     PSTR("I2C RGB (virtual)")}, // allows setting I2C address in _pin[0]
-  };
-  String json = "[";
+// credit @willmmiles
+static String LEDTypesToJson(const std::vector<LEDType>& types) {
+  String json;
   for (const auto &type : types) {
-    String id = String(type.id);
-    // capabilities follows similar pattern as JSON API 
+    // capabilities follows similar pattern as JSON API
     int capabilities = Bus::hasRGB(type.id) | Bus::hasWhite(type.id)<<1 | Bus::hasCCT(type.id)<<2 | Bus::is16bit(type.id)<<4;
-    json += "{i:" + id
-      + F(",c:") + String(capabilities)
-      + F(",t:\"") + FPSTR(type.type)
-      + F("\",n:\"") + FPSTR(type.name) + F("\"},");
+    char str[256];
+    sprintf_P(str, PSTR("{i:%d,c:%d,t:\"%s\",n:\"%s\"},"), type.id, capabilities, type.type, type.name);
+    json += str;
   }
-  json.setCharAt(json.length()-1, ']'); // replace last comma with bracket
   return json;
 }
 
+// credit @willmmiles & @netmindz https://github.com/Aircoookie/WLED/pull/4056
+String BusManager::getLEDTypesJSONString(void) {
+  String json = "[";
+  json += LEDTypesToJson(BusDigital::getLEDTypes());
+  json += LEDTypesToJson(BusOnOff::getLEDTypes());
+  json += LEDTypesToJson(BusPwm::getLEDTypes());
+  json += LEDTypesToJson(BusNetwork::getLEDTypes());
+  //json += LEDTypesToJson(BusVirtual::getLEDTypes());
+  json.setCharAt(json.length()-1, ']'); // replace last comma with bracket
+  return json;
+}
 
 void BusManager::useParallelOutput(void) {
   _parallelOutputs = 8; // hardcoded since we use NPB I2S x8 methods
@@ -844,7 +867,7 @@ void BusManager::esp32RMTInvertIdle(void) {
       if (u >= _parallelOutputs + 8) return; // only 8 RMT channels
       rmt = u - _parallelOutputs;
     #endif
-    if (busses[u]->getLength()==0 || !Bus::isDigital(busses[u]->getType()) || IS_2PIN(busses[u]->getType())) continue;
+    if (busses[u]->getLength()==0 || !busses[u]->isDigital() || busses[u]->is2Pin()) continue;
     //assumes that bus number to rmt channel mapping stays 1:1
     rmt_channel_t ch = static_cast<rmt_channel_t>(rmt);
     rmt_idle_level_t lvl;
@@ -863,7 +886,7 @@ void BusManager::on(void) {
   if (pinManager.getPinOwner(LED_BUILTIN) == PinOwner::BusDigital) {
     for (unsigned i = 0; i < numBusses; i++) {
       uint8_t pins[2] = {255,255};
-      if (Bus::isDigital(busses[i]->getType()) && busses[i]->getPins(pins)) {
+      if (busses[i]->isDigital() && busses[i]->getPins(pins)) {
         if (pins[0] == LED_BUILTIN || pins[1] == LED_BUILTIN) {
           BusDigital *bus = static_cast<BusDigital*>(busses[i]);
           bus->reinit();
diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index 1d1136fd83..f6bbf5f974 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -54,6 +54,13 @@ struct ColorOrderMap {
 };
 
 
+typedef struct {
+  uint8_t id;
+  const char *type;
+  const char *name;
+} LEDType;
+
+
 //parent class of BusDigital, BusPwm, and BusNetwork
 class Bus {
   public:
@@ -109,6 +116,7 @@ class Bus {
     inline  bool     isOffRefreshRequired(void) const             { return _needsRefresh; }
     inline  bool     containsPixel(uint16_t pix) const            { return pix >= _start && pix < _start + _len; }
 
+    static std::vector<LEDType> getLEDTypes(void)                 { return {{TYPE_NONE, "", PSTR("None")}}; }
     static constexpr uint8_t getNumberOfPins(uint8_t type)        { return isVirtual(type) ? 4 : isPWM(type) ? numPWMPins(type) : is2Pin(type) + 1; } // credit @PaoloTK
     static constexpr uint8_t getNumberOfChannels(uint8_t type)    { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
     static constexpr bool hasRGB(uint8_t type) {
@@ -226,6 +234,8 @@ class BusDigital : public Bus {
     void reinit(void);
     void cleanup(void);
 
+    static std::vector<LEDType> getLEDTypes(void);
+
   private:
     uint8_t _skip;
     uint8_t _colorOrder;
@@ -266,6 +276,8 @@ class BusPwm : public Bus {
     void show(void) override;
     void cleanup(void) { deallocatePins(); }
 
+    static std::vector<LEDType> getLEDTypes(void);
+
   private:
     uint8_t _pins[5];
     uint8_t _pwmdata[5];
@@ -290,6 +302,8 @@ class BusOnOff : public Bus {
     void show(void) override;
     void cleanup(void) { pinManager.deallocatePin(_pin, PinOwner::BusOnOff); }
 
+    static std::vector<LEDType> getLEDTypes(void);
+
   private:
     uint8_t _pin;
     uint8_t _onoffdata;
@@ -308,6 +322,8 @@ class BusNetwork : public Bus {
     void show(void) override;
     void cleanup(void);
 
+    static std::vector<LEDType> getLEDTypes(void);
+
   private:
     IPAddress _client;
     uint8_t   _UDPtype;
@@ -346,10 +362,7 @@ struct BusConfig {
   {
     refreshReq = (bool) GET_BIT(busType,7);
     type = busType & 0x7F;  // bit 7 may be/is hacked to include refresh info (1=refresh in off state, 0=no refresh)
-    size_t nPins = 1;
-    if (Bus::isVirtual(type))   nPins = 4; //virtual network bus. 4 "pins" store IP address
-    else if (Bus::is2Pin(type)) nPins = 2;
-    else if (Bus::isPWM(type))  nPins = Bus::numPWMPins(type);
+    size_t nPins = Bus::getNumberOfPins(type);
     for (size_t i = 0; i < nPins; i++) pins[i] = ppins[i];
   }
 
@@ -420,7 +433,7 @@ class BusManager {
     #endif
     static uint8_t getNumVirtualBusses(void) {
       int j = 0;
-      for (int i=0; i<numBusses; i++) if (busses[i]->getType() >= TYPE_NET_DDP_RGB && busses[i]->getType() < 96) j++;
+      for (int i=0; i<numBusses; i++) if (busses[i]->isVirtual()) j++;
       return j;
     }
 };

From 43cc4ec009d32c8ebe44bdac03d0ab7c2470701a Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Thu, 5 Sep 2024 22:18:50 +0200
Subject: [PATCH 25/45] Increase oappend buffer on ESP8266

---
 wled00/const.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wled00/const.h b/wled00/const.h
index af6ef5ed27..8e3263e8d2 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -493,7 +493,7 @@
 
 // string temp buffer (now stored in stack locally)
 #ifdef ESP8266
-#define SETTINGS_STACK_BUF_SIZE 2048
+#define SETTINGS_STACK_BUF_SIZE 2560
 #else
 #define SETTINGS_STACK_BUF_SIZE 3840  // warning: quite a large value for stack (640 * WLED_MAX_USERMODS)
 #endif

From ac689a9a2e62d6e5453ec4ab85ee6c5d15b48eef Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Fri, 6 Sep 2024 12:19:04 +0200
Subject: [PATCH 26/45] Remove array, un-inline calculateCCT

---
 wled00/bus_manager.cpp | 21 +++++++++++++++++++++
 wled00/bus_manager.h   | 29 ++++-------------------------
 2 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index e214604fcc..c6c54885c8 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -78,6 +78,27 @@ uint8_t IRAM_ATTR ColorOrderMap::getPixelColorOrder(uint16_t pix, uint8_t defaul
 }
 
 
+void Bus::calculateCCT(uint32_t c, uint8_t &ww, uint8_t &cw) {
+  unsigned cct = 0; //0 - full warm white, 255 - full cold white
+  unsigned w = W(c);
+
+  if (_cct > -1) {                                    // using RGB?
+    if (_cct >= 1900)    cct = (_cct - 1900) >> 5;    // convert K in relative format
+    else if (_cct < 256) cct = _cct;                  // already relative
+  } else {
+    cct = (approximateKelvinFromRGB(c) - 1900) >> 5;  // convert K (from RGB value) to relative format
+  }
+  
+  //0 - linear (CCT 127 = 50% warm, 50% cold), 127 - additive CCT blending (CCT 127 = 100% warm, 100% cold)
+  if (cct       < _cctBlend) ww = 255;
+  else                       ww = ((255-cct) * 255) / (255 - _cctBlend);
+  if ((255-cct) < _cctBlend) cw = 255;
+  else                       cw = (cct * 255) / (255 - _cctBlend);
+
+  ww = (w * ww) / 255; //brightness scaling
+  cw = (w * cw) / 255;
+}
+
 uint32_t Bus::autoWhiteCalc(uint32_t c) const {
   unsigned aWM = _autoWhiteMode;
   if (_gAWM < AW_GLOBAL_DISABLED) aWM = _gAWM;
diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index f6bbf5f974..3411f4e62c 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -6,7 +6,6 @@
  */
 
 #include "const.h"
-#include <array>
 #include <vector>
 
 //colors.cpp
@@ -116,7 +115,7 @@ class Bus {
     inline  bool     isOffRefreshRequired(void) const             { return _needsRefresh; }
     inline  bool     containsPixel(uint16_t pix) const            { return pix >= _start && pix < _start + _len; }
 
-    static std::vector<LEDType> getLEDTypes(void)                 { return {{TYPE_NONE, "", PSTR("None")}}; }
+    static inline std::vector<LEDType> getLEDTypes(void)          { return {{TYPE_NONE, "", PSTR("None")}}; } // not used. just for reference for derived classes
     static constexpr uint8_t getNumberOfPins(uint8_t type)        { return isVirtual(type) ? 4 : isPWM(type) ? numPWMPins(type) : is2Pin(type) + 1; } // credit @PaoloTK
     static constexpr uint8_t getNumberOfChannels(uint8_t type)    { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
     static constexpr bool hasRGB(uint8_t type) {
@@ -149,34 +148,14 @@ class Bus {
     static inline uint8_t  getGlobalAWMode(void)      { return _gAWM; }
     static inline void     setCCT(int16_t cct)        { _cct = cct; }
     static inline uint8_t  getCCTBlend(void)          { return _cctBlend; }
-    static void setCCTBlend(uint8_t b) {
-      if (b > 100) b = 100;
-      _cctBlend = (b * 127) / 100;
+    static inline void setCCTBlend(uint8_t b) {
+      _cctBlend = (std::min((int)b,100) * 127) / 100;
       //compile-time limiter for hardware that can't power both white channels at max
       #ifdef WLED_MAX_CCT_BLEND
         if (_cctBlend > WLED_MAX_CCT_BLEND) _cctBlend = WLED_MAX_CCT_BLEND;
       #endif
     }
-    static void calculateCCT(uint32_t c, uint8_t &ww, uint8_t &cw) {
-      uint8_t cct = 0; //0 - full warm white, 255 - full cold white
-      uint8_t w = byte(c >> 24);
-
-      if (_cct > -1) {
-        if (_cct >= 1900)    cct = (_cct - 1900) >> 5;
-        else if (_cct < 256) cct = _cct;
-      } else {
-        cct = (approximateKelvinFromRGB(c) - 1900) >> 5;
-      }
-      
-      //0 - linear (CCT 127 = 50% warm, 50% cold), 127 - additive CCT blending (CCT 127 = 100% warm, 100% cold)
-      if (cct       < _cctBlend) ww = 255;
-      else                       ww = ((255-cct) * 255) / (255 - _cctBlend);
-      if ((255-cct) < _cctBlend) cw = 255;
-      else                       cw = (cct * 255) / (255 - _cctBlend);
-
-      ww = (w * ww) / 255; //brightness scaling
-      cw = (w * cw) / 255;
-    }
+    static void calculateCCT(uint32_t c, uint8_t &ww, uint8_t &cw);
 
   protected:
     uint8_t  _type;

From c5b31e2f63f9206003b96b69bfc78c4dc16ea815 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Fri, 6 Sep 2024 17:56:36 +0200
Subject: [PATCH 27/45] Bugfix

---
 wled00/pin_manager.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 0a0f391554..8db61361cc 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -97,7 +97,7 @@ bool PinManagerClass::allocateMultiplePins(const managed_pin_type * mptArray, by
   bool shouldFail = false;
   // first verify the pins are OK and not already allocated
   for (int i = 0; i < arrayElementCount; i++) {
-    unsigned gpio = mptArray[i].pin;
+    byte gpio = mptArray[i].pin;
     if (gpio == 0xFF) {
       // explicit support for io -1 as a no-op (no allocation of pin),
       // as this can greatly simplify configuration arrays
@@ -135,7 +135,7 @@ bool PinManagerClass::allocateMultiplePins(const managed_pin_type * mptArray, by
 
   // all pins are available .. track each one
   for (int i = 0; i < arrayElementCount; i++) {
-    unsigned gpio = mptArray[i].pin;
+    byte gpio = mptArray[i].pin;
     if (gpio == 0xFF) {
       // allow callers to include -1 value as non-requested pin
       // as this can greatly simplify configuration arrays

From b4315152e2636244beb78d3b862e2b9ac851f0aa Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sun, 8 Sep 2024 11:07:53 +0200
Subject: [PATCH 28/45] Add numPins()

---
 wled00/data/settings_leds.htm | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/wled00/data/settings_leds.htm b/wled00/data/settings_leds.htm
index 58bd842058..f9bfd3dcad 100644
--- a/wled00/data/settings_leds.htm
+++ b/wled00/data/settings_leds.htm
@@ -30,6 +30,7 @@
 		function hasW(t)   { return !!(gT(t).c & 0x02); }           // has white channel
 		function hasCCT(t) { return !!(gT(t).c & 0x04); }           // is white CCT enabled
 		function is16b(t)  { return !!(gT(t).c & 0x10); }           // is digital 16 bit type
+		function numPins(t){ return Math.max(gT(t).t.length, 1); }  // type length determines number of GPIO pins
 		// https://www.educative.io/edpresso/how-to-dynamically-load-a-js-file-in-javascript
 		function loadJS(FILE_URL, async = true) {
 			let scE = d.createElement("script");
@@ -83,7 +84,7 @@
 				let t = parseInt(d.Sf["LT"+n].value, 10); // LED type SELECT
 				// ignore IP address
 				if (nm=="L0" || nm=="L1" || nm=="L2" || nm=="L3") {
-					if (t>=80) return;
+					if (isNet(t)) return;
 				}
 				//check for pin conflicts
 				if (nm=="L0" || nm=="L1" || nm=="L2" || nm=="L3" || nm=="L4")
@@ -237,7 +238,7 @@
 						p0d = "Data "+p0d;
 						break;
 					case 'A': // PWM analog
-						if (gT(t).t.length > 1) p0d = "GPIOs:";
+						if (numPins(t) > 1) p0d = "GPIOs:";
 						off = "Dithering";
 						break;
 					case 'N': // network
@@ -412,7 +413,7 @@
 				let t = s.value;
 				if (isDig(t) && !isD2P(t)) digitalB++;
 				if (isD2P(t)) twopinB++;
-				if (isPWM(t)) analogB += t-40; // type defines PWM pins
+				if (isPWM(t)) analogB += numPins(t); // each GPIO is assigned to a channel
 				if (isVir(t)) virtB++;
 			});
 

From eb06e575c2ff00aa663ca9d1ee0c5d5ce9ad2bf6 Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Tue, 10 Sep 2024 01:03:19 +0200
Subject: [PATCH 29/45] add check for pin reassigned conflict with pin defined
 for current bus

---
 wled00/FX_fcn.cpp      | 19 +++++++++++++++----
 wled00/pin_manager.cpp |  7 +++++++
 wled00/pin_manager.h   |  1 +
 3 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 74d6125643..6f218c93f8 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -76,7 +76,7 @@ static constexpr unsigned sumPinsRequired(const unsigned* current, size_t count)
 static constexpr bool validatePinsAndTypes(const unsigned* types, unsigned numTypes, unsigned numPins ) {
   // Pins provided < pins required -> always invalid
   // Pins provided = pins required -> always valid
-  // Pins provided > pins required -> last type will repeat until we run out of pins, make sure excess pins modulo last type pins == 0
+  // Pins provided > pins required -> valid if excess pins are a product of last type pins since it will be repeated
   return (sumPinsRequired(types, numTypes) > numPins) ? false :
           (numPins - sumPinsRequired(types, numTypes)) % Bus::getNumberOfPins(types[numTypes-1]) == 0;
 }
@@ -1240,7 +1240,7 @@ void WS2812FX::finalizeInit(void) {
     unsigned prevLen = 0;
     unsigned pinsIndex = 0;
     for (unsigned i = 0; i < WLED_MAX_BUSSES+WLED_MIN_VIRTUAL_BUSSES; i++) {
-      uint8_t defPin[OUTPUT_MAX_PINS]; // max 5 pins
+      uint8_t defPin[OUTPUT_MAX_PINS];
       // if we have less types than requested outputs and they do not align, use last known type to set current type
       unsigned dataType = defDataTypes[(i < defNumTypes) ? i : defNumTypes -1];
       unsigned busPins = Bus::getNumberOfPins(dataType);
@@ -1259,8 +1259,19 @@ void WS2812FX::finalizeInit(void) {
         // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
         if (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) {
           defPin[j] = 1; // start with GPIO1 and work upwards
-          // @FIX pins are allocated after the loop, so if we reassign to a pin that's already in the array for this output 2 fields will have the same pin
-          while ((pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) && defPin[j] < WLED_NUM_PINS) defPin[j]++;
+          while (
+                  (
+                    pinManager.isPinAllocated(defPin[j])                                                ||
+                    pinManager.isReadOnlyPin(defPin[j])                                                 ||
+                    // Check if pin is defined for current bus
+                    pinManager.isPinDefined(defPin[j], defDataPins, pinsIndex + j, pinsIndex + busPins)
+                  ) 
+                  &&
+                    defPin[j] < WLED_NUM_PINS
+                )
+          {
+              defPin[j]++;
+          }
         }
       }
       pinsIndex += busPins;
diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 2bd82115f6..814d81c1a9 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -281,6 +281,13 @@ bool PinManagerClass::isReadOnlyPin(byte gpio)
   return false;
 }
 
+bool PinManagerClass::isPinDefined(byte gpio, const unsigned *pins, unsigned start, unsigned end) {
+  for (unsigned i = start; i < end; i++) {
+    if (pins[i] == gpio) return true;
+  }
+  return false;
+}
+
 PinOwner PinManagerClass::getPinOwner(byte gpio) const
 {
   if (!isPinOk(gpio, false)) return PinOwner::None;
diff --git a/wled00/pin_manager.h b/wled00/pin_manager.h
index a8ddf5f751..1263dc4f4c 100644
--- a/wled00/pin_manager.h
+++ b/wled00/pin_manager.h
@@ -113,6 +113,7 @@ class PinManagerClass {
   bool isPinOk(byte gpio, bool output = true) const;
   
   static bool isReadOnlyPin(byte gpio);
+  static bool isPinDefined(byte gpio, const unsigned* pins, unsigned start = 0, unsigned end = WLED_NUM_PINS);
 
   PinOwner getPinOwner(byte gpio) const;
 

From 5869627b32366e4784435f84f6d4cbf10e0041c6 Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Wed, 11 Sep 2024 01:27:19 +0200
Subject: [PATCH 30/45] - More optimization on bus configuration logic. -
 Renamed LEDPIN to DEFAULT_LED_PIN. - Removed ability to override
 DEFAULT_LED_PIN, DEFAULT_LED_TYPE and DEFAULT_LED_COUNT. Use DATA_PINS,
 LED_TYPES and PIXEL_COUNTS instead.

---
 wled00/FX_fcn.cpp | 39 +++++++++++++++++----------------------
 wled00/const.h    | 22 +++++++---------------
 2 files changed, 24 insertions(+), 37 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 6f218c93f8..435998cdcd 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -53,7 +53,7 @@
 #endif
 
 #ifndef DATA_PINS
-  #define DATA_PINS LEDPIN
+  #define DATA_PINS DEFAULT_LED_PIN
 #endif
 
 #ifndef LED_TYPES
@@ -1245,32 +1245,27 @@ void WS2812FX::finalizeInit(void) {
       unsigned dataType = defDataTypes[(i < defNumTypes) ? i : defNumTypes -1];
       unsigned busPins = Bus::getNumberOfPins(dataType);
 
-      // check if we have enough pins left to configure an output of this type
-      // should never happen due to static assert above
-      if (pinsIndex + busPins > defNumPins) {
-        DEBUG_PRINTLN(F("LED outputs misaligned with defined pins. Some pins will remain unused."));
-        break;
-      }
+      // if we need more pins than available all outputs have been configured
+      if (pinsIndex + busPins > defNumPins) break;
       
       for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) {
         defPin[j] = defDataPins[pinsIndex + j];
 
-        // when booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
+        bool validPin = true;
+        // When booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
         // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
-        if (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j])) {
-          defPin[j] = 1; // start with GPIO1 and work upwards
-          while (
-                  (
-                    pinManager.isPinAllocated(defPin[j])                                                ||
-                    pinManager.isReadOnlyPin(defPin[j])                                                 ||
-                    // Check if pin is defined for current bus
-                    pinManager.isPinDefined(defPin[j], defDataPins, pinsIndex + j, pinsIndex + busPins)
-                  ) 
-                  &&
-                    defPin[j] < WLED_NUM_PINS
-                )
-          {
-              defPin[j]++;
+        // Pin should not be already allocated, read/only or defined for current bus
+        while (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j]) ||
+               pinManager.isPinDefined(defPin[j], defDataPins, pinsIndex + j + 1, pinsIndex + busPins)) {
+          if (validPin) {
+            defPin[j] = 1; // start with GPIO1 and work upwards
+            validPin = false;
+          }  
+          if (defPin[j] < WLED_NUM_PINS) {
+            defPin[j]++;
+          } else {
+            DEBUG_PRINTLN(F("No available pins left! Can't configure output."));
+            return;
           }
         }
       }
diff --git a/wled00/const.h b/wled00/const.h
index ffefb3ca5e..1bfca07584 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -563,15 +563,6 @@
   #define WLED_MAX_NODES 150
 #endif
 
-//this is merely a default now and can be changed at runtime
-#ifndef LEDPIN
-#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)  //|| (defined(ARDUINO_ARCH_ESP32) && defined(BOARD_HAS_PSRAM)) || defined(ARDUINO_ESP32_PICO)
-  #define LEDPIN 2    // GPIO2 (D4) on Wemos D1 mini compatible boards, safe to use on any board
-#else
-  #define LEDPIN 16   // aligns with GPIO2 (D4) on Wemos D1 mini32 compatible boards (if it is unusable it will be reassigned in WS2812FX::finalizeInit())
-#endif
-#endif
-
 // List of read only pins. Cannot be used for LED outputs.
 #if defined(CONFIG_IDF_TARGET_ESP32S2)
   #define READ_ONLY_PINS 46
@@ -593,13 +584,14 @@
 #endif
 #endif
 
-#ifndef DEFAULT_LED_TYPE
-  #define DEFAULT_LED_TYPE TYPE_WS2812_RGB
-#endif
-
-#ifndef DEFAULT_LED_COUNT
-  #define DEFAULT_LED_COUNT 30
+// Defaults pins, type and counts to configure LED output
+#if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)
+  #define DEFAULT_LED_PIN 2    // GPIO2 (D4) on Wemos D1 mini compatible boards, safe to use on any board
+#else
+  #define DEFAULT_LED_PIN 16   // aligns with GPIO2 (D4) on Wemos D1 mini32 compatible boards (if it is unusable it will be reassigned in WS2812FX::finalizeInit())
 #endif
+#define DEFAULT_LED_TYPE TYPE_WS2812_RGB
+#define DEFAULT_LED_COUNT 30
 
 #define INTERFACE_UPDATE_COOLDOWN 1000 // time in ms to wait between websockets, alexa, and MQTT updates
 

From 5df1a223c283769db9a696cc665d9b37dc6fb1bd Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Wed, 11 Sep 2024 16:45:39 +0200
Subject: [PATCH 31/45] Pre-allocate COM vector

---
 wled00/bus_manager.h | 1 +
 wled00/cfg.cpp       | 1 +
 wled00/set.cpp       | 1 +
 3 files changed, 3 insertions(+)

diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index 3411f4e62c..c3ebcad618 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -35,6 +35,7 @@ struct ColorOrderMap {
     bool add(uint16_t start, uint16_t len, uint8_t colorOrder);
 
     inline uint8_t count() const { return _mappings.size(); }
+    inline void reserve(size_t num) { _mappings.reserve(num); }
 
     void reset() {
       _mappings.clear();
diff --git a/wled00/cfg.cpp b/wled00/cfg.cpp
index 5f0c8593f1..bcb6f7aadf 100644
--- a/wled00/cfg.cpp
+++ b/wled00/cfg.cpp
@@ -244,6 +244,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
   // read color order map configuration
   JsonArray hw_com = hw[F("com")];
   if (!hw_com.isNull()) {
+    BusManager::getColorOrderMap().reserve(std::min(hw_com.size(), (size_t)WLED_MAX_COLOR_ORDER_MAPPINGS));
     for (JsonObject entry : hw_com) {
       uint16_t start = entry["start"] | 0;
       uint16_t len = entry["len"] | 0;
diff --git a/wled00/set.cpp b/wled00/set.cpp
index 7be27ed206..a0e762e61a 100644
--- a/wled00/set.cpp
+++ b/wled00/set.cpp
@@ -215,6 +215,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
     }
     //doInitBusses = busesChanged; // we will do that below to ensure all input data is processed
 
+    // we will not bother with pre-allocating ColorOrderMappings vector
     for (int s = 0; s < WLED_MAX_COLOR_ORDER_MAPPINGS; s++) {
       int offset = s < 10 ? 48 : 55;
       char xs[4] = "XS"; xs[2] = offset+s; xs[3] = 0; //start LED

From 23400d0449841a5d45f39e24b657cfa227d47502 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bla=C5=BE=20Kristan?= <blaz@kristan-sp.si>
Date: Thu, 12 Sep 2024 08:30:46 +0200
Subject: [PATCH 32/45] Conditional IRAM for gamma

---
 wled00/colors.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/wled00/colors.cpp b/wled00/colors.cpp
index ac1dee00a1..478a0a277d 100644
--- a/wled00/colors.cpp
+++ b/wled00/colors.cpp
@@ -479,14 +479,14 @@ void NeoGammaWLEDMethod::calcGammaTable(float gamma)
   }
 }
 
-uint8_t IRAM_ATTR NeoGammaWLEDMethod::Correct(uint8_t value)
+uint8_t IRAM_ATTR_YN NeoGammaWLEDMethod::Correct(uint8_t value)
 {
   if (!gammaCorrectCol) return value;
   return gammaT[value];
 }
 
 // used for color gamma correction
-uint32_t IRAM_ATTR NeoGammaWLEDMethod::Correct32(uint32_t color)
+uint32_t IRAM_ATTR_YN NeoGammaWLEDMethod::Correct32(uint32_t color)
 {
   if (!gammaCorrectCol) return color;
   uint8_t w = W(color);

From 6169c458bfb327a2a700481be52e6b71584df0d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bla=C5=BE=20Kristan?= <blaz@kristan-sp.si>
Date: Thu, 12 Sep 2024 08:48:31 +0200
Subject: [PATCH 33/45] Remove void

---
 wled00/bus_manager.cpp |  36 ++++-----
 wled00/bus_manager.h   | 162 ++++++++++++++++++++---------------------
 2 files changed, 99 insertions(+), 99 deletions(-)

diff --git a/wled00/bus_manager.cpp b/wled00/bus_manager.cpp
index c6c54885c8..7232971787 100644
--- a/wled00/bus_manager.cpp
+++ b/wled00/bus_manager.cpp
@@ -173,7 +173,7 @@ BusDigital::BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com)
 //I am NOT to be held liable for burned down garages or houses!
 
 // To disable brightness limiter we either set output max current to 0 or single LED current to 0
-uint8_t BusDigital::estimateCurrentAndLimitBri(void) {
+uint8_t BusDigital::estimateCurrentAndLimitBri() {
   bool useWackyWS2815PowerModel = false;
   byte actualMilliampsPerLed = _milliAmpsPerLed;
 
@@ -225,7 +225,7 @@ uint8_t BusDigital::estimateCurrentAndLimitBri(void) {
   return newBri;
 }
 
-void BusDigital::show(void) {
+void BusDigital::show() {
   _milliAmpsTotal = 0;
   if (!_valid) return;
 
@@ -286,7 +286,7 @@ void BusDigital::show(void) {
   if (newBri < _bri) PolyBus::setBrightness(_busPtr, _iType, _bri);
 }
 
-bool BusDigital::canShow(void) const {
+bool BusDigital::canShow() const {
   if (!_valid) return true;
   return PolyBus::canShow(_busPtr, _iType);
 }
@@ -410,12 +410,12 @@ std::vector<LEDType> BusDigital::getLEDTypes() {
   };
 }
 
-void BusDigital::reinit(void) {
+void BusDigital::reinit() {
   if (!_valid) return;
   PolyBus::begin(_busPtr, _iType, _pins);
 }
 
-void BusDigital::cleanup(void) {
+void BusDigital::cleanup() {
   DEBUG_PRINTLN(F("Digital Cleanup."));
   PolyBus::cleanup(_busPtr, _iType);
   _iType = I_NONE;
@@ -637,7 +637,7 @@ std::vector<LEDType> BusPwm::getLEDTypes() {
   };
 }
 
-void BusPwm::deallocatePins(void) {
+void BusPwm::deallocatePins() {
   unsigned numPins = getPins();
   for (unsigned i = 0; i < numPins; i++) {
     pinManager.deallocatePin(_pins[i], PinOwner::BusPwm);
@@ -689,7 +689,7 @@ uint32_t BusOnOff::getPixelColor(uint16_t pix) const {
   return RGBW32(_data[0], _data[0], _data[0], _data[0]);
 }
 
-void BusOnOff::show(void) {
+void BusOnOff::show() {
   if (!_valid) return;
   digitalWrite(_pin, _reversed ? !(bool)_data[0] : (bool)_data[0]);
 }
@@ -751,7 +751,7 @@ uint32_t BusNetwork::getPixelColor(uint16_t pix) const {
   return RGBW32(_data[offset], _data[offset+1], _data[offset+2], (hasWhite() ? _data[offset+3] : 0));
 }
 
-void BusNetwork::show(void) {
+void BusNetwork::show() {
   if (!_valid || !canShow()) return;
   _broadcastLock = true;
   realtimeBroadcast(_UDPtype, _client, _len, _data, _bri, hasWhite());
@@ -778,7 +778,7 @@ std::vector<LEDType> BusNetwork::getLEDTypes() {
   };
 }
 
-void BusNetwork::cleanup(void) {
+void BusNetwork::cleanup() {
   _type = I_NONE;
   _valid = false;
   freeData();
@@ -839,7 +839,7 @@ static String LEDTypesToJson(const std::vector<LEDType>& types) {
 }
 
 // credit @willmmiles & @netmindz https://github.com/Aircoookie/WLED/pull/4056
-String BusManager::getLEDTypesJSONString(void) {
+String BusManager::getLEDTypesJSONString() {
   String json = "[";
   json += LEDTypesToJson(BusDigital::getLEDTypes());
   json += LEDTypesToJson(BusOnOff::getLEDTypes());
@@ -850,13 +850,13 @@ String BusManager::getLEDTypesJSONString(void) {
   return json;
 }
 
-void BusManager::useParallelOutput(void) {
+void BusManager::useParallelOutput() {
   _parallelOutputs = 8; // hardcoded since we use NPB I2S x8 methods
   PolyBus::setParallelI2S1Output();
 }
 
 //do not call this method from system context (network callback)
-void BusManager::removeAll(void) {
+void BusManager::removeAll() {
   DEBUG_PRINTLN(F("Removing all."));
   //prevents crashes due to deleting busses while in use.
   while (!canAllShow()) yield();
@@ -870,7 +870,7 @@ void BusManager::removeAll(void) {
 // #2478
 // If enabled, RMT idle level is set to HIGH when off
 // to prevent leakage current when using an N-channel MOSFET to toggle LED power
-void BusManager::esp32RMTInvertIdle(void) {
+void BusManager::esp32RMTInvertIdle() {
   bool idle_out;
   unsigned rmt = 0;
   for (unsigned u = 0; u < numBusses(); u++) {
@@ -901,7 +901,7 @@ void BusManager::esp32RMTInvertIdle(void) {
 }
 #endif
 
-void BusManager::on(void) {
+void BusManager::on() {
   #ifdef ESP8266
   //Fix for turning off onboard LED breaking bus
   if (pinManager.getPinOwner(LED_BUILTIN) == PinOwner::BusDigital) {
@@ -922,7 +922,7 @@ void BusManager::on(void) {
   #endif
 }
 
-void BusManager::off(void) {
+void BusManager::off() {
   #ifdef ESP8266
   // turn off built-in LED if strip is turned off
   // this will break digital bus so will need to be re-initialised on On
@@ -937,7 +937,7 @@ void BusManager::off(void) {
   #endif
 }
 
-void BusManager::show(void) {
+void BusManager::show() {
   _milliAmpsUsed = 0;
   for (unsigned i = 0; i < numBusses; i++) {
     busses[i]->show();
@@ -984,7 +984,7 @@ uint32_t BusManager::getPixelColor(uint16_t pix) {
   return 0;
 }
 
-bool BusManager::canAllShow(void) {
+bool BusManager::canAllShow() {
   for (unsigned i = 0; i < numBusses; i++) {
     if (!busses[i]->canShow()) return false;
   }
@@ -997,7 +997,7 @@ Bus* BusManager::getBus(uint8_t busNr) {
 }
 
 //semi-duplicate of strip.getLengthTotal() (though that just returns strip._length, calculated in finalizeInit())
-uint16_t BusManager::getTotalLength(void) {
+uint16_t BusManager::getTotalLength() {
   unsigned len = 0;
   for (unsigned i=0; i<numBusses; i++) len += busses[i]->getLength();
   return len;
diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index c3ebcad618..8205bd66cd 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -79,46 +79,46 @@ class Bus {
 
     virtual ~Bus() {} //throw the bus under the bus
 
-    virtual void     show(void) = 0;
-    virtual bool     canShow(void) const                          { return true; }
-    virtual void     setStatusPixel(uint32_t c)                   {}
+    virtual void     show() = 0;
+    virtual bool     canShow() const                          { return true; }
+    virtual void     setStatusPixel(uint32_t c)                {}
     virtual void     setPixelColor(uint16_t pix, uint32_t c) = 0;
-    virtual void     setBrightness(uint8_t b)                     { _bri = b; };
-    virtual void     setColorOrder(uint8_t co)                    {}
-    virtual uint32_t getPixelColor(uint16_t pix) const            { return 0; }
-    virtual uint8_t  getPins(uint8_t* pinArray = nullptr) const   { return 0; }
-    virtual uint16_t getLength(void) const                        { return isOk() ? _len : 0; }
-    virtual uint8_t  getColorOrder(void) const                    { return COL_ORDER_RGB; }
-    virtual uint8_t  skippedLeds(void) const                      { return 0; }
-    virtual uint16_t getFrequency(void) const                     { return 0U; }
-    virtual uint16_t getLEDCurrent(void) const                    { return 0; }
-    virtual uint16_t getUsedCurrent(void) const                   { return 0; }
-    virtual uint16_t getMaxCurrent(void) const                    { return 0; }
-
-    inline  bool     hasRGB(void) const                           { return _hasRgb; }
-    inline  bool     hasWhite(void) const                         { return _hasWhite; }
-    inline  bool     hasCCT(void) const                           { return _hasCCT; }
-    inline  bool     isDigital(void) const                        { return isDigital(_type); }
-    inline  bool     is2Pin(void) const                           { return is2Pin(_type); }
-    inline  bool     isOnOff(void) const                          { return isOnOff(_type); }
-    inline  bool     isPWM(void) const                            { return isPWM(_type); }
-    inline  bool     isVirtual(void) const                        { return isVirtual(_type); }
-    inline  bool     is16bit(void) const                          { return is16bit(_type); }
-    inline  void     setReversed(bool reversed)                   { _reversed = reversed; }
-    inline  void     setStart(uint16_t start)                     { _start = start; }
-    inline  void     setAutoWhiteMode(uint8_t m)                  { if (m < 5) _autoWhiteMode = m; }
-    inline  uint8_t  getAutoWhiteMode(void) const                 { return _autoWhiteMode; }
-    inline  uint8_t  getNumberOfChannels(void) const              { return hasWhite() + 3*hasRGB() + hasCCT(); }
-    inline  uint16_t getStart(void) const                         { return _start; }
-    inline  uint8_t  getType(void) const                          { return _type; }
-    inline  bool     isOk(void) const                             { return _valid; }
-    inline  bool     isReversed(void) const                       { return _reversed; }
-    inline  bool     isOffRefreshRequired(void) const             { return _needsRefresh; }
-    inline  bool     containsPixel(uint16_t pix) const            { return pix >= _start && pix < _start + _len; }
-
-    static inline std::vector<LEDType> getLEDTypes(void)          { return {{TYPE_NONE, "", PSTR("None")}}; } // not used. just for reference for derived classes
-    static constexpr uint8_t getNumberOfPins(uint8_t type)        { return isVirtual(type) ? 4 : isPWM(type) ? numPWMPins(type) : is2Pin(type) + 1; } // credit @PaoloTK
-    static constexpr uint8_t getNumberOfChannels(uint8_t type)    { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
+    virtual void     setBrightness(uint8_t b)                  { _bri = b; };
+    virtual void     setColorOrder(uint8_t co)                 {}
+    virtual uint32_t getPixelColor(uint16_t pix) const         { return 0; }
+    virtual uint8_t  getPins(uint8_t* pinArray = nullptr) const { return 0; }
+    virtual uint16_t getLength() const                         { return isOk() ? _len : 0; }
+    virtual uint8_t  getColorOrder() const                     { return COL_ORDER_RGB; }
+    virtual uint8_t  skippedLeds() const                       { return 0; }
+    virtual uint16_t getFrequency() const                      { return 0U; }
+    virtual uint16_t getLEDCurrent() const                     { return 0; }
+    virtual uint16_t getUsedCurrent() const                    { return 0; }
+    virtual uint16_t getMaxCurrent() const                     { return 0; }
+
+    inline  bool     hasRGB() const                            { return _hasRgb; }
+    inline  bool     hasWhite() const                          { return _hasWhite; }
+    inline  bool     hasCCT() const                            { return _hasCCT; }
+    inline  bool     isDigital() const                         { return isDigital(_type); }
+    inline  bool     is2Pin() const                            { return is2Pin(_type); }
+    inline  bool     isOnOff() const                           { return isOnOff(_type); }
+    inline  bool     isPWM() const                             { return isPWM(_type); }
+    inline  bool     isVirtual() const                         { return isVirtual(_type); }
+    inline  bool     is16bit() const                           { return is16bit(_type); }
+    inline  void     setReversed(bool reversed)                { _reversed = reversed; }
+    inline  void     setStart(uint16_t start)                  { _start = start; }
+    inline  void     setAutoWhiteMode(uint8_t m)               { if (m < 5) _autoWhiteMode = m; }
+    inline  uint8_t  getAutoWhiteMode() const                  { return _autoWhiteMode; }
+    inline  uint8_t  getNumberOfChannels() const               { return hasWhite() + 3*hasRGB() + hasCCT(); }
+    inline  uint16_t getStart() const                          { return _start; }
+    inline  uint8_t  getType() const                           { return _type; }
+    inline  bool     isOk() const                              { return _valid; }
+    inline  bool     isReversed() const                        { return _reversed; }
+    inline  bool     isOffRefreshRequired() const              { return _needsRefresh; }
+    inline  bool     containsPixel(uint16_t pix) const         { return pix >= _start && pix < _start + _len; }
+
+    static inline std::vector<LEDType> getLEDTypes()           { return {{TYPE_NONE, "", PSTR("None")}}; } // not used. just for reference for derived classes
+    static constexpr uint8_t getNumberOfPins(uint8_t type)     { return isVirtual(type) ? 4 : isPWM(type) ? numPWMPins(type) : is2Pin(type) + 1; } // credit @PaoloTK
+    static constexpr uint8_t getNumberOfChannels(uint8_t type) { return hasWhite(type) + 3*hasRGB(type) + hasCCT(type); }
     static constexpr bool hasRGB(uint8_t type) {
       return !((type >= TYPE_WS2812_1CH && type <= TYPE_WS2812_WWA) || type == TYPE_ANALOG_1CH || type == TYPE_ANALOG_2CH || type == TYPE_ONOFF);
     }
@@ -144,11 +144,11 @@ class Bus {
     static constexpr bool  is16bit(uint8_t type)      { return type == TYPE_UCS8903 || type == TYPE_UCS8904 || type == TYPE_SM16825; }
     static constexpr int   numPWMPins(uint8_t type)   { return (type - 40); }
 
-    static inline int16_t  getCCT(void)               { return _cct; }
+    static inline int16_t  getCCT()                   { return _cct; }
     static inline void     setGlobalAWMode(uint8_t m) { if (m < 5) _gAWM = m; else _gAWM = AW_GLOBAL_DISABLED; }
-    static inline uint8_t  getGlobalAWMode(void)      { return _gAWM; }
+    static inline uint8_t  getGlobalAWMode()          { return _gAWM; }
     static inline void     setCCT(int16_t cct)        { _cct = cct; }
-    static inline uint8_t  getCCTBlend(void)          { return _cctBlend; }
+    static inline uint8_t  getCCTBlend()              { return _cctBlend; }
     static inline void setCCTBlend(uint8_t b) {
       _cctBlend = (std::min((int)b,100) * 127) / 100;
       //compile-time limiter for hardware that can't power both white channels at max
@@ -197,24 +197,24 @@ class BusDigital : public Bus {
     BusDigital(BusConfig &bc, uint8_t nr, const ColorOrderMap &com);
     ~BusDigital() { cleanup(); }
 
-    void show(void) override;
-    bool canShow(void) const override;
+    void show() override;
+    bool canShow() const override;
     void setBrightness(uint8_t b) override;
     void setStatusPixel(uint32_t c) override;
     void setPixelColor(uint16_t pix, uint32_t c) override;
     void setColorOrder(uint8_t colorOrder) override;
     uint32_t getPixelColor(uint16_t pix) const override;
-    uint8_t  getColorOrder(void) const override  { return _colorOrder; }
+    uint8_t  getColorOrder() const override  { return _colorOrder; }
     uint8_t  getPins(uint8_t* pinArray = nullptr) const override;
-    uint8_t  skippedLeds(void) const override    { return _skip; }
-    uint16_t getFrequency(void) const override   { return _frequencykHz; }
-    uint16_t getLEDCurrent(void) const override  { return _milliAmpsPerLed; }
-    uint16_t getUsedCurrent(void) const override { return _milliAmpsTotal; }
-    uint16_t getMaxCurrent(void) const override  { return _milliAmpsMax; }
-    void reinit(void);
-    void cleanup(void);
+    uint8_t  skippedLeds() const override    { return _skip; }
+    uint16_t getFrequency() const override   { return _frequencykHz; }
+    uint16_t getLEDCurrent() const override  { return _milliAmpsPerLed; }
+    uint16_t getUsedCurrent() const override { return _milliAmpsTotal; }
+    uint16_t getMaxCurrent() const override  { return _milliAmpsMax; }
+    void reinit();
+    void cleanup();
 
-    static std::vector<LEDType> getLEDTypes(void);
+    static std::vector<LEDType> getLEDTypes();
 
   private:
     uint8_t _skip;
@@ -240,7 +240,7 @@ class BusDigital : public Bus {
       return c;
     }
 
-    uint8_t  estimateCurrentAndLimitBri(void);
+    uint8_t  estimateCurrentAndLimitBri();
 };
 
 
@@ -252,11 +252,11 @@ class BusPwm : public Bus {
     void setPixelColor(uint16_t pix, uint32_t c) override;
     uint32_t getPixelColor(uint16_t pix) const override; //does no index check
     uint8_t  getPins(uint8_t* pinArray = nullptr) const override;
-    uint16_t getFrequency(void) const override { return _frequency; }
-    void show(void) override;
-    void cleanup(void) { deallocatePins(); }
+    uint16_t getFrequency() const override { return _frequency; }
+    void show() override;
+    void cleanup() { deallocatePins(); }
 
-    static std::vector<LEDType> getLEDTypes(void);
+    static std::vector<LEDType> getLEDTypes();
 
   private:
     uint8_t _pins[5];
@@ -267,7 +267,7 @@ class BusPwm : public Bus {
     uint8_t _depth;
     uint16_t _frequency;
 
-    void deallocatePins(void);
+    void deallocatePins();
 };
 
 
@@ -279,10 +279,10 @@ class BusOnOff : public Bus {
     void setPixelColor(uint16_t pix, uint32_t c) override;
     uint32_t getPixelColor(uint16_t pix) const override;
     uint8_t  getPins(uint8_t* pinArray) const override;
-    void show(void) override;
-    void cleanup(void) { pinManager.deallocatePin(_pin, PinOwner::BusOnOff); }
+    void show() override;
+    void cleanup() { pinManager.deallocatePin(_pin, PinOwner::BusOnOff); }
 
-    static std::vector<LEDType> getLEDTypes(void);
+    static std::vector<LEDType> getLEDTypes();
 
   private:
     uint8_t _pin;
@@ -295,14 +295,14 @@ class BusNetwork : public Bus {
     BusNetwork(BusConfig &bc);
     ~BusNetwork() { cleanup(); }
 
-    bool canShow(void) const override  { return !_broadcastLock; } // this should be a return value from UDP routine if it is still sending data out
+    bool canShow() const override  { return !_broadcastLock; } // this should be a return value from UDP routine if it is still sending data out
     void setPixelColor(uint16_t pix, uint32_t c) override;
     uint32_t getPixelColor(uint16_t pix) const override;
     uint8_t  getPins(uint8_t* pinArray = nullptr) const override;
-    void show(void) override;
-    void cleanup(void);
+    void show() override;
+    void cleanup();
 
-    static std::vector<LEDType> getLEDTypes(void);
+    static std::vector<LEDType> getLEDTypes();
 
   private:
     IPAddress _client;
@@ -367,20 +367,20 @@ class BusManager {
     //utility to get the approx. memory usage of a given BusConfig
     static uint32_t memUsage(BusConfig &bc);
     static uint32_t memUsage(unsigned channels, unsigned count, unsigned buses = 1);
-    static uint16_t currentMilliamps(void) { return _milliAmpsUsed; }
-    static uint16_t ablMilliampsMax(void)  { return _milliAmpsMax; }
+    static uint16_t currentMilliamps() { return _milliAmpsUsed; }
+    static uint16_t ablMilliampsMax()  { return _milliAmpsMax; }
 
     static int add(BusConfig &bc);
-    static void useParallelOutput(void); // workaround for inaccessible PolyBus
+    static void useParallelOutput(); // workaround for inaccessible PolyBus
 
     //do not call this method from system context (network callback)
-    static void removeAll(void);
+    static void removeAll();
 
-    static void on(void);
-    static void off(void);
+    static void on();
+    static void off();
 
-    static void show(void);
-    static bool canAllShow(void);
+    static void show();
+    static bool canAllShow();
     static void setStatusPixel(uint32_t c);
     static void setPixelColor(uint16_t pix, uint32_t c);
     static void setBrightness(uint8_t b);
@@ -389,16 +389,16 @@ class BusManager {
     static void setSegmentCCT(int16_t cct, bool allowWBCorrection = false);
     static inline void setMilliampsMax(uint16_t max) { _milliAmpsMax = max;}
     static uint32_t getPixelColor(uint16_t pix);
-    static inline int16_t getSegmentCCT(void) { return Bus::getCCT(); }
+    static inline int16_t getSegmentCCT() { return Bus::getCCT(); }
 
     static Bus* getBus(uint8_t busNr);
 
     //semi-duplicate of strip.getLengthTotal() (though that just returns strip._length, calculated in finalizeInit())
-    static uint16_t getTotalLength(void);
-    static inline uint8_t getNumBusses(void) { return numBusses; }
-    static String getLEDTypesJSONString(void);
+    static uint16_t getTotalLength();
+    static inline uint8_t getNumBusses() { return numBusses; }
+    static String getLEDTypesJSONString();
 
-    static inline ColorOrderMap& getColorOrderMap(void) { return colorOrderMap; }
+    static inline ColorOrderMap& getColorOrderMap() { return colorOrderMap; }
 
   private:
     static uint8_t numBusses;
@@ -409,9 +409,9 @@ class BusManager {
     static uint8_t _parallelOutputs;
 
     #ifdef ESP32_DATA_IDLE_HIGH
-    static void    esp32RMTInvertIdle(void) ;
+    static void    esp32RMTInvertIdle() ;
     #endif
-    static uint8_t getNumVirtualBusses(void) {
+    static uint8_t getNumVirtualBusses() {
       int j = 0;
       for (int i=0; i<numBusses; i++) if (busses[i]->isVirtual()) j++;
       return j;

From e59b38a5d23d0c885c2ea49d4cfb4f761218aca7 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Thu, 12 Sep 2024 15:04:10 +0200
Subject: [PATCH 34/45] Fix unsigned long in debug printf

---
 wled00/wled.cpp | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/wled00/wled.cpp b/wled00/wled.cpp
index 840c06bf7e..ade01dfb24 100644
--- a/wled00/wled.cpp
+++ b/wled00/wled.cpp
@@ -264,7 +264,7 @@ void WLED::loop()
   if (loopMillis > maxLoopMillis) maxLoopMillis = loopMillis;
   if (millis() - debugTime > 29999) {
     DEBUG_PRINTLN(F("---DEBUG INFO---"));
-    DEBUG_PRINTF_P(PSTR("Runtime: %u\n"),   millis());
+    DEBUG_PRINTF_P(PSTR("Runtime: %lu\n"),  millis());
     DEBUG_PRINTF_P(PSTR("Unix time: %u,%03u\n"), toki.getTime().sec, toki.getTime().ms);
     DEBUG_PRINTF_P(PSTR("Free heap: %u\n"), ESP.getFreeHeap());
     #if defined(ARDUINO_ARCH_ESP32)
@@ -283,14 +283,14 @@ void WLED::loop()
       wifiStateChangedTime = millis();
     }
     lastWifiState = WiFi.status();
-    DEBUG_PRINTF_P(PSTR("State time: %u\n"),         wifiStateChangedTime);
-    DEBUG_PRINTF_P(PSTR("NTP last sync: %u\n"),      ntpLastSyncTime);
+    DEBUG_PRINTF_P(PSTR("State time: %lu\n"),        wifiStateChangedTime);
+    DEBUG_PRINTF_P(PSTR("NTP last sync: %lu\n"),     ntpLastSyncTime);
     DEBUG_PRINTF_P(PSTR("Client IP: %u.%u.%u.%u\n"), Network.localIP()[0], Network.localIP()[1], Network.localIP()[2], Network.localIP()[3]);
     if (loops > 0) { // avoid division by zero
-      DEBUG_PRINTF_P(PSTR("Loops/sec: %u\n"),        loops / 30);
-      DEBUG_PRINTF_P(PSTR("Loop time[ms]: %u/%u\n"), avgLoopMillis/loops,    maxLoopMillis);
-      DEBUG_PRINTF_P(PSTR("UM time[ms]: %u/%u\n"),   avgUsermodMillis/loops, maxUsermodMillis);
-      DEBUG_PRINTF_P(PSTR("Strip time[ms]:%u/%u\n"), avgStripMillis/loops,   maxStripMillis);
+      DEBUG_PRINTF_P(PSTR("Loops/sec: %u\n"),         loops / 30);
+      DEBUG_PRINTF_P(PSTR("Loop time[ms]: %u/%lu\n"), avgLoopMillis/loops,    maxLoopMillis);
+      DEBUG_PRINTF_P(PSTR("UM time[ms]: %u/%lu\n"),   avgUsermodMillis/loops, maxUsermodMillis);
+      DEBUG_PRINTF_P(PSTR("Strip time[ms]:%u/%lu\n"), avgStripMillis/loops,   maxStripMillis);
     }
     strip.printSize();
     loops = 0;
@@ -368,11 +368,8 @@ void WLED::setup()
     DEBUG_PRINTLN(F("arduino-esp32 v1.0.x\n"));  // we can't say in more detail.
   #endif
 
-  DEBUG_PRINTF_P(PSTR("CPU:   "),      ESP.getChipModel());
-  DEBUG_PRINTF_P(PSTR(" rev."),        ESP.getChipRevision());
-  DEBUG_PRINTF_P(PSTR(", %d core(s)"), ESP.getChipCores());
-  DEBUG_PRINTF_P(PSTR(", %d MHz.\n"),  ESP.getCpuFreqMHz());
-  DEBUG_PRINTF_P(PSTR("FLASH: %dMB, Mode %d "), (ESP.getFlashChipSize()/1024)/1024, ESP.getFlashChipMode());
+  DEBUG_PRINTF_P(PSTR("CPU:   %s rev.%d, %d core(s), %d MHz.\n"), ESP.getChipModel(), (int)ESP.getChipRevision(), ESP.getChipCores(), ESP.getCpuFreqMHz());
+  DEBUG_PRINTF_P(PSTR("FLASH: %d MB, Mode %d "), (ESP.getFlashChipSize()/1024)/1024, (int)ESP.getFlashChipMode());
   #ifdef WLED_DEBUG
   switch (ESP.getFlashChipMode()) {
     // missing: Octal modes

From 71fcd6482d03d3e6c3fb1c270d478b6240313579 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Thu, 12 Sep 2024 15:07:49 +0200
Subject: [PATCH 35/45] Fix CRLF in boblight

---
 usermods/boblight/boblight.h | 918 +++++++++++++++++------------------
 1 file changed, 459 insertions(+), 459 deletions(-)

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

From a8c5bf257395a8985c5e80bf90f0b3464db00e76 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Thu, 12 Sep 2024 15:22:37 +0200
Subject: [PATCH 36/45] Ease IRAM

---
 wled00/FX.h       | 4 ++--
 wled00/FX_fcn.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/wled00/FX.h b/wled00/FX.h
index a9de2a1899..3c28274d60 100644
--- a/wled00/FX.h
+++ b/wled00/FX.h
@@ -573,7 +573,7 @@ typedef struct Segment {
     [[gnu::hot]] uint8_t  currentBri(bool useCct = false) const; // current segment brightness/CCT (blended while in transition)
     uint8_t  currentMode() const;                            // currently active effect/mode (while in transition)
     [[gnu::hot]] uint32_t currentColor(uint8_t slot) const;  // currently active segment color (blended while in transition)
-    [[gnu::hot]] CRGBPalette16 &loadPalette(CRGBPalette16 &tgt, uint8_t pal);
+    CRGBPalette16 &loadPalette(CRGBPalette16 &tgt, uint8_t pal);
     void     setCurrentPalette();
 
     // 1D strip
@@ -615,7 +615,7 @@ typedef struct Segment {
     // 2D matrix
     [[gnu::hot]] uint16_t virtualWidth()  const; // segment width in virtual pixels (accounts for groupping and spacing)
     [[gnu::hot]] uint16_t virtualHeight() const; // segment height in virtual pixels (accounts for groupping and spacing)
-    [[gnu::hot]] uint16_t nrOfVStrips() const;   // returns number of virtual vertical strips in 2D matrix (used to expand 1D effects into 2D)
+    uint16_t nrOfVStrips() const;                // returns number of virtual vertical strips in 2D matrix (used to expand 1D effects into 2D)
   #ifndef WLED_DISABLE_2D
     [[gnu::hot]] uint16_t XY(int x, int y);      // support function to get relative index within segment
     [[gnu::hot]] void setPixelColorXY(int x, int y, uint32_t c); // set relative pixel within segment with color
diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index d3521c90ce..29126527ff 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -202,7 +202,7 @@ void Segment::resetIfRequired() {
   reset = false;
 }
 
-CRGBPalette16 IRAM_ATTR_YN &Segment::loadPalette(CRGBPalette16 &targetPalette, uint8_t pal) {
+CRGBPalette16 &Segment::loadPalette(CRGBPalette16 &targetPalette, uint8_t pal) {
   if (pal < 245 && pal > GRADIENT_PALETTE_COUNT+13) pal = 0;
   if (pal > 245 && (strip.customPalettes.size() == 0 || 255U-pal > strip.customPalettes.size()-1)) pal = 0; // TODO remove strip dependency by moving customPalettes out of strip
   //default palette. Differs depending on effect
@@ -417,7 +417,7 @@ uint8_t IRAM_ATTR Segment::currentBri(bool useCct) const {
   return (useCct ? cct : (on ? opacity : 0));
 }
 
-uint8_t IRAM_ATTR_YN Segment::currentMode() const {
+uint8_t Segment::currentMode() const {
 #ifndef WLED_DISABLE_MODE_BLEND
   unsigned prog = progress();
   if (modeBlending && prog < 0xFFFFU) return _t->_modeT;

From 49d51c5af8234cbd6431c71221bf42110257243b Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Thu, 12 Sep 2024 15:26:26 +0200
Subject: [PATCH 37/45] Hot

---
 wled00/bus_manager.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/wled00/bus_manager.h b/wled00/bus_manager.h
index 8205bd66cd..bf4657d8b7 100644
--- a/wled00/bus_manager.h
+++ b/wled00/bus_manager.h
@@ -47,7 +47,7 @@ struct ColorOrderMap {
       return &(_mappings[n]);
     }
 
-    uint8_t getPixelColorOrder(uint16_t pix, uint8_t defaultColorOrder) const;
+    [[gnu::hot]] uint8_t getPixelColorOrder(uint16_t pix, uint8_t defaultColorOrder) const;
 
   private:
     std::vector<ColorOrderMapEntry> _mappings;
@@ -201,9 +201,9 @@ class BusDigital : public Bus {
     bool canShow() const override;
     void setBrightness(uint8_t b) override;
     void setStatusPixel(uint32_t c) override;
-    void setPixelColor(uint16_t pix, uint32_t c) override;
+    [[gnu::hot]] void setPixelColor(uint16_t pix, uint32_t c) override;
     void setColorOrder(uint8_t colorOrder) override;
-    uint32_t getPixelColor(uint16_t pix) const override;
+    [[gnu::hot]] uint32_t getPixelColor(uint16_t pix) const override;
     uint8_t  getColorOrder() const override  { return _colorOrder; }
     uint8_t  getPins(uint8_t* pinArray = nullptr) const override;
     uint8_t  skippedLeds() const override    { return _skip; }
@@ -382,7 +382,7 @@ class BusManager {
     static void show();
     static bool canAllShow();
     static void setStatusPixel(uint32_t c);
-    static void setPixelColor(uint16_t pix, uint32_t c);
+    [[gnu::hot]] static void setPixelColor(uint16_t pix, uint32_t c);
     static void setBrightness(uint8_t b);
     // for setSegmentCCT(), cct can only be in [-1,255] range; allowWBCorrection will convert it to K
     // WARNING: setSegmentCCT() is a misleading name!!! much better would be setGlobalCCT() or just setCCT()

From daf0bcfac364846928a2277c1f16475c8d32ac42 Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Thu, 12 Sep 2024 18:12:38 +0200
Subject: [PATCH 38/45] bug fix on pin already defined check

---
 wled00/FX_fcn.cpp      | 9 +++++----
 wled00/pin_manager.cpp | 8 +++++---
 wled00/pin_manager.h   | 2 +-
 3 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 435998cdcd..6b01d9a323 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -1248,15 +1248,16 @@ void WS2812FX::finalizeInit(void) {
       // if we need more pins than available all outputs have been configured
       if (pinsIndex + busPins > defNumPins) break;
       
-      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) {
-        defPin[j] = defDataPins[pinsIndex + j];
+      // Assign all pins first so we can check for conflicts on this bus
+      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) defPin[j] = defDataPins[pinsIndex + j];
 
+      for (unsigned j = 0; j < busPins && j < OUTPUT_MAX_PINS; j++) {
         bool validPin = true;
         // When booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
         // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
         // Pin should not be already allocated, read/only or defined for current bus
-        while (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j]) ||
-               pinManager.isPinDefined(defPin[j], defDataPins, pinsIndex + j + 1, pinsIndex + busPins)) {
+        while (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j]) || pinManager.isPinDefined(defPin[j], defPin, j)) {
+          DEBUG_PRINTLN(F("Some of the provided pins cannot be used to configure this LED output."));
           if (validPin) {
             defPin[j] = 1; // start with GPIO1 and work upwards
             validPin = false;
diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 9398ec94fd..815bddee36 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -281,9 +281,11 @@ bool PinManagerClass::isReadOnlyPin(byte gpio)
   return false;
 }
 
-bool PinManagerClass::isPinDefined(byte gpio, const unsigned *pins, unsigned start, unsigned end) {
-  for (unsigned i = start; i < end; i++) {
-    if (pins[i] == gpio) return true;
+// Given an array of pins, check if a given pin is defined except at given index
+bool PinManagerClass::isPinDefined(const byte gpio, const uint8_t *pins, const unsigned index) {
+  unsigned numPins = ((sizeof pins) / (sizeof pins[0]));
+  for (unsigned i = 0; i < numPins; i++) {
+    if ((pins[i] == gpio) && (i != index)) return true;
   }
   return false;
 }
diff --git a/wled00/pin_manager.h b/wled00/pin_manager.h
index 1263dc4f4c..6c57261308 100644
--- a/wled00/pin_manager.h
+++ b/wled00/pin_manager.h
@@ -113,7 +113,7 @@ class PinManagerClass {
   bool isPinOk(byte gpio, bool output = true) const;
   
   static bool isReadOnlyPin(byte gpio);
-  static bool isPinDefined(byte gpio, const unsigned* pins, unsigned start = 0, unsigned end = WLED_NUM_PINS);
+  static bool isPinDefined(const byte gpio, const uint8_t* pins, const unsigned index = 255);
 
   PinOwner getPinOwner(byte gpio) const;
 

From fa82e759bd0e2e29683f1b33ed7eff26311586db Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Thu, 12 Sep 2024 18:27:51 +0200
Subject: [PATCH 39/45] bug fix

---
 wled00/FX_fcn.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 6b01d9a323..d652435b7d 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -1257,8 +1257,8 @@ void WS2812FX::finalizeInit(void) {
         // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
         // Pin should not be already allocated, read/only or defined for current bus
         while (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j]) || pinManager.isPinDefined(defPin[j], defPin, j)) {
-          DEBUG_PRINTLN(F("Some of the provided pins cannot be used to configure this LED output."));
           if (validPin) {
+            DEBUG_PRINTLN(F("Some of the provided pins cannot be used to configure this LED output."));
             defPin[j] = 1; // start with GPIO1 and work upwards
             validPin = false;
           }  

From e3d9417b84dfac3e64b8634b78e3cd29ed3027de Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sat, 14 Sep 2024 11:39:56 +0200
Subject: [PATCH 40/45] Minor fixes - rely on HAL for RO pins and max pins -
 remove isPinDefined() and do clash check inline - JS fix to use HAL max pins

---
 wled00/FX_fcn.cpp             | 16 +++++++++++++---
 wled00/const.h                | 13 -------------
 wled00/data/settings_leds.htm |  2 +-
 wled00/data/settings_um.htm   | 12 ++++++------
 wled00/pin_manager.cpp        | 21 +++------------------
 wled00/pin_manager.h          |  1 -
 wled00/xml.cpp                | 12 +-----------
 7 files changed, 24 insertions(+), 53 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 447ceaab95..09b2ee517e 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -1256,18 +1256,28 @@ void WS2812FX::finalizeInit() {
         // When booting without config (1st boot) we need to make sure GPIOs defined for LED output don't clash with hardware
         // i.e. DEBUG (GPIO1), DMX (2), SPI RAM/FLASH (16&17 on ESP32-WROVER/PICO), read/only pins, etc.
         // Pin should not be already allocated, read/only or defined for current bus
-        while (pinManager.isPinAllocated(defPin[j]) || pinManager.isReadOnlyPin(defPin[j]) || pinManager.isPinDefined(defPin[j], defPin, j)) {
+        while (pinManager.isPinAllocated(defPin[j]) || !pinManager.isPinOk(defPin[j],true)) {
           if (validPin) {
             DEBUG_PRINTLN(F("Some of the provided pins cannot be used to configure this LED output."));
             defPin[j] = 1; // start with GPIO1 and work upwards
             validPin = false;
-          }  
-          if (defPin[j] < WLED_NUM_PINS) {
+          } else if (defPin[j] < WLED_NUM_PINS) {
             defPin[j]++;
           } else {
             DEBUG_PRINTLN(F("No available pins left! Can't configure output."));
             return;
           }
+          // is the newly assigned pin already defined? try next in line until there are no clashes
+          bool clash;
+          do {
+            clash = false;
+            for (const auto pin : defDataPins) {
+              if (pin == defPin[j]) {
+                defPin[j]++;
+                if (defPin[j] < WLED_NUM_PINS) clash = true;
+              }
+            }
+          } while (clash);
         }
       }
       pinsIndex += busPins;
diff --git a/wled00/const.h b/wled00/const.h
index a0ebeebb1e..47ec02c6a9 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -567,19 +567,6 @@
   #define WLED_MAX_NODES 150
 #endif
 
-// List of read only pins. Cannot be used for LED outputs.
-#if defined(CONFIG_IDF_TARGET_ESP32S2)
-  #define READ_ONLY_PINS 46
-#elif defined(CONFIG_IDF_TARGET_ESP32S3)
-// none for S3
-#elif defined(CONFIG_IDF_TARGET_ESP32C3)
-// none for C3
-#elif defined(ESP32)
-  #define READ_ONLY_PINS 34,35,36,37,38,39
-#else
-// none for ESP8266
-#endif
-
 #ifdef WLED_ENABLE_DMX
 #if (LEDPIN == 2)
   #undef LEDPIN
diff --git a/wled00/data/settings_leds.htm b/wled00/data/settings_leds.htm
index b3188f0d8b..206d4a8c75 100644
--- a/wled00/data/settings_leds.htm
+++ b/wled00/data/settings_leds.htm
@@ -671,7 +671,7 @@
 				if (i.type === "number" && fields.includes(i.name)) { //select all pin select elements
 					let v = parseInt(i.value);
 					let sel = addDropdown(i.name,0);
-					for (var j = -1; j <= d.max_gpio; j++) {
+					for (var j = -1; j < d.max_gpio; j++) {
 						if (d.rsvd.includes(j)) continue;
 						let foundPin = d.um_p.indexOf(j);
 						let txt = (j === -1) ? "unused" : `${j}`;
diff --git a/wled00/data/settings_um.htm b/wled00/data/settings_um.htm
index 686c881d93..e2fbd5eb74 100644
--- a/wled00/data/settings_um.htm
+++ b/wled00/data/settings_um.htm
@@ -32,8 +32,8 @@
 			GetV();
 			for (let r of d.rsvd) { pins.push(r); pinO.push("rsvd"); } // reserved pins
 			if (d.um_p[0]==-1) d.um_p.shift();	// remove filler
-			d.Sf.SDA.max = d.Sf.SCL.max = d.Sf.MOSI.max = d.Sf.SCLK.max = d.Sf.MISO.max = d.max_gpio;
-			//for (let i of d.getElementsByTagName("input")) if (i.type === "number" && i.name.replace("[]","").substr(-3) === "pin") i.max = d.max_gpio;
+			d.Sf.SDA.max = d.Sf.SCL.max = d.Sf.MOSI.max = d.Sf.SCLK.max = d.Sf.MISO.max = d.max_gpio-1;
+			//for (let i of d.getElementsByTagName("input")) if (i.type === "number" && i.name.replace("[]","").substr(-3) === "pin") i.max = d.max_gpio-1;
 			pinDD(); // convert INPUT to SELECT for pins
 		});
 		// error event
@@ -80,7 +80,7 @@
 			for (var i=0; i<pins.length; i++) {
 				if (k==pinO[i]) continue;
 				if (o.value==pins[i] && pinO[i]==="if") { o.style.color="lime"; break; }
-				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
+				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio-1) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
 			}
 		} else {
 			switch (o.name) {
@@ -94,7 +94,7 @@
 			for (var i=0; i<pins.length; i++) {
 				//if (k==pinO[i]) continue; // same owner
 				if (o.value==pins[i] && pinO[i]==="if") { o.style.color="tomato"; break; }
-				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
+				if (o.value==pins[i] || o.value<-1 || o.value>d.max_gpio-1) { o.style.color="red"; break; } else o.style.color=d.ro_gpio.some((e)=>e==parseInt(o.value,10))?"orange":"#fff";
 			}
 		}
 		*/
@@ -148,7 +148,7 @@
 				case "number":
 					c = `value="${o}"`;
 					if (f.substr(-3)==="pin") {
-						c += ` max="${d.max_gpio}" min="-1" class="s"`;
+						c += ` max="${d.max_gpio-1}" min="-1" class="s"`;
 						t = "int";
 					} else {
 						c += ' step="any" class="xxl"';
@@ -170,7 +170,7 @@
 			if (i.type === "number" && (i.name.includes("pin") || ["SDA","SCL","MOSI","MISO","SCLK"].includes(i.name))) { //select all pin select elements
 				let v = parseInt(i.value);
 				let sel = addDD(i.name,0);
-				for (var j = -1; j <= d.max_gpio; j++) {
+				for (var j = -1; j < d.max_gpio; j++) {
 					if (d.rsvd.includes(j)) continue;
 					let foundPin = pins.indexOf(j);
 					let txt = (j === -1) ? "unused" : `${j}`;
diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 815bddee36..9abaca5df0 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -269,24 +269,9 @@ bool PinManagerClass::isPinOk(byte gpio, bool output) const
 
 bool PinManagerClass::isReadOnlyPin(byte gpio)
 {
-  #ifdef READ_ONLY_PINS
-  const unsigned pins[] = {READ_ONLY_PINS};
-  const unsigned numPins = ((sizeof pins) / (sizeof pins[0]));
-
-  if (gpio <= WLED_NUM_PINS) {
-    for (unsigned i = 0; i < numPins; i++) if (gpio == pins[i]) return true;
-  }
-  #endif
-
-  return false;
-}
-
-// Given an array of pins, check if a given pin is defined except at given index
-bool PinManagerClass::isPinDefined(const byte gpio, const uint8_t *pins, const unsigned index) {
-  unsigned numPins = ((sizeof pins) / (sizeof pins[0]));
-  for (unsigned i = 0; i < numPins; i++) {
-    if ((pins[i] == gpio) && (i != index)) return true;
-  }
+#ifdef ARDUINO_ARCH_ESP32
+  if (gpio < WLED_NUM_PINS) return digitalPinCanOutput(gpio);
+#endif
   return false;
 }
 
diff --git a/wled00/pin_manager.h b/wled00/pin_manager.h
index 6c57261308..a8ddf5f751 100644
--- a/wled00/pin_manager.h
+++ b/wled00/pin_manager.h
@@ -113,7 +113,6 @@ class PinManagerClass {
   bool isPinOk(byte gpio, bool output = true) const;
   
   static bool isReadOnlyPin(byte gpio);
-  static bool isPinDefined(const byte gpio, const uint8_t* pins, const unsigned index = 255);
 
   PinOwner getPinOwner(byte gpio) const;
 
diff --git a/wled00/xml.cpp b/wled00/xml.cpp
index 800b6d4f82..338e795d43 100644
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -204,17 +204,7 @@ void appendGPIOinfo() {
 
   // add info about max. # of pins
   oappend(SET_F("d.max_gpio="));
-  #if defined(CONFIG_IDF_TARGET_ESP32S2)
-  oappendi(46);
-  #elif defined(CONFIG_IDF_TARGET_ESP32S3)
-  oappendi(48);
-  #elif defined(CONFIG_IDF_TARGET_ESP32C3)
-  oappendi(21);
-  #elif defined(ESP32)
-  oappendi(39);
-  #else
-  oappendi(16);
-  #endif
+  oappendi(WLED_NUM_PINS);
   oappend(SET_F(";"));
 }
 

From 81e412fe5b1a26da59311dc636e39009a4fbed5a Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sat, 14 Sep 2024 14:54:42 +0200
Subject: [PATCH 41/45] Use refernece to avoid ctor/dtor Use PinManager to
 determine reserved pins

---
 wled00/FX_fcn.cpp |  2 +-
 wled00/xml.cpp    | 50 ++++++++++++++++++-----------------------------
 2 files changed, 20 insertions(+), 32 deletions(-)

diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 09b2ee517e..12faaebd6b 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -1271,7 +1271,7 @@ void WS2812FX::finalizeInit() {
           bool clash;
           do {
             clash = false;
-            for (const auto pin : defDataPins) {
+            for (const auto &pin : defDataPins) {
               if (pin == defPin[j]) {
                 defPin[j]++;
                 if (defPin[j] < WLED_NUM_PINS) clash = true;
diff --git a/wled00/xml.cpp b/wled00/xml.cpp
index 338e795d43..079c0a91bd 100644
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -121,6 +121,7 @@ void fillUMPins(JsonObject &mods)
 void appendGPIOinfo() {
   char nS[8];
 
+  // add usermod pins as d.um_p array
   oappend(SET_F("d.um_p=[-1")); // has to have 1 element
   if (i2c_sda > -1 && i2c_scl > -1) {
     oappend(","); oappend(itoa(i2c_sda,nS,10));
@@ -140,54 +141,41 @@ void appendGPIOinfo() {
   }
   oappend(SET_F("];"));
 
-  // add reserved and usermod pins as d.um_p array
-  #if defined(CONFIG_IDF_TARGET_ESP32S2)
-  oappend(SET_F("d.rsvd=[22,23,24,25,26,27,28,29,30,31,32"));
-  #elif defined(CONFIG_IDF_TARGET_ESP32S3)
-  oappend(SET_F("d.rsvd=[19,20,22,23,24,25,26,27,28,29,30,31,32"));  // includes 19+20 for USB OTG (JTAG)
-  if (psramFound()) oappend(SET_F(",33,34,35,36,37")); // in use for "octal" PSRAM or "octal" FLASH -seems that octal PSRAM is very common on S3.
-  #elif defined(CONFIG_IDF_TARGET_ESP32C3)
-  oappend(SET_F("d.rsvd=[11,12,13,14,15,16,17"));
-  #elif defined(ESP32)
-  oappend(SET_F("d.rsvd=[6,7,8,9,10,11,24,28,29,30,31,37,38"));
-  if (!pinManager.isPinOk(16,false)) oappend(SET_F(",16")); // covers PICO & WROVER
-  if (!pinManager.isPinOk(17,false)) oappend(SET_F(",17")); // covers PICO & WROVER
-  #else
-  oappend(SET_F("d.rsvd=[6,7,8,9,10,11"));
-  #endif
-
+  // add reserved (unusable) pins
+  oappend(SET_F("d.rsvd=["));
+  for (unsigned i = 0; i < WLED_NUM_PINS; i++) {
+    if (!pinManager.isPinOk(i, false)) {  // include readonly pins
+      oappendi(i); oappend(",");
+    }
+  }
   #ifdef WLED_ENABLE_DMX
-  oappend(SET_F(",2")); // DMX hardcoded pin
+  oappend(SET_F("2,")); // DMX hardcoded pin
   #endif
-
   #if defined(WLED_DEBUG) && !defined(WLED_DEBUG_HOST)
-  oappend(SET_F(",")); oappend(itoa(hardwareTX,nS,10)); // debug output (TX) pin
+  oappend(itoa(hardwareTX,nS,10)); oappend(","); // debug output (TX) pin
   #endif
-
   //Note: Using pin 3 (RX) disables Adalight / Serial JSON
-
   #ifdef WLED_USE_ETHERNET
   if (ethernetType != WLED_ETH_NONE && ethernetType < WLED_NUM_ETH_TYPES) {
-    for (unsigned p=0; p<WLED_ETH_RSVD_PINS_COUNT; p++) { oappend(","); oappend(itoa(esp32_nonconfigurable_ethernet_pins[p].pin,nS,10)); }
-    if (ethernetBoards[ethernetType].eth_power>=0)     { oappend(","); oappend(itoa(ethernetBoards[ethernetType].eth_power,nS,10)); }
-    if (ethernetBoards[ethernetType].eth_mdc>=0)       { oappend(","); oappend(itoa(ethernetBoards[ethernetType].eth_mdc,nS,10)); }
-    if (ethernetBoards[ethernetType].eth_mdio>=0)      { oappend(","); oappend(itoa(ethernetBoards[ethernetType].eth_mdio,nS,10)); }
-    switch (ethernetBoards[ethernetType].eth_clk_mode) {
+    for (unsigned p=0; p<WLED_ETH_RSVD_PINS_COUNT; p++) { oappend(itoa(esp32_nonconfigurable_ethernet_pins[p].pin,nS,10)); oappend(","); }
+    if (ethernetBoards[ethernetType].eth_power>=0)      { oappend(itoa(ethernetBoards[ethernetType].eth_power,nS,10)); oappend(","); }
+    if (ethernetBoards[ethernetType].eth_mdc>=0)        { oappend(itoa(ethernetBoards[ethernetType].eth_mdc,nS,10)); oappend(","); }
+    if (ethernetBoards[ethernetType].eth_mdio>=0)       { oappend(itoa(ethernetBoards[ethernetType].eth_mdio,nS,10)); oappend(","); }
+    switch (ethernetBoards[ethernetType].eth_clk_mode)  {
       case ETH_CLOCK_GPIO0_IN:
       case ETH_CLOCK_GPIO0_OUT:
-        oappend(SET_F(",0"));
+        oappend(SET_F("0"));
         break;
       case ETH_CLOCK_GPIO16_OUT:
-        oappend(SET_F(",16"));
+        oappend(SET_F("16"));
         break;
       case ETH_CLOCK_GPIO17_OUT:
-        oappend(SET_F(",17"));
+        oappend(SET_F("17"));
         break;
     }
   }
   #endif
-
-  oappend(SET_F("];"));
+  oappend(SET_F("];")); // rsvd
 
   // add info for read-only GPIO
   oappend(SET_F("d.ro_gpio=["));

From f16ed4697ff949404ab1ec535848d446f1979dfb Mon Sep 17 00:00:00 2001
From: PaoloTK <github@paolotk.com>
Date: Sat, 14 Sep 2024 18:58:53 +0200
Subject: [PATCH 42/45] fix isReadOnlyPin() logic

---
 wled00/pin_manager.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wled00/pin_manager.cpp b/wled00/pin_manager.cpp
index 9abaca5df0..47cba2ec63 100644
--- a/wled00/pin_manager.cpp
+++ b/wled00/pin_manager.cpp
@@ -270,7 +270,7 @@ bool PinManagerClass::isPinOk(byte gpio, bool output) const
 bool PinManagerClass::isReadOnlyPin(byte gpio)
 {
 #ifdef ARDUINO_ARCH_ESP32
-  if (gpio < WLED_NUM_PINS) return digitalPinCanOutput(gpio);
+  if (gpio < WLED_NUM_PINS) return (digitalPinIsValid(gpio) && !digitalPinCanOutput(gpio));
 #endif
   return false;
 }

From 2264cc5d10aae1fff21bf34782a09ff5291c9c3d Mon Sep 17 00:00:00 2001
From: Will Miles <will@willmiles.net>
Date: Sat, 14 Sep 2024 16:11:46 -0400
Subject: [PATCH 43/45] Use tag to pin AsyncWebServer version

---
 platformio.ini | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platformio.ini b/platformio.ini
index 016d0d18d4..777083e3f6 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -140,7 +140,7 @@ lib_deps =
     IRremoteESP8266 @ 2.8.2
     makuna/NeoPixelBus @ 2.8.0
     #https://github.com/makuna/NeoPixelBus.git#CoreShaderBeta
-    https://github.com/Aircoookie/ESPAsyncWebServer.git @ 2.2.1
+    https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.2.1
   # for I2C interface
     ;Wire
   # ESP-NOW library
@@ -234,7 +234,7 @@ lib_deps_compat =
   IRremoteESP8266 @ 2.8.2
   makuna/NeoPixelBus @ 2.7.9
   https://github.com/blazoncek/QuickESPNow.git#optional-debug
-  https://github.com/Aircoookie/ESPAsyncWebServer.git @ 2.2.1
+  https://github.com/Aircoookie/ESPAsyncWebServer.git#v2.2.1
 
 
 [esp32]

From 5708d7a6b8186aab2e39ba93e8100c3a9d896a7c Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sat, 14 Sep 2024 22:30:56 +0200
Subject: [PATCH 44/45] Build bump, changelog update

---
 CHANGELOG.md                                  |  5 +++++
 platformio.ini                                |  4 ++--
 platformio_override.sample.ini                | 20 +++++++++----------
 usermods/mqtt_switch_v2/README.md             |  2 +-
 .../usermod_v2_HttpPullLightControl/readme.md |  2 +-
 wled00/FX_fcn.cpp                             |  5 -----
 wled00/const.h                                | 15 ++++++--------
 wled00/wled.h                                 |  4 ++--
 8 files changed, 27 insertions(+), 30 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5b0f64cf29..e377418e30 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 ## WLED changelog
 
+#### Build 2409140
+-   Configure different kinds of busses at compile (#4107 by @PaoloTK)
+    - BREAKING: removes LEDPIN and DEFAULT_LED_TYPE compile overrides
+-   Fetch LED types from Bus classes (dynamic UI) (#4129 by @netmindz, @blazoncek, @dedehai)
+
 #### Build 2409100
 -   WLED 0.15.0-b5 release
 -   Audioreactive usermod included by default in all compatible builds (including ESP8266)
diff --git a/platformio.ini b/platformio.ini
index 016d0d18d4..e5f3a9cff0 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -470,7 +470,7 @@ board_build.partitions = ${esp32.extended_partitions}
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32_idf_V4.build_flags} -D WLED_RELEASE_NAME=ESP32_WROVER
   -DBOARD_HAS_PSRAM -mfix-esp32-psram-cache-issue ;; Older ESP32 (rev.<3) need a PSRAM fix (increases static RAM used) https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/external-ram.html
-  -D LEDPIN=25
+  -D DATA_PINS=25
   ${esp32.AR_build_flags}
 lib_deps = ${esp32_idf_V4.lib_deps}
   ${esp32.AR_lib_deps}
@@ -569,7 +569,7 @@ build_flags = ${common.build_flags} ${esp32s2.build_flags} -D WLED_RELEASE_NAME=
   -DLOLIN_WIFI_FIX ; seems to work much better with this
   -D WLED_WATCHDOG_TIMEOUT=0
   -D CONFIG_ASYNC_TCP_USE_WDT=0
-  -D LEDPIN=16
+  -D DATA_PINS=16
   -D HW_PIN_SCL=35
   -D HW_PIN_SDA=33
   -D HW_PIN_CLOCKSPI=7
diff --git a/platformio_override.sample.ini b/platformio_override.sample.ini
index 7f6524922a..dedc8edf53 100644
--- a/platformio_override.sample.ini
+++ b/platformio_override.sample.ini
@@ -59,7 +59,7 @@ build_flags = ${common.build_flags} ${esp8266.build_flags}
 ;   -D WLED_ENABLE_DMX
 ;
 ; PIN defines - uncomment and change, if needed:
-;   -D LEDPIN=2
+;   -D DATA_PINS=2
 ; or use this for multiple outputs
 ;   -D DATA_PINS=1,3
 ;   -D BTNPIN=0
@@ -233,7 +233,7 @@ platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D LEDPIN=1 -D WLED_DISABLE_INFRARED
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 
 [env:esp32dev_qio80]
@@ -339,7 +339,7 @@ platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D LEDPIN=12 -D IRPIN=-1 -D RLYPIN=2
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=12 -D IRPIN=-1 -D RLYPIN=2
 lib_deps = ${esp8266.lib_deps}
 
 [env:esp32c3dev_2MB]
@@ -367,7 +367,7 @@ platform_packages = ${esp32.platform_packages}
 upload_speed = 460800
 build_unflags = ${common.build_unflags}
 build_flags = ${common.build_flags} ${esp32.build_flags}
-  -D LEDPIN=16
+  -D DATA_PINS=16
   -D RLYPIN=19
   -D BTNPIN=17
   -D IRPIN=18
@@ -386,7 +386,7 @@ board_build.partitions = ${esp32.default_partitions}
 [env:m5atom]
 board = esp32dev
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp32.build_flags} -D LEDPIN=27 -D BTNPIN=39
+build_flags = ${common.build_flags} ${esp32.build_flags} -D DATA_PINS=27 -D BTNPIN=39
 lib_deps = ${esp32.lib_deps}
 platform = ${esp32.platform}
 platform_packages = ${esp32.platform_packages}
@@ -396,14 +396,14 @@ board_build.partitions = ${esp32.default_partitions}
 board = esp_wroom_02
 platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_2m512k}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D LEDPIN=3 -D BTNPIN=1
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=3 -D BTNPIN=1
 lib_deps = ${esp8266.lib_deps}
 
 [env:sp511e]
 board = esp_wroom_02
 platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_2m512k}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D LEDPIN=3 -D BTNPIN=2 -D IRPIN=5 -D WLED_MAX_BUTTONS=3
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D DATA_PINS=3 -D BTNPIN=2 -D IRPIN=5 -D WLED_MAX_BUTTONS=3
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_RGBCW]        ;7w and 5w(GU10) bulbs
@@ -432,7 +432,7 @@ platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=-1 -D LEDPIN=1 -D WLED_DISABLE_INFRARED
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=-1 -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_4Pin_Controller]       ; With clock and data interface
@@ -441,7 +441,7 @@ platform = ${common.platform_wled_default}
 platform_packages = ${common.platform_packages}
 board_build.ldscript = ${common.ldscript_2m512k}
 build_unflags = ${common.build_unflags}
-build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=12 -D LEDPIN=1 -D WLED_DISABLE_INFRARED
+build_flags = ${common.build_flags} ${esp8266.build_flags} -D BTNPIN=0 -D RLYPIN=12 -D DATA_PINS=1 -D WLED_DISABLE_INFRARED
 lib_deps = ${esp8266.lib_deps}
 
 [env:Athom_5Pin_Controller]      ;Analog light strip controller
@@ -496,7 +496,7 @@ upload_speed = 921600
 build_flags = ${common.build_flags} ${esp32.build_flags} -D WLED_DISABLE_BROWNOUT_DET -D WLED_DISABLE_INFRARED
   -D USERMOD_RTC
   -D USERMOD_ELEKSTUBE_IPS
-  -D LEDPIN=12
+  -D DATA_PINS=12
   -D RLYPIN=27
   -D BTNPIN=34
   -D DEFAULT_LED_COUNT=6
diff --git a/usermods/mqtt_switch_v2/README.md b/usermods/mqtt_switch_v2/README.md
index 744d7fe3c3..4cb7ef0e84 100644
--- a/usermods/mqtt_switch_v2/README.md
+++ b/usermods/mqtt_switch_v2/README.md
@@ -33,7 +33,7 @@ board = esp12e
 platform = ${common.platform_wled_default}
 board_build.ldscript = ${common.ldscript_4m1m}
 build_flags = ${common.build_flags_esp8266} 
-   -D LEDPIN=3
+   -D DATA_PINS=3
    -D BTNPIN=4
    -D RLYPIN=12
    -D RLYMDE=1
diff --git a/usermods/usermod_v2_HttpPullLightControl/readme.md b/usermods/usermod_v2_HttpPullLightControl/readme.md
index cf7f971f79..eb56d505d2 100644
--- a/usermods/usermod_v2_HttpPullLightControl/readme.md
+++ b/usermods/usermod_v2_HttpPullLightControl/readme.md
@@ -93,7 +93,7 @@ After getting the URL (it can be a static file like static.json or a mylogic.php
 -  -D ABL_MILLIAMPS_DEFAULT=450
 -  -D DEFAULT_LED_COUNT=60 ; For a LED Ring of 60 LEDs
 -  -D BTNPIN=41  ; The M5Stack Atom S3 Lite has a button on GPIO41
--  -D LEDPIN=2 ; The M5Stack Atom S3 Lite has a Grove connector on the front, we use this GPIO2
+-  -D DATA_PINS=2 ; The M5Stack Atom S3 Lite has a Grove connector on the front, we use this GPIO2
 -  -D STATUSLED=35 ; The M5Stack Atom S3 Lite has a Multi-Color LED on GPIO35, although I didnt managed to control it
 -  -D IRPIN=4  ; The M5Stack Atom S3 Lite has a IR LED on GPIO4
 
diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 12faaebd6b..fe47ee5297 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -43,11 +43,6 @@
   19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 29, 28, 27, 26, 25]}
 */
 
-//factory defaults LED setup
-//#define PIXEL_COUNTS 30
-//#define DATA_PINS 2 (8266/C3) or 16 
-//#define DEFAULT_LED_TYPE TYPE_WS2812_RGB
-
 #ifndef PIXEL_COUNTS
   #define PIXEL_COUNTS DEFAULT_LED_COUNT
 #endif
diff --git a/wled00/const.h b/wled00/const.h
index 47ec02c6a9..14ec23b58a 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -567,17 +567,14 @@
   #define WLED_MAX_NODES 150
 #endif
 
-#ifdef WLED_ENABLE_DMX
-#if (LEDPIN == 2)
-  #undef LEDPIN
-  #define LEDPIN 1
-  #warning "Pin conflict compiling with DMX and LEDs on pin 2. The default LED pin has been changed to pin 1."
-#endif
-#endif
-
 // Defaults pins, type and counts to configure LED output
 #if defined(ESP8266) || defined(CONFIG_IDF_TARGET_ESP32C3)
-  #define DEFAULT_LED_PIN 2    // GPIO2 (D4) on Wemos D1 mini compatible boards, safe to use on any board
+  #ifdef WLED_ENABLE_DMX
+    #define DEFAULT_LED_PIN 1
+    #warning "Compiling with DMX. The default LED pin has been changed to pin 1."
+  #else
+    #define DEFAULT_LED_PIN 2    // GPIO2 (D4) on Wemos D1 mini compatible boards, safe to use on any board
+  #endif
 #else
   #define DEFAULT_LED_PIN 16   // aligns with GPIO2 (D4) on Wemos D1 mini32 compatible boards (if it is unusable it will be reassigned in WS2812FX::finalizeInit())
 #endif
diff --git a/wled00/wled.h b/wled00/wled.h
index 99c5f42263..8616934632 100644
--- a/wled00/wled.h
+++ b/wled00/wled.h
@@ -8,7 +8,7 @@
  */
 
 // version code in format yymmddb (b = daily build)
-#define VERSION 2409100
+#define VERSION 2409140
 
 //uncomment this if you have a "my_config.h" file you'd like to use
 //#define WLED_USE_MY_CONFIG
@@ -35,7 +35,7 @@
 #else
   #undef WLED_ENABLE_ADALIGHT      // disable has priority over enable
 #endif
-//#define WLED_ENABLE_DMX          // uses 3.5kb (use LEDPIN other than 2)
+//#define WLED_ENABLE_DMX          // uses 3.5kb
 //#define WLED_ENABLE_JSONLIVE     // peek LED output via /json/live (WS binary peek is always enabled)
 #ifndef WLED_DISABLE_LOXONE
   #define WLED_ENABLE_LOXONE       // uses 1.2kb

From 65a8dbfe416296acd6f66e7a4271eff70d53b4c6 Mon Sep 17 00:00:00 2001
From: Blaz Kristan <blaz@kristan-sp.si>
Date: Sun, 15 Sep 2024 11:04:02 +0200
Subject: [PATCH 45/45] FX: Usermod Temperature effect

---
 usermods/Temperature/usermod_temperature.h | 23 +++++++++++++++++++++-
 usermods/audioreactive/audio_reactive.h    |  6 ------
 wled00/FX.cpp                              |  5 -----
 wled00/fcn_declare.h                       |  1 +
 wled00/util.cpp                            |  5 +++++
 5 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/usermods/Temperature/usermod_temperature.h b/usermods/Temperature/usermod_temperature.h
index 5ac992f952..23c5606500 100644
--- a/usermods/Temperature/usermod_temperature.h
+++ b/usermods/Temperature/usermod_temperature.h
@@ -17,6 +17,8 @@
 #define USERMOD_DALLASTEMPERATURE_MEASUREMENT_INTERVAL 60000
 #endif
 
+static uint16_t mode_temperature();
+
 class UsermodTemperature : public Usermod {
 
   private:
@@ -60,6 +62,7 @@ class UsermodTemperature : public Usermod {
     static const char _sensor[];
     static const char _temperature[];
     static const char _Temperature[];
+    static const char _data_fx[];
     
     //Dallas sensor quick (& dirty) reading. Credit to - Author: Peter Scargill, August 17th, 2013
     float readDallas();
@@ -70,8 +73,13 @@ class UsermodTemperature : public Usermod {
     void publishHomeAssistantAutodiscovery();
 #endif
 
+    static UsermodTemperature* _instance; // to overcome nonstatic getTemperatureC() method and avoid usermods.lookup(USERMOD_ID_TEMPERATURE);
+
   public:
 
+    UsermodTemperature() { _instance = this; }
+    static UsermodTemperature *getInstance() { return UsermodTemperature::_instance; }
+
     /*
      * API calls te enable data exchange between WLED modules
      */
@@ -234,6 +242,7 @@ void UsermodTemperature::setup() {
       }
       temperaturePin = -1;  // allocation failed
     }
+    if (sensorFound && !initDone) strip.addEffect(255, &mode_temperature, _data_fx);
   }
   lastMeasurement = millis() - readingInterval + 10000;
   initDone = true;
@@ -440,6 +449,8 @@ const char *UsermodTemperature::getTemperatureUnit() {
   return degC ? "°C" : "°F";
 }
 
+UsermodTemperature* UsermodTemperature::_instance = nullptr;
+
 // strings to reduce flash memory usage (used more than twice)
 const char UsermodTemperature::_name[]         PROGMEM = "Temperature";
 const char UsermodTemperature::_enabled[]      PROGMEM = "enabled";
@@ -449,4 +460,14 @@ const char UsermodTemperature::_parasitePin[]  PROGMEM = "parasite-pwr-pin";
 const char UsermodTemperature::_domoticzIDX[]  PROGMEM = "domoticz-idx";
 const char UsermodTemperature::_sensor[]       PROGMEM = "sensor";
 const char UsermodTemperature::_temperature[]  PROGMEM = "temperature";
-const char UsermodTemperature::_Temperature[]  PROGMEM = "/temperature";
\ No newline at end of file
+const char UsermodTemperature::_Temperature[]  PROGMEM = "/temperature";
+const char UsermodTemperature::_data_fx[]      PROGMEM = "Temperature@Min,Max;;!;01;pal=54";
+
+static uint16_t mode_temperature() {
+  float low  = mapf((float)SEGMENT.speed, 0.f, 255.f, -150.f, 149.9f);    // default: 0°C, range: -15°C to 15°C
+  float high = mapf((float)SEGMENT.intensity, 0.f, 255.f, 150.f, 450.f);  // default: 30°C, range 15°C to 45°C
+  float temp = constrain(UsermodTemperature::getInstance()->getTemperatureC()*10.f, low, high);   // get a little better resolution
+  unsigned i = map(temp, (unsigned)low, (unsigned)high, 0, 255);
+  SEGMENT.fill(SEGMENT.color_from_palette(i, false, false, 255));
+  return FRAMETIME;
+}
diff --git a/usermods/audioreactive/audio_reactive.h b/usermods/audioreactive/audio_reactive.h
index 088ac880b8..fde7afded0 100644
--- a/usermods/audioreactive/audio_reactive.h
+++ b/usermods/audioreactive/audio_reactive.h
@@ -149,7 +149,6 @@ static bool useBandPassFilter = false;                    // if true, enables a
 ////////////////////
 
 // some prototypes, to ensure consistent interfaces
-static float mapf(float x, float in_min, float in_max, float out_min, float out_max); // map function for float
 static float fftAddAvg(int from, int to);   // average of several FFT result bins
 void FFTcode(void * parameter);      // audio processing task: read samples, run FFT, fill GEQ channels from FFT results
 static void runMicFilter(uint16_t numSamples, float *sampleBuffer);          // pre-filtering of raw samples (band-pass)
@@ -211,11 +210,6 @@ static ArduinoFFT<float> FFT = ArduinoFFT<float>( vReal, vImag, samplesFFT, SAMP
 
 // Helper functions
 
-// float version of map()
-static float mapf(float x, float in_min, float in_max, float out_min, float out_max){
-  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}
-
 // compute average of several FFT result bins
 static float fftAddAvg(int from, int to) {
   float result = 0.0f;
diff --git a/wled00/FX.cpp b/wled00/FX.cpp
index 807594e430..0084b09e0f 100644
--- a/wled00/FX.cpp
+++ b/wled00/FX.cpp
@@ -6483,11 +6483,6 @@ static const char _data_FX_MODE_2DWAVERLY[] PROGMEM = "Waverly@Amplification,Sen
 
 #endif // WLED_DISABLE_2D
 
-// float version of map()
-static float mapf(float x, float in_min, float in_max, float out_min, float out_max){
-  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}
-
 // Gravity struct requited for GRAV* effects
 typedef struct Gravity {
   int    topLED;
diff --git a/wled00/fcn_declare.h b/wled00/fcn_declare.h
index f8399b1ad6..a95064a2a6 100644
--- a/wled00/fcn_declare.h
+++ b/wled00/fcn_declare.h
@@ -378,6 +378,7 @@ uint16_t crc16(const unsigned char* data_p, size_t length);
 um_data_t* simulateSound(uint8_t simulationId);
 void enumerateLedmaps();
 uint8_t get_random_wheel_index(uint8_t pos);
+float mapf(float x, float in_min, float in_max, float out_min, float out_max);
 
 // RAII guard class for the JSON Buffer lock
 // Modeled after std::lock_guard
diff --git a/wled00/util.cpp b/wled00/util.cpp
index 2e70564489..99a75bdd30 100644
--- a/wled00/util.cpp
+++ b/wled00/util.cpp
@@ -612,3 +612,8 @@ uint8_t get_random_wheel_index(uint8_t pos) {
   }
   return r;
 }
+
+// float version of map()
+float mapf(float x, float in_min, float in_max, float out_min, float out_max) {
+  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}