SerialWombatWS2812.h

Go to the documentation of this file.

#pragma once
/*
Copyright 2021-2026 Broadwell Consulting Inc.
 
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.
*/
#include <stdint.h>
#include "SerialWombat.h"
 
 
enum SWWS2812Mode {
    ws2812ModeBuffered = 0,  
    ws2812ModeAnimation = 1, 
    ws2812ModeChase = 2, 
};

 
class SerialWombatWS2812 : public SerialWombatPin
{
public:
    SerialWombatWS2812(SerialWombatChip& serialWombat):SerialWombatPin(serialWombat)
    {
    }

    int16_t begin(uint8_t pin, uint8_t numberOfLEDs, uint16_t userBufferIndex)
    {
        _pin = pin;
        _numLEDS = numberOfLEDs;
        _userBufferIndex = userBufferIndex;
 
        uint8_t tx[8] = { 200,_pin,12,SW_LE16(userBufferIndex),_numLEDS,0x55 };
        return (_sw.sendPacket(tx));
    }

    int16_t write(uint8_t led, uint32_t color)
    {
        uint8_t tx[8] = { 201,_pin,12,led,SW_LE32(color) };
        if (swapRG)
        {
            uint8_t x = tx[6];
            tx[6] = tx[5];
            tx[5] = x;
        }
        tx[7] = 0x55;
        return _sw.sendPacket(tx);
    }

    int16_t write(uint8_t led, int16_t color)
    {
        return write(led, (uint32_t)color);
    }

    int16_t write(uint8_t led, int32_t color)
    {
        return write(led, (uint32_t)color);
    }

    int16_t write(int led, int color)
    {
        return write((uint8_t)led, (uint32_t)color);
    }
 
    /*
    \brief Set a number of LEDs to colors based on an array of uint32_t colors
    
    \param led  The index of the first led to set
    \param length The number of LEDs to set, and the number of entires in colors array
    \param An array of uint32_t integer colors in the format 0x00RRGGBB format
    \return 0 or higher for success or a negative number indicating an error code from the Serial Wombat chip.
    */
    int16_t write(uint8_t led, uint8_t length,  uint32_t colors[])
    {
        for (int i = 0; i < length; ++i)
        {
            int16_t result = 
            write((uint8_t)(led + i),(uint32_t) colors[i]);
 
            if (result < 0)
            {
                return (result);
            }
 
        }
        return(0);
    }
 
    /*
    \brief set the color of one LED in an animation frame
    
    \param frame The Frame index of the color being set
    \param led The LED index in that frame of the color being set
    \param color The color of the LED in 0x00RRGGBB format
    \return 0 or higher for success or a negative number indicating an error code from the Serial Wombat chip.
    */
    int16_t writeAnimationLED(uint8_t frame, uint8_t led, uint32_t color)
    {
        uint8_t tx[8] = { 203,_pin,12,frame,led,(uint8_t)((color >>16 ) & 0xFF),(uint8_t)((color >> 8) & 0xFF),(uint8_t)( color & 0xFF) };
        return _sw.sendPacket(tx);
    }

    int16_t writeAnimationLED(uint8_t frame, uint8_t led, int16_t color)
    {
        return writeAnimationLED(frame, led,(uint32_t)color);
    }

    int16_t writeAnimationLED(uint8_t frame, uint8_t led, int32_t color)
    {
        return writeAnimationLED(frame, led, (uint32_t)color);
    }

    int16_t writeAnimationFrame(uint8_t frame, uint32_t colors[])
    {
        for (int i = 0; i < _numLEDS; ++i)
        {
            int16_t result;
            result = writeAnimationLED(frame, i, colors[i]);
            if (result < 0)
            {
                return (result);
            }
        }
        return(0);
        
    }

    int16_t writeAnimationFrameDelay(uint8_t frame, uint16_t delay_mS)
    {
        uint8_t tx[8] = { 205,_pin,12,frame,SW_LE16(delay_mS),0x55,0x55 };
        return (_sw.sendPacket(tx));
    }

    int16_t writeAnimationUserBufferIndex(uint16_t index, uint8_t numberOfFrames)
    {
        uint8_t tx[8] = { 204,_pin,12,SW_LE16(index),numberOfFrames,0x55,0x55 };
        return (_sw.sendPacket(tx));
    }

    int16_t readBufferSize()
    {
        uint8_t tx[8] = { 202,_pin,12,_numLEDS,0x55,0x55,0x55,0x55 };
        uint8_t rx[8];
        int16_t result = _sw.sendPacket(tx,rx);
        if (result >= 0)
        {
            return (rx[3] + rx[4] * 256);
        }
        else
        {
            return (result);
        }
 
        return int16_t();
    }
 

    int16_t writeMode(SWWS2812Mode mode)
    {
        uint8_t tx[8] = { 206,_pin,12,(uint8_t)mode,0x55,0x55,0x55,0x55 };
        return _sw.sendPacket(tx);
    }

    int16_t barGraph(uint8_t sourcePin, uint32_t offRGB, uint32_t onRGB, uint16_t min, uint16_t max)
    {
        uint8_t tx[8] = { 206,_pin,12,3,sourcePin,0x55,0x55,0x55 };
        int16_t result = 0;
        result = _sw.sendPacket(tx);  if (result < 0) { return result; }
        result = write((uint8_t)0,(uint32_t) offRGB); if (result < 0) { return result; }
        result = write((uint8_t)1, (uint32_t)onRGB);  if (result < 0) { return result; }
 
        uint8_t minMax[8] = { 207,_pin,12,SW_LE16(min), SW_LE16(max),0x55 };
        return _sw.sendPacket(minMax);
 
        
    }

    int16_t barGraph(SerialWombatDataSource sourcePin, uint32_t offRGB, uint32_t onRGB, uint16_t min, uint16_t max)
        {
            return barGraph((uint8_t) sourcePin, offRGB, onRGB, min, max);
        }

    bool swapRG = false;
private:
    uint8_t _numLEDS = 0;
    uint16_t _userBufferIndex=0;
};