crgb.h

Go to the documentation of this file.

 
#pragma once
 
#include "fl/stdint.h"
#include "fl/int.h"
 
#include "chsv.h"
#include "fl/namespace.h"
#include "color.h"
#include "lib8tion/types.h"
#include "fl/force_inline.h"
#include "fl/type_traits.h"
#include "hsv2rgb.h"
#include "fl/ease.h"
 
 
 
namespace fl {
class string;
class XYMap;
struct HSV16;
}
 
FASTLED_NAMESPACE_BEGIN
 
// Whether to allow HD_COLOR_MIXING
#ifndef FASTLED_HD_COLOR_MIXING
#ifdef __AVR__
// Saves some memory on these constrained devices.
#define FASTLED_HD_COLOR_MIXING 0
#else
#define FASTLED_HD_COLOR_MIXING 1
#endif  // __AVR__
#endif  // FASTLED_HD_COLOR_MIXING
 
 
struct CRGB;
 
 

 
 

FASTLED_FORCE_INLINE void hsv2rgb_dispatch( const struct CHSV* phsv, struct CRGB * prgb, int numLeds)
{
#if defined(FASTLED_HSV_CONVERSION_SPECTRUM)
    hsv2rgb_spectrum(phsv, prgb, numLeds);
#elif defined(FASTLED_HSV_CONVERSION_FULL_SPECTRUM)
    hsv2rgb_fullspectrum(phsv, prgb, numLeds);
#elif defined(FASTLED_HSV_CONVERSION_RAINBOW)
    hsv2rgb_rainbow(phsv, prgb, numLeds);
#else
    // Default to rainbow for backward compatibility
    hsv2rgb_rainbow(phsv, prgb, numLeds);
#endif
}
 
FASTLED_FORCE_INLINE void hsv2rgb_dispatch( const struct CHSV& hsv, struct CRGB& rgb)
{
#if defined(FASTLED_HSV_CONVERSION_SPECTRUM)
    hsv2rgb_spectrum(hsv, rgb);
#elif defined(FASTLED_HSV_CONVERSION_FULL_SPECTRUM)
    hsv2rgb_fullspectrum(hsv, rgb);
#elif defined(FASTLED_HSV_CONVERSION_RAINBOW)
    hsv2rgb_rainbow(hsv, rgb);
#else
    hsv2rgb_rainbow(hsv, rgb);
#endif
}
 

struct CRGB {
    union {
        struct {
            union {
                fl::u8 r;    
                fl::u8 red;  
            };
            union {
                fl::u8 g;      
                fl::u8 green;  
            };
            union {
                fl::u8 b;     
                fl::u8 blue;  
            };
        };

        fl::u8 raw[3];
    };
 
    static CRGB blend(const CRGB& p1, const CRGB& p2, fract8 amountOfP2);
    static CRGB blendAlphaMaxChannel(const CRGB& upper, const CRGB& lower);

    static void downscale(const CRGB* src, const fl::XYMap& srcXY, CRGB* dst, const fl::XYMap& dstXY);
    static void upscale(const CRGB* src, const fl::XYMap& srcXY, CRGB* dst, const fl::XYMap& dstXY);
 
    // Are you using WS2812 (or other RGB8 LEDS) to display video?
    // Does it look washed out and under-saturated?
    //
    // Have you tried gamma correction but hate how it decimates the color into 8 colors per component?
    //
    // This is an alternative to gamma correction that preserves the hue but boosts the saturation.
    //
    // decimating the color from 8 bit -> gamma -> 8 bit (leaving only 8 colors for each component).
    // work well with WS2812 (and other RGB8) led displays.
    // This function converts to HSV16, boosts the saturation, and converts back to RGB8.
    // Note that when both boost_saturation and boost_contrast are true the resulting
    // pixel will be nearly the same as if you had used gamma correction pow = 2.0.
    CRGB colorBoost(fl::EaseType saturation_function = fl::EASE_NONE, fl::EaseType luminance_function = fl::EASE_NONE) const;
    static void colorBoost(const CRGB* src, CRGB* dst, size_t count, fl::EaseType saturation_function = fl::EASE_NONE, fl::EaseType luminance_function = fl::EASE_NONE);
 
    // Want to do advanced color manipulation in HSV and write back to CRGB?
    // You want to use HSV16, which is much better at preservering the color
    // space than CHSV.
    fl::HSV16 toHSV16() const;
    
    FASTLED_FORCE_INLINE fl::u8& operator[] (fl::u8 x)
    {
        return raw[x];
    }

    FASTLED_FORCE_INLINE const fl::u8& operator[] (fl::u8 x) const
    {
        return raw[x];
    }
 
    #if defined(__AVR__)
    // Saves a surprising amount of memory on AVR devices.
    CRGB() = default;
    #else
    FASTLED_FORCE_INLINE CRGB() {
        r = 0;
        g = 0;
        b = 0;
    }
    #endif

    constexpr CRGB(fl::u8 ir, fl::u8 ig, fl::u8 ib) noexcept
        : r(ir), g(ig), b(ib)
    {
    }

    constexpr CRGB(fl::u32 colorcode) noexcept
    : r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
    {
    }
 
    constexpr fl::u32 as_uint32_t() const noexcept {
        return fl::u32(0xff000000) |
               (fl::u32{r} << 16) |
               (fl::u32{g} << 8) |
               fl::u32{b};
    }

    constexpr CRGB(LEDColorCorrection colorcode) noexcept
    : r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
    {
    }

    constexpr CRGB(ColorTemperature colorcode) noexcept
    : r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
    {
    }

    FASTLED_FORCE_INLINE CRGB(const CRGB& rhs) = default;

    FASTLED_FORCE_INLINE CRGB(const CHSV& rhs)
    {
        hsv2rgb_dispatch( rhs, *this);
    }

    CRGB(const fl::HSV16& rhs);

    FASTLED_FORCE_INLINE CRGB& operator= (const CRGB& rhs) = default;

    FASTLED_FORCE_INLINE CRGB& operator= (const fl::u32 colorcode)
    {
        r = (colorcode >> 16) & 0xFF;
        g = (colorcode >>  8) & 0xFF;
        b = (colorcode >>  0) & 0xFF;
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& setRGB (fl::u8 nr, fl::u8 ng, fl::u8 nb)
    {
        r = nr;
        g = ng;
        b = nb;
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& setHSV (fl::u8 hue, fl::u8 sat, fl::u8 val)
    {
        hsv2rgb_dispatch( CHSV(hue, sat, val), *this);
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& setHue (fl::u8 hue)
    {
        hsv2rgb_dispatch( CHSV(hue, 255, 255), *this);
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& operator= (const CHSV& rhs)
    {
        hsv2rgb_dispatch( rhs, *this);
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& setColorCode (fl::u32 colorcode)
    {
        r = (colorcode >> 16) & 0xFF;
        g = (colorcode >>  8) & 0xFF;
        b = (colorcode >>  0) & 0xFF;
        return *this;
    }
 

    CRGB& operator+= (const CRGB& rhs);

    FASTLED_FORCE_INLINE CRGB& addToRGB (fl::u8 d);

    FASTLED_FORCE_INLINE CRGB& operator-= (const CRGB& rhs);

    FASTLED_FORCE_INLINE CRGB& subtractFromRGB(fl::u8 d);

    FASTLED_FORCE_INLINE CRGB& operator-- ();

    FASTLED_FORCE_INLINE CRGB operator-- (int );

    FASTLED_FORCE_INLINE CRGB& operator++ ();

    FASTLED_FORCE_INLINE CRGB operator++ (int );

    FASTLED_FORCE_INLINE CRGB& operator/= (fl::u8 d )
    {
        r /= d;
        g /= d;
        b /= d;
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& operator>>= (fl::u8 d)
    {
        r >>= d;
        g >>= d;
        b >>= d;
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& operator*= (fl::u8 d);

    FASTLED_FORCE_INLINE CRGB& nscale8_video (fl::u8 scaledown);

    FASTLED_FORCE_INLINE CRGB& operator%= (fl::u8 scaledown);

    FASTLED_FORCE_INLINE CRGB& fadeLightBy (fl::u8 fadefactor );

    CRGB& nscale8 (fl::u8 scaledown );

    FASTLED_FORCE_INLINE CRGB& nscale8 (const CRGB & scaledown );
 
    constexpr CRGB nscale8_constexpr (const CRGB scaledown ) const;
 

    FASTLED_FORCE_INLINE CRGB scale8 (fl::u8 scaledown ) const;

    FASTLED_FORCE_INLINE CRGB scale8 (const CRGB & scaledown ) const;

    CRGB& fadeToBlackBy (fl::u8 fadefactor );

    FASTLED_FORCE_INLINE CRGB& operator|= (const CRGB& rhs )
    {
        if( rhs.r > r) r = rhs.r;
        if( rhs.g > g) g = rhs.g;
        if( rhs.b > b) b = rhs.b;
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& operator|= (fl::u8 d )
    {
        if( d > r) r = d;
        if( d > g) g = d;
        if( d > b) b = d;
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& operator&= (const CRGB& rhs )
    {
        if( rhs.r < r) r = rhs.r;
        if( rhs.g < g) g = rhs.g;
        if( rhs.b < b) b = rhs.b;
        return *this;
    }

    FASTLED_FORCE_INLINE CRGB& operator&= (fl::u8 d )
    {
        if( d < r) r = d;
        if( d < g) g = d;
        if( d < b) b = d;
        return *this;
    }

    constexpr explicit operator bool() const
    {
        return r || g || b;
    }

    constexpr explicit operator fl::u32() const
    {
        return fl::u32(0xff000000) |
               (fl::u32{r} << 16) |
               (fl::u32{g} << 8) |
               fl::u32{b};
    }

    constexpr CRGB operator-() const
    {
        return CRGB(255 - r, 255 - g, 255 - b);
    }
 
#if (defined SmartMatrix_h || defined SmartMatrix3_h)
    operator rgb24() const {
        rgb24 ret;
        ret.red = r;
        ret.green = g;
        ret.blue = b;
        return ret;
    }
#endif
 
    fl::string toString() const;

    fl::u8 getLuma() const;
 
 

    FASTLED_FORCE_INLINE fl::u8 getAverageLight() const;

    FASTLED_FORCE_INLINE void maximizeBrightness( fl::u8 limit = 255 )  {
        fl::u8 max = red;
        if( green > max) max = green;
        if( blue > max) max = blue;
 
        // stop div/0 when color is black
        if(max > 0) {
            fl::u16 factor = ((fl::u16)(limit) * 256) / max;
            red =   (red   * factor) / 256;
            green = (green * factor) / 256;
            blue =  (blue  * factor) / 256;
        }
    }

    static CRGB computeAdjustment(fl::u8 scale, const CRGB & colorCorrection, const CRGB & colorTemperature);

    CRGB lerp8( const CRGB& other, fract8 amountOf2) const;

    FASTLED_FORCE_INLINE CRGB lerp16( const CRGB& other, fract16 frac) const;
    FASTLED_FORCE_INLINE fl::u8 getParity()
    {
        fl::u8 sum = r + g + b;
        return (sum & 0x01);
    }

    FASTLED_FORCE_INLINE void setParity( fl::u8 parity)
    {
        fl::u8 curparity = getParity();
 
        if( parity == curparity) return;
 
        if( parity ) {
            // going 'up'
            if( (b > 0) && (b < 255)) {
                if( r == g && g == b) {
                    ++r;
                    ++g;
                }
                ++b;
            } else if( (r > 0) && (r < 255)) {
                ++r;
            } else if( (g > 0) && (g < 255)) {
                ++g;
            } else {
                if( r == g && g == b) {
                    r ^= 0x01;
                    g ^= 0x01;
                }
                b ^= 0x01;
            }
        } else {
            // going 'down'
            if( b > 1) {
                if( r == g && g == b) {
                    --r;
                    --g;
                }
                --b;
            } else if( g > 1) {
                --g;
            } else if( r > 1) {
                --r;
            } else {
                if( r == g && g == b) {
                    r ^= 0x01;
                    g ^= 0x01;
                }
                b ^= 0x01;
            }
        }
    }

    typedef enum {
        AliceBlue=0xF0F8FF,             
        Amethyst=0x9966CC,              
        AntiqueWhite=0xFAEBD7,          
        Aqua=0x00FFFF,                  
        Aquamarine=0x7FFFD4,            
        Azure=0xF0FFFF,                 
        Beige=0xF5F5DC,                 
        Bisque=0xFFE4C4,                
        Black=0x000000,                 
        BlanchedAlmond=0xFFEBCD,        
        Blue=0x0000FF,                  
        BlueViolet=0x8A2BE2,            
        Brown=0xA52A2A,                 
        BurlyWood=0xDEB887,             
        CadetBlue=0x5F9EA0,             
        Chartreuse=0x7FFF00,            
        Chocolate=0xD2691E,             
        Coral=0xFF7F50,                 
        CornflowerBlue=0x6495ED,        
        Cornsilk=0xFFF8DC,              
        Crimson=0xDC143C,               
        Cyan=0x00FFFF,                  
        DarkBlue=0x00008B,              
        DarkCyan=0x008B8B,              
        DarkGoldenrod=0xB8860B,         
        DarkGray=0xA9A9A9,              
        DarkGrey=0xA9A9A9,              
        DarkGreen=0x006400,             
        DarkKhaki=0xBDB76B,             
        DarkMagenta=0x8B008B,           
        DarkOliveGreen=0x556B2F,        
        DarkOrange=0xFF8C00,            
        DarkOrchid=0x9932CC,            
        DarkRed=0x8B0000,               
        DarkSalmon=0xE9967A,            
        DarkSeaGreen=0x8FBC8F,          
        DarkSlateBlue=0x483D8B,         
        DarkSlateGray=0x2F4F4F,         
        DarkSlateGrey=0x2F4F4F,         
        DarkTurquoise=0x00CED1,         
        DarkViolet=0x9400D3,            
        DeepPink=0xFF1493,              
        DeepSkyBlue=0x00BFFF,           
        DimGray=0x696969,               
        DimGrey=0x696969,               
        DodgerBlue=0x1E90FF,            
        FireBrick=0xB22222,             
        FloralWhite=0xFFFAF0,           
        ForestGreen=0x228B22,           
        Fuchsia=0xFF00FF,               
        Gainsboro=0xDCDCDC,             
        GhostWhite=0xF8F8FF,            
        Gold=0xFFD700,                  
        Goldenrod=0xDAA520,             
        Gray=0x808080,                  
        Grey=0x808080,                  
        Green=0x008000,                 
        GreenYellow=0xADFF2F,           
        Honeydew=0xF0FFF0,              
        HotPink=0xFF69B4,               
        IndianRed=0xCD5C5C,             
        Indigo=0x4B0082,                
        Ivory=0xFFFFF0,                 
        Khaki=0xF0E68C,                 
        Lavender=0xE6E6FA,              
        LavenderBlush=0xFFF0F5,         
        LawnGreen=0x7CFC00,             
        LemonChiffon=0xFFFACD,          
        LightBlue=0xADD8E6,             
        LightCoral=0xF08080,            
        LightCyan=0xE0FFFF,             
        LightGoldenrodYellow=0xFAFAD2,  
        LightGreen=0x90EE90,            
        LightGrey=0xD3D3D3,             
        LightPink=0xFFB6C1,             
        LightSalmon=0xFFA07A,           
        LightSeaGreen=0x20B2AA,         
        LightSkyBlue=0x87CEFA,          
        LightSlateGray=0x778899,        
        LightSlateGrey=0x778899,        
        LightSteelBlue=0xB0C4DE,        
        LightYellow=0xFFFFE0,           
        Lime=0x00FF00,                  
        LimeGreen=0x32CD32,             
        Linen=0xFAF0E6,                 
        Magenta=0xFF00FF,               
        Maroon=0x800000,                
        MediumAquamarine=0x66CDAA,      
        MediumBlue=0x0000CD,            
        MediumOrchid=0xBA55D3,          
        MediumPurple=0x9370DB,          
        MediumSeaGreen=0x3CB371,        
        MediumSlateBlue=0x7B68EE,       
        MediumSpringGreen=0x00FA9A,     
        MediumTurquoise=0x48D1CC,       
        MediumVioletRed=0xC71585,       
        MidnightBlue=0x191970,          
        MintCream=0xF5FFFA,             
        MistyRose=0xFFE4E1,             
        Moccasin=0xFFE4B5,              
        NavajoWhite=0xFFDEAD,           
        Navy=0x000080,                  
        OldLace=0xFDF5E6,               
        Olive=0x808000,                 
        OliveDrab=0x6B8E23,             
        Orange=0xFFA500,                
        OrangeRed=0xFF4500,             
        Orchid=0xDA70D6,                
        PaleGoldenrod=0xEEE8AA,         
        PaleGreen=0x98FB98,             
        PaleTurquoise=0xAFEEEE,         
        PaleVioletRed=0xDB7093,         
        PapayaWhip=0xFFEFD5,            
        PeachPuff=0xFFDAB9,             
        Peru=0xCD853F,                  
        Pink=0xFFC0CB,                  
        Plaid=0xCC5533,                 
        Plum=0xDDA0DD,                  
        PowderBlue=0xB0E0E6,            
        Purple=0x800080,                
        Red=0xFF0000,                   
        RosyBrown=0xBC8F8F,             
        RoyalBlue=0x4169E1,             
        SaddleBrown=0x8B4513,           
        Salmon=0xFA8072,                
        SandyBrown=0xF4A460,            
        SeaGreen=0x2E8B57,              
        Seashell=0xFFF5EE,              
        Sienna=0xA0522D,                
        Silver=0xC0C0C0,                
        SkyBlue=0x87CEEB,               
        SlateBlue=0x6A5ACD,             
        SlateGray=0x708090,             
        SlateGrey=0x708090,             
        Snow=0xFFFAFA,                  
        SpringGreen=0x00FF7F,           
        SteelBlue=0x4682B4,             
        Tan=0xD2B48C,                   
        Teal=0x008080,                  
        Thistle=0xD8BFD8,               
        Tomato=0xFF6347,                
        Turquoise=0x40E0D0,             
        Violet=0xEE82EE,                
        Wheat=0xF5DEB3,                 
        White=0xFFFFFF,                 
        WhiteSmoke=0xF5F5F5,            
        Yellow=0xFFFF00,                
        YellowGreen=0x9ACD32,           
 
        // LED RGB color that roughly approximates
        // the color of incandescent fairy lights,
        // assuming that you're using FastLED
        // color correction on your LEDs (recommended).
        FairyLight=0xFFE42D,           
 
        // If you are using no color correction, use this
        FairyLightNCC=0xFF9D2A,         
 
        // TCL Color Extensions - Essential additions for LED programming
        // These colors provide useful grayscale levels and color variants
        
        // Essential grayscale levels (0-100 scale for precise dimming)
        Gray0=0x000000,                
        Gray10=0x1A1A1A,               
        Gray25=0x404040,               
        Gray50=0x7F7F7F,               
        Gray75=0xBFBFBF,               
        Gray100=0xFFFFFF,              
        
        // Alternative grey spellings
        Grey0=0x000000,                
        Grey10=0x1A1A1A,               
        Grey25=0x404040,               
        Grey50=0x7F7F7F,               
        Grey75=0xBFBFBF,               
        Grey100=0xFFFFFF,              
        
        // Primary color variants (1-4 intensity levels)
        Red1=0xFF0000,                 
        Red2=0xEE0000,                 
        Red3=0xCD0000,                 
        Red4=0x8B0000,                 
        
        Green1=0x00FF00,               
        Green2=0x00EE00,               
        Green3=0x00CD00,               
        Green4=0x008B00,               
        
        Blue1=0x0000FF,                
        Blue2=0x0000EE,                
        Blue3=0x0000CD,                
        Blue4=0x00008B,                
        
        // Useful warm color variants for LED ambience
        Orange1=0xFFA500,              
        Orange2=0xEE9A00,              
        Orange3=0xCD8500,              
        Orange4=0x8B5A00,              
        
        Yellow1=0xFFFF00,              
        Yellow2=0xEEEE00,              
        Yellow3=0xCDCD00,              
        Yellow4=0x8B8B00,              
        
        // Popular LED colors for effects
        Cyan1=0x00FFFF,                
        Cyan2=0x00EEEE,                
        Cyan3=0x00CDCD,                
        Cyan4=0x008B8B,                
        
        Magenta1=0xFF00FF,             
        Magenta2=0xEE00EE,             
        Magenta3=0xCD00CD,             
        Magenta4=0x8B008B,             
        
        // Additional useful colors for LED programming
        VioletRed=0xD02090,            
        DeepPink1=0xFF1493,            
        DeepPink2=0xEE1289,            
        DeepPink3=0xCD1076,            
        DeepPink4=0x8B0A50,            
        
        Gold1=0xFFD700,                
        Gold2=0xEEC900,                
        Gold3=0xCDAD00,                
        Gold4=0x8B7500                 
 
    } HTMLColorCode;
};
 

FASTLED_FORCE_INLINE bool operator== (const CRGB& lhs, const CRGB& rhs)
{
    return (lhs.r == rhs.r) && (lhs.g == rhs.g) && (lhs.b == rhs.b);
}

FASTLED_FORCE_INLINE bool operator!= (const CRGB& lhs, const CRGB& rhs)
{
    return !(lhs == rhs);
}

FASTLED_FORCE_INLINE bool operator== (const CHSV& lhs, const CHSV& rhs)
{
    return (lhs.h == rhs.h) && (lhs.s == rhs.s) && (lhs.v == rhs.v);
}

FASTLED_FORCE_INLINE bool operator!= (const CHSV& lhs, const CHSV& rhs)
{
    return !(lhs == rhs);
}

FASTLED_FORCE_INLINE bool operator< (const CRGB& lhs, const CRGB& rhs)
{
    fl::u16 sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl < sr;
}

FASTLED_FORCE_INLINE bool operator> (const CRGB& lhs, const CRGB& rhs)
{
    fl::u16 sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl > sr;
}

FASTLED_FORCE_INLINE bool operator>= (const CRGB& lhs, const CRGB& rhs)
{
    fl::u16 sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl >= sr;
}

FASTLED_FORCE_INLINE bool operator<= (const CRGB& lhs, const CRGB& rhs)
{
    fl::u16 sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl <= sr;
}
 
 

FASTLED_FORCE_INLINE CRGB operator/( const CRGB& p1, fl::u8 d)
{
    return CRGB( p1.r/d, p1.g/d, p1.b/d);
}
 

FASTLED_FORCE_INLINE CRGB operator&( const CRGB& p1, const CRGB& p2)
{
    return CRGB( p1.r < p2.r ? p1.r : p2.r,
                 p1.g < p2.g ? p1.g : p2.g,
                 p1.b < p2.b ? p1.b : p2.b);
}

FASTLED_FORCE_INLINE CRGB operator|( const CRGB& p1, const CRGB& p2)
{
    return CRGB( p1.r > p2.r ? p1.r : p2.r,
                 p1.g > p2.g ? p1.g : p2.g,
                 p1.b > p2.b ? p1.b : p2.b);
}

FASTLED_FORCE_INLINE CRGB operator+( const CRGB& p1, const CRGB& p2);

FASTLED_FORCE_INLINE CRGB operator-( const CRGB& p1, const CRGB& p2);

FASTLED_FORCE_INLINE CRGB operator*( const CRGB& p1, fl::u8 d);

FASTLED_FORCE_INLINE CRGB operator%( const CRGB& p1, fl::u8 d);

 
 
FASTLED_NAMESPACE_END