feedc0de/NeoPixelBus
1
0
Fork 0
forked from Makuna/NeoPixelBus
Code Pull Requests Activity

Update ReadMe.md

Browse Source 
Cleanup API section
This commit is contained in:
Michael Miller
2014-12-15 19:28:41 -08:00
parent be5dc5021a
commit e287cc9bea
1 changed files with 58 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
ReadMe.md
View File

@@ -1,5 +1,5 @@
NeoPixelBus
====
# NeoPixelBus
Arduino NeoPixel library
Clone this into your Arduino\Library folder
@@ -7,89 +7,75 @@ 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
------------------------
## 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.
## 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
-----------------
## API Documentation
RgbColor object:
### RgbColor object
This represents a color and exposes useful methods to manipulate colors.
<pre><code>
RgbColor(uint8_t r, uint8_t g, uint8_t b)
</code></pre>
instantiates a RgbColor object with the given r, g, b values.
<pre><code>
RgbColor(uint8_t brightness)
</code></pre>
instantiates a RgbColor object with the given brightness. 0 is black, 128 is grey, 255 is white.
<pre><code>
uint8_t CalculateBrightness()
</code></pre>
returns the general brightness of the pixe, averaging color.
<pre><code>
void Darken(uint8_t delta)
</code></pre>
this will darken the color by the given amount
<pre><code>
void Lighten(uint8_t delta)
</code></pre>
this will lighten the color by the given amount
<pre><code>
static RgbColor LinearBlend(RgbColor left, RgbColor right, uint8_t progress)
</code></pre>
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:
#### 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.
<pre><code>
NeoPixelBus(uint16_t n, uint8_t p = 6, uint8_t t = NEO_GRB | NEO_KHZ800);
<pre><code>
#### 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.
<pre><code>
NeoPixelBus strip = NeoPixelBus(4, 8, NEO_GRB | NEO_KHZ800);
</code></pre>
#### NeoPixelBus strip = NeoPixelBus(4, 8, NEO_RGB | 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.
<pre><code>
```
#define INCLUDE_NEO_KHZ400_SUPPORT
#include &lt;NeoPixelBus.h&gt;
#include <NeoPixelBus.h>
NeoPixelBus strip = NeoPixelBus(4, 8, NEO_GRB | NEO_KHZ400);
</code></pre>
NeoPixelBus strip = NeoPixelBus(4, 8, NEO_RGB | NEO_KHZ400);
```
<pre><code>
void SetPixelColor(uint16_t n, RgbColor c)
</code></pre>
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.
<pre><code>
RgbColor GetPixelColor(uint16_t n) const
</code></pre>
this allows retrieving the current pixel color
<pre><code>
void LinearFadePixelColor(uint16_t time, uint16_t n, RgbColor color)
</code></pre>
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.
<pre><code>
void StartAnimating()
</code></pre>
this method will initialize the animation state. This should be called only if there are no active animations and new animations are started.
<pre><code>
void UpdateAnimations()
</code></pre>
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.
<pre><code>
bool IsAnimating() const
</code></pre>
this method will return the current animation state. It will return false if there are no active animations.
#### 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 be 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.