Adafruit NeoPixel
Adafruit_NeoPixel.h
Go to the documentation of this file.
1 
36 #ifndef ADAFRUIT_NEOPIXEL_H
37 #define ADAFRUIT_NEOPIXEL_H
38 
39 #ifdef ARDUINO
40  #if (ARDUINO >= 100)
41  #include <Arduino.h>
42  #else
43  #include <WProgram.h>
44  #include <pins_arduino.h>
45  #endif
46 #endif
47 
48 #ifdef TARGET_LPC1768
49  #include <Arduino.h>
50 #endif
51 
52 // The order of primary colors in the NeoPixel data stream can vary among
53 // device types, manufacturers and even different revisions of the same
54 // item. The third parameter to the Adafruit_NeoPixel constructor encodes
55 // the per-pixel byte offsets of the red, green and blue primaries (plus
56 // white, if present) in the data stream -- the following #defines provide
57 // an easier-to-use named version for each permutation. e.g. NEO_GRB
58 // indicates a NeoPixel-compatible device expecting three bytes per pixel,
59 // with the first byte transmitted containing the green value, second
60 // containing red and third containing blue. The in-memory representation
61 // of a chain of NeoPixels is the same as the data-stream order; no
62 // re-ordering of bytes is required when issuing data to the chain.
63 // Most of these values won't exist in real-world devices, but it's done
64 // this way so we're ready for it (also, if using the WS2811 driver IC,
65 // one might have their pixels set up in any weird permutation).
66 
67 // Bits 5,4 of this value are the offset (0-3) from the first byte of a
68 // pixel to the location of the red color byte. Bits 3,2 are the green
69 // offset and 1,0 are the blue offset. If it is an RGBW-type device
70 // (supporting a white primary in addition to R,G,B), bits 7,6 are the
71 // offset to the white byte...otherwise, bits 7,6 are set to the same value
72 // as 5,4 (red) to indicate an RGB (not RGBW) device.
73 // i.e. binary representation:
74 // 0bWWRRGGBB for RGBW devices
75 // 0bRRRRGGBB for RGB
76 
77 // RGB NeoPixel permutations; white and red offsets are always same
78 // Offset: W R G B
79 #define NEO_RGB ((0<<6) | (0<<4) | (1<<2) | (2))
80 #define NEO_RBG ((0<<6) | (0<<4) | (2<<2) | (1))
81 #define NEO_GRB ((1<<6) | (1<<4) | (0<<2) | (2))
82 #define NEO_GBR ((2<<6) | (2<<4) | (0<<2) | (1))
83 #define NEO_BRG ((1<<6) | (1<<4) | (2<<2) | (0))
84 #define NEO_BGR ((2<<6) | (2<<4) | (1<<2) | (0))
85 
86 // RGBW NeoPixel permutations; all 4 offsets are distinct
87 // Offset: W R G B
88 #define NEO_WRGB ((0<<6) | (1<<4) | (2<<2) | (3))
89 #define NEO_WRBG ((0<<6) | (1<<4) | (3<<2) | (2))
90 #define NEO_WGRB ((0<<6) | (2<<4) | (1<<2) | (3))
91 #define NEO_WGBR ((0<<6) | (3<<4) | (1<<2) | (2))
92 #define NEO_WBRG ((0<<6) | (2<<4) | (3<<2) | (1))
93 #define NEO_WBGR ((0<<6) | (3<<4) | (2<<2) | (1))
94 
95 #define NEO_RWGB ((1<<6) | (0<<4) | (2<<2) | (3))
96 #define NEO_RWBG ((1<<6) | (0<<4) | (3<<2) | (2))
97 #define NEO_RGWB ((2<<6) | (0<<4) | (1<<2) | (3))
98 #define NEO_RGBW ((3<<6) | (0<<4) | (1<<2) | (2))
99 #define NEO_RBWG ((2<<6) | (0<<4) | (3<<2) | (1))
100 #define NEO_RBGW ((3<<6) | (0<<4) | (2<<2) | (1))
101 
102 #define NEO_GWRB ((1<<6) | (2<<4) | (0<<2) | (3))
103 #define NEO_GWBR ((1<<6) | (3<<4) | (0<<2) | (2))
104 #define NEO_GRWB ((2<<6) | (1<<4) | (0<<2) | (3))
105 #define NEO_GRBW ((3<<6) | (1<<4) | (0<<2) | (2))
106 #define NEO_GBWR ((2<<6) | (3<<4) | (0<<2) | (1))
107 #define NEO_GBRW ((3<<6) | (2<<4) | (0<<2) | (1))
108 
109 #define NEO_BWRG ((1<<6) | (2<<4) | (3<<2) | (0))
110 #define NEO_BWGR ((1<<6) | (3<<4) | (2<<2) | (0))
111 #define NEO_BRWG ((2<<6) | (1<<4) | (3<<2) | (0))
112 #define NEO_BRGW ((3<<6) | (1<<4) | (2<<2) | (0))
113 #define NEO_BGWR ((2<<6) | (3<<4) | (1<<2) | (0))
114 #define NEO_BGRW ((3<<6) | (2<<4) | (1<<2) | (0))
115 
116 // Add NEO_KHZ400 to the color order value to indicate a 400 KHz device.
117 // All but the earliest v1 NeoPixels expect an 800 KHz data stream, this is
118 // the default if unspecified. Because flash space is very limited on ATtiny
119 // devices (e.g. Trinket, Gemma), v1 NeoPixels aren't handled by default on
120 // those chips, though it can be enabled by removing the ifndef/endif below,
121 // but code will be bigger. Conversely, can disable the NEO_KHZ400 line on
122 // other MCUs to remove v1 support and save a little space.
123 
124 #define NEO_KHZ800 0x0000
125 #ifndef __AVR_ATtiny85__
126 #define NEO_KHZ400 0x0100
127 #endif
128 
129 // If 400 KHz support is enabled, the third parameter to the constructor
130 // requires a 16-bit value (in order to select 400 vs 800 KHz speed).
131 // If only 800 KHz is enabled (as is default on ATtiny), an 8-bit value
132 // is sufficient to encode pixel color order, saving some space.
133 
134 #ifdef NEO_KHZ400
135 typedef uint16_t neoPixelType;
136 #else
137 typedef uint8_t neoPixelType;
138 #endif
139 
140 // These two tables are declared outside the Adafruit_NeoPixel class
141 // because some boards may require oldschool compilers that don't
142 // handle the C++11 constexpr keyword.
143 
144 /* A PROGMEM (flash mem) table containing 8-bit unsigned sine wave (0-255).
145  Copy & paste this snippet into a Python REPL to regenerate:
146 import math
147 for x in range(256):
148  print("{:3},".format(int((math.sin(x/128.0*math.pi)+1.0)*127.5+0.5))),
149  if x&15 == 15: print
150 */
151 static const uint8_t PROGMEM _NeoPixelSineTable[256] = {
152  128,131,134,137,140,143,146,149,152,155,158,162,165,167,170,173,
153  176,179,182,185,188,190,193,196,198,201,203,206,208,211,213,215,
154  218,220,222,224,226,228,230,232,234,235,237,238,240,241,243,244,
155  245,246,248,249,250,250,251,252,253,253,254,254,254,255,255,255,
156  255,255,255,255,254,254,254,253,253,252,251,250,250,249,248,246,
157  245,244,243,241,240,238,237,235,234,232,230,228,226,224,222,220,
158  218,215,213,211,208,206,203,201,198,196,193,190,188,185,182,179,
159  176,173,170,167,165,162,158,155,152,149,146,143,140,137,134,131,
160  128,124,121,118,115,112,109,106,103,100, 97, 93, 90, 88, 85, 82,
161  79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40,
162  37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11,
163  10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0,
164  0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9,
165  10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35,
166  37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76,
167  79, 82, 85, 88, 90, 93, 97,100,103,106,109,112,115,118,121,124};
168 
169 /* Similar to above, but for an 8-bit gamma-correction table.
170  Copy & paste this snippet into a Python REPL to regenerate:
171 import math
172 gamma=2.6
173 for x in range(256):
174  print("{:3},".format(int(math.pow((x)/255.0,gamma)*255.0+0.5))),
175  if x&15 == 15: print
176 */
177 static const uint8_t PROGMEM _NeoPixelGammaTable[256] = {
178  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
179  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
180  1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
181  3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7,
182  7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12,
183  13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20,
184  20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29,
185  30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42,
186  42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
187  58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 75,
188  76, 77, 78, 80, 81, 82, 84, 85, 86, 88, 89, 90, 92, 93, 94, 96,
189  97, 99,100,102,103,105,106,108,109,111,112,114,115,117,119,120,
190  122,124,125,127,129,130,132,134,136,137,139,141,143,145,146,148,
191  150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,
192  182,184,186,188,191,193,195,197,199,202,204,206,209,211,213,215,
193  218,220,223,225,227,230,232,235,237,240,242,245,247,250,252,255};
194 
200 
201  public:
202 
203  // Constructor: number of LEDs, pin number, LED type
204  Adafruit_NeoPixel(uint16_t n, uint16_t pin=6,
206  Adafruit_NeoPixel(void);
208 
209  void begin(void);
210  void show(void);
211  void setPin(uint16_t p);
212  void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
213  void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b,
214  uint8_t w);
215  void setPixelColor(uint16_t n, uint32_t c);
216  void fill(uint32_t c=0, uint16_t first=0, uint16_t count=0);
217  void setBrightness(uint8_t);
218  void clear(void);
219  void updateLength(uint16_t n);
220  void updateType(neoPixelType t);
234  bool canShow(void) const { return (micros()-endTime) >= 300L; }
249  uint8_t *getPixels(void) const { return pixels; };
250  uint8_t getBrightness(void) const;
255  int16_t getPin(void) const { return pin; };
260  uint16_t numPixels(void) const { return numLEDs; }
261  uint32_t getPixelColor(uint16_t n) const;
274  static uint8_t sine8(uint8_t x) {
275  return pgm_read_byte(&_NeoPixelSineTable[x]); // 0-255 in, 0-255 out
276  }
288  static uint8_t gamma8(uint8_t x) {
289  return pgm_read_byte(&_NeoPixelGammaTable[x]); // 0-255 in, 0-255 out
290  }
302  static uint32_t Color(uint8_t r, uint8_t g, uint8_t b) {
303  return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
304  }
317  static uint32_t Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
318  return ((uint32_t)w << 24) | ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
319  }
320  static uint32_t ColorHSV(uint16_t hue, uint8_t sat=255, uint8_t val=255);
333  static uint32_t gamma32(uint32_t x);
334 
335  protected:
336 
337 #ifdef NEO_KHZ400 // If 400 KHz NeoPixel support enabled...
338  bool is800KHz;
339 #endif
340  bool begun;
341  uint16_t numLEDs;
342  uint16_t numBytes;
343  int16_t pin;
344  uint8_t brightness;
345  uint8_t *pixels;
346  uint8_t rOffset;
347  uint8_t gOffset;
348  uint8_t bOffset;
349  uint8_t wOffset;
350  uint32_t endTime;
351 #ifdef __AVR__
352  volatile uint8_t *port;
353  uint8_t pinMask;
354 #endif
355 #if defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_ARDUINO_CORE_STM32)
356  GPIO_TypeDef *gpioPort;
357  uint32_t gpioPin;
358 #endif
359 };
360 
361 #endif // ADAFRUIT_NEOPIXEL_H
#define NEO_GRB
Transmit as G,R,B.
Definition: Adafruit_NeoPixel.h:81
void fill(uint32_t c=0, uint16_t first=0, uint16_t count=0)
Fill all or part of the NeoPixel strip with a color.
Definition: Adafruit_NeoPixel.cpp:2340
uint16_t numBytes
Size of &#39;pixels&#39; buffer below.
Definition: Adafruit_NeoPixel.h:342
uint16_t numLEDs
Number of RGB LEDs in strip.
Definition: Adafruit_NeoPixel.h:341
void updateLength(uint16_t n)
Change the length of a previously-declared Adafruit_NeoPixel strip object. Old data is deallocated an...
Definition: Adafruit_NeoPixel.cpp:126
Class that stores state and functions for interacting with Adafruit NeoPixels and compatible devices...
Definition: Adafruit_NeoPixel.h:199
uint8_t gOffset
Index of green byte.
Definition: Adafruit_NeoPixel.h:347
int16_t pin
Output pin number (-1 if not yet set)
Definition: Adafruit_NeoPixel.h:343
int16_t getPin(void) const
Retrieve the pin number used for NeoPixel data output.
Definition: Adafruit_NeoPixel.h:255
uint8_t brightness
Strip brightness 0-255 (stored as +1)
Definition: Adafruit_NeoPixel.h:344
uint16_t neoPixelType
3rd arg to Adafruit_NeoPixel constructor
Definition: Adafruit_NeoPixel.h:135
void show(void)
Transmit pixel data in RAM to NeoPixels.
Definition: Adafruit_NeoPixel.cpp:195
uint32_t endTime
Latch timing reference.
Definition: Adafruit_NeoPixel.h:350
bool is800KHz
true if 800 KHz pixels
Definition: Adafruit_NeoPixel.h:338
void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b)
Set a pixel&#39;s color using separate red, green and blue components. If using RGBW pixels, white will be set to 0.
Definition: Adafruit_NeoPixel.cpp:2243
void setPin(uint16_t p)
Set/change the NeoPixel output pin number. Previous pin, if any, is set to INPUT and the new pin is s...
Definition: Adafruit_NeoPixel.cpp:2218
bool begun
true if begin() previously called
Definition: Adafruit_NeoPixel.h:340
uint8_t bOffset
Index of blue byte.
Definition: Adafruit_NeoPixel.h:348
bool canShow(void) const
Check whether a call to show() will start sending data immediately or will &#39;block&#39; for a required int...
Definition: Adafruit_NeoPixel.h:234
uint8_t wOffset
Index of white (==rOffset if no white)
Definition: Adafruit_NeoPixel.h:349
static uint32_t Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w)
Convert separate red, green, blue and white values into a single "packed" 32-bit WRGB color...
Definition: Adafruit_NeoPixel.h:317
static uint32_t gamma32(uint32_t x)
A gamma-correction function for 32-bit packed RGB or WRGB colors. Makes color transitions appear more...
Definition: Adafruit_NeoPixel.cpp:2577
void clear(void)
Fill the whole NeoPixel strip with 0 / black / off.
Definition: Adafruit_NeoPixel.cpp:2571
static uint32_t ColorHSV(uint16_t hue, uint8_t sat=255, uint8_t val=255)
Convert hue, saturation and value into a packed 32-bit RGB color that can be passed to setPixelColor(...
Definition: Adafruit_NeoPixel.cpp:2385
uint8_t * pixels
Holds LED color values (3 or 4 bytes each)
Definition: Adafruit_NeoPixel.h:345
uint32_t getPixelColor(uint16_t n) const
Query the color of a previously-set pixel.
Definition: Adafruit_NeoPixel.cpp:2472
void updateType(neoPixelType t)
Change the pixel format of a previously-declared Adafruit_NeoPixel strip object. If format changes fr...
Definition: Adafruit_NeoPixel.cpp:156
void begin(void)
Configure NeoPixel pin for output.
Definition: Adafruit_NeoPixel.cpp:108
uint8_t * getPixels(void) const
Get a pointer directly to the NeoPixel data buffer in RAM. Pixel data is stored in a device-native fo...
Definition: Adafruit_NeoPixel.h:249
uint16_t numPixels(void) const
Return the number of pixels in an Adafruit_NeoPixel strip object.
Definition: Adafruit_NeoPixel.h:260
uint8_t rOffset
Red index within each 3- or 4-byte pixel.
Definition: Adafruit_NeoPixel.h:346
static uint32_t Color(uint8_t r, uint8_t g, uint8_t b)
Convert separate red, green and blue values into a single "packed" 32-bit RGB color.
Definition: Adafruit_NeoPixel.h:302
void setBrightness(uint8_t)
Adjust output brightness. Does not immediately affect what&#39;s currently displayed on the LEDs...
Definition: Adafruit_NeoPixel.cpp:2526
static uint8_t sine8(uint8_t x)
An 8-bit integer sine wave function, not directly compatible with standard trigonometric units like r...
Definition: Adafruit_NeoPixel.h:274
static uint8_t gamma8(uint8_t x)
An 8-bit gamma-correction function for basic pixel brightness adjustment. Makes color transitions app...
Definition: Adafruit_NeoPixel.h:288
~Adafruit_NeoPixel()
Deallocate Adafruit_NeoPixel object, set data pin back to INPUT.
Definition: Adafruit_NeoPixel.cpp:100
#define NEO_KHZ800
800 KHz data transmission
Definition: Adafruit_NeoPixel.h:124
Adafruit_NeoPixel(void)
"Empty" NeoPixel constructor when length, pin and/or pixel type are not known at compile-time, and must be initialized later with updateType(), updateLength() and setPin().
Definition: Adafruit_NeoPixel.cpp:89
uint8_t getBrightness(void) const
Retrieve the last-set brightness value for the strip.
Definition: Adafruit_NeoPixel.cpp:2564