led_group.hpp

Go to the documentation of this file.

#pragma once
#include "led_strand.hpp"
#include "led_profile.hpp"
#include <cstddef>
#include <vector>

 
namespace hitlib {
 
// ============================================================================

class LedGroup {
public:
 
    // ========================================================================

    void add(LedStrand* strand);

    void init(uint32_t refreshMs = 20);

    void start();

 
    // ========================================================================

    void off();

    void setColor(uint32_t color);

    void pulse(uint32_t color, uint8_t runLength, LedStrand::Speed speed,
               uint32_t bgColor = 0x000000, bool invert = false, bool bounce = false);

    void flash(uint32_t color, uint32_t onMs, uint32_t offMs, uint32_t bgColor = 0x000000);

    void flow(uint32_t color1, uint32_t color2, LedStrand::Speed speed, bool invert = false,
              bool seamless = true);

    void rainbow(LedStrand::Speed speed);

    void twinkle(const std::vector<uint32_t>& colors, uint8_t densityPct = 30,
                 uint8_t fadeStep = 16, uint32_t bgColor = 0x000000);

    void bitscroll(const std::vector<LedStrand::BitScrollSegment>& segments, LedStrand::Speed speed,
                   bool invert = false, uint32_t bgColor = 0x000000, bool bounce = false,
                   uint8_t spacing = 5, bool repeating = true);

    void levelFill(uint32_t color, uint32_t color2 = 0x000000, bool gradient = false,
                   uint32_t bgColor = 0x000000, bool invert = false);

    void setLevel(uint8_t level);

    void levelSource(LedStrand::LevelFn read, double emptyAt, double fullAt, bool wrap = false,
                     uint8_t smoothing = 0);

    void clearLevelSource();

    void musicSync(const LedStrand::MusicTrack& track, uint32_t color, uint32_t color2 = 0x000000,
                   bool gradient = false, uint32_t bgColor = 0x000000, bool invert = false,
                   uint8_t sensitivity = 100, bool loop = false);

    void musicSeek(uint32_t positionMs);

    void musicPause(bool paused = true);

    void setSensitivity(uint8_t pct);

    void spliceMask(uint8_t sections, bool invert = false, bool alternating = false,
                    uint32_t altPeriodMs = 100, uint32_t bgColor = 0x000000,
                    bool useOverlay = false);

    void spliceMaskCustom(const std::vector<LedStrand::SpliceRegion>& regions);

    void clearSpliceMask();

    void setBrightness(uint8_t pct);

 
    // ========================================================================

    void overlaySetColor(uint32_t color);

    void overlayPulse(uint32_t color, uint8_t runLength, LedStrand::Speed speed,
                      uint32_t bgColor = 0x000000);

    void overlayFlash(uint32_t color, uint32_t onMs, uint32_t offMs,
                      uint32_t bgColor = 0x000000);

    void overlayFlow(uint32_t color1, uint32_t color2, LedStrand::Speed speed, bool seamless = true);

    void overlayRainbow(LedStrand::Speed speed);

 
    // ========================================================================

    void attachProfile(const Profile* profile);

    void detachProfile();

    void activateMode(uint8_t modeIdx);

    void activateModeTimed(uint8_t modeIdx, uint32_t durationMs);

    void deactivateMode(uint8_t modeIdx);

 
    // ========================================================================

    LedStrand* operator[](size_t i);

    size_t size() const;

 
private:
    std::vector<LedStrand*> strands;
    uint32_t refreshMs   = 20;
    bool     initialized = false;
    bool     started     = false;
    // Guards the fields above, so add() can run while the task is going round
    // the strands. The task holds it only to copy the list, never across a
    // tick. See the lock order in led_group.cpp.
    mutable platform::Mutex mutex;
 
    void groupTask();
    static void taskEntry(void* group);
 
    // Calls fn(strand) for every strand, holding the lock across the loop.
    template <typename Fn>
    void forEach(Fn fn) {
        mutex.take();
        for (LedStrand* s : strands) fn(*s);
        mutex.give();
    }
};
 
} // namespace hitlib