addrled.hpp

 
#pragma once
#include <cstdint>
#include <vector>
 
#include "sylib/env.hpp"
#include "sylib/system.hpp"
#include "sylib/sylib_apitypes.hpp"
 
 
namespace sylib {
 
typedef struct {
    double r;
    double g;
    double b;
} rgb;
 
typedef struct {
    double h;
    double s;
    double v;
} hsv;
 
class Addrled : private Device {
   private:
    static const std::vector<uint32_t> off_buffer;
    const std::uint8_t smart_port;
    const std::uint8_t adi_port;
    const std::uint8_t strip_length;
    std::vector<uint32_t> buffer;
    std::vector<uint32_t> template_buffer;
    std::vector<uint32_t> rotation_buffer;
    std::vector<uint32_t> buffer_saved;
    static std::vector<sylib::Addrled*>& getAllAddrleds();
    const V5_DeviceT device;
    static void setAddrledUpdateCycles(int count);
    sylib::SylibAddrledControlMode addrledControlMode;
    double controlSpeed        = 1;
    double pulseSpeed          = 1;
    int cyclePixelsShifted     = 0;
    int end_pixel              = -1;
    bool pulseControlReversed  = false;
    bool cycleControlReversed  = false;
    int pixelsToMove           = 0;
    int pulseStartMovementTime = 0;
    int cycleStartMovementTime = 0;
    bool sendingPulse          = false;
    int controlPulseWidth      = 1;
    int redShift               = 0;
    int greenShift             = 0;
    int blueShift              = 0;
    int pulsePixelsShifted     = 0;
 
   public:
    Addrled(const std::uint8_t smart_port, const std::uint8_t adi_port,
            const std::uint8_t strip_length,
            const std::vector<std::uint32_t> colors = std::vector<std::uint32_t>());
 
    ~Addrled();
 
    static bool addrled_enabled;
 
    void set_all(std::uint32_t color);
 
    void set_pixel(std::uint32_t color, std::uint8_t index);
 
    void set_buffer(std::vector<uint32_t> colors);
 
    void update() override;
 
    void turn_off();
 
    void turn_on();
 
    void clear();
 
    void pulse(std::uint32_t color, int pulse_width, int speed = 1, int start_pos = 0,
               bool reverse = false, int end_pixel = -1);
 
    void gradient(std::uint32_t start_color, std::uint32_t end_color, int fade_width = 0,
                  int start_pos = 0, bool reverse = false, bool hsv_mode = false);
 
    void cycle(std::vector<uint32_t> pattern, int speed = 1, int start_pos = 0,
               bool reverse = false);
 
    void rotate(int pixels = 0, bool reverse = false);
 
    void color_shift(int red, int green, int blue);
 
    int get_smart_port();
 
    int get_adi_port();
 
    uint32_t& operator[](std::uint32_t index);
 
    std::vector<uint32_t>& operator*();
 
    sylib::SylibAddrledControlMode getControlMode();
 
    static std::uint32_t interpolate_hsv(std::uint32_t start_color, std::uint32_t end_color,
                                         int step, int fade_width);
 
    static std::uint32_t interpolate_rgb(std::uint32_t start_color, std::uint32_t end_color,
                                         int step, int fade_width);
 
    static std::uint32_t hsv_to_rgb(hsv in);
 
    static hsv rgb_to_hsv(std::uint32_t in);
 
    static std::uint32_t rgb_to_hex(int r, int g, int b);
 
    static rgb hex_to_rgb(std::uint32_t color);
};
}  // namespace sylib