How to use WS2812B RGB LED with Arduino (Complete Guide)

This post is about the addressable RGB WS2812B LED strip. The knowledge in this post also works with other similar LED strips, including strips from the WS28XX family, Neopixel strips, and others. We show you in this post how to use WS2812B RGB LED with Arduino and the code you need to upload to produce effects.

WS2812B LED Strip with LEDEdit PRO

Introducing the WS2812B LED Strip

The WS2812B addressable LED strip comes in several models, each of which differs in size, sealant, and LED density. Choose the one that best fits your needs.

Where can I buy the WS2812B LED Strip?

I've got a WS2812B LED strip, which you can see in the below image. The LEDs are protected by weatherproof silicone and are 5 meters long. So there is no issue if they are left outdoors in the rain and dust.

The coolest type of LED strip, in my view, is this one. You may manually adjust each LED's brightness and color, allowing you to produce amazing and complicated effects simply.

WS2812B LEDs are wired in series to create this LED strip. These LEDs include an IC right within the LED itself. This enables one-wire interface communication. This means that using only one digital pin on your Arduino, you can control lots of LEDs.

The chip inside the LED may be seen in the following image: It works like an RGB LED.

WS2812B RGB LED with Arduino

You may cut this kind of strip to whatever length you choose since it is highly flexible. As you can see, the strip has been divided into parts, and each segment has an RGB LED.

WS2812B RGB LED with Arduino sections

You may change the size of the strip by cutting it in the right places with scissors (the proper places to cut the strip are noted).

Cutting the strip

These strips have connectors on both ends. I've decided to cut the connectors and solder the header pins together. It comes in handy when connecting the strip to an Arduino or a breadboard.

cut the connectors and solder the header pins together

How to Power the WS2812B LED Strip

Using a 5V power source, the LED strip should be powered. When set at its maximum brightness, each LED at 5 volts consumes around 50 mA. This means that the strip might draw up to 1.5 A for every 30 LEDs. Make sure the power source you select is appropriate for the strip. It should work with an AC-to-DC power adapter that offers 5V and 2A.

Don't forget to connect the power source ground to the Arduino ground if you're using an external power source.


The WS2812B LED strip will be powered in this example using the Arduino's 5V pin. In my case, I'm controlling 14 LEDs. You'll need an external power source if you wish to control a lot of LEDs.

Arduino's 5V pin

Useful tips:

  • Connect a capacitor with a capacitance of 100 uF to 1000 uF from power to ground to smooth out the power supply.
  • To reduce noise on the line, connect a 220 or 470-ohm resistor between the Arduino digital output pin and the strip data input pin.
  • To minimize voltage loss, keep the wires connecting the Arduino, power supply, and strip as short as possible.
  • If your strip is damaged and no longer works, check to see whether the first LED is broken. If so, cut it, resolder the header pins, and it should work again.


You'll need to download the FastLED library to control the WS2812B LED strip.

Installing the FastLED library:

  1. Click here to download the FastLED library. You should have a .zip folder in your Downloads folder.
  2. Unzip the .zip folder, and you should get the “FastLED-master” folder.
  3. Rename your folder from “FastLED-master” to “FastLED“.
  4. Move the “FastLED” folder to your Arduino IDE installation “libraries” folder.
  5. Finally, re-open your Arduino IDE.

After installing the required library, you need to upload the following code to your Arduino board (this is an example sketch supplied in the library examples folder). Copy the code below, or go to File > Examples > FastLED > ColorPalette.

#include <FastLED.h>

#define LED_PIN     5
#define NUM_LEDS    14
#define BRIGHTNESS  64
#define LED_TYPE    WS2811


// This example shows several ways to set up and use 'palettes' of colors
// with FastLED.
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code.  Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
// Some notes on the more abstract 'theory and practice' of
// FastLED compact palettes are at the bottom of this file.

CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;

void setup() {
    delay( 3000 ); // power-up safety delay
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness(  BRIGHTNESS );
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;

void loop()
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
    FillLEDsFromPaletteColors( startIndex);;
    FastLED.delay(1000 / UPDATES_PER_SECOND);

void FillLEDsFromPaletteColors( uint8_t colorIndex)
    uint8_t brightness = 255;
    for( int i = 0; i < NUM_LEDS; i++) {
        leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
        colorIndex += 3;

// 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.  All are shown here.

void ChangePalettePeriodically()
    uint8_t secondHand = (millis() / 1000) % 60;
    static uint8_t lastSecond = 99;
    if( lastSecond != secondHand) {
        lastSecond = secondHand;
        if( secondHand ==  0)  { currentPalette = RainbowColors_p;         currentBlending = LINEARBLEND; }
        if( secondHand == 10)  { currentPalette = RainbowStripeColors_p;   currentBlending = NOBLEND;  }
        if( secondHand == 15)  { currentPalette = RainbowStripeColors_p;   currentBlending = LINEARBLEND; }
        if( secondHand == 20)  { SetupPurpleAndGreenPalette();             currentBlending = LINEARBLEND; }
        if( secondHand == 25)  { SetupTotallyRandomPalette();              currentBlending = LINEARBLEND; }
        if( secondHand == 30)  { SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; }
        if( secondHand == 35)  { SetupBlackAndWhiteStripedPalette();       currentBlending = LINEARBLEND; }
        if( secondHand == 40)  { currentPalette = CloudColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 45)  { currentPalette = PartyColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 50)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND;  }
        if( secondHand == 55)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }

// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
    for( int i = 0; i < 16; i++) {
        currentPalette[i] = CHSV( random8(), 255, random8());

// 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 );

// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM.  A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
    CRGB::Gray, // 'white' is too bright compared to red and blue

// Additionl notes on FastLED compact palettes:
// Normally, in computer graphics, the palette (or "color lookup table")
// has 256 entries, each containing a specific 24-bit RGB color.  You can then
// index into the color palette using a simple 8-bit (one byte) value.
// A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// is quite possibly "too many" bytes.
// FastLED does offer traditional 256-element palettes, for setups that
// can afford the 768-byte cost in RAM.
// However, FastLED also offers a compact alternative.  FastLED offers
// palettes that store 16 distinct entries, but can be accessed AS IF
// they actually have 256 entries; this is accomplished by interpolating
// between the 16 explicit entries to create fifteen intermediate palette
// entries between each pair.
// So for example, if you set the first two explicit entries of a compact 
// palette to Green (0,255,0) and Blue (0,0,255), and then retrieved 
// the first sixteen entries from the virtual palette (of 256), you'd get
// Green, followed by a smooth gradient from green-to-blue, and then Blue.

The NUM_LEDS variable must be changed to reflect the number of LEDs in your LED strip. The LED strip in our illustration is 14 LEDs long.

#define NUM_LEDS 14

The LED_PIN variable has to be changed if you wish to control the LED strip with a different Arduino pin.

#define LED_PIN 5


This is what you'll have at the end. Amazing effects like this:

Amazing effects from the WS2812B RGB LED

And this one:

Amazing effects from the WS2812B RGB LED

And this one:

Amazing effects from the WS2812B RGB LED

This post provides an introduction to using the WS2812B RGB LED with Arduino. We've just played with the library example. To display only the effects you want, you need to modify the example. We hope you find this guide helpful.

Oh hi there It’s nice to meet you.

Sign up to receive awesome content in your inbox, every month.

We don’t spam! Read our privacy policy for more info.

Leave a Reply

Your email address will not be published. Required fields are marked *