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 3010006
#ifndef FASTLED_INTERNAL
#  ifdef  FASTLED_SHOW_VERSION
#    ifdef FASTLED_HAS_PRAGMA_MESSAGE
#      pragma message "FastLED version 3.010.006"
#    else
#      warning FastLED version 3.010.006  (Not really a warning, just telling you here.)
#    endif
#  endif
#endif
// ESP32 I2S Driver: `FASTLED_ESP32_I2S` used to opt into the Yves
// parallel-out clockless driver. Removed at FastLED#3526 Phase 2e — the
// modern unified engine on `Bus::FLEX_IO, 0` is now the only I2S path.
// Users who previously defined `-DFASTLED_ESP32_I2S=1` should drop the
// flag; clockless output still routes through RMT by default. If the
// modern I2S path is specifically desired, use
// `FastLED.setExclusiveDriver<fl::Bus::FLEX_IO, 0>()`.
#if defined(FASTLED_ESP32_I2S) && !defined(FASTLED_INTERNAL)
#warning "-DFASTLED_ESP32_I2S is removed (FastLED#3526 Phase 2e). Drop the flag; the modern I2S engine is now on Bus::FLEX_IO, 0. Runtime select via FastLED.setExclusiveDriver<fl::Bus::FLEX_IO, 0>()."
#endif
 
// Pre-4.0 Teensy boards are end-of-life.
//
// Teensy LC and 3.0-3.6 are discontinued. FastLED still compiles for them and
// we still fix reported bugs, but they get no hardware validation -- see
// FastLED#3983, where bench testing is scoped to Teensy 4.0/4.1 only. Users on
// these boards should know they are on an unvalidated path before they debug
// something we cannot reproduce.
//
// Note the guard covers BOTH umbrellas: `FL_IS_TEENSY_3X` is only 3.0-3.6, and
// Teensy LC sits beside it rather than inside it (see
// platforms/arm/teensy/is_teensy.h). Testing 3X alone would silently miss the
// LC, which is the most end-of-life board of the set.
#if (defined(FL_IS_TEENSY_3X) || defined(FL_IS_TEENSY_LC)) &&                  \
    !defined(FASTLED_INTERNAL) && !defined(FL_TEENSY_EOL_SUPPRESS_WARNING)
#warning "This Teensy (pre-4.0) is out of production and FastLED no longer hardware-validates it. If you hit a problem, try FastLED 3.10.3, the last release verified against these boards, and please file a report at https://github.com/FastLED/FastLED/issues -- we do still fix these. Define FL_TEENSY_EOL_SUPPRESS_WARNING to silence this."
#endif
 
// Legacy RMT4 backend is ESP-IDF 4.x only.
//
// On IDF 5.x the legacy TX and RX implementations no longer build: RMTMEM is not
// exposed by the public headers, and both engines predate the current
// IChannelDriver / RmtRxChannel contracts. `-DFASTLED_RMT5=0` there produced a
// wall of unrelated compiler errors, and the old guard sent users chasing
// -DESP32_ARDUINO_NO_RGB_BUILTIN=1, which gets past the guard but not past the
// build. Reject the combination up front with one accurate diagnostic instead.
// RMT5 is already the IDF 5.x default, so nothing that builds today is lost.
// See FastLED#3936.
//
// Note the version test: FASTLED_RMT5 also defaults to 0 on IDF 4.x, where RMT4
// is the correct native backend and must keep building.
#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 && ESP_IDF_VERSION_5_OR_HIGHER
#error "FASTLED_RMT5=0 (legacy RMT4 backend) is not supported on ESP-IDF 5.x or newer. Remove -DFASTLED_RMT5=0 to use the RMT5 backend, which is the default on this IDF. RMT4 remains available only when building against ESP-IDF 4.x. See https://github.com/FastLED/FastLED/issues/3936"
#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) || \
                            defined(FL_IS_RP2040) || defined(FL_IS_RP2350))
#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_info.h"     // for fl::deviceInfo (portable bus introspection)
#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/slim_spi_bridge_controller.h"  // for fl::SlimSpiBridgeController (#4585)
#include "fl/channels/rx/channel.h"
#include "fl/stl/type_traits.h"  // for fl::true_type/false_type (SPI addLeds<> dispatch, #4585)
 
#include "fl/audio/input.h"
#include "fl/audio/audio_processor.h"
 
// CFastLED::add(UIAudio&) only needs the name, which audio_manager.h forward
// declares; the full UI headers (and the JSON UI they pull in on host/wasm)
// are provided to sketches by the convenience block at the bottom of this
// file, not to every library TU.
#include "fl/audio/audio_manager.h"
 
// ============================================================================
// 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"
 
// Default example pins; must follow platforms.h so board pin tables win.
#include "platforms/default_pins.h"
 
// Library Dependency Finder (LDF) hint headers
// These headers use #if 0 blocks to hint library dependencies to the 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 "fl/channels/power_prepass.h"
 
#include "fastspi.h"
#include "chipsets.h"
#include "fl/chipsets/analog.h"
#include "fl/system/engine_events.h"
 
#include "fl/gfx/leds.h"
#include "fl/gfx/rgbw.h"  // RGBW mode config (wrapped on CFastLED below)
#include "fl/color/rgbw.h"  // colorimetric profile facade
 
// 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),   
    MY9221    = static_cast<int>(fl::SpiChipset::MY9221),    
    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),     
    HD107S    = static_cast<int>(fl::SpiChipset::HD107S),    
    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 TM1908 : public TM1908Controller<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 OSTW2020C1E : public OSTW2020C1EController<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 GS1903Controller<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 LC8816E : public LC8816EController<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 WS2814 : public WS2814Controller<DATA_PIN, RGB_ORDER> {};

template<fl::u8 DATA_PIN, fl::EOrder RGB_ORDER>
class WS2818 : public WS2818Controller<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;
}

#define FL_DITHER_ENABLE_MIN_REFRESH_HZ 100

class CFastLED {
    friend fl::PowerCodecPolicy fl::powerChannelCodecPolicy(
        const fl::CLEDController& controller) FL_NO_EXCEPT;
    // int m_nControllers;
    fl::u8  mScale;         
            fl::u16 mNFPS;          
    fl::u32 mNMinMicros;    
    fl::u32 mNPowerData;    
    power_func mPPowerFunc;  
    fl::u8  mLastRequestedScale;  
    fl::u8  mLastShownScale;      
    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);
 
    template<fl::ProfileId Profile>
    static fl::ChannelPtr add(const fl::ChannelConfig& config) {
        fl::ChannelPtr channel = fl::Channel::create<Profile>(config);
        if (channel != nullptr) add(channel);
        return channel;
    }

    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);


    template<template<fl::u8, fl::u8, fl::u8> class CHIPSET,
             fl::u8 RED_PIN, fl::u8 GREEN_PIN, fl::u8 BLUE_PIN>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset,
                                      int nLedsIfOffset = 0) {
        static CHIPSET<RED_PIN, GREEN_PIN, BLUE_PIN> controller;
        return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset);
    }


 
 
    // 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(MY9221, MY9221Controller)
    _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);
    }
 
    #endif  // FASTLED_FAKE_SPI_FORWARDS_TO_FAKE_CLOCKLESS (fake-SPI overloads)
 
    // Channel-API SPI entry points (#4585). Always declared (templates are only
    // instantiated on use) so host tests can pin the exact code path that
    // `addLeds<ESPIChipsets ...>()` takes when FASTLED_SPI_USES_CHANNEL_API=1,
    // even though the shared test PCH parses FastLED.h with the host default
    // (0). Under FASTLED_SPI_USES_CHANNEL_API the public addLeds<> overloads
    // below forward here verbatim.
    //
    // Compile-time dispatch (#4585, #4636): every SPI chipset routes through
    // the slim `fl::SlimSpiBridgeController`. MY9221 uses the bit-bang
    // `MY9221Controller` instead, because it is dual-edge (DDR) clocked and
    // cannot be carried as SPI bytes. No runtime `fl::Channel` is ever built
    // for legacy `addLeds<>`. C++11 has no `if constexpr`, so the two bodies
    // are separate overloads selected via a `fl::true_type`/`fl::false_type`
    // tag -- only the overload actually called gets instantiated, so the
    // never-taken branch never names `SlimSpiBridgeController<..., MY9221, ...>`.
    //
    // DATA_PIN / CLOCK_PIN / RATE / VARIANT exist only to key the
    // function-local statics exactly like the old per-`addLeds<>`-instantiation
    // `static ChannelPtr sChannel` was keyed: two strips of the same chipset on
    // different pins (or via different overloads) must get distinct controllers.
    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::u32 RATE, int VARIANT,
             fl::EOrder RGB_ORDER, fl::Bus B, fl::u8 B_WHICH>
    static ::CLEDController &addLedsSpiDispatch(CRGB *data, int nLedsOrOffset, int nLedsIfOffset,
                                                 const fl::SpiChipsetConfig &spiCfg, fl::true_type /*useSlim*/) {
        static fl::SlimSpiBridgeController<static_cast<fl::SpiChipset>(CHIPSET), RGB_ORDER, B, B_WHICH> sCtrl(spiCfg);
        return addLeds(&sCtrl, data, nLedsOrOffset, nLedsIfOffset);
    }
 
    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::u32 RATE, int VARIANT,
             fl::EOrder RGB_ORDER, fl::Bus B, fl::u8 B_WHICH>
    static ::CLEDController &addLedsSpiDispatch(CRGB *data, int nLedsOrOffset, int nLedsIfOffset,
                                                 const fl::SpiChipsetConfig &spiCfg, fl::false_type /*isMY9221 -> bit-bang*/) {
        (void)spiCfg;
        static MY9221Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, (RATE ? RATE : DATA_RATE_MHZ(1))> sCtrl;
        // Register (and bind the LED buffer) only once per specialization; a
        // repeated call must not rebind the shared controller's buffer.
        static bool sRegistered = false;
        if (sRegistered) {
            return sCtrl;
        }
        sRegistered = true;
        return addLeds(&sCtrl, data, nLedsOrOffset, nLedsIfOffset);
    }

    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, fl::u8 B_WHICH = 0>
    ::CLEDController &addLedsSpiChannel(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::SpiEncoder encoder = fl::SpiEncoder::spiEncoderForChipset(
            static_cast<fl::SpiChipset>(CHIPSET), SPI_DATA_RATE);
        fl::SpiChipsetConfig spiCfg(DATA_PIN, CLOCK_PIN, encoder);
        typedef typename fl::conditional<CHIPSET != MY9221, fl::true_type, fl::false_type>::type UseSlim;
        return addLedsSpiDispatch<CHIPSET, DATA_PIN, CLOCK_PIN, SPI_DATA_RATE, 0, RGB_ORDER, B, B_WHICH>(data, nLedsOrOffset, nLedsIfOffset, spiCfg, UseSlim());
    }

    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, fl::u8 B_WHICH = 0>
    ::CLEDController &addLedsSpiChannel(CRGB *data, int nLeds, fl::Esp32SpiBus spiBus) {
        fl::SpiEncoder encoder = fl::SpiEncoder::spiEncoderForChipset(
            static_cast<fl::SpiChipset>(CHIPSET), SPI_DATA_RATE);
        fl::SpiChipsetConfig spiCfg(DATA_PIN, CLOCK_PIN, encoder, spiBus);
        typedef typename fl::conditional<CHIPSET != MY9221, fl::true_type, fl::false_type>::type UseSlim;
        return addLedsSpiDispatch<CHIPSET, DATA_PIN, CLOCK_PIN, SPI_DATA_RATE, 1, RGB_ORDER, B, B_WHICH>(data, nLeds, 0, spiCfg, UseSlim());
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::Bus B = fl::Bus::AUTO, fl::u8 B_WHICH = 0>
    static ::CLEDController &addLedsSpiChannel(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        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;
        typedef typename fl::conditional<CHIPSET != MY9221, fl::true_type, fl::false_type>::type UseSlim;
        return addLedsSpiDispatch<CHIPSET, DATA_PIN, CLOCK_PIN, 0, 2, order, B, B_WHICH>(data, nLedsOrOffset, nLedsIfOffset, spiCfg, UseSlim());
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO, fl::u8 B_WHICH = 0>
    ::CLEDController& addLedsSpiChannel(CRGB* data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        fl::SpiEncoder encoder = fl::SpiEncoder::spiEncoderForChipset(
            static_cast<fl::SpiChipset>(CHIPSET));
        fl::SpiChipsetConfig spiCfg(DATA_PIN, CLOCK_PIN, encoder);
        typedef typename fl::conditional<CHIPSET != MY9221, fl::true_type, fl::false_type>::type UseSlim;
        return addLedsSpiDispatch<CHIPSET, DATA_PIN, CLOCK_PIN, 0, 3, RGB_ORDER, B, B_WHICH>(data, nLedsOrOffset, nLedsIfOffset, spiCfg, UseSlim());
    }
 
    #if FASTLED_FAKE_SPI_FORWARDS_TO_FAKE_CLOCKLESS
    // Fake-SPI overloads declared above.
    #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, fl::u8 B_WHICH = 0>
    ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        return addLedsSpiChannel<CHIPSET, DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE, B, B_WHICH>(data, nLedsOrOffset, nLedsIfOffset);
    }

    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, fl::u8 B_WHICH = 0>
    ::CLEDController &addLeds(CRGB *data, int nLeds, fl::Esp32SpiBus spiBus) {
        return addLedsSpiChannel<CHIPSET, DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE, B, B_WHICH>(data, nLeds, spiBus);
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::Bus B = fl::Bus::AUTO, fl::u8 B_WHICH = 0>
    static ::CLEDController &addLeds(CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        return addLedsSpiChannel<CHIPSET, DATA_PIN, CLOCK_PIN, B, B_WHICH>(data, nLedsOrOffset, nLedsIfOffset);
    }

    template<ESPIChipsets CHIPSET, fl::u8 DATA_PIN, fl::u8 CLOCK_PIN, fl::EOrder RGB_ORDER, fl::Bus B = fl::Bus::AUTO, fl::u8 B_WHICH = 0>
    ::CLEDController& addLeds(CRGB* data, int nLedsOrOffset, int nLedsIfOffset = 0) {
        return addLedsSpiChannel<CHIPSET, DATA_PIN, CLOCK_PIN, RGB_ORDER, B, B_WHICH>(data, nLedsOrOffset, nLedsIfOffset);
    }
 
    #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::EOrder RGB_ORDER, fl::u32 SPI_DATA_RATE, fl::Bus B = fl::Bus::AUTO>
    ::CLEDController &addLeds(CRGB *data, int nLeds, fl::Esp32SpiBus spiBus) {
        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_AND_FREQ<RGB_ORDER, SPI_DATA_RATE>::ControllerType ControllerTypeWithFreq;
        static ControllerTypeWithFreq c;
        c.setSpiBus(spiBus);
        return addLeds(&c, data, nLeds, 0);
    }

    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<fl::ProfileId PROFILE, 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_STATIC_ASSERT(PROFILE == fl::ProfileId::WS2812B, "Unsupported color profile");
        fl::busKeepAlive<B>();
        using Controller = fl::StaticProfileClocklessController<fl::profiles::WS2812B,
            CHIPSET, DATA_PIN, RGB_ORDER>;
        static Controller controller;
        return addLedsImpl(&controller, 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, fl::u8 Which = 0>
    void setExclusiveDriver() FL_NO_EXCEPT {
        fl::channelManager().setExclusiveDriver<B, Which>();
    }

    bool setExclusiveDriver(fl::Bus bus, fl::u8 which = 0);

    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) {
        mNPowerData = milliwatts;
#if FL_COLOR_PIPELINE_SHARED
        fl::activeFramePowerDispatch() = fl::framePowerDispatch();
        mPPowerFunc = fl::activeFramePowerDispatch()->showBrightness;
#else
        mPPowerFunc = static_cast<power_func>(&calculate_max_brightness_for_power_mW);
#endif
    }

    void setHdFieldFloor(fl::u8 min_field);
    fl::u8 getHdFieldFloor() const;

    fl::u8 getLastShowBrightness() const;

    bool isPowerLimited() const;


    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();
    }
 
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_NO_EXCEPT;
    static fl::u32 _getWaitSpinBudgetUs() FL_NO_EXCEPT;
public:

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

    inline fl::u32 getWaitSpinBudgetUs() const FL_NO_EXCEPT {
        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_NO_EXCEPT {
        fl::set_rgbw_colorimetric_profile(profile);
    }

    inline const fl::DiodeProfile* getRgbwColorimetricProfile() const FL_NO_EXCEPT {
        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 setColorManagementStrict(bool strict) FL_NO_EXCEPT {
        fl::detail::colorProfileStrictMode() = strict;
    }
    bool colorManagementStrict() const FL_NO_EXCEPT {
        return fl::detail::colorProfileStrictMode();
    }
    void setDefaultSourceProfile(const fl::SourceProfile& profile) FL_NO_EXCEPT {
        fl::detail::defaultSourceProfile() = profile;
    }
    const fl::SourceProfile& defaultSourceProfile() const FL_NO_EXCEPT {
        return fl::detail::defaultSourceProfile();
    }

            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"  // FL_WARN("time now: %s", millis()), FL_WARN_IF(...), FL_PRINT(...), 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
 
// The remote RPC system (fl/remote/remote.h) is opt-in: it pulls the JSON
// parser, the RPC server and the scheduler (57 headers) into every sketch
// that includes FastLED.h. Sketches that use it include it directly, or
// define FL_INCLUDE_REMOTE before including FastLED.h.
#if defined(FL_INCLUDE_REMOTE)
#include "fl/remote/remote.h"  // Remote RPC system for JSON-based function calls
#endif
 
// 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