【雕爷学编程】Arduino动手做（200）---WS2812B幻彩LED灯带6

37款传感器与模块的提法，在网络上广泛流传，其实Arduino能够兼容的传感器模块肯定是不止37种的。鉴于本人手头积累了一些传感器和执行器模块，依照实践出真知（一定要动手做）的理念，以学习和交流为目的，这里准备逐一动手试试多做实验，不管成功与否，都会记录下来——小小的进步或是搞不掂的问题，希望能够抛砖引玉。

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）
实验二百：WS2812B幻彩LED灯带 5V全彩灯条5050灯珠内置IC炫彩 单点单控软灯条模块

知识点：WS2812B
是一个集控制电路与发光电路于一体的智能外控LED光源。其外型与一个5050LED灯珠相同，每个元件即为一个像素点。像素点内部包含了智能数字接口数据锁存信号整形放大驱动电路，还包含有高精度的内部振荡器和12V高压可编程定电流控制部分，有效保证了像素点光的颜色高度一致。数据协议采用单线归零码的通讯方式，像素点在上电复位以后，DIN端接受从控制器传输过来的数据，首先送过来的24bit数据被第一个像素点提取后，送到像素点内部的数据锁存器，剩余的数据经过内部整形处理电路整形放大后通过DO端口开始转发输出给下一个级联的像素点，每经过一个像素点的传输，信号减少24bit。像素点采用自动整形转发技术，使得该像素点的级联个数不受信号传送的限制，仅仅受限信号传输速度要求。

主要特点
1、智能反接保护，电源反接不会损坏IC。
2、IC控制电路与LED点光源公用一个电源。
3、控制电路与RGB芯片集成在一个5050封装的元器件中，构成一个完整的外控像素点。
4、内置信号整形电路，任何一个像素点收到信号后经过波形整形再输出，保证线路波形畸变不会累加。
5、内置上电复位和掉电复位电路。
6、每个像素点的三基色颜色可实现256级亮度显示，完成16777216种颜色的全真色彩显示，扫描频率不低于400Hz/s。
7、串行级联接口，能通过一根信号线完成数据的接收与解码。
8、任意两点传传输距离在不超过5米时无需增加任何电路。
9、当刷新速率30帧/秒时，级联数不小于1024点。
10、数据发送速度可达800Kbps。
11、光的颜色高度一致，性价比高。

应用领域
具有低电压驱动，环保节能，亮度高，散射角度大，一致性好，超低功率，超长寿命等优点。将控制电路集成于LED上面，电路变得更加简单，体积小，安装更加简便。主要应用领域，LED全彩发光字灯串，LED全彩模组， LED全彩软灯条硬灯条，LED护栏管。LED点光源，LED像素屏，LED异形屏，各种电子产品，电器设备跑马灯等。

Arduino实验接线示意图

测试环境中可以直接使用Arduino的5V引脚直接供电，如果灯带长度过长，则需要外接电源。下为实验接线示意图。

实验提示
1、可以在电源到地之间连接一个电容在 100uF 到 1000uF 之间的电容器，以平滑电源。
2、在 Arduino 数字输出引脚和条形数据输入引脚之间添加一个 220 或 470 Ohm 电阻器，以减少该线路上的噪声。
3、使arduino，电源和条带之间的电线尽可能短，以最大程度地减少电压损失。
4、如果您的灯条损坏且无法正常工作，请检查第一个 LED 是否损坏。如果是这样，剪掉它，重新焊接头针，它应该会再次工作。
5、WS2812 需要 5v 电源，每个 LED 在其全亮度下需要大约 60mA 电流。如果您的 LED 灯条有 30 个 LED，您需要 60mA x 30 = 1800 mA 或 1.8 Amp 电流。因此，您必须使用额定电流为 1.8 安培或更高的 5v 电源。

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）
实验二百一十六：WS2812B幻彩LED灯带 5V全彩灯条5050灯珠内置IC炫彩单点单控软灯条模块
实验程序十六：太平洋——‎‎温柔的蓝绿色海浪

Arduino实验开源代码

/*【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）实验二百一十六：WS2812B幻彩LED灯带 5V全彩灯条5050灯珠内置IC炫彩单点单控软灯条模块实验程序十六：太平洋——‎‎温柔的蓝绿色海浪
*/#define FASTLED_ALLOW_INTERRUPTS 0
#include <FastLED.h>
FASTLED_USING_NAMESPACE#define DATA_PIN            6
#define NUM_LEDS            24
#define MAX_POWER_MILLIAMPS 500
#define LED_TYPE            WS2812B
#define COLOR_ORDER         GRB//CRGB leds[NUM_LEDS];void setup() {delay( 3000); // 3 second delay for boot recovery, and a moment of silenceFastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );FastLED.setMaxPowerInVoltsAndMilliamps( 5, MAX_POWER_MILLIAMPS);
}void loop(){EVERY_N_MILLISECONDS( 20) {pacifica_loop();FastLED.show();}
}//
//
// The code for this animation is more complicated than other examples, and 
// while it is "ready to run", and documented in general, it is probably not 
// the best starting point for learning.  Nevertheless, it does illustrate some
// useful techniques.
//
//
//
// In this animation, there are four "layers" of waves of light.  
//
// Each layer moves independently, and each is scaled separately.
//
// All four wave layers are added together on top of each other, and then 
// another filter is applied that adds "whitecaps" of brightness where the 
// waves line up with each other more.  Finally, another pass is taken
// over the led array to 'deepen' (dim) the blues and greens.
//
// The speed and scale and motion each layer varies slowly within independent 
// hand-chosen ranges, which is why the code has a lot of low-speed 'beatsin8' functions
// with a lot of oddly specific numeric ranges.
//
// These three custom blue-green color palettes were inspired by the colors found in
// the waters off the southern coast of California, https://goo.gl/maps/QQgd97jjHesHZVxQ7
//
CRGBPalette16 pacifica_palette_1 = { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117, 0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x14554B, 0x28AA50 };
CRGBPalette16 pacifica_palette_2 = { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117, 0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x0C5F52, 0x19BE5F };
CRGBPalette16 pacifica_palette_3 = { 0x000208, 0x00030E, 0x000514, 0x00061A, 0x000820, 0x000927, 0x000B2D, 0x000C33, 0x000E39, 0x001040, 0x001450, 0x001860, 0x001C70, 0x002080, 0x1040BF, 0x2060FF };void pacifica_loop()
{// Increment the four "color index start" counters, one for each wave layer.// Each is incremented at a different speed, and the speeds vary over time.static uint16_t sCIStart1, sCIStart2, sCIStart3, sCIStart4;static uint32_t sLastms = 0;uint32_t ms = GET_MILLIS();uint32_t deltams = ms - sLastms;sLastms = ms;uint16_t speedfactor1 = beatsin16(3, 179, 269);uint16_t speedfactor2 = beatsin16(4, 179, 269);uint32_t deltams1 = (deltams * speedfactor1) / 256;uint32_t deltams2 = (deltams * speedfactor2) / 256;uint32_t deltams21 = (deltams1 + deltams2) / 2;sCIStart1 += (deltams1 * beatsin88(1011,10,13));sCIStart2 -= (deltams21 * beatsin88(777,8,11));sCIStart3 -= (deltams1 * beatsin88(501,5,7));sCIStart4 -= (deltams2 * beatsin88(257,4,6));// Clear out the LED array to a dim background blue-greenfill_solid( leds, NUM_LEDS, CRGB( 2, 6, 10));// Render each of four layers, with different scales and speeds, that vary over timepacifica_one_layer( pacifica_palette_1, sCIStart1, beatsin16( 3, 11 * 256, 14 * 256), beatsin8( 10, 70, 130), 0-beat16( 301) );pacifica_one_layer( pacifica_palette_2, sCIStart2, beatsin16( 4,  6 * 256,  9 * 256), beatsin8( 17, 40,  80), beat16( 401) );pacifica_one_layer( pacifica_palette_3, sCIStart3, 6 * 256, beatsin8( 9, 10,38), 0-beat16(503));pacifica_one_layer( pacifica_palette_3, sCIStart4, 5 * 256, beatsin8( 8, 10,28), beat16(601));// Add brighter 'whitecaps' where the waves lines up morepacifica_add_whitecaps();// Deepen the blues and greens a bitpacifica_deepen_colors();
}// Add one layer of waves into the led array
void pacifica_one_layer( CRGBPalette16& p, uint16_t cistart, uint16_t wavescale, uint8_t bri, uint16_t ioff)
{uint16_t ci = cistart;uint16_t waveangle = ioff;uint16_t wavescale_half = (wavescale / 2) + 20;for( uint16_t i = 0; i < NUM_LEDS; i++) {waveangle += 250;uint16_t s16 = sin16( waveangle ) + 32768;uint16_t cs = scale16( s16 , wavescale_half ) + wavescale_half;ci += cs;uint16_t sindex16 = sin16( ci) + 32768;uint8_t sindex8 = scale16( sindex16, 240);CRGB c = ColorFromPalette( p, sindex8, bri, LINEARBLEND);leds[i] += c;}
}// Add extra 'white' to areas where the four layers of light have lined up brightly
void pacifica_add_whitecaps()
{uint8_t basethreshold = beatsin8( 9, 55, 65);uint8_t wave = beat8( 7 );for( uint16_t i = 0; i < NUM_LEDS; i++) {uint8_t threshold = scale8( sin8( wave), 20) + basethreshold;wave += 7;uint8_t l = leds[i].getAverageLight();if( l > threshold) {uint8_t overage = l - threshold;uint8_t overage2 = qadd8( overage, overage);leds[i] += CRGB( overage, overage2, qadd8( overage2, overage2));}}
}// Deepen the blues and greens
void pacifica_deepen_colors()
{for( uint16_t i = 0; i < NUM_LEDS; i++) {leds[i].blue = scale8( leds[i].blue,  145); leds[i].green= scale8( leds[i].green, 200); leds[i] |= CRGB( 2, 5, 7);}
}

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）
实验二百一十六：WS2812B幻彩LED灯带 5V全彩灯条5050灯珠内置IC炫彩单点单控软灯条模块
实验程序十七：内置调色板（森林，云彩，熔岩，海洋，派对）

Arduino实验开源代码

/*【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）实验二百一十六：WS2812B幻彩LED灯带 5V全彩灯条5050灯珠内置IC炫彩单点单控软灯条模块实验程序十七：内置调色板（森林，云彩，熔岩，海洋，派对）
*/#include <FastLED.h>#define LED_PIN     6
#define BRIGHTNESS  24
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
#define BRIGHTNESS  33// Params for width and height
const uint8_t kMatrixWidth  = 24;
const uint8_t kMatrixHeight = 1;// Param for different pixel layouts
const bool    kMatrixSerpentineLayout = true;#define NUM_LEDS (kMatrixWidth * kMatrixHeight)
#define MAX_DIMENSION ((kMatrixWidth>kMatrixHeight) ? kMatrixWidth : kMatrixHeight)// The leds
CRGB leds[kMatrixWidth * kMatrixHeight];// The 16 bit version of our coordinates
static uint16_t x;
static uint16_t y;
static uint16_t z;// We're using the x/y dimensions to map to the x/y pixels on the matrix.  We'll
// use the z-axis for "time".  speed determines how fast time moves forward.  Try
// 1 for a very slow moving effect, or 60 for something that ends up looking like
// water.
uint16_t speed = 20; // speed is set dynamically once we've started up// Scale determines how far apart the pixels in our noise matrix are.  Try
// changing these values around to see how it affects the motion of the display.  The
// higher the value of scale, the more "zoomed out" the noise iwll be.  A value
// of 1 will be so zoomed in, you'll mostly see solid colors.
uint16_t scale = 30; // scale is set dynamically once we've started up// This is the array that we keep our computed noise values in
uint8_t noise[MAX_DIMENSION][MAX_DIMENSION];CRGBPalette16 currentPalette( PartyColors_p );
uint8_t       colorLoop = 1;void setup() {delay(3000);FastLED.addLeds<LED_TYPE,LED_PIN,COLOR_ORDER>(leds,NUM_LEDS);FastLED.setBrightness(BRIGHTNESS);// Initialize our coordinates to some random valuesx = random16();y = random16();z = random16();
}// Fill the x/y array of 8-bit noise values using the inoise8 function.
void fillnoise8() {// If we're runing at a low "speed", some 8-bit artifacts become visible// from frame-to-frame.  In order to reduce this, we can do some fast data-smoothing.// The amount of data smoothing we're doing depends on "speed".uint8_t dataSmoothing = 0;if( speed < 50) {dataSmoothing = 200 - (speed * 4);}for(int i = 0; i < MAX_DIMENSION; i++) {int ioffset = scale * i;for(int j = 0; j < MAX_DIMENSION; j++) {int joffset = scale * j;uint8_t data = inoise8(x + ioffset,y + joffset,z);// The range of the inoise8 function is roughly 16-238.// These two operations expand those values out to roughly 0..255// You can comment them out if you want the raw noise data.data = qsub8(data,16);data = qadd8(data,scale8(data,39));if( dataSmoothing ) {uint8_t olddata = noise[i][j];uint8_t newdata = scale8( olddata, dataSmoothing) + scale8( data, 256 - dataSmoothing);data = newdata;}noise[i][j] = data;}}z += speed;// apply slow drift to X and Y, just for visual variation.x += speed / 8;y -= speed / 16;
}void mapNoiseToLEDsUsingPalette()
{static uint8_t ihue=0;for(int i = 0; i < kMatrixWidth; i++) {for(int j = 0; j < kMatrixHeight; j++) {// We use the value at the (i,j) coordinate in the noise// array for our brightness, and the flipped value from (j,i)// for our pixel's index into the color palette.uint8_t index = noise[j][i];uint8_t bri =   noise[i][j];// if this palette is a 'loop', add a slowly-changing base valueif( colorLoop) { index += ihue;}// brighten up, as the color palette itself often contains the // light/dark dynamic range desiredif( bri > 127 ) {bri = 255;} else {bri = dim8_raw( bri * 2);}CRGB color = ColorFromPalette( currentPalette, index, bri);leds[XY(i,j)] = color;}}ihue+=1;
}void loop() {// Periodically choose a new palette, speed, and scaleChangePaletteAndSettingsPeriodically();// generate noise datafillnoise8();// convert the noise data to colors in the LED array// using the current palettemapNoiseToLEDsUsingPalette();FastLED.show();// delay(10);
}#define HOLD_PALETTES_X_TIMES_AS_LONG 1void ChangePaletteAndSettingsPeriodically()
{uint8_t secondHand = ((millis() / 1000) / HOLD_PALETTES_X_TIMES_AS_LONG) % 60;static uint8_t lastSecond = 99;if( lastSecond != secondHand) {lastSecond = secondHand;if( secondHand ==  0)  { currentPalette = RainbowColors_p;         speed = 20; scale = 30; colorLoop = 1; }if( secondHand ==  5)  { SetupPurpleAndGreenPalette();             speed = 10; scale = 50; colorLoop = 1; }if( secondHand == 10)  { SetupBlackAndWhiteStripedPalette();       speed = 20; scale = 30; colorLoop = 1; }if( secondHand == 15)  { currentPalette = ForestColors_p;          speed =  8; scale =120; colorLoop = 0; }if( secondHand == 20)  { currentPalette = CloudColors_p;           speed =  4; scale = 30; colorLoop = 0; }if( secondHand == 25)  { currentPalette = LavaColors_p;            speed =  8; scale = 50; colorLoop = 0; }if( secondHand == 30)  { currentPalette = OceanColors_p;           speed = 20; scale = 90; colorLoop = 0; }if( secondHand == 35)  { currentPalette = PartyColors_p;           speed = 20; scale = 30; colorLoop = 1; }if( secondHand == 40)  { SetupRandomPalette();                     speed = 20; scale = 20; colorLoop = 1; }if( secondHand == 45)  { SetupRandomPalette();                     speed = 50; scale = 50; colorLoop = 1; }if( secondHand == 50)  { SetupRandomPalette();                     speed = 90; scale = 90; colorLoop = 1; }if( secondHand == 55)  { currentPalette = RainbowStripeColors_p;   speed = 30; scale = 20; colorLoop = 1; }}
}// This function generates a random palette that's a gradient
// between four different colors.  The first is a dim hue, the second is 
// a bright hue, the third is a bright pastel, and the last is 
// another bright hue.  This gives some visual bright/dark variation
// which is more interesting than just a gradient of different hues.
void SetupRandomPalette()
{currentPalette = CRGBPalette16( CHSV( random8(), 255, 32), CHSV( random8(), 255, 255), CHSV( random8(), 128, 255), CHSV( random8(), 255, 255)); 
}// This function sets up a palette of black and white stripes,
// using code.  Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
void SetupBlackAndWhiteStripedPalette()
{// 'black out' all 16 palette entries...fill_solid( currentPalette, 16, CRGB::Black);// and set every fourth one to white.currentPalette[0] = CRGB::White;currentPalette[4] = CRGB::White;currentPalette[8] = CRGB::White;currentPalette[12] = CRGB::White;}// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
{CRGB purple = CHSV( HUE_PURPLE, 255, 255);CRGB green  = CHSV( HUE_GREEN, 255, 255);CRGB black  = CRGB::Black;currentPalette = CRGBPalette16( green,  green,  black,  black,purple, purple, black,  black,green,  green,  black,  black,purple, purple, black,  black );
}//
// Mark's xy coordinate mapping code.  See the XYMatrix for more information on it.
//
uint16_t XY( uint8_t x, uint8_t y)
{uint16_t i;if( kMatrixSerpentineLayout == false) {i = (y * kMatrixWidth) + x;}if( kMatrixSerpentineLayout == true) {if( y & 0x01) {// Odd rows run backwardsuint8_t reverseX = (kMatrixWidth - 1) - x;i = (y * kMatrixWidth) + reverseX;} else {// Even rows run forwardsi = (y * kMatrixWidth) + x;}}return i;
}

实验的视频记录

https://v.youku.com/v_show/id_XNTg4NjQyMzE4OA==.html?spm=a2hcb.playlsit.page.1

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）
实验二百一十六：WS2812B幻彩LED灯带 5V全彩灯条5050灯珠内置IC炫彩单点单控软灯条模块
实验程序十八：三速七彩风火轮

Arduino实验开源代码

/*【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）实验二百一十六：WS2812B幻彩LED灯带 5V全彩灯条5050灯珠内置IC炫彩单点单控软灯条模块实验程序十八：三速七彩风火轮
*/#include <Adafruit_NeoPixel.h>
#define LED_PIN    6
#define LED_COUNT 24Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);void setup() {strip.begin();           // INITIALIZE NeoPixel strip object (REQUIRED)strip.show();            // Turn OFF all pixels ASAPstrip.setBrightness(30); // Set BRIGHTNESS to about 1/5 (max = 255)
}void loop() {theaterChaseTwo(strip.Color(127, 127, 127), 100);  // set brightness to 100theaterChaseTwo(strip.Color(255, 255, 0), 100); theaterChaseTwo(strip.Color(127, 0, 0), 100); theaterChaseTwo(strip.Color(0, 255, 0), 100); theaterChaseTwo(strip.Color(0, 0, 127), 100); theaterChaseTwo(strip.Color(143, 0, 255), 100); theaterChase(strip.Color(127, 127, 127), 50); // 50 = half brightnesstheaterChase(strip.Color(255, 255, 0), 50); theaterChase(strip.Color(127,   0,   0), 50); theaterChase(strip.Color(  0, 255,   0), 50); theaterChase(strip.Color(  0,   0, 127), 50); theaterChase(strip.Color(143, 0, 255), 50); theaterChase(strip.Color(127, 127, 127), 25); // set brightness to 25theaterChase(strip.Color(255, 255, 0), 25); theaterChase(strip.Color(127,   0,   0), 25); theaterChase(strip.Color(  0, 255,   0), 25); theaterChase(strip.Color(  0,   0, 127), 25); theaterChase(strip.Color(143, 0, 255), 25);  }void theaterChase(uint32_t color, int wait) {for(int a=0; a<10; a++) {  for(int b=0; b<3; b++) { strip.clear();         for(int c=b; c<strip.numPixels(); c += 3) {strip.setPixelColor(c, color); }strip.show(); delay(wait);  }}}void theaterChaseTwo(uint32_t color, int wait) {for(int a=0; a<5; a++) {  for(int b=0; b<4; b++) { strip.clear();        for(int c=b; c<strip.numPixels(); c += 3) {strip.setPixelColor(c, color); }strip.show();delay(wait);  }}}void theaterChaseThree(uint32_t color, int wait) {for(int a=0; a<10; a++) {  for(int b=0; b<2; b++) { strip.clear();         for(int c=b; c<strip.numPixels(); c += 3) {strip.setPixelColor(c, color); }strip.show(); delay(wait); }}}

Arduino实验场景图