NeoPixelBus/ReadMe.md

NeoPixelBus

Arduino NeoPixel library

Clone this into your Arduino\Library folder

This library is a modification of the Adafruit NeoPixel library. The Api is similiar, but it removes the overal brightness feature and adds animation support.

Installing This Library

Create a directory in your Arduino\Library folder named "NeoPixelBus" Clone (Git) this project into that folder.
It should now show up in the import list.

Samples

NeoPixelTest - this is simple example that sets four neopixels to red, green, blue, and then white in order; and then flashes them. If the first pixel is green and the second is red, you need to pass the NEO_RGB flag into the NeoPixelBus constructor. NeoPixelFun - this is a more complex example, that includes code for three effects, and demonstrates animations.

API Documentation

RgbColor object: This represents a color and exposes useful methods to manipulate colors.

RgbColor(uint8_t r, uint8_t g, uint8_t b)

instantiates a RgbColor object with the given r, g, b values.

RgbColor(uint8_t brightness)

instantiates a RgbColor object with the given brightness. 0 is black, 128 is grey, 255 is white.

uint8_t CalculateBrightness()

returns the general brightness of the pixe, averaging color.

void Darken(uint8_t delta)

this will darken the color by the given amount

void Lighten(uint8_t delta)

this will lighten the color by the given amount

static RgbColor LinearBlend(RgbColor left, RgbColor right, uint8_t progress)

this will return a color that is a blend between the given colors.  The amount to blend is given by the value of progress, 0 will return the left value, 255 will return the right value, 128 will return the value between them.
NOTE:  This is not an accurate "visible light" color blend but is fast and in most cases good enough.

NeoPixelBus object: This represents a single NeoPixel Bus that is connected by a single pin. Please see Adafruit's documentation for details, but the differences are documented below.

NeoPixelBus(uint16_t n, uint8_t p = 6, uint8_t t = NEO_GRB | NEO_KHZ800);

instantiates a NewoPixelBus object, with n number of pixels on the bus, over the p pin, using the defined NeoPixel type.
There are some NeoPixels that address the color values differently, so if you set the green color but it displays as red, use the NEO_RGB type flag.

NeoPixelBus strip = NeoPixelBus(4, 8, NEO_GRB | NEO_KHZ800);

It is rare, but some older NeoPixels require a slower communications speed, to include this support you must include the following define before the NeoPixelBus library include and then include the NEO_KHZ400 type flag to enable this slower speed.

#define INCLUDE_NEO_KHZ400_SUPPORT 
#include <NeoPixelBus.h>

NeoPixelBus strip = NeoPixelBus(4, 8, NEO_GRB | NEO_KHZ400);


void SetPixelColor(uint16_t n, RgbColor c)

This allows setting a pixel on the bus to a color as defined by a color object.	If an animation is actively running on a pixel, it will be stopped.


RgbColor GetPixelColor(uint16_t n) const

this allows retrieving the current pixel color


void LinearFadePixelColor(uint16_t time, uint16_t n, RgbColor color)

this will setup an animation for a pixel to linear fade between the current color and the given color over the time given.  The time is in milliseconds.


void StartAnimating()

this method will initialize the animation state.  This should be called only if there are no active animations and new animations are started.  


void UpdateAnimations()

this method will allow the animations to processed and update the pixel color state. 
NOTE:  Show must still be called to push the color state to the physical NeoPixels.


bool IsAnimating() const

this method will return the current animation state.  It will return false if there are no active animations.