led灯带

参考实例：

使用ESP8266和Neopixels营造酷炫的火焰效果：
https://www.yiboard.com/thread-1071-1-1.html

相关库文件

https://github.com/FastLED/FastLED
https://github.com/adafruit/Adafruit_NeoPixel
——库的使用说明：https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use
ws2812文档
http://www.all4lib.com/topic/5155

Arduino DIY：带LED灯的咖啡桌
http://www.icxbk.com/video/detail/415.html

1. Digital RGB LED Weatherproof Strip 60LED/m*3m SKU: FIT0352

https://www.dfrobot.com/wiki/index.php/Digital_RGB_LED_Weatherproof_Strip_60LED/m*3m_SKU:_FIT0352
简介这是一种chip_inside LED灯条，因此您可以单独控制每个LED！每米有60RGB的LED，当你改变它们的颜色时它是如此美妙。而对于LED的控制，它只需要一个3.3V-5V的其他MCU电源的Arduino的数字引脚。每个LED中的芯片名为WS2812，您可以在我们的网站上找到数据表。一旦我们知道您的条带有多长，您就可以轻松获得LED的数量。
技术规格

• 60 LED /米* 3m
• 电源：5V @ 1A / m（可在3.3V至5V工作）对于此条带至少需要5V / 3A，因为它长3m，如果电流不够，颜色可能不正确
• IC名称：WS2812
• 亮度等级数量：256
• Weatherproof contains
  原图：
  
  对比图片：
  
  Sample Code

/*
 This code can be a good test code for your strip
 function: leds.setPixelColor(i,y) can be used to let number i of your led turn on with color of y
 and you can draw your idea easily with this function but never forget function: led.show() 
*/

#include <Adafruit_NeoPixel.h>

#define PIN 6     //The signal pin connected with Arduino    
#define LED_COUNT 180 // the amount of the leds of your strip

// Create an instance of the Adafruit_NeoPixel class called "leds".
// That'll be what we refer to from here on...
Adafruit_NeoPixel leds = Adafruit_NeoPixel(LED_COUNT, PIN, NEO_GRB + NEO_KHZ800);

void setup()
{
  leds.begin();  // Call this to start up the LED strip.
  clearLEDs();   // This function, defined below, turns all LEDs off...
  leds.show();   // ...but the LEDs don't actually update until you call this.
}

void loop()
{
    for (int i=0; i<LED_COUNT; i++)
  {
    rainbow(i);
    delay(50);  // Delay between rainbow slides
  }
}
  

// Sets all LEDs to off, but DOES NOT update the display;
// call leds.show() to actually turn them off after this.
void clearLEDs()
{
  for (int i=0; i<LED_COUNT; i++)
  {
    leds.setPixelColor(i, 0);
  }
}

// Prints a rainbow on the ENTIRE LED strip.
//  The rainbow begins at a specified position. 
// ROY G BIV!
void rainbow(byte startPosition) 
{
  // Need to scale our rainbow. We want a variety of colors, even if there
  // are just 10 or so pixels.
  int rainbowScale = 192 / LED_COUNT;
  
  // Next we setup each pixel with the right color
  for (int i=0; i<LED_COUNT; i++)
  {
    // There are 192 total colors we can get out of the rainbowOrder function.
    // It'll return a color between red->orange->green->...->violet for 0-191.
    leds.setPixelColor(i, rainbowOrder((rainbowScale * (i + startPosition)) % 192));
  }
  // Finally, actually turn the LEDs on:
  leds.show();
}

// Input a value 0 to 191 to get a color value.
// The colors are a transition red->yellow->green->aqua->blue->fuchsia->red...
//  Adapted from Wheel function in the Adafruit_NeoPixel library example sketch
uint32_t rainbowOrder(byte position) 
{
  // 6 total zones of color change:
  if (position < 31)  // Red -> Yellow (Red = FF, blue = 0, green goes 00-FF)
  {
    return leds.Color(0xFF, position * 8, 0);
  }
  else if (position < 63)  // Yellow -> Green (Green = FF, blue = 0, red goes FF->00)
  {
    position -= 31;
    return leds.Color(0xFF - position * 8, 0xFF, 0);
  }
  else if (position < 95)  // Green->Aqua (Green = FF, red = 0, blue goes 00->FF)
  {
    position -= 63;
    return leds.Color(0, 0xFF, position * 8);
  }
  else if (position < 127)  // Aqua->Blue (Blue = FF, red = 0, green goes FF->00)
  {
    position -= 95;
    return leds.Color(0, 0xFF - position * 8, 0xFF);
  }
  else if (position < 159)  // Blue->Fuchsia (Blue = FF, green = 0, red goes 00->FF)
  {
    position -= 127;
    return leds.Color(position * 8, 0, 0xFF);
  }
  else  //160 <position< 191   Fuchsia->Red (Red = FF, green = 0, blue goes FF->00)
  {
    position -= 159;
    return leds.Color(0xFF, 0x00, 0xFF - position * 8);
  }
}

2. 如何使用Arduino控制采用WS2812B可独立寻址的LED灯

https://www.yiboard.com/thread-989-1-1.html

在本篇文章中，我们将学习如何使用Arduino开发板控制可独立寻址的RGB LED灯或基于WS2812B的LED灯条。首先，我们通过一些基本示例阐释其工作原理，然后看一个非常酷的使用这些LED灯的Arduino项目 - DIY交互式LED咖啡桌。咖啡桌带有一颗WS2812B LED灯、用于检测物体的红外接近传感器和用于通过定制的Android应用程序控制颜色的HC-05蓝牙模块。

WS2812B LED灯是如何工作的

让我们首先仔细看看LED灯条。它由5050型RGB LED灯组成，其中集成了非常紧凑的WS2812B LED驱动器IC。

根据三个红色、绿色和蓝色LED的强度，我们可以模拟出我们想要的任何颜色。

使用这些LED灯的优点在于我们只需使用Arduino开发板上的一个引脚即可控制整个LED灯条。每个LED在每端有三个连接器接口，两个用于供电，一个用于数据。箭头表示数据流方向。前一个LED的数据输出焊盘连接到下一个LED的数据输入焊盘。我们可以将灯带切割成我们想要的任何尺寸，也可以使用电线增加LED灯距离。

至于供电，它们工作在5V，每个红色、绿色和蓝色LED需要大约20mA，或者在全亮度下每个LED总共60mA。请注意，当Arduino通过USB供电时，5V引脚只能处理大约400 mA的电流，当使用桶式电源连接器供电时，5V引脚可以处理大约900 mA的电流。因此，如果您使用更多LED并且它们将绘制的电流量超过上述限制，则必须使用单独的5V电源。在这种情况下，您还需要将两条地线彼此连接起来。此外，建议在Arduino和LED灯条数据引脚之间使用大约330欧姆的电阻，以降低该线路上的噪声，以及5V和地线上大约100uF的电容，以平滑电源。

2. 使用WS2812B LED的交互式LED咖啡桌

现在让我们来看看在开始时提到的DIY交互式LED咖啡桌项目。这是我与Creativity Hero的Marija之间的合作项目。
您可以查看她的网站文章，在那里她解释制作桌子的整个过程，从切割和组装木结构，到焊接和连接所有电子部件。在这里，我将解释电子部件如何工作，如何构建自定义Android应用程序和编程Arduino开发板。

以下是该项目的完整电路原理图。

因此，该原理图由45个可寻址LED灯、45个红外接近传感器和一个HC-05蓝牙模块组成，所有这些都连接到Arduino Mega开发板。该电路由5V/6A电源供电。

该示例所需的组件：

● WS2812B LED灯带

● 红外接近传感器

● HC-05蓝牙模块

● Arduino开发板

● 5V 6A直流电源.

以下是该项目的Arduino代码，如果我们排除蓝牙颜色控制功能，可以注意到代码实际上非常简单。

#include "FastLED.h"
#define NUM_LEDS 45
#define LED_PIN 2
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];
void setup() {
  FastLED.addLeds<WS2812, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);
  FastLED.setBrightness(brightness);
  // Set the 45 proximity sensors pins as inputs, from digital pin 3 to pin 48
  for (int pinNo = 0 + 3; pinNo <= 45 + 3; pinNo++) {
    pinMode(pinNo, INPUT);
  }
}
void loop() {
  for (int pinNo = 0; pinNo <= NUM_LEDS-1; pinNo++) {
    leds[pinNo] = CRGB( 0, 255, 0);    // Set all 45 LEDs to green color 
    // If an object is detected on top of the particular sensor, turn on the particular led
    if ( digitalRead(pinNo + 3) == LOW ) {
      leds[pinNo] = CRGB( 0, 0, 255); // Set the reactive LED to bluee
    }
  }
  FastLED.show(); // Update the LEDs
  delay(20);
}

代码描述：如前所述，首先我们需要定义基本参数，然后将45个接近传感器引脚设置为输入。

在使用单个“for”循环的主循环中，我们将所有LED设置为特定颜色，并检查接近传感器是否检测到对象。如果检测到，或者本例中为低逻辑状态，则特定的反应颜色将被设置为特定的LED。最后，使用FastLED.show()函数更新LED颜色。
要包含蓝牙色彩控制功能，我们需要添加更多代码行以及。

制作Android应用程序

以下是Android应用程序的工作原理。它由我们可以拾取颜色的调色板图像、两个检查按钮组成，我们可以从中选择是将所选颜色应用于反应LED还是背景LED，以及用于调整亮度的滑块。

如果我们看看应用程序的块，我们可以看到当我们触摸放置调色板图像的画布时会发生什么。使用.GetPixelColor块我们获取拾取颜色的红色、绿色和蓝色值，并使用蓝牙SendText块我们以文本形式将此信息发送到Arduino。

根据所选复选框，我们会发送不同的第一个字符或标记，这有助于在Arduino上接收文本时。当我们改变滑块的位置时会发生同样的情况，一个从10到100的值以文本形式发送到Arduino，前面带有标记“3”。

以下是Arduino代码：

#include <SoftwareSerial.h>
#include "FastLED.h"
#define NUM_LEDS 45
#define LED_PIN 2
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];
SoftwareSerial Bluetooth(53, 52); // Arduino(RX, TX) - Bluetooth (TX, RX)
// Initial background color 
int backR = 100;
int backG = 50;
int backB = 10;
// Initial reactive color 
int reactiveR = 10;
int reactiveG = 50;
int reactiveB = 100;
int brightness = 50; // Initial brightness
String dataIn = "";
void setup() {
  FastLED.addLeds<WS2812, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);
  FastLED.setBrightness(brightness);
  Serial.begin(38400);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  for (int pinNo = 0 + 3; pinNo <= 45 + 3; pinNo++) {
    pinMode(pinNo, INPUT);
  }
}
void loop() {
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();
    delay(20);
    if (dataIn.startsWith("1")) {
      delay(10);
      String stringR = dataIn.substring(dataIn.indexOf("R") + 1, dataIn.indexOf("G"));
      reactiveR = stringR.toInt();
      String stringG = dataIn.substring(dataIn.indexOf("G") + 1, dataIn.indexOf("B"));
      reactiveG = stringG.toInt();
      String stringB = dataIn.substring(dataIn.indexOf("B") + 1, dataIn.indexOf("E"));
      reactiveB = stringB.toInt();
    }
    else if (dataIn.startsWith("2")) {
      String stringR = dataIn.substring(dataIn.indexOf("R") + 1, dataIn.indexOf("G"));
      backR = stringR.toInt();
      String stringG = dataIn.substring(dataIn.indexOf("G") + 1, dataIn.indexOf("B"));
      backG = stringG.toInt();
      String stringB = dataIn.substring(dataIn.indexOf("B") + 1, dataIn.indexOf("E"));
      backB = stringB.toInt();
    }
    else if (dataIn.startsWith("3")) {
      String stringBrightness = dataIn.substring(dataIn.indexOf("3") + 1, dataIn.length());
      brightness = stringBrightness.toInt();
      FastLED.setBrightness(brightness);
    }
  }
  for (int pinNo = 0; pinNo <= NUM_LEDS-1; pinNo++) {
    leds[pinNo] = CRGB( backR, backG, backB);
    if ( digitalRead(pinNo + 3) == LOW ) {
      leds[pinNo] = CRGB( reactiveR, reactiveG, reactiveB);
    }
  }
  FastLED.show();
  delay(20);
}

代码描述：首先，我们需要定义Arduino开发板和HC-05蓝牙模块之间的串行通信，或模块所连接的引脚。在setup函数部分，我们需要设置此模块工作的波特率。然后在主循环中，使用Bluetooth.available()函数，我们检查是否有来自智能手机的传入数据。如果有，使用Bluetooth.readString()函数我们将数据作为字符串接收。然后使用.startsWith()函数检查第一个字符或标记，以此方式知道我们是否要更改反应颜色、背景或亮度。

使用.substring()函数，我们从接收的文本中提取红色、绿色和蓝色值，并将它们转换为整数。然后在下面的“for”循环中使用这些值，如前所述，它设置颜色并点亮LED。我们以同样的方式调整LED的亮度。

以上就是本教程的全部内容。如果遇到任何问题，请随时在本帖下面进行回复。

4. Adafruit_NeoPixel库的示例

4.1 buttoncycler

// This is a demonstration on how to use an input device to trigger changes on your neo pixels.
// You should wire a momentary push button to connect from ground to a digital IO pin.  When you
// press the button it will change to a new pixel animation.  Note that you need to press the
// button once to start the first animation!

//这是关于如何使用输入设备触发neo像素更改的演示。
//您应该连接一个瞬时按钮，并连接到数字IO引脚。 当你按下按钮，它将变为新的像素动画。
// 请注意，您需要按一次按钮来启动第一个动画！
#include <Adafruit_NeoPixel.h>

#define BUTTON_PIN   2    // Digital IO pin connected to the button.  This will be
// driven with a pull-up resistor（电阻） so the switch should
// pull the pin to ground momentarily（瞬间）.  On a high -> low
// transition（过度） the button press logic will execute.

#define PIXEL_PIN    6    // Digital IO pin connected to the NeoPixels.

#define PIXEL_COUNT 16

// Parameter 1 = number of pixels in strip（条、带）,  neopixel stick has 8
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_RGB     Pixels（像素） are wired for RGB bitstream（比特流）
//   NEO_GRB     Pixels are wired for GRB bitstream, correct for neopixel stick
//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)
//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool oldState = HIGH;
int showType = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // Get current button state.
  bool newState = digitalRead(BUTTON_PIN);

  // Check if state changed from high to low (button press).
  if (newState == LOW && oldState == HIGH) {
    // Short delay to debounce button.
    delay(20);
    // Check if button is still low after debounce.
    newState = digitalRead(BUTTON_PIN);
    if (newState == LOW) {
      showType++;
      if (showType > 9)
        showType = 0;
      startShow(showType);
    }
  }

  // Set the last button state to the old state.
  oldState = newState;
}

void startShow(int i) {
  switch (i) {
    case 0: colorWipe(strip.Color(0, 0, 0), 50);    // Black/off
      break;
    case 1: colorWipe(strip.Color(255, 0, 0), 50);  // Red
      break;
    case 2: colorWipe(strip.Color(0, 255, 0), 50);  // Green
      break;
    case 3: colorWipe(strip.Color(0, 0, 255), 50);  // Blue
      break;
    case 4: theaterChase(strip.Color(127, 127, 127), 50); // White
      break;
    case 5: theaterChase(strip.Color(127,   0,   0), 50); // Red
      break;
    case 6: theaterChase(strip.Color(  0,   0, 127), 50); // Blue
      break;
    case 7: rainbow(20);
      break;
    case 8: rainbowCycle(20);
      break;
    case 9: theaterChaseRainbow(50);
      break;
  }
}

// Fill the dots one after the other with a color
//用颜色一个接一个地填充
void colorWipe(uint32_t c, uint8_t wait) {
  for (uint16_t i = 0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for (j = 0; j < 256; j++) {
    for (i = 0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
//略有不同，这使得彩虹在整个过程中均匀分布
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for (j = 0; j < 256 * 5; j++) { // 5 cycles of all colors on wheel
    for (i = 0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

//Theatre-style crawling lights.剧院式爬行灯。
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j = 0; j < 10; j++) { //do 10 cycles of chasing
    for (int q = 0; q < 3; q++) {
      for (int i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, c);  //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, 0);      //turn every third pixel off
      }
    }
  }
}

//Theatre-style crawling lights with rainbow effect. 带有彩虹效果的剧院式爬行灯。
void theaterChaseRainbow(uint8_t wait) {
  for (int j = 0; j < 256; j++) {   // cycle all 256 colors in the wheel
    for (int q = 0; q < 3; q++) {
      for (int i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, Wheel( (i + j) % 255)); //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, 0);      //turn every third pixel off
      }
    }
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition（过渡） r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if (WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

AAdafruit_NeoPixel库使用

https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use
此时假设您已安装Arduino的Adafruit_NeoPixel库并成功运行了strandtest示例草图。 如果没有，请返回上一页以获取并设置(如何在arduino中添加库。
要了解如何编写自己的NeoPixel草图，让我们首先剖析最好的草图 …
所有NeoPixel草图都首先包含头文件：

1.	#include <Adafruit_NeoPixel.h> 

下面的代码块主要是描述性注释。只有最后一行才真正做任何工作：

      #define PIN 6
 
//参数1 =条带中的像素数
//参数2 =引脚号(大多数有效)
//参数3 =像素类型标志，根据需要加在一起：
// NEO_KHZ800 800 KHz比特流(大多数NeoPixel产品带WS2812 LED)
// NEO_KHZ400 400 KHz(经典'v1'(非v2)FLORA像素，WS2811驱动程序)
// NEO_GRB像素用于GRB比特流(大多数NeoPixel产品)
// NEO_RGB像素连接RGB比特流(v1 FLORA像素，而不是v2)
Adafruit_NeoPixel strip = Adafruit_NeoPixel (60 ，PIN ，NEO_GRB + NEO_KHZ800 ); 

第一行为符号“PIN”分配一个数字供以后参考。它不需要以这种方式完成，但可以更容易地更改NeoPixels所连接的引脚，而无需深入挖掘代码。

最后一行声明了一个NeoPixel 对象。我们稍后会通过名称来引用它来控制led灯带。括号中有三个参数或参数：

1. 条带中连续NeoPixel的数量。在该示例中，这被设置为60，等于1米的中密度条带。更改此项以匹配您正在使用的实际数字。
2. NeoPixel条带(或其他设备)所连接的引脚编号。通常这是一个数字，但我们之前声明符号PIN在这里按名称引用它。
3. 一个值，指示已连接的NeoPixels的类型。在大多数情况下，您可以将其关闭并仅传递两个参数; 示例代码只是额外的描述性。如果您有经典的“V1”Flora led，那么需要NEO_KHZ400 + NEO_RGB才能在这里传递。

对于通孔8mm NeoPixels，在条带声明中使用NEO_RGB而不是NEO_GRB。对于RGBW LED，使用NEO_RGBW(一些RGBW条带使用NEO_GRBW，所以如果你得到意想不到的结果，试试吧！)
然后，在setup()函数中，调用begin()为NeoPixel输出准备数据引脚：

1.	void setup (){ 
2.	  strip.begin();
3.	  Strip.show(); //将所有像素初始化为“关闭” 
4.	}

第二行，strip.show()，并非绝对必要，它只是在那里彻底关闭灯带。该函数将数据推出到LED灯…由于尚未设置任何颜色，因此如果某些被先前事件的程序点亮，则将所有NeoPixel初始化为初始“关闭”状态。
在strandtest示例中，loop()不会自行设置任何像素颜色 - 它会调用其他创建动画效果的函数。因此，让我们暂时忽略它并继续，并在各个函数内了解条带是如何被控制的。

有两种方法可以设置像素的颜色。首先是：

strip.setPixelColor (n ，红色，绿色，蓝色);

或者，如果您使用的是RGBW条带：

strip.setPixelColor (n ，红色，绿色，蓝色，白色);

第一个参数 - 在本例中为n - 是沿着条带的led数，从最接近Arduino的0开始。如果你有一个30像素的条带，它们的编号为0到29.这是一个计算机的事情。您将在代码中看到使用for循环的各个位置，将循环计数器变量作为led数传递给此函数，以设置多个led的值。

接下来的三个参数是led颜色，表示为红色，绿色和蓝色亮度级别，其中0表示最暗(关闭)，255表示最大亮度。最后一个可选参数是白色，只有在创建过程中将条带定义为RGBW类型并且条带实际上是RGBW类型时才会使用该参数。

要设置第12个led(＃11，从0开始计数)到品红色(红色+蓝色)，您可以写：

     strip.setPixelColor (11 ，255 ，0 ，255 );   

将第8个led(＃7从0开始计数)设置为半亮度白色，没有红色/绿色/蓝色光，使用：

strip.setPixelColor (7 ，0 ，0 ，0 ，127 );    

另一种语法只有两个参数：

strip.setPixelColor (n ，color );

这里，color是一种32位类型，它将红色，绿色和蓝色值合并为一个数字。对于某些(但不是所有)程序来说，这有时更容易或更快; 你会看到strandtest代码在不同的地方使用这两种语法。

您还可以将单独的红色，绿色和蓝色值转换为单个32位类型以供以后使用：

      uint32_t magenta = strip.color(255 ，0 ，255 );  

然后您可以将“magenta”作为参数传递给setPixelColor，而不是每次都使用单独的红色，绿色和蓝色数字。
您也可以(可选)在末尾为颜色添加白色组件，如下所示：

uint32_t greenishwhite = strip.color(0 ，64 ，0 ，64);   

setPixelColor()对LED没有立竿见影的效果。要将颜色数据“推”到条带，请调用show()：

strip.show();

这会立即更新整个条带，尽管额外的步骤实际上是一件好事。如果对setPixelColor()的每次调用都立即生效，那么动画就会显得跳跃而不是黄油般平滑。
您可以使用getPixelColor()查询以前设置的像素的颜色：

uint32_t color = strip.getPixelColor (11 );

这将返回32位合并的颜色值。
可以使用numPixels()查询先前声明的条带中的led数：

1.	uint16_t n = strip.numPixels ();

可以使用setBrightness()调整所有LED的整体亮度。这需要一个参数，一个在0(关闭)到255(最大亮度)范围内的数字。例如，要将条带设置为1/4亮度：

strip.setBrightness (64 );

就像setPixel()一样，这不会立即生效。您需要通过调用show()来执行此操作。
setBrightness()旨在在setup()中调用一次，以在草图的整个生命周期内限制LED的当前/亮度。它本身不是动画效果！该函数的操作是“有损” - 它修改了RAM中的当前像素数据，而不是show()调用 - 以满足NeoPixels的严格时序要求。通过单独保留亮度设置，在您自己的草图逻辑中调整像素亮度并使用setPixel()重绘整个条带，可以更好地实现某些动画效果。
我正在调用setPixel()但没有发生任何事情！
这有两个主要原因：

1. 忘了在setup()中调用strip.begin ()。
2. 忘记在设置led颜色后调用strip.show()。
   另一种(不常见的)可能性是RAM耗尽 - 请参阅下面的最后一节。如果程序之类的工作，但具有不可预知的结果，考虑这一点。
   我可以在不同的引脚上有多个NeoPixel对象吗？
   当然！每个都需要具有唯一名称的声明：

1.	Adafruit_NeoPixel strip_a = Adafruit_NeoPixel (16 ，5 );  
2.	Adafruit_NeoPixel strip_b = Adafruit_NeoPixel (16 ，6 );  

上面声明了两个截然不同的NeoPixel对象，分别位于引脚5和6上，每个对象包含16个像素，并使用隐含的默认类型(NEO_KHZ800 + NEO_GRB)。
我可以将多个NeoPixel条连接到同一个Arduino引脚吗？
在许多情况下，是的。然后所有条带将显示完全相同的东西。这只能达到一定程度…单个引脚上的四个条带是一个好的和可靠的数字。如果您需要更多，可以使用单独的NeoPixels作为缓冲区“扇出”到更多条带：将一个Arduino引脚连接到四个独立NeoPixel的输入，然后将每个led的输出连接到四个条带的输入(或更少) ，如果你不需要那么多)。如果条带长度为10像素，则将NeoPixel对象声明为11像素。额外的“缓冲”像素将位于＃0位置 - 只需将它们关闭 - 然后条带从位置1到10运行。
我的颜色错了。红色和蓝色交换！
使用通孔8mm NeoPixels(或V1 Flora像素)时，请使用NEO_RGB作为Adafruit_NeoPixel声明中的第三个参数。对于所有其他类型的NeoPixels，请使用NEO_GRB。
我多次使用setBrightness()时颜色会崩溃！
见上面的注释; setBrightness()被设计为一次性设置功能，而不是动画效果。
另请参阅“高级编码”页面 - 还有一个替代库，其中包括“非破坏性”亮度调整等功能！
像素狼吞虎咽的消耗RAM
每个NeoPixel需要大约3个字节的RAM。这听起来不是很多，但是当你开始使用几十甚至几百个像素时，并认为主流的Arduino Uno只有2千字节的RAM(通常在其他图书馆提出索赔之后要少得多)，这可能是一个真正的问题！

对于使用大量LED，您可能需要升级到更强大的电路板，如Arduino Mega或Due。但是如果你很接近并且只需要一点额外的空间，你有时可以调整代码以提高RAM的效率。本教程对内存使用情况有一些指示。