Practica: Luces árbol de Navidad NeoPixel con Arduino. Una buena práctica, para navidades o carnavales u otra ocasión, sería poder controlar de alguna manera las luces del árbol o una máscara con Arduino.
Esta interesante práctica de "programarfacil" combina neopixel y su control con placas arduino.
Una buena práctica, para navidades o carnavales u otra ocasión, sería poder controlar de alguna manera las luces del árbol o una máscara con Arduino.
Hoy te presentaremos NeoPixel, otra manera de decorar tu árbol de Navidad.
Hoy vamos a hablar precisamente de esto. Veremos varios ejemplos y un tipo de LED direccionable, que darán rienda suelta a nuestra imaginación.
También tenemos las luces tradicionales, ya sean de LED o no. Veremos sus ventajas y sus inconvenientes.
Una buena práctica es utilizar LEDs para iluminar nuestra casa. Ya sea el árbol de Navidad u otra cosa. Hablaremos de los NeoPixel, un nuevo sistema de iluminación que está revolucionando este sector.
Indice de contenidos
- 1 Opciones para luces del árbol de Navidad con Arduino
- 2 Dando color a las luces árbol de Navidad con NeoPixel
- 3 Tiras de LEDs NeoPixel para las luces del árbol de Navidad con Arduino
- 4 Circuito eléctrico del NeoPixel
- 5 Programando las luces de Navidad con Arduino
- 6 Luces de Navidad hazlo tu mismo, proyectos
- 7 Otros proyectos con NeoPixel
Podemos encontrar dos tipos tradicionales (seguro que hay alguno más), las luces de navidad convencionales y las tiras de LEDs. Y por último, podemos utilizar los LEDs direccionables.
Luces de navidad tradicionales
Lo más comunes son las típicas luces de navidad, que pueden ser LED o no y que vienen con algún sistema para su control. El precio oscila entre los 4€ y 12€. Yo tengo unas luces de Navidad LED de unos 6€ y lo primero que he hecho para escribir este artículo es abrirlas. Esto es lo que nos encontramos.
En este tipo de luces, tenemos tres partes. Los diodos funcionan como un rectificador de onda completa de la corriente alterna. Lo único que hacen es voltear la media onda negativa y ponerla en el cuadrante positivo. Esto no reduce su voltaje ni intensidad.
Luego tenemos los tiristores, que se encargan de controlar la potencia que pasa a los LEDs. Estos componentes funcionan con alto voltaje así que mucho ojo. Controlan la cantidad de energía que queremos dejar pasar a los LEDs.
Por último tenemos, en la parte central, un controlador que se encarga de controlar los tiristores.
Es difícil y complicado conectar aquí un Arduino ya que en todo momento se trabaja con alto voltaje (entre 110V y 220V). Así que mucho ojo.
Tiras de LEDs de 12V para las luces de Navidad
Por otro lado, tenemos unas tiras de LED que funcionan con 12V. En este caso deberíamos tener un circuito con transistores para controlar que tira se enciende y cual no. Para cada tira necesitamos una bobina, un transistor, un diodo y un pin digital.
Esto complica bastante el circuito y la programación, así que no es recomendable utilizar estas tiras. Además no controlamos de forma individual las luces, ni tampoco podemos controlar la intensidad de las luces, a no ser que utilicemos las salidas PWM.
Utilizando LEDs direccionables en las luces del árbol de Navidad
Una de las opciones que a mi más me ha gustado, es utilizar LEDs direccionables. Como su nombre indica, son LEDs a los que podemos acceder individualmente para cambiar su intensidad y su color, ya que son 3 LEDs RGB (Rojo, Verde y Azul). Esto lo haremos a través de una dirección.
Para conseguir esto, hacen uso de un chip que llevan integrado cada uno de los LEDs. Sí, has leído bien, cada uno de ellos lleva un chip. Esto, como es normal, encarece el producto pero también da mucha funcionalidad a este tipo de LEDs.
Imagen obtenida de Adafruit
Para utilizarlas necesitaremos de un microcontrolador, ya sea un Arduino o un ESP8266. Esto tiene una ventaja y una desventaja. La ventaja es que la programación es infinita, podemos hacer todo aquello que se nos ocurra. La desventaja es que debemos saber programar.
Debido a quesiguen la misma filosofía que los píxeles de una pantalla o monitor, se llaman NeoPixel.
NeoPixel es una idea original de Adafruit pero los chip y los LEDs los fabrica World Semiconductors. Es el término que se aplica al sistema de 3 LEDs RGB y un chip para controlarlos. Adafruit los comercializa de diferentes maneras y con diferentes nombres. DoStars, LPD8806, Flora, Tiras, etc… Cada uno tiene su factor forma y están creados para un propósito concreto.
Utilizan diferentes chips para controlar la intensidad y el color, pero el más común es el WS2811. A todo el conjunto se le llama de forma común NeoPixel y de forma técnica WS2812S.
Ventajas de utilizar NeoPixel o WS2812S
Existen varias ventajas para utilizar este tipo de iluminación, pero las más importantes son:
- Libera al microcontrolador de gestionar los LEDs, de esto se encarga el WS2811.
- Podemos controlar los píxeles de una forma individual.
- Solo necesitamos un pin digital de nuestra placa microcontroladora para controlarlos a todos.
- Podemos controlar tanto intensidad como color.
Inconvenientes de utilizar NeoPixel o WS2812S
Seguramente haya muchos que no conozca. Uno de ellos, que no tendré en cuenta, es el precio. Es una iluminación más cara que la convencional. Pero cabe destacar los siguientes inconvenientes:
- Necesitamos un microcontrolador ya sea un Arduino o un ESP8266.
- Necesitamos saber programar a un nivel más bien medio. Requiere de librerías externas.
Características principales
Como siempre, antes de meternos a fondo con un componente, debemos conocer sus características principales:
- Son flexibles, permiten cierto grado de flexibilidad. Mucho ojo porque los píxeles están unidos con soldaduras y se pueden romper.
- Hay diferentes versiones para exterior.
- Norma IP65: soportan chorros de agua.
- Norma IP67: sumergilbes a un metro durante 30 minutos.
- Son modulares. Podemos cortar o añadir un píxel o un grupo de píxeles.
- El voltaje de operación es de 5V.
- Tienen una frecuencia de refresco máxima de 400 Hz. Esto indica que cada 1/400 segundos se puede actualizar su brillo y color. No es apta para utilizarla de pantalla.
- No hay límite en el número de píxeles conectados a la vez, pero debemos tener ciertas consideraciones a tener en cuenta.
- Cada píxel utiliza una porción de la memoria RAM del microcontrolador. Debemos tener precaución dependiendo de la placa que utilicemos.
- El consumo de cada píxel es de 20 mA de media. A su intensidad máxima consumen 60 mA.
- Necesitaremos un tiempo de procesado y envío por cada píxel.
- Hay diferentes factores de forma y configuraciones. Algunas típicas que podemos encontrar son:
- Píxel individual muy útiles para wereables.
- Matrices.
- Anillos
- Tiras.
En este último tipo, las tiras de NeoPixel, nos vamos a centrar para decorar nuestro árbol de Navidad.
La tiras de NeoPixel son píxeles unidos unos a otros en forma de tira.
Lo primero que debemos saber es el precio. Existe una gran variedad pero para que te hagas una idea, en Adafruit las encontramos desde $16,95 con 30 LEDs por metro hasta los $24,95 con 60 LEDs por metro.
Pero en Amazón podemos encontrar unas réplicas muy económicas. Las que yo me he comprado son dos metros de tira, con 60 LEDs por metro y con un circuito integrado para control y alimentación. Su precio es de unos 16€.
Existen dos versiones. Las que llevan 3 LEDs (rojo, verde y azul) y las que llevan un cuarto LED para el blanco.
¿Cómo funcionan las tiras de NeoPixel?
Al final tenemos que pensar como si estuviéramos trabajando con un microcontrolador como Arduino muy pequeñito y enfocado a una tarea específica, controlar la intensidad y el color del Píxel. El conjunto entero se llama WS2812S o NeoPixel y tiene diferentes pines.
- Dos pines de alimentación (+5), uno de entrada y otro de salida.
- Dos pines de masa (GND), uno de entrada y otro de salida.
- Dos pines de datos, uno de entrada (DIN) y otro de salida (DOUT).
Los datos se transmiten desde el microcontrolador. Utiliza niveles lógicos a 5 V. Mientras utilicemos un Arduino UNO no tendremos problema pero si queremos controlarlo con un ESP8266 o un Arduino MKR1000, deberemos utilizar un conversor de niveles lógicos.
Aunque las pruebas que he realizado con un Arduino MKR1000 y un NodeMCU, no he tenido problemas, eso no garantiza que en el futuro no los tenga. Es recomendable utilizar el conversor.
Para controlar los píxeles de forma individual, se crea una trama de 24 bits por cada píxel. Se envía a través del pin de datos y cada píxel se queda con los primero 24 bits y los demás los manda por el pin de salida de datos (DOUT).
Si por ejemplo tenemos 60 píxeles, necesitaremos una trama de 24 x 60 = 1.440 bits.
Alimentación
Aunque ya hemos hablado de la alimentación del NeoPixel, voy a dar los detalles del consumo. El voltaje de operación es de 5V. El consumo de cada Píxel es de 20 mA de media y un máximo de 60 mA (cuando están a tope de brillo).
Dependiendo del número de píxeles, deberás utilizar una fuente de alimentación u otra. Por ejemplo, si tenemos 60 píxeles y nos ponemos en el peor de los casos (60 mA por píxel), el consumo será 60 * 60 = 3.600 mA = 3,6 A.
Si lo calculamos con la media de 20 mA, serían unos 1,2 A. Por lo tanto necesitaremos una fuente como mínimo de 1,2 A. También tenemos que tener en cuenta que esto sería si tuviéramos todos los LEDs a la vez encendidos.
Yo he utilizado un cargador de móvil de 5V y 1 A y ha funcionado correctamente. Mi consejo es que se utilice uno de 2 A que por unos 10€ lo tenemos.
También podemos alimentar diferentes zonas de la tira con diferentes cargadores. Pero esto supone tener más cargadores conectados y llevar precaución en cortar la conexión de 5V entre las zonas.
Recomendaciones
Por último, y antes de meternos en la programación, voy a hacer unas recomendaciones.
- Compartir la conexión a tierra entre el microcontrolador (Arduino o ESP8266) y la tira de LEDs.
- Añadir condensador de entre 100 μF y 1.000 μF a la entrada de la alimentación. Esto sirve para amortiguar variaciones de consumo.
- Añadir resistencia en serie entre 220 Ω y 470 Ω con el pin por donde se transmiten los datos. Esto protegerá el pin del microcontrolador.
- Los cables de alimentación y datos lo más cortos posibles para prevenir interferencias.
- Al desconectar la tira de píxeles, lo último siempre tierra (GND).
- Al conectar la tira de píxeles, lo primero siempre tierra (GND).
- Por experiencia, si la tierra (GND) está mal conectada, el primer LED (el más cercano a la fuente de alimentación) corre peligro.
Circuito eléctrico del NeoPixel
Con todas las especificaciones y precauciones comentadas, en la siguiente imagen te muestro una propuesta de conexión. Dependerá mucho de la tira que hayas comprado, por ejemplo en mi caso, viene con un mando integrado. Este mando que está entre la alimentación y la tira de LEDs, ya tiene los sistemas de protección pertinentes.
Lo único que me faltaría en mi caso es colocar la resistencia de 470 Ω en serie con el pin de transmisión de datos.
Puedes sustituir el Arduino UNO por cualquier otra placa.
Ahora toca la parte de la programación, la que más me gusta. Como siempre te digo, si no programamos nuestros proyectos, no servirán de nada así que vamos a ver cómo lo hacemos.
Lo primero elegir la placa. Ya hemos visto que el NeoPixel trabaja con 5 V de nivel lógico así que lo más recomendable, utilizar un Arduino UNO. Si utilizamos un Arduino MKR1000 o un ESP8266 (cualquiera de sus versiones), deberemos tener en cuenta este dato y utilizar un conversor de niveles.
Una vez que tenemos clara la placa que vamos a utilizar, vamos a ver cómo debemos programar para acceder a cada uno de los píxeles. Como en muchos casos haremos uso de librerías que nos facilitan muchísimo esta tarea.
Este tipo de componentes requiere de mucha peripecia programando matrices y tener ciertos conocimientos matemáticos. Esto nos permitirá crear nuestros propios efectos.
Librería de Adafruit para Arduino y ESP8266
Quizás sea la primera opción que debamos utilizar. La podemos encontrar tanto en el repositorio de oficial de Arduino como en GitHub. Cuando la instalamos tenemos varios ejemplos para ir probando.
A continuación te voy a dejar el sketch o programa muy básico donde cambiamos el color entre rojo, verde y azul píxel a píxel.
|
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
|
#include <Adafruit_NeoPixel.h>
#define PIN 6 // Pin donde tenemos conectado la tira NeoPixel
#define NUMPIXELS 60 // Número de píxeles o LEDs
// Declaramos el objeto. El último parámetro dependerá de tu tipo de NeoPixel
// 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)
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
// Iniciamos neopixel
pixels.begin();
pixels.show();
}
void loop() {
// Efecto ola con rojo, verde y azul
for (int color = 0; color < 3; color++)
{
// Recorremos todos los píxeles
for (int i = 0; i < NUMPIXELS; i++)
{
// Rojo
if (color == 0)
{
pixels.setPixelColor(i, pixels.Color(150, 0, 0));
}
// Verde
else if (color == 1)
{
pixels.setPixelColor(i, pixels.Color(0, 150, 0));
}
// Azul
else if (color == 2)
{
pixels.setPixelColor(i, pixels.Color(0, 0, 150));
}
// Actualizamos el píxel
pixels.show();
// Esperamos un tiempo
delay(50);
}
}
}
|
Librería FastLED
Se trata de una librería muy rápida, de aquí su nombre FastLED. Además es muy eficiente y fácil de usar. Compatible con Arduino y ESP8266 y la encontramos en GitHub o en el repositorio oficial de Arduino.
Una vez que la instalamos, tenemos acceso a un montón de ejemplos. Quizás sea esta la que más me gusta por la cantidad de información que tenemos a nuestra disposición. Además, incorpora una librería de matemáticas optimizada para Arduino y ESP8266.
A continuación te dejo el mismo ejemplo del caso anterior pero escrito con esta librería.
|
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
|
#include "FastLED.h"
#define NUM_LEDS 60 // Número de píxeles
#define DATA_PIN 6 // Pin de datos
// Definimos el array de LEDs
CRGB leds[NUM_LEDS];
void setup() {
// Iniciamos la librería
FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
}
void loop() {
// Efecto ola con rojo, verde y azul
for (int color = 0; color < 3; color++)
{
// Recorremos todos los píxeles
for (int i = 0; i < NUM_LEDS; i++)
{
// Rojo
if (color == 0)
{
leds[i] = CRGB::Red;
}
// Verde
else if (color == 1)
{
leds[i] = CRGB::Green;
}
// Azul
else if (color == 2)
{
leds[i] = CRGB::Blue;
}
// Actualizamos el píxel
FastLED.show();
// Esperamos un tiempo
delay(50);
}
}
}
|
Librería NeoPixelBus
Esta es otra librería que encontramos en GitHub. Funciona correctamente tanto para Arduino como para el ESP8266. Pero mucho ojo con la WiFi. Debido a que los NeoPixel requieren de un uso continuo del procesador, puede ser que si estamos utilizando la WiFi, esta se desconecte.
NeoPixelBus y FastLED tienen esto en cuenta y gestión de una manera óptima esta situación. Una de las cosas más curiosas de esta librería, es que proporciona funciones para manejar animaciones.
En el siguiente ejemplo puedes ver el uso básico de esta librería con el código que he utilizado anteriormente.
|
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
|
#include <NeoPixelBus.h>
#define NUM_LEDS 60 // Número de píxeles
#define DATA_PIN 6 // Pin de datos
// Colores
RgbColor red(125, 0, 0);
RgbColor green(0, 125, 0);
RgbColor blue(0, 0, 125);
// Declaramos objeto
NeoPixelBus<NeoGrbFeature, Neo800KbpsMethod> strip(NUM_LEDS, DATA_PIN);
void setup() {
// Iniciamos la tira
strip.Begin();
strip.Show();
}
void loop() {
// Efecto ola con rojo, verde y azul
for (int color = 0; color < 3; color++)
{
// Recorremos todos los píxeles
for (int i = 0; i < NUM_LEDS; i++)
{
// Rojo
if (color == 0)
{
strip.SetPixelColor(i, red);
}
// Verde
else if (color == 1)
{
strip.SetPixelColor(i, green);
}
// Azul
else if (color == 2)
{
strip.SetPixelColor(i, blue);
}
// Actualizamos el píxel
strip.Show();
// Esperamos un tiempo
delay(50);
}
}
}
|
Una vez que ya hemos visto las tiras NeoPixel, hemos visto como hacer el circuito y cómo programarlo, ahora van unas ideas para decorar las luces del árbol de Navidad. Las voy a clasificar por placas, con conexión WiFi y sin conexión.
Utilizando el ESP8266 o el Arduino MKR1000:
- Controlar luces de Navidad desde el móvil.
- Encendido, apagado y modos.
- Temporizador a través de sincronización NTP.
- Poder apagar y encender las luces de forma automática según la hora y el día.
Utilizando Arduino UNO:
- Utilizando pulsadores para activar, desactivar y diferentes modos.
- Utilizando un RTC (Real Time Clock) apagar y encender las luces de forma automática según la hora y el día.
Otros proyectos con NeoPixel
Y como la Navidad tiene un principio y un final. Te dejo una serie de ejemplos donde podrás utilizar este componente una vez se acabe este periodo festivo.
Control de NeoPixel con el ESP8266 a través de la WiFi, utilizando la librería NeoPixelBus
Visita el sitio web.
Analizador gráfico de audio de 7 bandas con ESP8266 y un MSGEQ7
Visita el sitio web.
Tetrix con una matriz de LEDs y un Arduino
Fuente: programar fácil