Nivel inicial10 min de lectura · Publicado el 1 de mayo de 2018

ESP8266 con tira LED WS2812B: conexión y código

Quieres que una tira de LED cambie de color, haga un arcoíris o se encienda LED a LED, y quieres controlarla con un ESP8266, una placa barata y con Wi-Fi. Aquí tienes la lista de la compra, cómo se conecta sin quemar nada y dos ejemplos de código que compilan con las versiones actuales.

Tiras RGB frente a tiras direccionables (WS2812B, NeoPixel)

Con una tira LED RGB normal controlas el color de toda la tira a la vez. Si cambias el color, cambia en todos los LED. Es como el interruptor de la luz de una habitación: enciende todas las bombillas o ninguna.

Con una tira direccionable (también llamada inteligente, digital, smart o NeoPixel, el nombre comercial de Adafruit) controlas cada LED por separado. Funciona como una fila de personas pasándose una lista de colores: el primero se queda con el suyo y pasa el resto al siguiente, que hace lo mismo. Por eso basta un único cable de datos, que entra por DIN y sale por DOUT hacia el siguiente LED.

Hay varios chips de LED direccionables (WS2801, WS2811, WS2812B, WS2813…), cada uno con sus particularidades. Este artículo usa la WS2812B, que lleva el controlador dentro de cada LED.

Así queda una tira RGB normal en un escritorio:

Y así, una tira WS2812B controlada por una NodeMCU:

Componentes necesarios

En 2018, la placa, la tira, el convertidor y la fuente costaban unos 13 € en AliExpress. La resistencia y el condensador cuestan céntimos.

¿Qué fuente necesito?

Cada LED gasta como máximo 60 mA, cuando está en blanco y al máximo brillo. La guía de Adafruit propone una regla aproximada de 20 mA por LED para usos normales:

Multiplica el número de LED por 20 (o por 60, si quieres ir sobrado) y divide entre 1000: eso son los amperios mínimos. Que la fuente dé más amperios no es un problema; que dé más voltios, sí. Busca una de 5 V (en el montaje original se usó una de 5 V y 8 A, más que suficiente para 30 LED).

Esquema de conexión

El DOUT del último LED se deja sin conectar. Alimenta el convertidor según su hoja de datos.

Al montar, en este orden

1. Monta todo con la fuente desenchufada.
2. Si tienes que conectar con la fuente encendida: primero GND, luego +5 V y por último el cable de datos. Para desconectar, al revés.
3. Alimenta la tira antes que la placa, para que no se alimente a través del cable de datos.
4. Deja el cable entre la placa y el primer LED corto: uno o dos metros como mucho.

Primero la masa, luego la corriente y al final los datos.

Prepara el entorno (Arduino IDE)

1. En Archivo › Preferencias › Gestor de URLs adicionales de tarjetas, añade https://arduino.esp8266.com/stable/package_esp8266com_index.json.
2. En Herramientas › Placa › Gestor de tarjetas, instala esp8266 (versión 3.1.2).
3. En el Gestor de bibliotecas, instala Adafruit NeoPixel (versión 1.15.5).
4. Elige la placa NodeMCU 1.0 (ESP-12E Module).

Si prefieres la terminal, con arduino-cli es lo mismo:

arduino-cli config init --additional-urls https://arduino.esp8266.com/stable/package_esp8266com_index.json
arduino-cli core update-index
arduino-cli core install esp8266:esp8266
arduino-cli lib install "Adafruit NeoPixel"
arduino-cli compile --fqbn esp8266:esp8266:nodemcuv2 Encender

En PlatformIO ya no se instalan las bibliotecas por número (la de NeoPixel era la nº 28). Ahora se nombran por su autor en platformio.ini:

[env:nodemcuv2]
platform = espressif8266
board = nodemcuv2
framework = arduino
lib_deps = adafruit/Adafruit NeoPixel@^1.15.5

Si PlatformIO no encuentra la placa por USB, mira Error al conectar con USB en PlatformIO.

Código: encender los LED uno a uno

Este ejemplo enciende los LED en verde, uno tras otro, y vuelve a empezar. Solo tienes que cambiar dos valores: el pin de datos (PIN_DATOS) y el número de LED (NUM_LEDS).

// Enciende los LED de la tira uno a uno, en verde.
#include <Adafruit_NeoPixel.h>

const uint8_t PIN_DATOS = D2;      // D2 en la NodeMCU es el GPIO4
const uint16_t NUM_LEDS = 30;      // 1 m de tira de 30 LED/m

Adafruit_NeoPixel tira(NUM_LEDS, PIN_DATOS, NEO_GRB + NEO_KHZ800);

void setup() {
  tira.begin();            // prepara el pin de datos
  tira.setBrightness(80);  // brillo de 0 a 255, una sola vez, en setup()
  tira.clear();            // todos apagados
  tira.show();
}

void loop() {
  for (uint16_t i = 0; i < tira.numPixels(); i++) {
    tira.setPixelColor(i, tira.Color(0, 150, 0));  // rojo, verde, azul
    tira.show();                                   // envía los colores a la tira
    delay(100);
  }
  tira.clear();
  tira.show();
  delay(500);
}

Código: efecto arcoíris

La versión 2018 de este artículo calculaba los colores del arcoíris a mano, con una función Wheel(). La biblioteca actual ya trae rainbow(), que reparte un arcoíris completo por la tira y corrige los colores para que se vean naturales:

// Arcoíris que recorre la tira.
#include <Adafruit_NeoPixel.h>

const uint8_t PIN_DATOS = D2;      // D2 en la NodeMCU es el GPIO4
const uint16_t NUM_LEDS = 30;

Adafruit_NeoPixel tira(NUM_LEDS, PIN_DATOS, NEO_GRB + NEO_KHZ800);

void setup() {
  tira.begin();
  tira.setBrightness(80);  // cerca de un tercio del máximo
}

void loop() {
  // El tono va de 0 a 65535: una vuelta completa al círculo de color.
  // En cada paso, el arcoíris empieza un poco más adelante y parece moverse.
  for (uint32_t tonoInicial = 0; tonoInicial < 65536; tonoInicial += 256) {
    tira.rainbow(tonoInicial);  // reparte el arcoíris por toda la tira
    tira.show();
    delay(20);
  }
}

Si quieres más control, ColorHSV(tono) te da el color de un tono concreto y gamma32() lo corrige: tira.setPixelColor(i, tira.gamma32(tira.ColorHSV(tono))).

Si no funciona

Siguiente paso

Los ejemplos usan delay(), que deja la placa parada mientras espera. Si quieres que la tira siga animándose mientras el ESP8266 hace otra cosa (leer un botón o atender peticiones por Wi-Fi), necesitas dejar de bloquearla. Tienes un ejemplo en Multitarea con máquina de estados.

Y si quieres controlar la tira desde el navegador, el proyecto Controlling NeoPixels with a webserver on an ESP8266 (en inglés) monta un servidor web en la propia NodeMCU.

Fuentes

Comprobado en noviembre de 2026:

• Adafruit NeoPixel Überguide: páginas Best Practices (resistencia, condensador, orden de conexión, nivel lógico, masa común), Powering NeoPixels (consumo por LED, cálculo de la fuente, regla del 70 %) y Arduino Library Use (API).
• Adafruit NeoPixel 1.15.5: firma de rainbow(), ColorHSV() y gamma32() en Adafruit_NeoPixel.h.
• Núcleo ESP8266 para Arduino 3.1.2, última versión publicada: instalación y correspondencia de pines de la NodeMCU (D2 = 4) en variants/nodemcu/pins_arduino.h.
• Registro de PlatformIO: adafruit/Adafruit NeoPixel 1.15.5.
• FastLED 3.10.9: solo se ha comprobado la versión; no se ha compilado.

Ejecutado: los dos sketches compilan sin errores para esp8266:esp8266:nodemcuv2 con arduino-cli 1.5.1, núcleo esp8266 3.1.2 y Adafruit NeoPixel 1.15.5, en un contenedor Docker python:3.14. No se han probado sobre una tira física en esta revisión; los vídeos son del montaje original de 2018.