FastLED.h

Go to the documentation of this file.

#pragma once
 
// IWYU pragma: private  // no IWYU recommend for internal apis, obviously you can use this
#ifndef __INC_FASTSPI_LED2_H
#define __INC_FASTSPI_LED2_H
 
 
 
#include "fl/stl/stdint.h"
#include "fl/system/dll.h"  // Will optionally compile in.
#include "platforms/is_platform.h"
 
// Include Arduino.h early and immediately normalize its math macros (min, max, abs,
// round, radians, degrees, map). On Arduino platforms the IDE injects Arduino.h
// before the sketch, so those macros are already active by the time FastLED.h is
// processed. Pulling fl/system/arduino.h in here — before any internal FastLED headers —
// ensures all subsequent headers see a clean, macro-free environment.
// fl/stl/undef.h (included by fl/system/arduino.h) is intentionally re-includable, so a
// second cleanup in fl/math/math.h (included later, after platform headers) will
// catch any macros re-introduced by those platform headers.
#if defined(ARDUINO)
#include "fl/system/arduino.h"
#endif

 
#if defined(FL_IS_GCC) || defined(FL_IS_CLANG)
#define FASTLED_HAS_PRAGMA_MESSAGE
#endif

#define FASTLED_VERSION 3010004
#ifndef FASTLED_INTERNAL
#  ifdef  FASTLED_SHOW_VERSION
#    ifdef FASTLED_HAS_PRAGMA_MESSAGE
#      pragma message "FastLED version 3.010.003"
#    else
#      warning FastLED version 3.010.003  (Not really a warning, just telling you here.)
#    endif
#  endif
#endif
// ESP32 I2S Driver compatibility warning
#if defined(FASTLED_ESP32_I2S) && !defined(FASTLED_INTERNAL)
#include "platforms/esp/esp_version.h"  // ok platform headers
#if defined(ESP_IDF_VERSION_MAJOR) && ESP_IDF_VERSION_MAJOR >= 5
#warning "ESP32 I2S Driver: ESP-IDF 5.x detected. This driver may not work reliably with ESP-IDF 5.x+. Consider using RMT driver instead or staying on ESP-IDF 4.x. See ESP32_I2S_ISSUES.md for details. Report issues at: https://github.com/FastLED/FastLED/issues"
#endif
#endif
 
// ESP32 RMT Driver conflict prevention
// Arduino ESP32 Core 3.x (ESP-IDF 5.x+) includes a neopixelWrite() function that uses the RMT driver,
// which conflicts with FastLED's legacy RMT4 driver (FASTLED_RMT5=0).
// Disable Arduino's built-in RGB LED support to prevent the conflict.
// This is only needed for ESP-IDF 5.x+ with legacy RMT4 driver, not earlier versions or RMT5 driver.
// Only applies to platforms that actually have RMT hardware (excludes ESP32-C2 which lacks RMT).
// Reference: https://github.com/espressif/arduino-esp32/issues/9866
#if defined(FL_IS_ESP32)
#include "platforms/esp/esp_version.h"  // ok platform headers
#include "platforms/esp/32/feature_flags/enabled.h"  // ok platform headers
#if FASTLED_RMT5 == 0 && FASTLED_ESP32_HAS_RMT && !defined(ESP32_ARDUINO_NO_RGB_BUILTIN)
#error "ESP-IDF 5.x+ with legacy RMT4 driver detected: Please define ESP32_ARDUINO_NO_RGB_BUILTIN=1 to prevent conflicts with Arduino's neopixelWrite() function. Add '-DESP32_ARDUINO_NO_RGB_BUILTIN=1' to your build flags or use '-DFASTLED_RMT5=1' to enable RMT5 driver."
#endif
#endif
 
 
#if !defined(FASTLED_FAKE_SPI_FORWARDS_TO_FAKE_CLOCKLESS)
#if defined(FL_IS_WASM)
#define FASTLED_FAKE_SPI_FORWARDS_TO_FAKE_CLOCKLESS 1
#else
#define FASTLED_FAKE_SPI_FORWARDS_TO_FAKE_CLOCKLESS 0
#endif
#endif
 
// Platforms that register real hardware channel drivers (clockless and/or SPI).
// User-overridable: define before including FastLED.h to force on/off.
#if !defined(FASTLED_HAS_CHANNELS)
#if defined(FL_IS_ESP32) || defined(FL_IS_TEENSY_4X) || \
    defined(FL_IS_RP) || defined(FL_IS_STM32) || \
    defined(FL_IS_SAMD) || defined(FL_IS_NRF52)
#define FASTLED_HAS_CHANNELS 1
#else
#define FASTLED_HAS_CHANNELS 0
#endif
#endif
 
// Route SPI chipsets (APA102, SK9822, etc.) through the Channel API instead of
// legacy APA102Controller/SPIOutput. Only enabled on platforms where
// DATA_RATE_MHZ() returns Hz (not clock dividers) so that the SPI_DATA_RATE
// template parameter can be passed directly to the channel encoder.
#if !defined(FASTLED_SPI_USES_CHANNEL_API)
#if FASTLED_HAS_CHANNELS && (defined(FL_IS_ESP32) || defined(FL_IS_TEENSY_4X))
#define FASTLED_SPI_USES_CHANNEL_API 1
#else
#define FASTLED_SPI_USES_CHANNEL_API 0
#endif
#endif
 
#ifndef __PROG_TYPES_COMPAT__
#define __PROG_TYPES_COMPAT__
#endif
 
#ifdef FL_IS_WASM
#include "platforms/wasm/js.h"  // ok platform headers
#include "platforms/wasm/led_sysdefs_wasm.h"  // ok platform headers
#include "platforms/wasm/compiler/Arduino.h"  // ok platform headers
#include "platforms/wasm/js_fetch.h"  // ok platform headers
#endif
 
#ifdef SmartMatrix_h
// IWYU pragma: begin_keep
#include <SmartMatrix.h>
// IWYU pragma: end_keep
#endif
 
#ifdef DmxSimple_h
// IWYU pragma: begin_keep
#include <DmxSimple.h>
// IWYU pragma: end_keep
#endif
 
#ifdef DmxSerial_h
// IWYU pragma: begin_keep
#include <DMXSerial.h>
// IWYU pragma: end_keep
#endif
 
#ifdef USE_OCTOWS2811
// IWYU pragma: begin_keep
#include <OctoWS2811.h>
// IWYU pragma: end_keep
#endif
 
// Convenience includes for sketch inclusion
#include "fl/task/executor.h"
#include "fl/system/sketch_macros.h"
#include "fl/channels/rx.h"
#include "fl/stl/array.h"
#include "fl/stl/vector.h"
#include "fl/stl/cstring.h"
#include "fl/system/pin.h"
 
 
#include "fl/stl/compiler_control.h"
#include "fl/stl/static_assert.h"
#include "cpp_compat.h"
 
#include "fastled_config.h"
#include "led_sysdefs.h"
 
// Include the internal FastLED header (provides core types without cycles)
#include "fl/system/fastled.h"
 
#include "fl/channels/channel.h"
#include "fl/channels/channel_events.h"
#include "fl/wdt/watchdog.h"  // for fl::Watchdog (FastLED.watchdog() accessor)
#include "fl/channels/manager.h"
#include "fl/channels/config.h"  // for ChannelConfig, MultiChannelConfig
#include "fl/channels/bus.h"          // for fl::Bus, fl::DefaultBus (Phase 3b, #2428)
#include "fl/channels/bus_traits.h"   // for fl::BusTraits, fl::BusSupports (Phase 3b, #2428)
#include "fl/channels/channel_typed.h"  // for fl::TypedChannel<B, Chipset> (Phase 3b, #2428)
#include "fl/channels/rx/channel.h"
 
#include "fl/audio/input.h"
#include "fl/audio/audio_processor.h"
#include "fl/ui/ui.h"  // for UIAudio (needed for CFastLED::add(UIAudio&) overload)
 
// ============================================================================
// C STRING FUNCTION USING DECLARATIONS
// ============================================================================

 
// Utility functions
#include "fastled_delay.h"
#include "bitswap.h"
 
#include "lib8tion.h"
 
// ============================================================================
// MATH FUNCTION USING DECLARATIONS
// ============================================================================
 
// Arduino macros (min, max, abs, etc.) are cleaned up in two passes:
//   Pass 1 — top of FastLED.h (above): fl/system/arduino.h cleans up before internal headers.
//   Pass 2 — fl/math/math.h (below): cleans up any macros re-introduced by platform headers.
// fl/stl/undef.h is intentionally re-includable to support both passes.
 
#include "controller.h"
#include "fastpin.h"
#include "fastspi_types.h"
#include "dmx.h"
 
#include "platforms.h"
 
// PlatformIO Library Dependency Finder (LDF) hint headers
// These headers use #if 0 blocks to hint library dependencies to PlatformIO's LDF scanner
// without actually compiling the code. This works around LDF's limitation of scanning
// headers without evaluating preprocessor paths.
#include "platforms/ldf_headers.h"
 
// Pass 2 macro cleanup: fl/math/math.h includes fl/stl/undef.h which undefs any
// min/max/abs/round/radians/degrees/map macros re-introduced by platform headers above.
// Then provides type-safe fl:: replacements brought into global scope via using below.
#include "fl/math/math.h"
 
// Bring fl:: math functions into global namespace for Arduino compatibility
// Teensy platforms define their own template min/max in wiring.h (global namespace),
// so we skip bringing fl::min/fl::max into global scope to avoid ambiguity.
#if !defined(FL_IS_TEENSY)
using fl::min;
using fl::max;
#endif
using fl::abs;
using fl::radians;
using fl::degrees;
 
// Note: Arduino map() function is defined in global namespace (platforms/stub/Arduino.h)
// fl::map refers to the map container (red-black tree) and our map() function delegate.
#include "fastled_progmem.h"
#include "pixeltypes.h"
#include "hsv2rgb.h"
#include "colorutils.h"
#include "pixelset.h"
#include "colorpalettes.h"
 
#include "noise.h"
#include "power_mgt.h"
 
#include "fastspi.h"
#include "chipsets.h"
#include "fl/system/engine_events.h"
 
#include "fl/gfx/leds.h"
#include "fl/gfx/rgbw.h"  // DiodeProfile + InputGamut (wrapped on CFastLED below)
 
// clockless.h removed - BulkClockless API has been superseded by Channel API
 
// SPI chipset enumeration (modern type-safe enum class)
#include "fl/chipsets/spi_chipsets.h"

enum ESPIChipsets {
    LPD6803   = static_cast<int>(fl::SpiChipset::LPD6803),   
    LPD8806   = static_cast<int>(fl::SpiChipset::LPD8806),   
    WS2801    = static_cast<int>(fl::SpiChipset::WS2801),    
    WS2803    = static_cast<int>(fl::SpiChipset::WS2803),    
    SM16716   = static_cast<int>(fl::SpiChipset::SM16716),   
    P9813     = static_cast<int>(fl::SpiChipset::P9813),     
    APA102    = static_cast<int>(fl::SpiChipset::APA102),    
    SK9822    = static_cast<int>(fl::SpiChipset::SK9822),    
    SK9822HD  = static_cast<int>(fl::SpiChipset::SK9822HD),  
    DOTSTAR   = static_cast<int>(fl::SpiChipset::DOTSTAR),   
    DOTSTARHD = static_cast<int>(fl::SpiChipset::DOTSTARHD), 
    APA102HD  = static_cast<int>(fl::SpiChipset::APA102HD),  
    HD107     = static_cast<int>(fl::SpiChipset::HD107),     
    HD107HD   = static_cast<int>(fl::SpiChipset::HD107HD),   
    HD108     = static_cast<int>(fl::SpiChipset::HD108),     
};

enum ESM { SMART_MATRIX };

enum OWS2811 { OCTOWS2811,OCTOWS2811_400, OCTOWS2813};

enum SWS2812 { WS2812SERIAL };
 
#ifdef HAS_PIXIE
template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER> class PIXIE : public PixieController<DATA_PIN, RGB_ORDER> {};
#endif
 
#ifdef FL_CLOCKLESS_CONTROLLER_DEFINED

template<fl::u8 DATA_PIN> class NEOPIXEL : public WS2812Controller800Khz<DATA_PIN, GRB> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER> 
class SM16703 : public SM16703Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER> 
class SM16824E : public SM16824EController<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class TM1829 : public TM1829Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class TX1813N1 : public TM1829Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class TM1812 : public TM1809Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class TM1809 : public TM1809Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class TM1804 : public TM1809Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class TM1803 : public TM1803Controller400Khz<DATA_PIN, RGB_ORDER> {}; 

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS1903 : public UCS1903Controller400Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS1903B : public UCS1903BController800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS1904 : public UCS1904Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS2903 : public UCS2903Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS7604 : public UCS7604Controller8bit<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS7604HD : public UCS7604Controller16bit<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS7604HD_1600 : public UCS7604Controller16bit1600<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2812 : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2815 : public WS2815Controller<DATA_PIN, RGB_ORDER> {};

template <fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2816 : public WS2816Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2852 : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2812B : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2812BMiniV3 : public WS2812BMiniV3Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2812BV5 : public WS2812BV5Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class GS1903 : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class SK6812 : public SK6812Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class SK6812WWA : public SK6812Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class SK6822 : public SK6822Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class APA106 : public SK6822Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class PL9823 : public PL9823Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2811 : public WS2811Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2813 : public WS2813Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class APA104 : public WS2811Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2811_400 : public WS2811Controller400Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class GE8822 : public GE8822Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class GW6205 : public GW6205Controller800Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class GW6205_400 : public GW6205Controller400Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class LPD1886 : public LPD1886Controller1250Khz<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class LPD1886_8BIT : public LPD1886Controller1250Khz_8bit<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class UCS1912 : public UCS1912Controller<DATA_PIN, RGB_ORDER> {};
 
#if defined(DmxSimple_h) || defined(FASTLED_DOXYGEN)
template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER> class DMXSIMPLE : public DMXSimpleController<DATA_PIN, RGB_ORDER> {};
#endif
#if defined(DmxSerial_h) || defined(FASTLED_DOXYGEN)
template<fl::EOrder RGB_ORDER> class DMXSERIAL : public DMXSerialController<RGB_ORDER> {};
#endif
#endif
 

enum EBlockChipsets {
#ifdef PORTA_FIRST_PIN
    WS2811_PORTA,
    WS2813_PORTA,
    WS2811_400_PORTA,
    TM1803_PORTA,
    UCS1903_PORTA,
#endif
#ifdef PORTB_FIRST_PIN
    WS2811_PORTB,
    WS2813_PORTB,
    WS2811_400_PORTB,
    TM1803_PORTB,
    UCS1903_PORTB,
#endif
#ifdef PORTC_FIRST_PIN
    WS2811_PORTC,
    WS2813_PORTC,
    WS2811_400_PORTC,
    TM1803_PORTC,
    UCS1903_PORTC,
#endif
#ifdef PORTD_FIRST_PIN
    WS2811_PORTD,
    WS2813_PORTD,
    WS2811_400_PORTD,
    TM1803_PORTD,
    UCS1903_PORTD,
#endif
#ifdef HAS_PORTDC
    WS2811_PORTDC,
    WS2813_PORTDC,
    WS2811_400_PORTDC,
    TM1803_PORTDC,
    UCS1903_PORTDC,
#endif
};
 

typedef fl::u8 (*power_func)(fl::u8 scale, fl::u32 data);

enum class ClearFlags : fl::u32 {
    NONE            = 0,       
    CHANNELS        = 1 << 0,  
    POWER_SETTINGS  = 1 << 1,  
    BRIGHTNESS      = 1 << 2,  
    REFRESH_RATE    = 1 << 3,  
    FPS_COUNTER     = 1 << 4,  
    CHANNEL_ENGINES = 1 << 5   
};

inline ClearFlags operator|(ClearFlags a, ClearFlags b) {
    return static_cast<ClearFlags>(static_cast<fl::u32>(a) | static_cast<fl::u32>(b));
}

inline ClearFlags operator&(ClearFlags a, ClearFlags b) {
    return static_cast<ClearFlags>(static_cast<fl::u32>(a) & static_cast<fl::u32>(b));
}

inline ClearFlags& operator|=(ClearFlags& a, ClearFlags b) {
    a = a | b;
    return a;
}

class CFastLED {
    // int m_nControllers;
    fl::u8  mScale;         
            fl::u16 mNFPS;          
    fl::u32 mNMinMicros;    
    fl::u32 mNPowerData;    
    power_func mPPowerFunc;  
    static fl::vector<fl::ChannelPtr>& channels(); 
 
public:
    CFastLED();

    void init();
 
    // Useful when you want to know when an event like onFrameBegin or onFrameEnd is happening.
    // This is disabled on AVR to save space.
    void addListener(fl::EngineEvents::Listener *listener) { fl::EngineEvents::addListener(listener); }
    void removeListener(fl::EngineEvents::Listener *listener) { fl::EngineEvents::removeListener(listener); }

    static fl::ChannelEvents& channelEvents();

    static fl::Watchdog& watchdog();

    
    void onBeginFrame() ;
    
    void onEndShowLeds() ;
    

    static ::CLEDController &addLeds(::CLEDController *pLed, CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0);


    static void add(fl::ChannelPtr channel);

    static fl::ChannelPtr add(const fl::ChannelConfig& config);

    static fl::vector<fl::ChannelPtr> add(fl::span<const fl::ChannelConfig> configs);

    static fl::vector<fl::ChannelPtr> add(fl::initializer_list<fl::ChannelConfig> configs);

    static fl::vector<fl::ChannelPtr> add(const fl::MultiChannelConfig& multiConfig);

    static fl::RxChannelPtr addRx(const fl::RxChannelConfig& config);

    static fl::shared_ptr<fl::audio::Processor> add(const fl::audio::Config& config);

    static fl::shared_ptr<fl::audio::Processor> add(fl::shared_ptr<fl::audio::IInput> input);

    static fl::shared_ptr<fl::audio::Processor> add(fl::UIAudio& uiAudio);

    static void enableAllDrivers();

    static void remove(fl::ChannelPtr channel);

    static void remove(fl::shared_ptr<fl::audio::Processor> processor);


 
 
    // Base template: Causes a compile-time error if an unsupported CHIPSET is used
    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN>
    struct ClockedChipsetHelper {
        // Default implementation, will be specialized for supported chipsets
        static const bool IS_VALID = false;
    };
 
    // Macro to define a mapping from the ESPIChipeset enum to the controller class
    // in it's various template configurations.
    #define _FL_MAP_CLOCKED_CHIPSET(CHIPSET_ENUM, CONTROLLER_CLASS)                              \
        template<fl::u8 DATA_PIN, fl::u8 CLOCK_PIN>                                              \
        struct ClockedChipsetHelper<CHIPSET_ENUM, DATA_PIN, CLOCK_PIN> {                           \
            static const bool IS_VALID = true;                                                     \
            typedef CONTROLLER_CLASS<DATA_PIN, CLOCK_PIN> ControllerType;                          \
            /* Controller type with RGB_ORDER specified */                                         \
            template<fl::EOrder RGB_ORDER>                                                             \
            struct CONTROLLER_CLASS_WITH_ORDER {                                                   \
                typedef CONTROLLER_CLASS<DATA_PIN, CLOCK_PIN, RGB_ORDER> ControllerType;           \
            };                                                                                     \
            /* Controller type with RGB_ORDER and spi frequency specified */                       \
            template<fl::EOrder RGB_ORDER, fl::u32 FREQ>                                              \
            struct CONTROLLER_CLASS_WITH_ORDER_AND_FREQ {                                          \
                typedef CONTROLLER_CLASS<DATA_PIN, CLOCK_PIN, RGB_ORDER, FREQ> ControllerType;     \
            };                                                                                     \
        };
 
    // Define specializations for each supported CHIPSET
    // Note: Using unscoped enum values for backwards compatibility
    _FL_MAP_CLOCKED_CHIPSET(LPD6803, LPD6803Controller)
    _FL_MAP_CLOCKED_CHIPSET(LPD8806, LPD8806Controller)
    _FL_MAP_CLOCKED_CHIPSET(WS2801, WS2801Controller)
    _FL_MAP_CLOCKED_CHIPSET(WS2803, WS2803Controller)
    _FL_MAP_CLOCKED_CHIPSET(SM16716, SM16716Controller)
    _FL_MAP_CLOCKED_CHIPSET(P9813, P9813Controller)
 
    // Both DOTSTAR and APA102 use the same controller class
    _FL_MAP_CLOCKED_CHIPSET(DOTSTAR, APA102Controller)
    _FL_MAP_CLOCKED_CHIPSET(APA102, APA102Controller)
 
    // Both DOTSTARHD and APA102HD use the same controller class
    _FL_MAP_CLOCKED_CHIPSET(DOTSTARHD, APA102ControllerHD)
    _FL_MAP_CLOCKED_CHIPSET(APA102HD, APA102ControllerHD)
 
    _FL_MAP_CLOCKED_CHIPSET(HD107, APA102Controller)
    _FL_MAP_CLOCKED_CHIPSET(HD107HD, APA102ControllerHD)
 
    _FL_MAP_CLOCKED_CHIPSET(HD108, HD108Controller)
 
    _FL_MAP_CLOCKED_CHIPSET(SK9822, SK9822Controller)
    _FL_MAP_CLOCKED_CHIPSET(SK9822HD, SK9822ControllerHD)
 
 
    #if FASTLED_FAKE_SPI_FORWARDS_TO_FAKE_CLOCKLESS
    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::u32 SPI_DATA_RATE, fl::Bus B = fl::Bus::AUTO> ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        // Instantiate the controller using ClockedChipsetHelper
        // Always USE WS2812 clockless controller since it's the common path.
        return addLeds<WS2812, DATA_PIN, RGB_ORDER, B>(data, nLedsOrOffset, nLedsIfOffset);
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::Bus B = fl::Bus::AUTO> static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        // Always USE WS2812 clockless controller since it's the common path.
        return addLeds<WS2812, DATA_PIN, B>(data, nLedsOrOffset, nLedsIfOffset);
    }
 
 
    // The addLeds function using ChipsetHelper
    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    ::CLEDController& addLeds(CRGB* data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        // Always USE WS2812 clockless controller since it's the common path.
        return addLeds<WS2812, DATA_PIN, RGB_ORDER, B>(data, nLedsOrOffset, nLedsIfOffset);
    }
 
    #elif FASTLED_SPI_USES_CHANNEL_API

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::u32 SPI_DATA_RATE, fl::Bus B = fl::Bus::AUTO>
    ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        int nOffset = (nLedsIfOffset > 0) ? nLedsOrOffset : 0;
        int nLeds = (nLedsIfOffset > 0) ? nLedsIfOffset : nLedsOrOffset;
        fl::SpiEncoder encoder = fl::SpiEncoder::spiEncoderForChipset(
            static_cast<fl::SpiChipset>(CHIPSET), SPI_DATA_RATE);
        fl::SpiChipsetConfig spiCfg(DATA_PIN, CLOCK_PIN, encoder);
        fl::ChannelConfig config(spiCfg, fl::span<CRGB>(data + nOffset, nLeds), RGB_ORDER);
        config.options.mBus = B;
        static fl::ChannelPtr sChannel;
        if (!sChannel) {
            sChannel = add(config);
        }
        return *sChannel;
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        int nOffset = (nLedsIfOffset > 0) ? nLedsOrOffset : 0;
        int nLeds = (nLedsIfOffset > 0) ? nLedsIfOffset : nLedsOrOffset;
        fl::SpiEncoder encoder = fl::SpiEncoder::spiEncoderForChipset(
            static_cast<fl::SpiChipset>(CHIPSET));
        fl::SpiChipsetConfig spiCfg(DATA_PIN, CLOCK_PIN, encoder);
        // HD108 defaults to GRB; all other SPI chipsets default to RGB.
        constexpr fl::EOrder order =
            (static_cast<fl::SpiChipset>(CHIPSET) == fl::SpiChipset::HD108)
                ? GRB : RGB;
        fl::ChannelConfig config(spiCfg, fl::span<CRGB>(data + nOffset, nLeds), order);
        config.options.mBus = B;
        static fl::ChannelPtr sChannel;
        if (!sChannel) {
            sChannel = add(config);
        }
        return *sChannel;
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    ::CLEDController& addLeds(CRGB* data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        int nOffset = (nLedsIfOffset > 0) ? nLedsOrOffset : 0;
        int nLeds = (nLedsIfOffset > 0) ? nLedsIfOffset : nLedsOrOffset;
        fl::SpiEncoder encoder = fl::SpiEncoder::spiEncoderForChipset(
            static_cast<fl::SpiChipset>(CHIPSET));
        fl::SpiChipsetConfig spiCfg(DATA_PIN, CLOCK_PIN, encoder);
        fl::ChannelConfig config(spiCfg, fl::span<CRGB>(data + nOffset, nLeds), RGB_ORDER);
        config.options.mBus = B;
        static fl::ChannelPtr sChannel;
        if (!sChannel) {
            sChannel = add(config);
        }
        return *sChannel;
    }
 
    #else

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::u32 SPI_DATA_RATE, fl::Bus B = fl::Bus::AUTO> ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        // Instantiate the controller using ClockedChipsetHelper
        typedef ClockedChipsetHelper<CHIPSET, DATA_PIN, CLOCK_PIN> CHIP;
        FL_STATIC_ASSERT(CHIP::IS_VALID, "Unsupported chipset");
        typedef typename CHIP::template CONTROLLER_CLASS_WITH_ORDER_AND_FREQ<RGB_ORDER, SPI_DATA_RATE>::ControllerType ControllerTypeWithFreq;
        static ControllerTypeWithFreq c;
        return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::Bus B = fl::Bus::AUTO> static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        typedef ClockedChipsetHelper<CHIPSET, DATA_PIN, CLOCK_PIN> CHIP;
        FL_STATIC_ASSERT(CHIP::IS_VALID, "Unsupported chipset");
        typedef typename CHIP::ControllerType ControllerType;
        static ControllerType c;
        return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    ::CLEDController& addLeds(CRGB* data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        typedef ClockedChipsetHelper<CHIPSET, DATA_PIN, CLOCK_PIN> CHIP;
        FL_STATIC_ASSERT(CHIP::IS_VALID, "Unsupported chipset");
        typedef typename CHIP::template CONTROLLER_CLASS_WITH_ORDER<RGB_ORDER>::ControllerType ControllerTypeWithOrder;
        static ControllerTypeWithOrder c;
        return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
    }
    #endif
 
 
#ifdef SPI_DATA
    template<ESPIChipsets CHIPSET, fl::Bus B = fl::Bus::AUTO> static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        return addLeds<CHIPSET, SPI_DATA, SPI_CLOCK, RGB, B>(data, nLedsOrOffset, nLedsIfOffset);
    }
 
    template<ESPIChipsets CHIPSET, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO> static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        return addLeds<CHIPSET, SPI_DATA, SPI_CLOCK, RGB_ORDER, B>(data, nLedsOrOffset, nLedsIfOffset);
    }
 
    template<ESPIChipsets CHIPSET, fl::EOrder RGB_ORDER, fl::u32 SPI_DATA_RATE, fl::Bus B = fl::Bus::AUTO> static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        return addLeds<CHIPSET, SPI_DATA, SPI_CLOCK, RGB_ORDER, SPI_DATA_RATE, B>(data, nLedsOrOffset, nLedsIfOffset);
    }
 
#endif
 
#ifdef FL_CLOCKLESS_CONTROLLER_DEFINED
    template<typename ControllerType>
    static inline ::CLEDController& addLedsImpl(ControllerType* controller, CRGB *data, int nLedsOrOffset, int nLedsIfOffset) {
        ::CLEDController* pLed = static_cast<::CLEDController*>(controller);
        return addLeds(pLed, data, nLedsOrOffset, nLedsIfOffset);
    }

    template<template<fl::u8, fl::EOrder> class CHIPSET, fl::u8 DATA_PIN, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        static CHIPSET<DATA_PIN, RGB_ORDER> c;
        return addLedsImpl(&c, data, nLedsOrOffset, nLedsIfOffset);
    }

    template<template<fl::u8, fl::EOrder> class CHIPSET, fl::u8 DATA_PIN, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        static CHIPSET<DATA_PIN, RGB> c;
        return addLedsImpl(&c, data, nLedsOrOffset, nLedsIfOffset);
    }

    template<template<fl::u8> class CHIPSET, fl::u8 DATA_PIN, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        static CHIPSET<DATA_PIN> c;
        return addLedsImpl(&c, data, nLedsOrOffset, nLedsIfOffset);
    }
 
    template<template<fl::u8> class CHIPSET, fl::u8 DATA_PIN, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(fl::Leds& leds, int nLedsOrOffset, int nLedsIfOffset = 0) {
        CRGB* rgb = leds;
        return addLeds<CHIPSET, DATA_PIN, B>(rgb, nLedsOrOffset, nLedsIfOffset);
    }
 
#if defined(__FASTLED_HAS_FIBCC) && (__FASTLED_HAS_FIBCC == 1)
    template<fl::u8 NUM_LANES, template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER> class CHIPSET, fl::u8 DATA_PIN, fl::EOrder RGB_ORDER=RGB, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLeds) {
        fl::busKeepAlive<B>();
        static fl::__FIBCC<CHIPSET, DATA_PIN, NUM_LANES, RGB_ORDER> c;
        return addLeds(&c, data, nLeds);
    }
#endif
 
    #ifdef FASTSPI_USE_DMX_SIMPLE
    template<EClocklessChipsets CHIPSET, fl::u8 DATA_PIN, fl::EOrder RGB_ORDER=RGB, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
    {
        fl::busKeepAlive<B>();
        switch(CHIPSET) {
            case DMX: { static DMXController<DATA_PIN> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
        }
    }
    #endif
#endif


    template<template<fl::EOrder RGB_ORDER> class CHIPSET, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        static CHIPSET<RGB_ORDER> c;
        return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
    }

    template<template<fl::EOrder RGB_ORDER> class CHIPSET, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        static CHIPSET<RGB> c;
        return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
    }
 
#ifdef USE_OCTOWS2811
    template<OWS2811 CHIPSET, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
    {
        fl::busKeepAlive<B>();
        switch(CHIPSET) {
            case OCTOWS2811: { static fl::COctoWS2811Controller<RGB_ORDER,WS2811_800kHz> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
            case OCTOWS2811_400: { static fl::COctoWS2811Controller<RGB_ORDER,WS2811_400kHz> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
#ifdef WS2813_800kHz
      case OCTOWS2813: { static fl::COctoWS2811Controller<RGB_ORDER,WS2813_800kHz> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
#endif
        }
    }

    template<OWS2811 CHIPSET, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
    {
        return addLeds<CHIPSET,GRB,B>(data,nLedsOrOffset,nLedsIfOffset);
    }
 
#endif
 
#ifdef USE_WS2812SERIAL
    template<SWS2812 CHIPSET, int DATA_PIN, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
    {
        fl::busKeepAlive<B>();
        static CWS2812SerialController<DATA_PIN,RGB_ORDER> controller;
        return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset);
    }
#endif
 
#ifdef SmartMatrix_h
    template<ESM CHIPSET, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
    {
        fl::busKeepAlive<B>();
        switch(CHIPSET) {
            case SMART_MATRIX: { static CSmartMatrixController controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
        }
    }
#endif
 
 
#ifdef FASTLED_HAS_BLOCKLESS


    template<EBlockChipsets CHIPSET, int NUM_LANES, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::busKeepAlive<B>();
        switch(CHIPSET) {
        #ifdef PORTA_FIRST_PIN
                case WS2811_PORTA: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, fl::TIMING_WS2811_800KHZ_LEGACY, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case WS2811_400_PORTA: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, fl::TIMING_WS2811_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        case WS2813_PORTA: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, fl::TIMING_WS2813, RGB_ORDER, 0, false>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case TM1803_PORTA: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, fl::TIMING_TM1803_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case UCS1903_PORTA: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, fl::TIMING_UCS1903_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        #endif
        #ifdef PORTB_FIRST_PIN
                case WS2811_PORTB: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, fl::TIMING_WS2811_800KHZ_LEGACY, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case WS2811_400_PORTB: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, fl::TIMING_WS2811_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        case WS2813_PORTB: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, fl::TIMING_WS2813, RGB_ORDER, 0, false>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case TM1803_PORTB: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, fl::TIMING_TM1803_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case UCS1903_PORTB: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, fl::TIMING_UCS1903_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        #endif
        #ifdef PORTC_FIRST_PIN
                case WS2811_PORTC: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, fl::TIMING_WS2811_800KHZ_LEGACY, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case WS2811_400_PORTC: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, fl::TIMING_WS2811_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        case WS2813_PORTC: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, fl::TIMING_WS2813, RGB_ORDER, 0, false>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case TM1803_PORTC: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, fl::TIMING_TM1803_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case UCS1903_PORTC: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, fl::TIMING_UCS1903_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        #endif
        #ifdef PORTD_FIRST_PIN
                case WS2811_PORTD: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, fl::TIMING_WS2811_800KHZ_LEGACY, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case WS2811_400_PORTD: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, fl::TIMING_WS2811_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        case WS2813_PORTD: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, fl::TIMING_WS2813, RGB_ORDER, 0, false>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case TM1803_PORTD: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, fl::TIMING_TM1803_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case UCS1903_PORTD: return addLeds(new fl::InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, fl::TIMING_UCS1903_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        #endif
        #ifdef HAS_PORTDC
                case WS2811_PORTDC: return addLeds(new fl::SixteenWayInlineBlockClocklessController<NUM_LANES, fl::TIMING_WS2811_800KHZ_LEGACY, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case WS2811_400_PORTDC: return addLeds(new fl::SixteenWayInlineBlockClocklessController<NUM_LANES, fl::TIMING_WS2811_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        case WS2813_PORTDC: return addLeds(new fl::SixteenWayInlineBlockClocklessController<NUM_LANES, fl::TIMING_WS2813, RGB_ORDER, 0, false>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case TM1803_PORTDC: return addLeds(new fl::SixteenWayInlineBlockClocklessController<NUM_LANES, fl::TIMING_TM1803_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
                case UCS1903_PORTDC: return addLeds(new fl::SixteenWayInlineBlockClocklessController<NUM_LANES, fl::TIMING_UCS1903_400KHZ, RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);  // ok bare allocation
        #endif
        }
    }

    template<EBlockChipsets CHIPSET, int NUM_LANES, fl::Bus B = fl::Bus::AUTO>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        return addLeds<CHIPSET,NUM_LANES,GRB,B>(data,nLedsOrOffset,nLedsIfOffset);
    }
#endif

    void setBrightness(fl::u8 scale) { mScale = scale; }

    fl::u8 getBrightness() { return mScale; }


    void setDriverEnabled(const char* name, bool enabled);

    template<fl::Bus B>
    void setExclusiveDriver() FL_NOEXCEPT {
        fl::channelManager().setExclusiveDriver<B>();
    }

    bool setExclusiveDriver(fl::Bus bus);

    bool isDriverEnabled(const char* name) const;

    fl::size getDriverCount() const;

    fl::span<const fl::DriverInfo> getDriverInfos() const;


    void wait();

    bool wait(fl::u32 timeout_ms);

    inline void setMaxPowerInVoltsAndMilliamps(fl::u8 volts, fl::u32 milliamps) { setMaxPowerInMilliWatts(volts * milliamps); }

    inline void setMaxPowerInMilliWatts(fl::u32 milliwatts) { mPPowerFunc = static_cast<power_func>(&calculate_max_brightness_for_power_mW); mNPowerData = milliwatts; }


    inline void setPowerModel(const PowerModelRGB& model) {
        set_power_model(model);
    }

    inline void setPowerScalingExponent(float exponent) {
        set_power_scaling_exponent(exponent);
    }

    inline float getPowerScalingExponent() const {
        return get_power_scaling_exponent();
    }


    inline void setInputGamut(fl::DiodeProfile* profile, fl::InputGamut g) FL_NOEXCEPT {
        fl::set_input_gamut(profile, g);
    }

    inline void setInputGamut(fl::DiodeProfile* profile, fl::InputGamut g,
                              const float white_xy[2]) FL_NOEXCEPT {
        fl::set_input_gamut(profile, g, white_xy);
    }

 
private:
    // Forward shims for the tiered-wait spin budget (#2818). Full impl
    // lives in src/fl/channels/detail/wait_spin_budget.{h,cpp.hpp}.
    // Declared here so we don't drag the channel-detail include graph
    // into FastLED.h.
    static void _setWaitSpinBudgetUs(fl::u32 budget_us) FL_NOEXCEPT;
    static fl::u32 _getWaitSpinBudgetUs() FL_NOEXCEPT;
public:

    inline void setWaitSpinBudgetUs(fl::u32 budget_us) FL_NOEXCEPT {
        _setWaitSpinBudgetUs(budget_us);
    }

    inline fl::u32 getWaitSpinBudgetUs() const FL_NOEXCEPT {
        return _getWaitSpinBudgetUs();
    }

    inline void setPowerModel(const PowerModelRGBW& model) {
        set_power_model(model);
    }

    inline void setPowerModel(const PowerModelRGBWW& model) {
        set_power_model(model);
    }

    inline PowerModelRGB getPowerModel() const {
        return get_power_model();
    }

    fl::u32 getEstimatedPowerInMilliWatts(bool apply_limiter = true) const;



    inline void setRgbwColorimetricProfile(const fl::DiodeProfile* profile) FL_NOEXCEPT {
        fl::set_rgbw_colorimetric_profile(profile);
    }

    inline const fl::DiodeProfile* getRgbwColorimetricProfile() const FL_NOEXCEPT {
        return fl::get_rgbw_colorimetric_profile();
    }


    void show(fl::u8 scale);

    void show() { show(mScale); }
 
    // Called automatically at the end of show().
    void onEndFrame();

    void clear(bool writeData = false);

    static void clear(ClearFlags flags);

    void clearData();

    void showColor(const CRGB & color, fl::u8 scale);

    void showColor(const CRGB & color) { showColor(color, mScale); }

    void delay(unsigned long ms);

    void setTemperature(const CRGB & temp);

    void setCorrection(const CRGB & correction);

    void setDither(fl::u8 ditherMode = BINARY_DITHER);

            void setMaxRefreshRate(fl::u16 refresh, bool constrain=false);

    void countFPS(int nFrames=25);

            fl::u16 getFPS() { return mNFPS; }

    int count();

    CLEDController & operator[](int x);

    int size();

    CRGB *leds();
};

#define FastSPI_LED FastLED
#define FastSPI_LED2 FastLED
#ifndef LEDS
#define LEDS FastLED
#endif

extern CFastLED FastLED;

#ifndef HAS_HARDWARE_PIN_SUPPORT
#warning "No pin/port mappings found, pin access will be slightly slower. See fastpin.h for info."
#define NO_HARDWARE_PIN_SUPPORT
#endif
 
 
#endif
 

 
#if !defined(FASTLED_INTERNAL) && !defined(FASTLED_LEAN_AND_MEAN)
 
#include "fl/stl/string.h"   // Awesome Str class that has stack allocation and heap overflow, copy on write.
#include "fl/math/xymap.h"  // XYMap class for mapping 2D coordinates on seperintine matrices.
 
#include "fl/math/math.h"  // fl::clamp, fl::map_range, fl::min, fl::max, etc.
 
#include "fl/log/log.h"
#include "fl/log/log.h"  // FL_WARN("time now: " << millis()), FL_WARN_IF(condition, "time now: " << millis());"
#include "fl/log/log.h"  // FL_PRINT("message" << value), FL_LOG_*() category-specific logging
#include "fl/system/serial.h"  // Arduino-compatible Serial API: fl::Serial.print(), fl::Serial.read(), etc.
#include "fl/stl/assert.h"  // FASTLED_ASSERT(condition, "message");
#include "fl/stl/sstream.h"  // fl::sstream for string stream operations
#include "fl/remote/remote.h"  // Remote RPC system for JSON-based function calls
 
// provides:
//   fl::vector<T> - Standard heap vector
//   fl::vector_inlined<T,N> - Allocate on stack N elements, then overflow to heap vector.
//   fl::vector_fixed<T,N> - Stack allocated fixed size vector, elements will fail to add when full.
#include "fl/stl/vector.h"
 
// Flexible callbacks in the style of std::function.
#include "fl/stl/function.h"
 
// Clears the led data and other objects.
// CRGB leds[NUM_LEDS];
// fl::clear(leds)
#include "fl/gfx/clear.h"
 
// Leds has a CRGB block and an XYMap
#include "fl/gfx/leds.h"
 
#include "fl/channels/spi.h"  // SPI device and multi-lane SPI support (1-16 lanes)
 
#include "fl/ui/ui.h"  // Provides UIButton, UISlider, UICheckbox, UINumberField and UITitle, UIDescription, UIHelp, UIGroup.
using fl::UITitle;
using fl::UIDescription;
using fl::UIHelp;
using fl::UIButton;  // These names are unique enough that we don't need to namespace them
using fl::UICheckbox;
using fl::UINumberField;
using fl::UISlider;
using fl::UIDropdown;
using fl::UIGroup;
using fl::XYMap;
using fl::round;  // Template version avoids conflicts with ::round
// Only expose fl::delay as global delay() on non-hardware platforms (stub/WASM).
// On real Arduino platforms, Arduino's native delay(uint32_t) is already in scope;
// importing fl::delay there causes an ambiguous-overload error for any third-party
// library (e.g. IRremote) that calls the unqualified delay().
// Users who need fl::delay's async-task-pumping behaviour can call fl::delay() or
// fl::delayMs() explicitly.
#if defined(FASTLED_STUB_IMPL)
using fl::delay;
#endif
 
// Common fl:: type aliases for global namespace convenience
template<typename T> using fl_vector = fl::vector<T>;
template<typename Key, typename Value, typename Compare = fl::less<Key>> using fl_map = fl::flat_map<Key, Value, Compare>;
using fl_string = fl::string;
 
// Note: delayMicroseconds and delayMillis are provided by Arduino core
// The fl:: namespace versions are available for explicit use when needed
 
#define FASTLED_TITLE(text) fl::UITitle g_title(text)
#define FASTLED_DESCRIPTION(text) fl::UIDescription g_description(text)
#define FASTLED_HELP(text) fl::UIHelp g_help(text)
 
 
#endif // FASTLED_INTERNAL && !FASTLED_LEAN_AND_MEAN
 
 
 
// Experimental: loop() hijacking.
//
// EngineEvents requires that FastLED.show() be invoked.
// If the user skips that then certain updates will be skipped.
//
// Right now this isn't a big deal, but in the future it could be.
//
// Therefore this experiment is done so that this loop() hijack trick
// can be used to insert code at the start of every loop(), such as a
// scoped object that forces a begin and end frame event.
//
// It's possible to hijack the loop() via a macro so that
// extra code can be injected at the start of every frame.
// When FASTLED_LOOP_RUNS_ASYNC == 1
// then use loop() to also run the async.
// 
// EXAMPLE:
// #define FASTLED_LOOP_RUNS_ASYNC 1
// #include "FastLED.h"
// void loop() {
//     FL_WARN("async will run in the loop");
//     delay(500);
// }
 
#ifndef FASTLED_LOOP_RUNS_ASYNC
#define FASTLED_LOOP_RUNS_ASYNC 0
#endif
 
#if FASTLED_LOOP_RUNS_ASYNC == 1
// The loop is set as a macro that re-defines the user loop function
// to sketch_loop()
#define loop() \
     sketch_loop(); \
     void loop() { sketch_loop(); fl::task::run(); } \
     void sketch_loop()
#endif
 
// Backdoor to get the size of the CLedController object. The one place
// that includes this just uses extern to declare the function.
// Declaration moved to src/fl/system/fastled.h