LEDStrip Effects

LEDEffects

Below an overview of this article.

All these effects work with NeoPixel and FastLED, and with each effect I made a little demo video.

Overview

• 1LEDEffects
• 2Preparing your Arduino and your LED strip
• 3Helpful tool: Color Picker
• 4Make your effects cooler: Diffuse Light (toilet paper magic)
• 5Required Library - NeoPixel or FastLED ?
• Basic framework
• FastLED Framework
• NeoPixel Framework
• 6LEDStrip Effect - Fade In and Fade Out: Red, Green and Blue
• 7LEDStrip Effect - Fade In and Fade Out Your own Color(s)
• 8LEDStrip Effect - Strobe
• 9LEDStrip Effect - Blinking Halloween Eyes
• 10LEDStrip Effect - Cylon
• 11LEDStrip Effect - The new KITT
• 12LEDStrip Effect - Twinkle
• 13LEDStrip Effect - Random Color Twinkle
• 14LEDStrip Effect - Sparkle
• 15LEDStrip Effect - Snow Sparkle
• 16LEDStrip Effect - Running Lights
• 17LEDStrip Effect - Color Wipe
• 18LEDStrip Effect - Rainbow Cycle
• 19LEDStrip Effect - Theatre Chase
• 20LEDStrip Effect - Theatre Chase Rainbow
• 21LEDStrip Effect - Fire
• 22LEDStrip Effect - Bouncing Balls
• 23LEDStrip Effect - Multi Color Bouncing Balls
• 24LEDStrip Effect - Meteor Rain

Preparing your Arduino and your LED strip

Please keep in mind that these effects are here for you to play with and hopefully invite you to create your own cool effects … 

For your convenience, you can download all sources here as well:

These examples rely on the following setup (as described in the Controlling a WS2812 LED with an Arduino article).
Please read carefully.

Arduino Connected to PC

The following I use for when the Arduino is connected to my PC:

Arduino & WS2812 – USB and External Power

Arduino Standalone

After you’ve uploaded your variation of effects into the Arduino, and you’d like it to run standalone, then this setup is what you need. Without a connection to your computer, the Arduino will need +5V from the external power supply.

 This is for stand-alone ONLY so when the Arduino is NOT connect to a PC!

Arduino & WS2812 – Only running on external power supply

Helpful tool: Color Picker

This tool might be helpful when picking colors:
LED colors are build up out of 3 numbers: red, green and blue (RGB).
Each number is a byte so it each has a range of 256 values (Decimal: 0 … 255, Hexadecimal: 00 … FF).

Now the human brain (usually) doesn’t work with RGB numbers, so I’ve added this little tool to pick colors.
You can select the color and it should give you the hexadecimal value of the selected color.
Please note that the LED colors might be slightly off – after all they are not calibrated.

Color picker:

Usage:
Click the input box and a popup will show a color picker. Choose your color, and the hexadecimal value will appear.
To use this in your Arduino Sketch:

The first 2 characters represent RED,
the second set of two characters is for GREEN and
the last 2 characters represent BLUE.

Add ‘0x‘ in front of each of these hex values when using them (‘0x’ designates a hexadecimal value).

Example:
This purple is B700FE.
The hexadecimal values: red is B7, green is 00 and blue is FE.

As the Arduino can work straight away with hexadecimal number, you will need to type “0x” in front of it – so it can see the difference between regular decimal number and these hexadecimal numbers.
So for example a NeoPixel strip.Color() call would look something like this:

strip.Color( 0xB7, 0x00, 0xFE );

Make your effects cooler: Diffuse Light (toilet paper magic)

I love playing with these LED strips, but sometimes they feel a little too … I don’t know how to say it.
With some effects you’d prefer to not see the individual LEDs light up.

To remedy that without too much effort, you can diffuse the light – make it more fuzzy.

There are different techniques for that, anywhere from using ping-pong balls (which works great for one or two LEDs), frosted glass (tube light!) or plastic tubes, cloth sheets etc.

I had none of these available – I used to have ping ping balls but my dog decided it to be awesome for chasing and chewing. So I’m out of those.

To my surprise, regular toilet paper (yes!) actually does a pretty good job with the diffusing as well. Naturally, I had only “fancy” toilet paper with a print on it, and neutral toilet paper would have looked even better, but you get the idea when you se these two examples.

Just make sure to keep the toilet paper roughly an inch (2 to 3 centimeter) above the LEDs – don’t let the LEDs touch the toilet paper.

Note: Both examples look better when held vertical, but without much assistance in my house, I had to do it horizontally.

The Fire Effect is my favorite and shows best in a darker environment, but look at what the toilet paper is doing … I love it!

The Red, White and Blue bouncing balls look a lot more interesting when diffused as well.

Required Library – NeoPixel or FastLED ?

Since both are pretty good, but are not used in the same way – ie. they are not drop-in replacements for each other. That’s why I decided to create a few “generic” functions so that the “effect” function here can be generic as well, so these functions work with either of these 2 libraries.

Either library can be used! 

First make sure either NeoPixel or FastLED is installed. To install one (or both) of these desired library, I refer you to the article “Arduino – Controlling a WS2812 LED strand with NeoPixel or FastLED“.

 Note : FastLED seems slightly faster. In the tests I’ve run I would estimate that FastLED is about 15% faster than NeoPixel. You will notice this with large amounts of LEDs (as I experienced with 300+ LEDs). On the other hand, NeoPixel seems to take less memory on your Arduino. Also note that the functions in FastLED are far superior to NeoPixel.

Now I wrote tiny wrappers around some of the basic functions of NeoPixel and FastLED – and I’m sure there is room for improvement. Suggestions are welcome.

Basic framework

For each of the LEDStrip effects, we will use a basic framework of code which we reuse in each of the effects.
It is important that you pay attention to these since the basic settings for your strip is being done there.

Now in this framework I’ve also defined 3 generic functions.
These functions will automatically grab the code needed for the library you’re using (when compiling).

showStrip();

This function simply applies the recent changes to pixel colors and makes them visible.
It calls strip.show (NeoPixel) or FastLED.show (FastLED).

setPixel(Pixel, red, green, blue);

With this function we set the color of an individual pixel (LED).
You will need to pass the pixel number (start counting at zero) and the RGB values.
For NeoPixel it will call setPixelColor, and for FastLED it will assign values to the leds array.

setAll(red, green, blue);

This function sets the entire strip to a give color. You can use it to set the entire strip to a given color or for example with setAll(0,0,0) to black (off).

The code we present, with each of the effects, is simple replacing this part of the code in the framework code:

1
2
3
4
5
6
7
// *** REPLACE FROM HERE ***

void loop() { 

  // ---> here we call the effect function <---

}



// ---> here we define the effect function <---

// *** REPLACE TO HERE ***

So in our effects code examples you will only see the loop() section and the effect function.
Settings and the 3 wrapper functions will not be displayed, but are most certainly needed!

FastLED Framework

This is the basic code for use with the FastLED library.

Here we include the needed library (line 1), define the number of LEDs (line 2), define the Arduino pin used (line 4), and define some strip specific settings (line 8) like color order (RGB, GRB etc.).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "FastLED.h"

#define NUM_LEDS 60 

CRGB leds[NUM_LEDS];

#define PIN 6 



void setup()

{

  FastLED.addLeds<WS2811, PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );

}



// *** REPLACE FROM HERE ***
void loop() { 
  // ---> here we call the effect function <---
}

// ---> here we define the effect function <---
// *** REPLACE TO HERE ***


void showStrip() {

 #ifdef ADAFRUIT_NEOPIXEL_H 

   // NeoPixel

   strip.show();

 #endif

 #ifndef ADAFRUIT_NEOPIXEL_H

   // FastLED

   FastLED.show();

 #endif

}



void setPixel(int Pixel, byte red, byte green, byte blue) {

 #ifdef ADAFRUIT_NEOPIXEL_H 

   // NeoPixel

   strip.setPixelColor(Pixel, strip.Color(red, green, blue));

 #endif

 #ifndef ADAFRUIT_NEOPIXEL_H 

   // FastLED

   leds[Pixel].r = red;

   leds[Pixel].g = green;

   leds[Pixel].b = blue;

 #endif

}



void setAll(byte red, byte green, byte blue) {

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

    setPixel(i, red, green, blue); 

  }

  showStrip();

}

NeoPixel Framework

For NeoPixel we use a similar framework for each of the effects.

Line 1 includes the NeoPixel library, line 2 defines the used Arduino pin (6), the comment lines explain a little about the parameters used in line 10, and in line 10 we define strip specifics.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <Adafruit_NeoPixel.h>

#define PIN 6

#define NUM_LEDS 60

// Parameter 1 = number of pixels in strip

// Parameter 2 = 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)

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);



void setup() {

  strip.begin();

  strip.show(); // Initialize all pixels to 'off'

}



// *** REPLACE FROM HERE ***
void loop() { 
 // ---> here we call the effect function <---
}

// ---> here we define the effect function <---
// *** REPLACE TO HERE ***


void showStrip() {

 #ifdef ADAFRUIT_NEOPIXEL_H 

   // NeoPixel

   strip.show();

 #endif

 #ifndef ADAFRUIT_NEOPIXEL_H

   // FastLED

   FastLED.show();

 #endif

}



void setPixel(int Pixel, byte red, byte green, byte blue) {

 #ifdef ADAFRUIT_NEOPIXEL_H 

   // NeoPixel

   strip.setPixelColor(Pixel, strip.Color(red, green, blue));

 #endif

 #ifndef ADAFRUIT_NEOPIXEL_H 

   // FastLED

   leds[Pixel].r = red;

   leds[Pixel].g = green;

   leds[Pixel].b = blue;

 #endif

}



void setAll(byte red, byte green, byte blue) {

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

    setPixel(i, red, green, blue); 

  }

  showStrip();

}

LEDStrip Effect – Fade In and Fade Out: Red, Green and Blue

With this effect, we use fixed colors for all LEDs, in sequence: Red, Green and Blue.
We will slowly increase brightness and when the maximum brightness has been reached, we will start decreasing the brightness again until the LEDs are OFF.

Since the function is in the loop(), it will keep repeating itself.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void loop() { 

  RGBLoop();

}



void RGBLoop(){

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

    // Fade IN

    for(int k = 0; k < 256; k++) { 

      switch(j) { 

        case 0: setAll(k,0,0); break;

        case 1: setAll(0,k,0); break;

        case 2: setAll(0,0,k); break;

      }

      showStrip();

      delay(3);

    }

    // Fade OUT

    for(int k = 255; k >= 0; k--) { 

      switch(j) { 

        case 0: setAll(k,0,0); break;

        case 1: setAll(0,k,0); break;

        case 2: setAll(0,0,k); break;

      }

      showStrip();

      delay(3);

    }

  }

}

LEDStrip Effect – Fade In and Fade Out Your own Color(s)

Now fading in and out only red, green and blue is nice, but what about fade in and out your own color?

If you’re not sure how to determine your own color, check out the previously mentioned Color Picker.

As with all of these effects, you can mix and match whatever you like. But if you’re in a patriotic mood, then there is not much better than our belowed red, white and blue. You can accomplish that by calling the function for each individual color. So, for example, by replacing the loop() with the following:

1
2
3
4
5
6
7
8
9
...



void loop() { 

  FadeInOut(0xff, 0x00, 0x00); // red

  FadeInOut(0xff, 0xff, 0xff); // white 

  FadeInOut(0x00, 0x00, 0xff); // blue

}



...

The effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void loop() { 

  FadeInOut(0xff, 0x77, 0x00);

}



void FadeInOut(byte red, byte green, byte blue){

  float r, g, b;

      

  for(int k = 0; k < 256; k=k+1) { 

    r = (k/256.0)*red;

    g = (k/256.0)*green;

    b = (k/256.0)*blue;

    setAll(r,g,b);

    showStrip();

  }

     

  for(int k = 255; k >= 0; k=k-2) {

    r = (k/256.0)*red;

    g = (k/256.0)*green;

    b = (k/256.0)*blue;

    setAll(r,g,b);

    showStrip();

  }

}

LEDStrip Effect – Strobe

Now, this effect quickly flashes all LEDs a number of time and then pause a certain time after that.

I made this one more configurable, so you determine how much time should be paused between flashes, and how much the “end pause” should last.

The function takes 6 parameters.

The first 3 are the same red, green and blue we have seen in the previous effect so you can define your own color – see the Color Picker above for picking a color. In the example I used White.

The next parameter (StrobeCount) indicates how many flashes you’d like to see.
Parameters 5 (FlashDelay) and 6 (EndPause) are for delays between each individual flash and how long the function should wait once it completed all flashes.

  Be careful with the strobe effect – it may cause epileptic seizures!

Effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void loop() { 

  // Slower:

  // Strobe(0xff, 0x77, 0x00, 10, 100, 1000);

  // Fast:

  Strobe(0xff, 0xff, 0xff, 10, 50, 1000);

}



void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause){

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

    setAll(red,green,blue);

    showStrip();

    delay(FlashDelay);

    setAll(0,0,0);

    showStrip();

    delay(FlashDelay);

  }

 

 delay(EndPause);

}

LEDStrip Effect – Blinking Halloween Eyes

Well, this one is for those amongst us who like a good Halloween decoration – it shows two red eyes at a random spot on the strip that fade away.

I created this function to be somewhat flexible, and as you can see in the example code, I did use the random function a bit to make it more suitable for a Halloween setup.

Anyhow, theHalloweenEyes() function takes quite a few parameters.

Again I’ve used the option to pass your preferred color by passing Red, Green and Blue (see also: Color Picker).
Usually one would probably pick red as the eye color (0xff, 0x00, 0x00).

As you can see in the code as straight forward call would be:

But a more advanced call could make things more alive and interesting:

1
2
3
4
HalloweenEyes(0xff, 0x00, 0x00, 

              1, 4, 

              true, random(5,50), random(50,150), 

              random(1000, 10000));

In the more advanced call example, we make the fade out steps and fade out delays a little random. So some eyes disappear faster than others. And the “EndPause” delays has been made random as well, so that in the end eyes will appear more random.

Something to play with …

The effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
void loop() {

  // Fixed:

  // HalloweenEyes(0xff, 0x00, 0x00, 1,4, true, 10, 80, 3000);

  // or Random:

  HalloweenEyes(0xff, 0x00, 0x00, 

                1, 4, 

                true, random(5,50), random(50,150), 

                random(1000, 10000));

}



void HalloweenEyes(byte red, byte green, byte blue, 

                   int EyeWidth, int EyeSpace, 

                   boolean Fade, int Steps, int FadeDelay,

                   int EndPause){

  randomSeed(analogRead(0));

  

  int i;

  int StartPoint  = random( 0, NUM_LEDS - (2*EyeWidth) - EyeSpace );

  int Start2ndEye = StartPoint + EyeWidth + EyeSpace;

  

  for(i = 0; i < EyeWidth; i++) {

    setPixel(StartPoint + i, red, green, blue);

    setPixel(Start2ndEye + i, red, green, blue);

  }

  

  showStrip();

  

  if(Fade==true) {

    float r, g, b;

  

    for(int j = Steps; j >= 0; j--) {

      r = j*(red/Steps);

      g = j*(green/Steps);

      b = j*(blue/Steps);

      

      for(i = 0; i < EyeWidth; i++) {

        setPixel(StartPoint + i, r, g, b);

        setPixel(Start2ndEye + i, r, g, b);

      }

      

      showStrip();

      delay(FadeDelay);

    }

  }

  

  setAll(0,0,0); // Set all black

  

  delay(EndPause);

}

LEDStrip Effect – Cylon

I suppose not all of us know what a Cylon is, but I grew up with those cool robots and I for sure wanted to have one.
My familiar with Knight Rider (although that’s about the same era)? It’s kind-a similar.

This type of “scanner” is often referred to as a Larson scanner is named after Glen Larson, the man responsible for producing both the original Battlestar Galactica and Knight Rider television shows.

Anyhow, here an effect that simulates the moving “eye” of a Cylon: A red “eye” moves from left to right and back, over and over again. Kind-a ike a bouncy ball haha.

The Cylon() function takes 6 parameters, where the first 3 are you preferred color (a Cylon has a red “eye”, but you can pick whatever you like with the Color Picker). The 4th parameter (EyeSize) determines how many LEDs run around, or: the width of the “eye” (outer 2, faded, LEDs not counted).

The 5th parameter (SpeedDelay) influences how fast the eye moves, higher values means slow movement.
The last parameter (ReturnDelay) sets how much time it should wait to bounce back.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
void loop() {

  CylonBounce(0xff, 0, 0, 4, 10, 50);

}



void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){



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

    setAll(0,0,0);

    setPixel(i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(i+j, red, green, blue); 

    }

    setPixel(i+EyeSize+1, red/10, green/10, blue/10);

    showStrip();

    delay(SpeedDelay);

  }



  delay(ReturnDelay);



  for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {

    setAll(0,0,0);

    setPixel(i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(i+j, red, green, blue); 

    }

    setPixel(i+EyeSize+1, red/10, green/10, blue/10);

    showStrip();

    delay(SpeedDelay);

  }

  

  delay(ReturnDelay);

}

LEDStrip Effect – The new KITT

I mentioned KITT already in the previous effect, and KITT did make a rather miserable comeback (see also this KITT-duino Instructables article).

In this comeback the KITT scanner started behaving differently. Instead of bouncing back and forth it now follows this pattern:

New Larson Scanner (KITT) directions

I had no clue about the change – I guess the revived show didn’t make that much of an impression – so I did get this pattern from the earlier mentioned KITT-duino Instructable.

As you can see, all steps repeat so I decided to make separate functions for the repeating patterns.
All these functions take the same parameters – so you can use them individually as well.

Obviously first the color definition (red, green and blue), then the size of the “moving eye”, the speed delay and how long we’d like to wait when the LEDs bounce.

NewKITT() calls for the complete routine of earlier mentioned pattern, where as CenterToOutside(), OutsideToCenter(), LeftToRight() and RightToLeft() do their fraction of the pattern. Again: they can be used on their own, so feel free to mix and match.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
void loop() {

  NewKITT(0xff, 0, 0, 8, 10, 50);

}



void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay){

  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);

}



void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {

  for(int i =((NUM_LEDS-EyeSize)/2); i>=0; i--) {

    setAll(0,0,0);

    

    setPixel(i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(i+j, red, green, blue); 

    }

    setPixel(i+EyeSize+1, red/10, green/10, blue/10);

    

    setPixel(NUM_LEDS-i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(NUM_LEDS-i-j, red, green, blue); 

    }

    setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);

    

    showStrip();

    delay(SpeedDelay);

  }

  delay(ReturnDelay);

}



void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {

  for(int i = 0; i<=((NUM_LEDS-EyeSize)/2); i++) {

    setAll(0,0,0);

    

    setPixel(i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(i+j, red, green, blue); 

    }

    setPixel(i+EyeSize+1, red/10, green/10, blue/10);

    

    setPixel(NUM_LEDS-i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(NUM_LEDS-i-j, red, green, blue); 

    }

    setPixel(NUM_LEDS-i-EyeSize-1, red/10, green/10, blue/10);

    

    showStrip();

    delay(SpeedDelay);

  }

  delay(ReturnDelay);

}



void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {

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

    setAll(0,0,0);

    setPixel(i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(i+j, red, green, blue); 

    }

    setPixel(i+EyeSize+1, red/10, green/10, blue/10);

    showStrip();

    delay(SpeedDelay);

  }

  delay(ReturnDelay);

}



void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {

  for(int i = NUM_LEDS-EyeSize-2; i > 0; i--) {

    setAll(0,0,0);

    setPixel(i, red/10, green/10, blue/10);

    for(int j = 1; j <= EyeSize; j++) {

      setPixel(i+j, red, green, blue); 

    }

    setPixel(i+EyeSize+1, red/10, green/10, blue/10);

    showStrip();

    delay(SpeedDelay);

  }

  delay(ReturnDelay);

}

LEDStrip Effect – Twinkle

This effect will blink one or more LEDs in a given color.
The function takes the usual color parameters, which you can determine with the Color Picker.

The 4th parameter (Count) determines how many pixels will be done in one run, where as the 5th parameter determines how much time will be paused between individual pixels (speed).

The 6th parameter (OnlyOne) should be true if you want to see only one LED at a time.
If it’s set to false then all “Count” number of LEDs will be visible (added one at a time).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void loop() {

  Twinkle(0xff, 0, 0, 10, 100, false);

}



void Twinkle(byte red, byte green, byte blue, int Count, int SpeedDelay, boolean OnlyOne) {

  setAll(0,0,0);

  

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

     setPixel(random(NUM_LEDS),red,green,blue);

     showStrip();

     delay(SpeedDelay);

     if(OnlyOne) { 

       setAll(0,0,0); 

     }

   }

  

  delay(SpeedDelay);

}

LEDStrip Effect – Random Color Twinkle

This is a variation on the Twinkle() effect.
The only difference is that the colors are now randomly generated, and therefor the first 3 color parameters are no longer of use and have been removed.

So we use only 3 parameters:

The first parameter (Count) determines how many pixels will be done in one run, where as the second parameter determines how much time will be paused between individual pixels (speed).

The last parameter (OnlyOne) should be true if you want to see only one LED at a time.
If it’s set to false then all “Count” number of LEDs will be visible (added one at a time).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void loop() {

  TwinkleRandom(20, 100, false);

}



void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) {

  setAll(0,0,0);

  

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

     setPixel(random(NUM_LEDS),random(0,255),random(0,255),random(0,255));

     showStrip();

     delay(SpeedDelay);

     if(OnlyOne) { 

       setAll(0,0,0); 

     }

   }

  

  delay(SpeedDelay);

}

LEDStrip Effect – Sparkle

With this one, a variation of Twinkle, I had Christmas in mind.

The function only lights up one LED and switches it off right after that.
When placed in the loop() it will continuously do that.

Again the usual parameters: Color and SpeedDelay.

If you’d prefer random colors, then you can could Sparkle as such:

Sparkle(random(255), random(255), random(255), 0);

The effect code, with white as the selected color:

1
2
3
4
5
6
7
8
9
10
11
void loop() {

  Sparkle(0xff, 0xff, 0xff, 0);

}



void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {

  int Pixel = random(NUM_LEDS);

  setPixel(Pixel,red,green,blue);

  showStrip();

  delay(SpeedDelay);

  setPixel(Pixel,0,0,0);

}

LEDStrip Effect – Snow Sparkle

This variant of Sparkle is intended to look like snow with to occasional sparkle.

Having snow in mind, the first 3 parameters (the background color) should be a more dim white and that’s why I choose 10 10 10 – but feel free to pick your own color.

The 4th parameter, SparkleDelay, indicates how long a “sparkle” will be visible. Do not set it too short, otherwise you’d barely notice anything happening.

The last parameter indicates how much time should be waited after a sparkle has been made visible and has been removed.

You could use a fixed interval for that:

SnowSparkle(0x10, 0x10, 0x10, 20, 200);

I like it better though when it’s more random. For that I’ve added the random function again to the function call where (in this example) the wait time between sparkles is a random number between 100 and 1000 milliseconds (1/10th of a second and a full second).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void loop() {

  SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));

}



void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay) {

  setAll(red,green,blue);

  

  int Pixel = random(NUM_LEDS);

  setPixel(Pixel,0xff,0xff,0xff);

  showStrip();

  delay(SparkleDelay);

  setPixel(Pixel,red,green,blue);

  showStrip();

  delay(SpeedDelay);

}

LEDStrip Effect – Running Lights

This effect makes multiple groups of LEDs chase each other. Kind-a like the running lights you’d use to see in stores during the holidays.

It takes 4 parameters, of which the first 3 define the color (roughly).
The last parameter indicates how much delay is put in the loop, the higher the number, the slower it will go.

You could of course play with the colors, for example on a theme night:

1
2
3
4
5
void loop() {

  RunningLights(0xff,0,0, 50);        // red

  RunningLights(0xff,0xff,0xff, 50);  // white

  RunningLights(0,0,0xff, 50);        // blue

}

The effect:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void loop() {

  RunningLights(0xff,0xff,0x00, 50);

}



void RunningLights(byte red, byte green, byte blue, int WaveDelay) {

  int Position=0;

  

  for(int j=0; j<NUM_LEDS*2; j++)

  {

      Position++; // = 0; //Position + Rate;

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

        // sine wave, 3 offset waves make a rainbow!

        //float level = sin(i+Position) * 127 + 128;

        //setPixel(i,level,0,0);

        //float level = sin(i+Position) * 127 + 128;

        setPixel(i,((sin(i+Position) * 127 + 128)/255)*red,

                   ((sin(i+Position) * 127 + 128)/255)*green,

                   ((sin(i+Position) * 127 + 128)/255)*blue);

      }

      

      showStrip();

      delay(WaveDelay);

  }

}

LEDStrip Effect – Color Wipe

I took this one from the NeoPixel library. It sets one LED after the other to a give color. The result being a full strip in a given color if you’d run it only once.

In the example below I actually call this function twice, the first one to set all LEDs to green and the second on to set each LED to black (OFF), so we get a chaser like effect.

The function parameters are simple; the usual color parameters (see color picker), and a delay time (the higher this number, the slower it will go).

1
2
3
4
5
6
7
8
9
10
11
12
void loop() {

  colorWipe(0x00,0xff,0x00, 50);

  colorWipe(0x00,0x00,0x00, 50);

}



void colorWipe(byte red, byte green, byte blue, int SpeedDelay) {

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

      setPixel(i, red, green, blue);

      showStrip();

      delay(SpeedDelay);

  }

}

LEDStrip Effect – Rainbow Cycle

Again one I took from the NeoPixel library.
This function cycles rainbow colors, where the only parameter is the speed delay.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
void loop() {

  rainbowCycle(20);

}



void rainbowCycle(int SpeedDelay) {

  byte *c;

  uint16_t i, j;



  for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel

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

      c=Wheel(((i * 256 / NUM_LEDS) + j) & 255);

      setPixel(i, *c, *(c+1), *(c+2));

    }

    showStrip();

    delay(SpeedDelay);

  }

}



byte * Wheel(byte WheelPos) {

  static byte c[3];

  

  if(WheelPos < 85) {

   c[0]=WheelPos * 3;

   c[1]=255 - WheelPos * 3;

   c[2]=0;

  } else if(WheelPos < 170) {

   WheelPos -= 85;

   c[0]=255 - WheelPos * 3;

   c[1]=0;

   c[2]=WheelPos * 3;

  } else {

   WheelPos -= 170;

   c[0]=0;

   c[1]=WheelPos * 3;

   c[2]=255 - WheelPos * 3;

  }



  return c;

}

LEDStrip Effect – Theatre Chase

Another one converted from the NeoPixel library.
With this effect LEDs are chasing each other like what you’d see in an old Theatre.
Parameters are again color and speed delay.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void loop() {

  theaterChase(0xff,0,0,50);

}



void theaterChase(byte red, byte green, byte blue, int SpeedDelay) {

  for (int j=0; j<10; j++) {  //do 10 cycles of chasing

    for (int q=0; q < 3; q++) {

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

        setPixel(i+q, red, green, blue);    //turn every third pixel on

      }

      showStrip();

     

      delay(SpeedDelay);

     

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

        setPixel(i+q, 0,0,0);        //turn every third pixel off

      }

    }

  }

}

LEDStrip Effect – Theatre Chase Rainbow

Another one from NeoPixel, which combines Rainbow and TheatreChase.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
void loop() {

  theaterChaseRainbow(50);

}



void theaterChaseRainbow(int SpeedDelay) {

  byte *c;

  

  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 < NUM_LEDS; i=i+3) {

          c = Wheel( (i+j) % 255);

          setPixel(i+q, *c, *(c+1), *(c+2));    //turn every third pixel on

        }

        showStrip();

       

        delay(SpeedDelay);

       

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

          setPixel(i+q, 0,0,0);        //turn every third pixel off

        }

    }

  }

}



byte * Wheel(byte WheelPos) {

  static byte c[3];

  

  if(WheelPos < 85) {

   c[0]=WheelPos * 3;

   c[1]=255 - WheelPos * 3;

   c[2]=0;

  } else if(WheelPos < 170) {

   WheelPos -= 85;

   c[0]=255 - WheelPos * 3;

   c[1]=0;

   c[2]=WheelPos * 3;

  } else {

   WheelPos -= 170;

   c[0]=0;

   c[1]=WheelPos * 3;

   c[2]=255 - WheelPos * 3;

  }



  return c;

}

LEDStrip Effect – Fire

This effect looks best when hanging your LED strip vertical and it simulates a one LED wide “fire”, and is adapted from an example in FastLED, which is adapted from work done by Mark Kriegsman (called “Fire2012”).

Note that this effect looks awesome when using diffuse light!

This function takes 3 parameters.

The first one (Cooling) indicates how fast a flame cools down. More cooling means shorter flames, and the recommended values are between 20 and 100. 50 seems the nicest.

The Second parameter (Sparking), indicates the chance (out of 255) that a spark will ignite. A higher value makes the fire more active. Suggested values lay between 50 and 200, with my personal preference being 120.

The last parameter (SpeedDelay) allows you to slow down the fire activity … a higher value makes the flame appear slower.
You’ll have to play a little with that, but personally I like a value between 0 and 20.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
void loop() {

  Fire(55,120,15);

}



void Fire(int Cooling, int Sparking, int SpeedDelay) {

  static byte heat[NUM_LEDS];

  int cooldown;

  

  // Step 1.  Cool down every cell a little

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

    cooldown = random(0, ((Cooling * 10) / NUM_LEDS) + 2);

    

    if(cooldown>heat[i]) {

      heat[i]=0;

    } else {

      heat[i]=heat[i]-cooldown;

    }

  }

  

  // 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' near the bottom

  if( random(255) < Sparking ) {

    int y = random(7);

    heat[y] = heat[y] + random(160,255);

    //heat[y] = random(160,255);

  }



  // Step 4.  Convert heat to LED colors

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

    setPixelHeatColor(j, heat[j] );

  }



  showStrip();

  delay(SpeedDelay);

}



void setPixelHeatColor (int Pixel, byte temperature) {

  // Scale 'heat' down from 0-255 to 0-191

  byte t192 = round((temperature/255.0)*191);

 

  // calculate ramp up from

  byte heatramp = t192 & 0x3F; // 0..63

  heatramp <<= 2; // scale up to 0..252

 

  // figure out which third of the spectrum we're in:

  if( t192 > 0x80) {                     // hottest

    setPixel(Pixel, 255, 255, heatramp);

  } else if( t192 > 0x40 ) {             // middle

    setPixel(Pixel, 255, heatramp, 0);

  } else {                               // coolest

    setPixel(Pixel, heatramp, 0, 0);

  }

}

LEDStrip Effect – Bouncing Balls

This effect looks best with the LEDstrip vertical, and shows one or more bouncing balls in a given color.
This effect is an adapted version of bouncing balls by Danny Wilson.

The parameters are as usual the color of (all) the balls, and the last parameter is the number of balls you’d like to see bounce.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
void loop() {

  BouncingBalls(0xff,0,0, 3);

}



void BouncingBalls(byte red, byte green, byte blue, int BallCount) {

  float Gravity = -9.81;

  int StartHeight = 1;

  

  float Height[BallCount];

  float ImpactVelocityStart = sqrt( -2 * Gravity * StartHeight );

  float ImpactVelocity[BallCount];

  float TimeSinceLastBounce[BallCount];

  int   Position[BallCount];

  long  ClockTimeSinceLastBounce[BallCount];

  float Dampening[BallCount];

  

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

    ClockTimeSinceLastBounce[i] = millis();

    Height[i] = StartHeight;

    Position[i] = 0; 

    ImpactVelocity[i] = ImpactVelocityStart;

    TimeSinceLastBounce[i] = 0;

    Dampening[i] = 0.90 - float(i)/pow(BallCount,2); 

  }



  while (true) {

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

      TimeSinceLastBounce[i] =  millis() - ClockTimeSinceLastBounce[i];

      Height[i] = 0.5 * Gravity * pow( TimeSinceLastBounce[i]/1000 , 2.0 ) + ImpactVelocity[i] * TimeSinceLastBounce[i]/1000;

  

      if ( Height[i] < 0 ) {                      

        Height[i] = 0;

        ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];

        ClockTimeSinceLastBounce[i] = millis();

  

        if ( ImpactVelocity[i] < 0.01 ) {

          ImpactVelocity[i] = ImpactVelocityStart;

        }

      }

      Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);

    }

  

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

      setPixel(Position[i],red,green,blue);

    }

    

    showStrip();

    setAll(0,0,0);

  }

}

LEDStrip Effect – Multi Color Bouncing Balls

This is a more complex variant of the Bouncing Balls effect.
Instead of just one color, it allows the use of multiple colors, each defined by you.

This makes the function call a little bit more complex, since I wanted it to work for any number of balls you’d like set. The problem would be how to pass the color for each ball.

To accomplish this you will have to define a so called multi dimensional array – which may sound scary, but I’ll walk you through that.

Let’s first look at the effect itself.

The function BouncingColoredBalls() takes only two parameters. The number of balls and that scary array of colors. Easy so far, right?

Now, let’s say we want to use 3 balls and use a red, white and blue ball. So 3 balls, requires 3 colors.

1
2
3
byte colors[3][3] = { {0xff, 0,0}, 

                      {0xff, 0xff, 0xff}, 

                      {0, 0, 0xff} };

The first line defines the variable “colors” as a 3 x 3 array of bytes: byte colors[3][3] (downside: you can only use up to 255 balls)
We want 3 balls, so we need 3 sets of 3 values to define their colors. So the first “3” indicates the number of Balls.
Remember the Color Picker? Each color has 3 values: red, green and blue. So the second “3” indicates the 3 colors for each ball.

I guess I didn’t think that one through … argh … oh well I’ll show you some examples with a different number of balls.

We’d like to assign these values right away and in C we have a specific notation for that. For a regular array we use { value1, value2, ... valuen } …. so for 3 values this could be { 1, 2, 3 } , enclosed with accolades ( { and } ) .

Since we have a multi dimensional array – an array that has arrays as values – we will need to pass the arrays (colors) as values, so for a 3 balls and 3 colors array we need to do something like this: { { value1, value2, value2 }, { value1, value2, value2 }, { value1, value2, value2 } } .

See the pattern? { value1, value2, value2 } is a set of 3 values (bytes) for one color.

Here an example if we would use only 2 balls, say for Christmas we use red and green balls:

1
2
byte colors[2][3] = { {0xff, 0, 0},  

                      {0, 0xdd, 0} };

2 Balls, each having a red, green and blue value (3).

Now to make this work we have to make 100% sure that the first number (2 in the 2 ball example) of the array matches with the first parameter we pass to the function. So the 2 ball Christmas example would be called as such:

1
2
3
4
5
6
void loop() {

  byte colors[2][3] = { {0xff, 0,0}, 

                        {0, 0xff, 0} };



  BouncingBalls(2, colors);

}

I know these can be a little out there to grasp, I hope I did explain this right …

Just another example, with 5 balls (red, green, blue, white and yellow), to illustrate the usage of the array:

1
2
3
4
5
6
7
8
9
void loop() {

  byte colors[5][3] = { {0xff, 0,0},       // red

                        {0, 0xff, 0},      // green

                        {0, 0, 0xff},      // blue

                        {0xff, 0xff, 0xff},// white 

                        {0xff, 0xff, 0} }; // yellow



  BouncingBalls(5, colors);

}

OK, now that we understand that part, here the effect code, for the red, white and blue Bouncing Balls effect:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
void loop() {

  byte colors[3][3] = { {0xff, 0,0}, 

                        {0xff, 0xff, 0xff}, 

                        {0   , 0   , 0xff} };



  BouncingColoredBalls(3, colors);

}



void BouncingColoredBalls(int BallCount, byte colors[][3]) {

  float Gravity = -9.81;

  int StartHeight = 1;

  

  float Height[BallCount];

  float ImpactVelocityStart = sqrt( -2 * Gravity * StartHeight );

  float ImpactVelocity[BallCount];

  float TimeSinceLastBounce[BallCount];

  int   Position[BallCount];

  long  ClockTimeSinceLastBounce[BallCount];

  float Dampening[BallCount];

  

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

    ClockTimeSinceLastBounce[i] = millis();

    Height[i] = StartHeight;

    Position[i] = 0; 

    ImpactVelocity[i] = ImpactVelocityStart;

    TimeSinceLastBounce[i] = 0;

    Dampening[i] = 0.90 - float(i)/pow(BallCount,2); 

  }



  while (true) {

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

      TimeSinceLastBounce[i] =  millis() - ClockTimeSinceLastBounce[i];

      Height[i] = 0.5 * Gravity * pow( TimeSinceLastBounce[i]/1000 , 2.0 ) + ImpactVelocity[i] * TimeSinceLastBounce[i]/1000;

  

      if ( Height[i] < 0 ) {                      

        Height[i] = 0;

        ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];

        ClockTimeSinceLastBounce[i] = millis();

  

        if ( ImpactVelocity[i] < 0.01 ) {

          ImpactVelocity[i] = ImpactVelocityStart;

        }

      }

      Position[i] = round( Height[i] * (NUM_LEDS - 1) / StartHeight);

    }

  

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

      setPixel(Position[i],colors[i][0],colors[i][1],colors[i][2]);

    }

    

    showStrip();

    setAll(0,0,0);

  }

}

LEDStrip Effect – Meteor Rain

This effect, based on a request by Hendrik, has been added almost 2 years (Januari 1st 2018) after writing this article – the video could have been done better and this effect should be vertical. None the less … here it is. This effect came with it’s own challenge since FastLED has a great function for dimming LEDs, NeoPixel however does not.

As you can see, it’s a kind of meteor falling from the sky.

An example of how to call this meteor effect:

meteorRain(0xff,0xff,0xff,10, 64, true, 30);

As with some of the previous examples, you can use the red, green and blue parameters to set the color of your meteor – you can use the Color Picker to find a color (even though it’s not perfect – it will get you in the right direction).

After the color, we can set the meteor size – the number of LEDs that represent the meteor, not counting the tail of the meteor.

The 5th parameter sets how fast the meteor tail decays/ disappears. A larger number makes the tail short and/or disappear faster. Theoretically a value of 64 should reduce the brightness by 25% for each time the meteor gets drawn.

Since meteors are not perfect, I’ve added the 6th parameter to mimic some sorts of difference in debris by making the decay a little random. If this value is set to “true” then some randomness is added to the rail. If you set the value to “false” then the tail will be very smooth.

Finally there is the last parameter, which basically indicates how much the drawing speed has to be delayed. A value of zero (0) means maximum speed. Any value above zero indicates how many milliseconds (1000 milliseconds in a second) the drawing will be delayed.

The effect code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
void loop() {

  meteorRain(0xff,0xff,0xff,10, 64, true, 30);

}



void meteorRain(byte red, byte green, byte blue, byte meteorSize, byte meteorTrailDecay, boolean meteorRandomDecay, int SpeedDelay) {  

  setAll(0,0,0);

  

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

    

    

    // fade brightness all LEDs one step

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

      if( (!meteorRandomDecay) || (random(10)>5) ) {

        fadeToBlack(j, meteorTrailDecay );        

      }

    }

    

    // draw meteor

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

      if( ( i-j <NUM_LEDS) && (i-j>=0) ) {

        setPixel(i-j, red, green, blue);

      } 

    }

   

    showStrip();

    delay(SpeedDelay);

  }

}



void fadeToBlack(int ledNo, byte fadeValue) {

 #ifdef ADAFRUIT_NEOPIXEL_H 

    // NeoPixel

    uint32_t oldColor;

    uint8_t r, g, b;

    int value;

    

    oldColor = strip.getPixelColor(ledNo);

    r = (oldColor & 0x00ff0000UL) >> 16;

    g = (oldColor & 0x0000ff00UL) >> 8;

    b = (oldColor & 0x000000ffUL);



    r=(r<=10)? 0 : (int) r-(r*fadeValue/256);

    g=(g<=10)? 0 : (int) g-(g*fadeValue/256);

    b=(b<=10)? 0 : (int) b-(b*fadeValue/256);

    

    strip.setPixelColor(ledNo, r,g,b);

 #endif

 #ifndef ADAFRUIT_NEOPIXEL_H

   // FastLED

   leds[ledNo].fadeToBlackBy( fadeValue );

 #endif  

}