NeoRgbwXXFeature

[TMoney1099]

Hello,

I am looking at implementing a custom feature for 8-bit RGBW with an extra 16 bits of nothing padded to the end. So the total size of the packet should be 48 bits, hence the name RgbwXX. However I am mainly using this with WLED, and have been able to propagate data between the two systems.

I went ahead and added the feature to NeoColorFeatures.h that inherits a "custom" Neo4ByteElementsNoSettings class. The reason it is custom is because I replaced the RgbwColor typedef with my own, RgbwXXColor that includes a uint16_t variable that I intend to set to 0. It is identical to RgbwColor other than the 16-bit extra variable.

// NeoColorFeatures.h

class CustomNeo4ByteElements
{
public:
    static const size_t PixelSize = 4;

    static uint8_t* getPixelAddress(uint8_t* pPixels, uint16_t indexPixel) 
    {
        return pPixels + indexPixel * PixelSize;
    }
    static const uint8_t* getPixelAddress(const uint8_t* pPixels, uint16_t indexPixel)
    {
        return pPixels + indexPixel * PixelSize;
    }

    static void replicatePixel(uint8_t* pPixelDest, const uint8_t* pPixelSrc, uint16_t count)
    {
        uint32_t* pDest = reinterpret_cast<uint32_t*>(pPixelDest);
        const uint32_t* pSrc = reinterpret_cast<const uint32_t*>(pPixelSrc);

        uint32_t* pEnd = pDest + count;
        while (pDest < pEnd)
        {
            *pDest++ = *pSrc;
        }
    }

    static void movePixelsInc(uint8_t* pPixelDest, const uint8_t* pPixelSrc, uint16_t count)
    {
        uint32_t* pDest = reinterpret_cast<uint32_t*>(pPixelDest);
        const uint32_t* pSrc = reinterpret_cast<const uint32_t*>(pPixelSrc);
        uint32_t* pEnd = pDest + count;
        while (pDest < pEnd)
        {
            *pDest++ = *pSrc++;
        }
    }

    static void movePixelsInc_P(uint8_t* pPixelDest, PGM_VOID_P pPixelSrc, uint16_t count)
    {
        uint32_t* pDest = reinterpret_cast<uint32_t*>(pPixelDest);
        const uint32_t* pSrc = reinterpret_cast<const uint32_t*>(pPixelSrc);
        uint32_t* pEnd = pDest + count;
        while (pDest < pEnd)
        {
            *pDest++ = pgm_read_dword(pSrc++); 
        }
    }

    static void movePixelsDec(uint8_t* pPixelDest, const uint8_t* pPixelSrc, uint16_t count)
    {
        uint32_t* pDest = reinterpret_cast<uint32_t*>(pPixelDest);
        const uint32_t* pSrc = reinterpret_cast<const uint32_t*>(pPixelSrc);
        uint32_t* pDestBack = pDest + count;
        const uint32_t* pSrcBack = pSrc + count;
        while (pDestBack > pDest)
        {
            *--pDestBack = *--pSrcBack;
        }
    }

    typedef RgbwXXColor ColorObject;
};

// idential to Neo4ByteElementsNoSettings
class CustomNeo4ByteElementsNoSettings : public CustomNeo4ByteElements
{
public:
    typedef NeoNoSettings SettingsObject;
    static const size_t SettingsSize = 0;

    static void applySettings(uint8_t*, const SettingsObject&)
    {
    }

    static uint8_t* pixels(uint8_t* pData)
    {
        return pData;
    }

    static const uint8_t* pixels(const uint8_t* pData)
    {
        return pData;
    }
};

class NeoRgbwXXFeature : public CustomNeo4ByteElementsNoSettings
{
public:
    static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color)
    {
        uint8_t* p = getPixelAddress(pPixels, indexPixel);

        *p++ = color.R;
        *p++ = color.G;
        *p++ = color.B;
        *p++ = color.W;
        *p = color.X;
    }

    static ColorObject retrievePixelColor(const uint8_t* pPixels, uint16_t indexPixel)
    {
        ColorObject color;
        const uint8_t* p = getPixelAddress(pPixels, indexPixel);

        color.R = *p++;
        color.G = *p++;
        color.B = *p++;
        color.W = *p++;
        color.X = *p;

        return color;
    }

    static ColorObject retrievePixelColor_P(PGM_VOID_P pPixels, uint16_t indexPixel)
    {
        ColorObject color;
        const uint8_t* p = getPixelAddress(reinterpret_cast<const uint8_t*>(pPixels), indexPixel);

        color.R = pgm_read_byte(p++);
        color.G = pgm_read_byte(p++);
        color.B = pgm_read_byte(p++);
        color.W = pgm_read_byte(p++);
        color.X = pgm_read_byte(p);

        return color;
    }
};

// RgbwXXColor.h
// Not including the entire file as only a handful of lines were modified.
struct RgbwXXColor
{
    typedef NeoRgbwCurrentSettings SettingsObject;

    // ------------------------------------------------------------------------
    // Construct a Rgbw48Color using R, G, B, W values (0-255)
    // ------------------------------------------------------------------------
    RgbwXXColor(uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0, uint16_t x = 0) :
        R(r), G(g), B(b), W(w), X(x)
    {
    };

    // ------------------------------------------------------------------------
    // Construct a RgbColor using a single brightness value (0-255)
    // This works well for creating gray tone colors
    // (0) = black, (255) = white, (128) = gray
    // ------------------------------------------------------------------------
    RgbwXXColor(uint8_t brightness) :
        R(0), G(0), B(0), W(brightness), X(0)
    {
    };

    // ------------------------------------------------------------------------
    // Construct a Rgbw48Color using RgbColor
    // ------------------------------------------------------------------------
    RgbwXXColor(const RgbColor& color) :
        R(color.R),
        G(color.G),
        B(color.B),
        W(0),
        X(0)
    {
    };
...
    // ------------------------------------------------------------------------
    // Red, Green, Blue, White color members (0-255) where 
    // (0,0,0,0) is black and (255,255,255, 0) and (0,0,0,255) is white
    // Note (255,255,255,255) is extreme bright white
    // ------------------------------------------------------------------------
    uint8_t R;
    uint8_t G;
    uint8_t B;
    uint8_t W;
    uint16_t X; // don't care. make 0

Any suggestions? I only seem to get 32-bit output. Also, the order of the colors seems to come out incorrectly as well. When I add print statements inside applyPixelColor() R and W are always flipped.

Thank you.

[Makuna]

*ByteElements represent the number of actual bytes in the output stream to represent the "Pixel" (aka, single Item).
Your CustomNeo4ByteElements used 4 bytes when you need 6 bytes. This why the output was only 4 bytes.
See the standard Neo6ByteElements; copy it, name it Neo4Byte2BytePaddedElements, change the line within it from typedef Rgb48Color ColorObject; to typedef RgbwColor ColorObject
Merge this through the NoSettings object and NeoRgbwXXFeature (change the names to use the above naming, and case is important in the name, it should be NeoRgbwxxFeature))
In your NeoRgbwxxFeature , you need only the 4 bytes of the RGBW, but the last two bytes can just be constant zeros. Also is that really the byte order RGBW? You will find out the first time it works, you may need to reorder assignments but look at other color features.
Like...

    static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color)
    {
        uint8_t* p = getPixelAddress(pPixels, indexPixel);

        *p++ = color.R;  // reorder for correct output byte order
        *p++ = color.G;
        *p++ = color.B;
        *p++ = color.W;
        // zero the xx, this maybe unnecessary though, but its thorough
        *p++ = 0; 
        *p = 0; 
    }

    static ColorObject retrievePixelColor(const uint8_t* pPixels, uint16_t indexPixel)
    {
        ColorObject color;
        const uint8_t* p = getPixelAddress(pPixels, indexPixel);

        color.R = *p++;  // reorder for correct output byte order
        color.G = *p++;
        color.B = *p++;
        color.W = *p;
        // ignore the xx

        return color;
    }

Get rid of your RgbwXXColor, you don't need it. Just use the standard RgbwColor object.

[TMoney1099]

This worked! Thank you so much!

[Makuna]

Can you share what you ended up with? I think this would be a good addition.

[TMoney1099]

Do you want me to share the files?

[Makuna]

sure. You can also just create a pull request. Either way.

[Makuna]

created an issue as to not loose this feature #677

[Makuna]

#680