FastLED_NeoPixel.h

Go to the documentation of this file.

/*
 *  Project     FastLED NeoPixel Library
 *  @author     David Madison
 *  @link       github.com/dmadison/FastLED_NeoPixel
 *  @license    MIT - Copyright (c) 2021 David Madison
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */
 
#ifndef FASTLED_NEOPIXEL_H
#define FASTLED_NEOPIXEL_H
 
#include <Arduino.h>
 
#include <Adafruit_NeoPixel.h>
#include <FastLED.h>
 
 
class FastLED_NeoPixel_Variant {
public:
    FastLED_NeoPixel_Variant(CRGB* ledPtr, uint16_t nLeds);
 
    void begin(CLEDController& ctrl);
 
    void show();
 
 
    void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
 
    void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w);
 
    void setPixelColor(uint16_t n, uint32_t c);
 
    void fill(uint32_t c = 0, uint16_t first = 0, uint16_t count = 0);
 
 
    void setBrightness(uint8_t bright) { brightness = bright; }
 
    void clear();
 
    void updateLength(uint16_t n);
 
    bool canShow();
 
 
    uint8_t* getPixels() const { return (uint8_t*) leds; };
 
    uint8_t  getBrightness() const { return brightness; }
 
    uint16_t numPixels() const { return numLEDs; }
 
    uint32_t getPixelColor(uint16_t n) const;
 
 
    static uint8_t sine8(uint8_t x)  { return Adafruit_NeoPixel::sine8(x); }
 
    static uint8_t gamma8(uint8_t x) { return Adafruit_NeoPixel::gamma8(x); }
 
 
    static uint32_t Color(uint8_t r, uint8_t g, uint8_t b) { return Adafruit_NeoPixel::Color(r, g, b); }
 
    static uint32_t Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w) { return Adafruit_NeoPixel::Color(r, g, b, w); }
 
    static uint32_t ColorHSV(uint16_t hue, uint8_t sat = 255, uint8_t val = 255) { return Adafruit_NeoPixel::ColorHSV(hue, sat, val); }
 
    static uint32_t gamma32(uint32_t x) { return Adafruit_NeoPixel::gamma32(x); }
 
    
    CRGB* getLeds() const { return leds; };
 
    CLEDController* getController() const { return controller; }
 
    static uint32_t Color(const CRGB& c) { return Adafruit_NeoPixel::Color(c.r, c.g, c.b); }
 
    void setBlendWhite(bool blend) { blendWhite = blend; }
 
    void setPin(uint16_t p);
 
    void updateType(neoPixelType T);
 
private:
    CRGB packedToColor(uint32_t c) const;
 
    CRGB* const leds;          
    const uint16_t maxLEDs;    
    uint16_t numLEDs;          
    CLEDController* controller = nullptr;  
 
    uint8_t brightness = 255;  
    uint32_t endTime;          
    bool blendWhite = false;   
};
 
 
inline constexpr EOrder NeoToEOrder(uint32_t neoOrder) {
    return
        // FastLED Color Orders
        neoOrder == ((uint32_t) RGB) ? RGB :
        neoOrder == ((uint32_t) RBG) ? RBG :
        neoOrder == ((uint32_t) GRB) ? GRB :
        neoOrder == ((uint32_t) GBR) ? GBR :
        neoOrder == ((uint32_t) BRG) ? BRG :
        neoOrder == ((uint32_t) BGR) ? BGR :
 
        // NeoPixel Color Orders at Speed 'NEO_KHZ800'
        neoOrder == (NEO_RGB + NEO_KHZ800) ? RGB :
        neoOrder == (NEO_RBG + NEO_KHZ800) ? RBG :
        neoOrder == (NEO_GRB + NEO_KHZ800) ? GRB :
        neoOrder == (NEO_GBR + NEO_KHZ800) ? GBR :
        neoOrder == (NEO_BRG + NEO_KHZ800) ? BRG :
        neoOrder == (NEO_BGR + NEO_KHZ800) ? BGR :
 
        // NeoPixel Color Orders at Speed 'NEO_KHZ400'
        neoOrder == (NEO_RGB + NEO_KHZ400) ? RGB :
        neoOrder == (NEO_RBG + NEO_KHZ400) ? RBG :
        neoOrder == (NEO_GRB + NEO_KHZ400) ? GRB :
        neoOrder == (NEO_GBR + NEO_KHZ400) ? GBR :
        neoOrder == (NEO_BRG + NEO_KHZ400) ? BRG :
        neoOrder == (NEO_BGR + NEO_KHZ400) ? BGR :
 
        GRB;  // 'neoOrder' is not a valid color selection, using GRB as default
}
 
 
template<uint16_t NumLeds, uint8_t DataPin, uint32_t RgbOrder = GRB>
class FastLED_NeoPixel : public FastLED_NeoPixel_Variant {
public:
    FastLED_NeoPixel() : FastLED_NeoPixel_Variant(ledData, NumLeds) 
    {
        memset(ledData, 0, sizeof(ledData));  // set all LEDs to black
    }
 
    void begin() {
        FastLED_NeoPixel_Variant::begin(FastLED.addLeds<WS2812B, DataPin, NeoToEOrder(RgbOrder)>(ledData, NumLeds));
    }
 
    uint8_t getPin() const { return DataPin; };
 
private:
    CRGB ledData[NumLeds];
};
 
 
#endif // FASTLED_NEOPIXEL_H