File content as of revision 4:70bc3528e07e:

#include "TI_NEOPIXEL_SPI.h"
#include "mbed.h"

TI_NEOPIXEL_SPI::TI_NEOPIXEL_SPI(PinName input) : _neoPixel(input)
{
}

void TI_NEOPIXEL_SPI::switchLightOff(int count)
{

    Pixel pixels[count];

    for (int i = 0; i < count; i++)
    {
        pixels[i].r = 0;
        pixels[i].g = 0;
        pixels[i].b = 0;
    }

    _neoPixel.send(pixels, count);
}

void TI_NEOPIXEL_SPI::switchLightOn(int count, int startCount, int endCount, rgbColor rgbColor)
{
    Pixel pixels[count];

    for (int i = 0; i < count; i++)
    {
        if (startCount <= i && i < endCount)
        {
            pixels[i].r = rgbColor.red;
            pixels[i].g = rgbColor.green;
            pixels[i].b = rgbColor.blue;
        }
        else
        {
            pixels[i].r = 0;
            pixels[i].g = 0;
            pixels[i].b = 0;
        }
    }

    _neoPixel.send(pixels, count);
}

void TI_NEOPIXEL_SPI::changeColor(int count, int startCount, int endCount, rgbColor rgbColor)
{
    Pixel pixels[count];

    for (int i = 0; i < count; i++)
    {
        if (startCount <= i && i < endCount)
        {
            pixels[i].r = rgbColor.red;
            pixels[i].g = rgbColor.green;
            pixels[i].b = rgbColor.blue;
        }
        else
        {
            pixels[i].r = 0;
            pixels[i].g = 0;
            pixels[i].b = 0;
        }
    }

    _neoPixel.send(pixels, count);
}

void TI_NEOPIXEL_SPI::changePointColor(int count, int topIndex, int endIndex, rgbColor topColor, rgbColor bottomColor)
{
    Pixel pixels[count];

    for (int i = 0; i < count; i++)
    {
        if (i == topIndex)
        {
            pixels[i].r = topColor.red;
            pixels[i].g = topColor.green;
            pixels[i].b = topColor.blue;
        }
        else if (i == endIndex)
        {
            pixels[i].r = bottomColor.red;
            pixels[i].g = bottomColor.green;
            pixels[i].b = bottomColor.blue;
        }
        else
        {
            pixels[i].r = 0;
            pixels[i].g = 0;
            pixels[i].b = 0;
        }
    }

    _neoPixel.send(pixels, count);
}

void TI_NEOPIXEL_SPI::circle(int count, int startCount, int endCount, rgbColor rgbColor)
{
    for (int j = 0; j < count; j++)
    {
        Pixel pixels[count];

        for (int i = 0; i < count; i++)
        {
            if (i <= j)
            {
                if (startCount <= i && i < endCount)
                {
                    pixels[i].r = rgbColor.red;
                    pixels[i].g = rgbColor.green;
                    pixels[i].b = rgbColor.blue;
                }
                else
                {
                    pixels[i].r = 0;
                    pixels[i].g = 0;
                    pixels[i].b = 0;
                }
            }
            else
            {
                pixels[i].r = 0;
                pixels[i].g = 0;
                pixels[i].b = 0;
            }
        }

        _neoPixel.send(pixels, count);

        if (startCount <= j && j < endCount)
        {
            if (count == 16)
            {
                wait(0.05);
            }
            else
            {
                wait(0.015);
            }
        }
    }
}

void TI_NEOPIXEL_SPI::chase(int count, int bufferCount, rgbColor c1, rgbColor c2)
{
    int virtualCount = count + bufferCount;
    Pixel pixels[virtualCount];

    for (int j = 0; j < virtualCount; j++)
    {
        pixels[j].r = c2.red;
        pixels[j].g = c2.green;
        pixels[j].b = c2.blue;
    }

    for (int j = 0; j < count; j++)
    {
        pixels[j].r = c1.red;
        pixels[j].g = c1.green;
        pixels[j].b = c1.blue;

        pixels[j - bufferCount].r = c2.red;
        pixels[j - bufferCount].g = c2.green;
        pixels[j - bufferCount].b = c2.blue;

        _neoPixel.send(pixels, virtualCount);

        if (count == 16)
        {
            wait(0.05);
        }
        else
        {
            wait(0.015);
        }
    }
}

void TI_NEOPIXEL_SPI::chase2(int count, int bufferCount, rgbColor c1, rgbColor c2)
{
    for (int j = 0; j < count; j++)
    {
        Pixel pixels[count];

        for (int i = 0; i < count; i++)
        {
            if (i <= j)
            {
                pixels[i].r = c1.red;
                pixels[i].g = c1.green;
                pixels[i].b = c1.blue;

                // LEDを節約
                pixels[i - bufferCount].r = c2.red;
                pixels[i - bufferCount].g = c2.green;
                pixels[i - bufferCount].b = c2.blue;
            }
            else
            {
                pixels[i].r = c2.red;
                pixels[i].g = c2.green;
                pixels[i].b = c2.blue;
            }
        }

        _neoPixel.send(pixels, count);

        if (count == 16)
        {
            wait(0.05);
        }
        else
        {
            wait(0.015);
        }
    }
}

void TI_NEOPIXEL_SPI::chaseReverse(int count, int bufferCount, rgbColor c1, rgbColor c2)
{
    printf("chaseReverse \n");

    Pixel pixels[count];

    for (int j = 0; j <= count; j++)
    {
        pixels[j].r = c2.red;
        pixels[j].g = c2.green;
        pixels[j].b = c2.blue;
    }

    _neoPixel.send(pixels, count);

    for (int j = 0; j <= count; j++)
    {
        if (0 <= (count - j))
        {
            pixels[count - j].r = c1.red;
            pixels[count - j].g = c1.green;
            pixels[count - j].b = c1.blue;
        }

        if (bufferCount <= j)
        {
            pixels[count + bufferCount - j].r = c2.red;
            pixels[count + bufferCount - j].g = c2.green;
            pixels[count + bufferCount - j].b = c2.blue;
        }

        _neoPixel.send(pixels, count);

        if (count == 16)
        {
            wait(0.05);
        }
        else
        {
            wait(0.015);
        }
    }
}

void TI_NEOPIXEL_SPI::chaseRainbow(int count, int bufferCount)
{
    for (int j = 0; j < count; j++)
    {
        Pixel pixels[count];

        for (int i = 0; i < count; i++)
        {
            if (i <= j)
            {
                uint8_t phase = 256 / count * i;
                rgbColor rgbColor = convertHsvToRgb(phase / 256.0, 1.0, 1.0);
                pixels[i].r = rgbColor.red;
                pixels[i].g = rgbColor.green;
                pixels[i].b = rgbColor.blue;

                // LEDを節約
                pixels[i - bufferCount].r = 0;
                pixels[i - bufferCount].g = 0;
                pixels[i - bufferCount].b = 0;
            }
            else
            {
                pixels[i].r = 0;
                pixels[i].g = 0;
                pixels[i].b = 0;
            }
        }

        _neoPixel.send(pixels, count);

        if (count == 16)
        {
            wait(0.05);
        }
        else
        {
            wait(0.015);
        }
    }
}

void TI_NEOPIXEL_SPI::circleRainbow(int count)
{
    for (int j = 0; j < count; j++)
    {
        Pixel pixels[count];

        for (int i = 0; i < count; i++)
        {
            if (i <= j)
            {
                uint8_t phase = 256 / count * i;
                rgbColor rgbColor = convertHsvToRgb(phase / 256.0, 1.0, 1.0);
                pixels[i].r = rgbColor.red;
                pixels[i].g = rgbColor.green;
                pixels[i].b = rgbColor.blue;
            }
            else
            {
                pixels[i].r = 0;
                pixels[i].g = 0;
                pixels[i].b = 0;
            }
        }

        _neoPixel.send(pixels, count);

        if (count == 16)
        {
            wait(0.05);
        }
        else
        {
            wait(0.015);
        }
    }
}

void TI_NEOPIXEL_SPI::moon(int count, int startIndex, int stopIndex, rgbColor c1, rgbColor c2)
{

    Pixel pixels[count];

    for (int j = 0; j < count; j++)
    {
        if (0 <= j && j <= count)
        {
            pixels[j].r = c2.red;
            pixels[j].g = c2.green;
            pixels[j].b = c2.blue;
        }
    }

    int loopCount = (stopIndex - startIndex) / 2;
    int middlePoint = startIndex + loopCount;

    for (int i = 0; i <= loopCount - 1; i++)
    {
        pixels[middlePoint + i].r = c1.red;
        pixels[middlePoint + i].g = c1.green;
        pixels[middlePoint + i].b = c1.blue;

        pixels[middlePoint - i].r = c1.red;
        pixels[middlePoint - i].g = c1.green;
        pixels[middlePoint - i].b = c1.blue;

        _neoPixel.send(pixels, count);

        if (count == 16)
        {
            wait(0.05);
        }
        else
        {
            wait(0.04);
        }
    }

    for (int i = 0; i <= loopCount - 1; i++)
    {
        pixels[startIndex + i].r = c2.red;
        pixels[startIndex + i].g = c2.green;
        pixels[startIndex + i].b = c2.blue;

        pixels[stopIndex - i].r = c2.red;
        pixels[stopIndex - i].g = c2.green;
        pixels[stopIndex - i].b = c2.blue;

        _neoPixel.send(pixels, count);

        if (count == 16)
        {
            wait(0.05);
        }
        else
        {
            wait(0.04);
        }
    }
}

rgbColor TI_NEOPIXEL_SPI::convertHsvToRgb(float h, float s, float v)
{
    int i = floor(h * 6);
    float f = h * 6 - i;
    float p = v * (1 - s);
    float q = v * (1 - f * s);
    float t = v * (1 - (1 - f) * s);
    float r = 0, g = 0, b = 0;

    switch (i % 6)
    {
    case 0:
        r = v;
        g = t;
        b = p;
        break;
    case 1:
        r = q;
        g = v;
        b = p;
        break;
    case 2:
        r = p;
        g = v;
        b = t;
        break;
    case 3:
        r = p;
        g = q;
        b = v;
        break;
    case 4:
        r = t;
        g = p;
        b = v;
        break;
    case 5:
        r = v;
        g = p;
        b = q;
        break;
    }

    return (rgbColor){r * 255, g * 255, b * 255};
}