LEDPixelEngine.h

Go to the documentation of this file.

#ifndef LEDPIXELENGINE_H
#define LEDPIXELENGINE_H
 
#ifndef USE_LEDLIB
 #ifdef ESP32
  #define USE_LEDLIB 0 //0 for FastLED, 1 for Adafruit_NeoPixel, 2 for NeoPixelBus
 #else
  #define USE_LEDLIB 1 //0 for FastLED, 1 for Adafruit_NeoPixel, 2 for NeoPixelBus
 #endif
#endif
 
#include "ReelTwo.h"
#if USE_LEDLIB == 0
 #include <FastLED.h>
 #include <Adafruit_NeoPixel.h>
#elif USE_LEDLIB == 1
 #include <Adafruit_NeoPixel.h>
 #include "core/NeoPixel_FastLED.h"
#else
 #error Not supported
#endif
 
#if USE_LEDLIB == 0
/*
 *  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.
 *
 */
 
class FastLED_NeoPixel_Variant {
public:
    FastLED_NeoPixel_Variant(CRGB* ledPtr, uint16_t nLeds) :
        fLED(ledPtr),
        fMaxLEDs(nLeds),
        fNumLEDs(nLeds)
    {
        fEndTime = micros();
    }
 
    void begin(CLEDController& ctrl)
    {
        fController = &ctrl;
    }
 
    void show()
    {
        if (fController != nullptr)
        {
            fController->show(fLED, fNumLEDs, fBrightness);
            fEndTime = micros();
        }
    }
 
    void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b)
    {
        if (n < fNumLEDs)
        {
            fLED[n] = CRGB(r, g, b);
        }
    }
 
    void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w)
    {
        setPixelColor(n, Color(r, g, b, w));
    }
 
    void setPixelColor(uint16_t n, uint32_t c)
    {
        if (n < fNumLEDs)
        {
            fLED[n] = packedToColor(c);
        }
    }
 
    void fill(uint32_t c = 0, uint16_t first = 0, uint16_t count = 0)
    {
        if (first >= fNumLEDs)
            return;
 
        if (first == 0 && count == 0)
        {
            // if auto, fill from start to end
            count = fNumLEDs;
        }
        else if (first != 0 && count == 0)
        {
            // if only first is set, fill from first to end
            count = fNumLEDs - first;
        }
        else
        {
            // if both are set, fill from first to end without overrunning buffer
            count = min(count, uint16_t(fNumLEDs - first));
        }
 
        fill_solid(fLED + first, count, packedToColor(c));
    }
 
    inline void setBrightness(uint8_t bright)
    {
        fBrightness = bright;
    }
 
    void clear()
    {
        fill_solid(fLED, fNumLEDs, CRGB::Black);
    }
 
    void updateLength(uint16_t n)
    {
        if (n <= fMaxLEDs)
        {
            fNumLEDs = n;
            clear();
        }
    }
 
    bool canShow()
    {
        if (fEndTime > micros())
        {
            fEndTime = micros();
        }
        return (micros() - fEndTime) >= 300UL;
    }
 
    inline uint8_t* getPixels() const
    {
        return (uint8_t*)fLED;
    }
 
    inline uint8_t getBrightness() const
    {
        return fBrightness;
    }
 
    inline uint16_t numPixels() const
    {
        return fNumLEDs;
    }
 
    uint32_t getPixelColor(uint16_t n) const
    {
        if (n >= fNumLEDs)
            return Color(CRGB::Black);
        return Color(fLED[n]);
    }
 
    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); }
 
 
    inline CRGB* getLeds() const
    {
        return fLED;
    }
 
    inline CLEDController* getController() const
    {
        return fController;
    }
 
    static uint32_t Color(const CRGB& c)
    {
        return Adafruit_NeoPixel::Color(c.r, c.g, c.b);
    }
 
    void setBlendWhite(bool blend)
    {
        fBlendWhite = blend;
    }
 
    void setPin(uint16_t p);
 
    void updateType(neoPixelType T);
 
private:
    CRGB packedToColor(uint32_t c) const
    {
        CRGB color(c);
        if (fBlendWhite == true)
            color.addToRGB(c >> 24);
        return color;
    }
 
    CRGB* const fLED;          
    const uint16_t fMaxLEDs;   
    uint16_t fNumLEDs;         
    CLEDController* fController = nullptr;  
 
    uint8_t fBrightness = 255; 
    uint32_t fEndTime;         
    bool fBlendWhite = 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 NUM_LEDS, uint8_t DATA_PIN, uint32_t RGB_ORDER = GRB>
class FastLED_NeoPixel : public FastLED_NeoPixel_Variant {
public:
    FastLED_NeoPixel() : FastLED_NeoPixel_Variant(fLEDData, NUM_LEDS)
    {
        memset(fLEDData, 0, sizeof(fLEDData));  // set all LEDs to black
    }
 
    void begin()
    {
        FastLED_NeoPixel_Variant::begin(
            FastLED.addLeds<WS2812B, DATA_PIN, NeoToEOrder(RGB_ORDER)>(fLEDData, NUM_LEDS));
    }
 
    inline uint8_t getPin() const
    {
        return DATA_PIN;
    }
 
private:
    CRGB fLEDData[NUM_LEDS];
};
 
 
#endif
 
#endif