【雕爷学编程】Arduino动手做（138）---64位WS2812点阵屏模块5 中等

/*
  【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）
  实验一百三十八：64位 WS2812B8*8 xRGB 5050 LED模块 ws2812s像素点阵屏
  项目二十四：将噪声数据转换为 LED 阵列中的动态颜色
  实验接线
  Module    UNO
  VCC —— 3.3V
  GND —— GND
  DI  ——  D6
*/

#include <FastLED.h>

#define LED_PIN     6
#define BRIGHTNESS  26
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB

// Params for width and height
const uint8_t kMatrixWidth  = 8;
const uint8_t kMatrixHeight = 8;

// Param for different pixel layouts
const bool    kMatrixSerpentineLayout = true;


// This example combines two features of FastLED to produce a remarkable range of
// effects from a relatively small amount of code.  This example combines FastLED's
// color palette lookup functions with FastLED's Perlin noise generator, and
// the combination is extremely powerful.
//
// You might want to look at the "ColorPalette" and "Noise" examples separately
// if this example code seems daunting.
//
//
// The basic setup here is that for each frame, we generate a new array of
// 'noise' data, and then map it onto the LED matrix through a color palette.
//
// Periodically, the color palette is changed, and new noise-generation parameters
// are chosen at the same time.  In this example, specific noise-generation
// values have been selected to match the given color palettes; some are faster,
// or slower, or larger, or smaller than others, but there's no reason these
// parameters can't be freely mixed-and-matched.
//
// In addition, this example includes some fast automatic 'data smoothing' at
// lower noise speeds to help produce smoother animations in those cases.
//
// The FastLED built-in color palettes (Forest, Clouds, Lava, Ocean, Party) are
// used, as well as some 'hand-defined' ones, and some proceedurally generated
// palettes.


#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 values
  x = 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 value
      if ( colorLoop) {
        index += ihue;
      }

      // brighten up, as the color palette itself often contains the
      // light/dark dynamic range desired
      if ( 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 scale
  ChangePaletteAndSettingsPeriodically();

  // generate noise data
  fillnoise8();

  // convert the noise data to colors in the LED array
  // using the current palette
  mapNoiseToLEDsUsingPalette();

  FastLED.show();
  // delay(10);
}



// There are several different palettes of colors demonstrated here.
//
// FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
//
// Additionally, you can manually define your own color palettes, or you can write
// code that creates color palettes on the fly.

// 1 = 5 sec per palette
// 2 = 10 sec per palette
// etc
#define HOLD_PALETTES_X_TIMES_AS_LONG 1

void 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 backwards
      uint8_t reverseX = (kMatrixWidth - 1) - x;
      i = (y * kMatrixWidth) + reverseX;
    } else {
      // Even rows run forwards
      i = (y * kMatrixWidth) + x;
    }
  }
  return i;
}

/*

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）

  实验一百三十八：64位 WS2812B8*8 xRGB 5050 LED模块 ws2812s像素点阵屏

 项目二十五： "太平洋"柔和的蓝绿色海浪

 实验接线

 Module  UNO

 VCC —— 3.3V

 GND —— GND

 DI —— D6

*/

#define FASTLED_ALLOW_INTERRUPTS 0

#include <FastLED.h>

FASTLED_USING_NAMESPACE

#define DATA_PIN      6

#define NUM_LEDS      64

#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 silence

 FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS)

 .setCorrection( TypicalLEDStrip );

 FastLED.setBrightness(30);

 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-green

 fill_solid( leds, NUM_LEDS, CRGB( 2, 6, 10));

 // Render each of four layers, with different scales and speeds, that vary over time

 pacifica_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 more

 pacifica_add_whitecaps();

 // Deepen the blues and greens a bit

 pacifica_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种传感器模块系列实验（资料代码+图形编程+仿真编程）
  实验一百四十六：64位WS2812B 8*8 xRGB 5050 LED模块 ws2812s像素点阵屏
  项目二十六：简单的WS2812FX自动模式循环
  实验接线
  Module    UNO
  VCC —— 3.3V
  GND —— GND
  DI  ——  D6
*/

#include <WS2812FX.h>

#define LED_COUNT 64
#define LED_PIN    6

#define TIMER_MS 5000

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
WS2812FX ws2812fx = WS2812FX(LED_COUNT, LED_PIN, NEO_RGB + NEO_KHZ800);

unsigned long last_change = 0;
unsigned long now = 0;

void setup() {
  ws2812fx.init();
  ws2812fx.setBrightness(25);
  ws2812fx.setSpeed(1000);
  ws2812fx.setColor(0x007BFF);
  ws2812fx.setMode(FX_MODE_STATIC);
  ws2812fx.start();
}

void loop() {
  now = millis();
  ws2812fx.service();
  if(now - last_change > TIMER_MS) {
    ws2812fx.setMode((ws2812fx.getMode() + 1) % ws2812fx.getModeCount());
    last_change = now;
  }
}

/*

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）

  实验一百三十八：64位 WS2812B8*8 xRGB 5050 LED模块 ws2812s像素点阵屏

 项目二十七：模拟的火焰山动画

 实验接线

 Module  UNO

 VCC —— 3.3V

 GND —— GND

 DI —— D6

*/

#include "FastLED.h" // be sure to install and include the FastLED lib

#include <WS2812FX.h>

#define NUM_LEDS 64

#define LED_PIN 6

WS2812FX ws2812fx = WS2812FX(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);

// declare global parameters used by Fire2012

bool gReverseDirection = false;

void setup() {

 Serial.begin(115200);

 // init WS2812FX to use a custom effect

 ws2812fx.init();

 ws2812fx.setBrightness(25);

 ws2812fx.setColor(BLUE);

 ws2812fx.setSpeed(1000);

 ws2812fx.setMode(FX_MODE_CUSTOM);

 ws2812fx.setCustomMode(myCustomEffect);

 ws2812fx.start();

}

void loop() {

 ws2812fx.service();

}

// in the custom effect run the Fire2012 algorithm

uint16_t myCustomEffect() {

 Fire2012();

 // return the animation speed based on the ws2812fx speed setting

 return (ws2812fx.getSpeed() / NUM_LEDS);

}

/*

  paste in the Fire2012 code with a small edit at the end which uses the

  setPixelColor() function to copy the color data to the ws2812fx instance.

*/

// Fire2012 by Mark Kriegsman, July 2012

// as part of "Five Elements" shown here: http://youtu.be/knWiGsmgycY

////

// This basic one-dimensional 'fire' simulation works roughly as follows:

// There's a underlying array of 'heat' cells, that model the temperature

// at each point along the line. Every cycle through the simulation,

// four steps are performed:

// 1) All cells cool down a little bit, losing heat to the air

// 2) The heat from each cell drifts 'up' and diffuses a little

// 3) Sometimes randomly new 'sparks' of heat are added at the bottom

// 4) The heat from each cell is rendered as a color into the leds array

//   The heat-to-color mapping uses a black-body radiation approximation.

//

// Temperature is in arbitrary units from 0 (cold black) to 255 (white hot).

//

// This simulation scales it self a bit depending on NUM_LEDS; it should look

// "OK" on anywhere from 20 to 100 LEDs without too much tweaking.

//

// I recommend running this simulation at anywhere from 30-100 frames per second,

// meaning an interframe delay of about 10-35 milliseconds.

//

// Looks best on a high-density LED setup (60+ pixels/meter).

//

//

// There are two main parameters you can play with to control the look and

// feel of your fire: COOLING (used in step 1 above), and SPARKING (used

// in step 3 above).

//

// COOLING: How much does the air cool as it rises?

// Less cooling = taller flames. More cooling = shorter flames.

// Default 50, suggested range 20-100

#define COOLING 55

// SPARKING: What chance (out of 255) is there that a new spark will be lit?

// Higher chance = more roaring fire. Lower chance = more flickery fire.

// Default 120, suggested range 50-200.

#define SPARKING 120

void Fire2012()

{

 // Array of temperature readings at each simulation cell

 static byte heat[NUM_LEDS];

 // Step 1. Cool down every cell a little

 for ( int i = 0; i < NUM_LEDS; i++) {

  heat[i] = qsub8( heat[i], random8(0, ((COOLING * 10) / NUM_LEDS) + 2));

 }

 // Step 2. Heat from each cell drifts 'up' and diffuses a little

 for ( int k = NUM_LEDS - 1; k >= 2; k--) {

  heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;

 }

 // Step 3. Randomly ignite new 'sparks' of heat near the bottom

 if ( random8() < SPARKING ) {

  int y = random8(7);

  heat[y] = qadd8( heat[y], random8(160, 255) );

 }

 // Step 4. Map from heat cells to LED colors

 for ( int j = 0; j < NUM_LEDS; j++) {

  CRGB color = HeatColor( heat[j]);

  int pixelnumber;

  if ( gReverseDirection ) {

   pixelnumber = (NUM_LEDS - 1) - j;

  } else {

   pixelnumber = j;

  }

  // **** modified for use with WS2812FX ****

  //leds[pixelnumber] = color;

  ws2812fx.setPixelColor(pixelnumber, color.red, color.green, color.blue);

  // **** modified for use with WS2812FX ****

 }

}

/*

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）

  实验一百三十八：64位 WS2812B8*8 xRGB 5050 LED模块 ws2812s像素点阵屏

 项目二十八：随机追逐的彗星效果

 实验接线

 Module  UNO

 VCC —— 3.3V

 GND —— GND

 DI —— D6

*/

#include <WS2812FX.h>

#define LED_COUNT 64

#define LED_PIN  6

WS2812FX ws2812fx = WS2812FX(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {

 Serial.begin(115200);

 ws2812fx.init();

 ws2812fx.setBrightness(25);

 // segment 0 is the builtin comet effect

 ws2812fx.setSegment(0, 0,      LED_COUNT / 2 - 1, FX_MODE_COMET, RED, 1000, false);

 // segment 1 is our custom effect

 ws2812fx.setCustomMode(myCustomEffect);

 ws2812fx.setSegment(1, LED_COUNT / 2, LED_COUNT - 1,  FX_MODE_CUSTOM, RED, 50, false);

 ws2812fx.start();

}

void loop() {

 ws2812fx.service();

}

uint16_t myCustomEffect(void) { // random chase

 WS2812FX::Segment* seg = ws2812fx.getSegment(); // get the current segment

 for (uint16_t i = seg->stop; i > seg->start; i--) {

  ws2812fx.setPixelColor(i, ws2812fx.getPixelColor(i - 1));

 }

 uint32_t color = ws2812fx.getPixelColor(seg->start + 1);

 int r = random(6) != 0 ? (color >> 16 & 0xFF) : random(256);

 int g = random(6) != 0 ? (color >> 8 & 0xFF) : random(256);

 int b = random(6) != 0 ? (color    & 0xFF) : random(256);

 ws2812fx.setPixelColor(seg->start, r, g, b);

 return seg->speed; // return the delay until the next animation step (in msec)

}

/*

【Arduino】168种传感器模块系列实验（资料代码+仿真编程+图形编程）

  实验一百三十八：64位 WS2812B8*8 xRGB 5050 LED模块 ws2812s像素点阵屏

 项目二十九：自定义效果的演示

 实验接线

 Module  UNO

 VCC —— 3.3V

 GND —— GND

 DI —— D6

*/

#include <WS2812FX.h>

//include the custom effects

//#include "custom/BlockDissolve.h"

#include "custom/DualLarson.h"

//#include "custom/MultiComet.h"

//#include "custom/Oscillate.h"

//#include "custom/RainbowLarson.h"

//#include "custom/RandomChase.h"

//#include "custom/TriFade.h"

//#include "custom/VUMeter.h"

#define LED_COUNT 64

#define LED_PIN  6

WS2812FX ws2812fx = WS2812FX(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {

 Serial.begin(115200);

  

 ws2812fx.init();

 ws2812fx.setBrightness(25);

 // setup the custom effects

 uint8_t dualLarsonMode = ws2812fx.setCustomMode(F("Dual Larson"), dualLarson);

 uint32_t colors[] = {RED, BLUE, WHITE};

 ws2812fx.setSegment(0, 0, LED_COUNT - 1, dualLarsonMode, colors, 2000, FADE_SLOW);

 ws2812fx.start();

}

void loop() {

 ws2812fx.service();

}