Controla tiras de led RGB con Arduino

Hola linces, en esta oportunidad les traigo un post de inteligencia colectiva que nada que ver con autos.. se pensaban que solo sabia hacer ?.. pues no!

Resulta que hace unas semanas fui a un casamiento y cuando llego el momento en el que reparten el cotillon me dieron una de esas barras de goma espuma que tiene tres leds adentro y un boton en una punta para cambiar entre tres modos de destello

Aca les dejo una publicacion de mercadolibre para que vean de lo que hablo, aunque las deben conocer:

Barra goma espuma

Para los que no conocen, no encontre video asi que les cuento los tres modos de destello:

1- Blink rapido (prende y apaga, los tres leds al mismo tiempo)
2- No me acuerdo (usen su imaginacion, igual no viene al caso)
3- Efecto Fade de los tres leds individuales (el que mas me gusto y motivo del post)

Dije, "que efecto copado", o sea, es una boludes, se puede hace re facil con Arduino, pero quedaria bueno para ambientar una habitacion o algo asi mientras se mira una pelicula o en todo momento, o mientras estas con tu lincesa

un estilo a esto:





Entonces me pase el resto del casamiento pensando en que cuando volviera a casa me iba a poner a investigar sobre el tema..
total, con haber hecho ese descubrimiento la noche ya estaba salvada para mi.. fui a la pista y consegui esa barra solo porque mi novia me llevo casi arrastrandome (si, tengo novia)

Y aca estamos, unos dias despues de varios trabajos practicos para la uni, buscar un poco de info sobre el tema y me puse a hacerlo.

Estas son las pruebas que hice solo para asegurarme que podia lograr ese efecto que me habia gustado, despues vamos a lo grande, los materiales que use fueron:

-Arduino nano compatible (en el momento de comprarlo no tenia plata para uno original, no me juzguen, algun dia comprare el original)
-Cable usb a usb mini para conectar el Arduino a la pc
-pc para programar el Arduino
-3 Leds de alta luminosidad (no tenia azules asi que puse uno amarillo-naranja, despues de todo es solo para probar)
-3 resistencias de 100 ohm
-Protoboard
-Cables varios



El cableado es asi:





(si se dan cuenta en la foto, el cable marron que serian los negros en el esquema(tierra) esta conectado a la parte superior del Arduino, eso es porque hace un tiempo me dejo de funcionar el pin de abajo, por suerte tiene otro GND, supongo que debe haber fallado por ser una copia china)

Las salidas utilizadas son las 3, 5, 6 ya que son tres de las seis salidas que tienen PWM (modulacion por ancho de pulso) y permiten dar ese efecto de que baja y sube la intensidad de la luz representado en la programacion por un numero entre 0 y 255, las demas salidas digitales solo
trabajan con dos valores, 0 y 1, apagado y prendido, led apagado y led prendido al maximo, se entiende no? ok.. seguimos

De cada salida vamos a una resistencia, de la resistencia al anodo (pata mas larga) del led, y del catodo (lado con la muesca) al negativo del Arduino..

(sisi, dije "ano" )


una imagen dice mas que mil palabras



Programacion de la placa: muy sencillo, abrimos el IDE de Arduino, vamos a Archivo > Ejemplos > Analog > Fading



Y ya tenemos la base.. podemos hacer el efecto con solo un led conectado en el pin 9.. pero no es lo que buscamos, asi que vamos a meter mano al codigo

Antes del void setup() cambie el nombre de la variable para identificar el color del led, el numero del pin al que estaba asociado y agregue los otros dos que faltaban:

int ledAzul = 3; //(que en mi caso es color amarillo-naranja)
int ledVerde = 5;
int ledRojo = 6;

Ahora, en criollo, lo que pasa dentro del void loop() es: los leds empiezan apagados, aumentan la luminosidad hasta llegar al maximo, luego desde el maximo reducen la luminosidad hasta llegar a apagarse y empieza de nuevo el ciclo.

Agregamos la escritura de valores para los nuevos pines dentro de los ciclos for:

analogWrite(ledAzul, fadeValue);
analogWrite(ledVerde, fadeValue);
analogWrite(ledRojo, fadeValue);

Con esto basico ya podemos estar haciendo el efecto con los tres leds.. ahora vamos a los cambios que yo le hice al codigo para mejorarlo (a mi gusto)..

Para mi gusto era muy rapido el aumento y decremento de luminosidad, entonces donde dice "delay(30);" dentro de cada for le cambie el valor a "50", 20 milisegundos mas no es mucho, pero en 255 veces que se espera ese tiempo si tiene sentido, si quieren que dure mas tiempo el efecto
le ponen un valor mas grande, de igual manera si quieren que dure menos le pueden poner un valor mas chico.

Otra cosa, si lo estan probando mientras leen, se daran cuenta que los leds en un punto se apagan completamente, y vuelven a aumentar el brillo.. o si saben programar, "int fadeValue = 0" en la inicializacion del for quiere decir que el valor inicial, obviamente, va a ser 0, o sea, el led apagado totalmente, eso no me gustaba por lo que cambie "0" por "10", lo mismo en la condicion de finalizacion del otro for, para que no se lleguen a apagar totalmente. Ahora los leds van de 10 a 255 y de vuelta a 10, siempre sin llegar a apagarse del todo.

Y una ultima modificacion, por si quieren que el efecto se mantenga en algun punto por un tiempo, en mi caso me gustaba que cuando lleguen al maximo de luminosidad se mantenga un momento, por eso agregue entre los dos for un "delay(1500);", una espera de 1 segundo y medio.. Ahora los leds suben la luminosidad hasta el maximo, se detiene un momento, y empieza a bajar, no es instantaneo.. si quisieran que la pausa sea cuando los led estan al minimo de luminosidad pueden poner el delay con el tiempo que deseen despues del segundo for.

Con esto ya tendriamos el mismo efecto para los tres leds, no es como yo habia visto en la barra de espuma.. pero vamos de a poco..

El codigo completo dentro del void setup() a mi me quedo asi:

void loop() {
// fade in from min to max in increments of 5 points:
for (int fadeValue = 10 ; fadeValue <= 255; fadeValue += 5) {
// sets the value (range from 0 to 255):
analogWrite(ledAzul, fadeValue);
analogWrite(ledVerde, fadeValue);
analogWrite(ledRojo, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(50);
}

delay(1500); //delay para detener el efecto en el maximo del brillo

// fade out from max to min in increments of 5 points:
for (int fadeValue = 255 ; fadeValue >= 10; fadeValue -= 5) {
// sets the value (range from 0 to 255):
analogWrite(ledAzul, fadeValue);
analogWrite(ledVerde, fadeValue);
analogWrite(ledRojo, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(50);
}
}

Un video para mostrar el resultado hasta aca:


link: Fade control LED con Arduino


AHORA LA PARTE MAS INTERESANTE:

Hay que a ver como se puede hacer lo mismo con una tira de leds ya que Arduino directamente solo puede manejar hasta 3-4 leds por salida lo cual (12 leds en total), para una habitacion es bastante poco, entonces..

Como le conecto una tira de leds que en un metro tiene al rededor de 60 leds?

Facil, transistores.. ah.. y que es un transistor?

Es como una "llave" electronica, te explico.. viste cuando vas a la casa de la lincesa que te gusta y tocas el timbre de la casa?
El dedo empuja el boton y este permite el paso de corriente entre dos contactos que hacen sonar el timbre.. en el transistor es lo mismo solo que no hay dedo, sino una señal electrica que va a permitir el paso de corriente entre los otros dos contactos.

Otro ejemplo ilustrado con una canilla:



Y esto para que sirve?

Ahora Arduino con el pulso que encendia uno de los led va a accionar el transistor, la tira de led no va a estar conectada al Arduino directamente sino a una fuente externa por lo que ahora vamos a poder conectar un par de metros de tira, todo depende de la fuente que usemos, pero ya podemos conectar muchos mas leds que directo al Arduino

Ahora los materiales son:

-Arduino nano compatible
-cable usb a usb mini para conectar el Arduino a la pc
-pc para programar el Arduino
-tira RGB 5060 30 led por metro
-3 transistores mosfet tipo N K2647
-Protoboard
-cables varios
-fuente externa



El cableado es asi:







Una vista de atras para ver bien las conexiones:



Las resistencias ya no son necesarias porque las tiras de led ya las traen incluidas

En transistores comunes las patas se llaman (el orden depende de cada uno):
1 - Emisor
2 - Base
3 - Colector

En transistores mosfet:
1 - Drain (Drenador)
2 - Gate (puerta)
3 - Source (fuente)

El funcionamiento es igual para los dos tipos.. cuando se aplica una carga electrica positiva en el pin 2, se permite el paso de corriente entre el 3 y el 1, la diferencia esta en que los mosfet son mas rapidos, mas sensibles y pueden soportar mucha mas corriente (dependiendo del modelo)

Yo use transistores mosfet canal N K2647 porque queria conectar la tira de led completa que tiene 5 metros, si van a conectar solo un metro o menos tranquilamente pueden usar unos TIP31 que son mas baratos y va a andar bien igual..
En el programa que use para hacer el diagrama no habia tiras de led asi que puse un led RGB pero es exactamente lo mismo, cada color con el que le corresponde y el positivo de la tira (porque es anodo comun) con el positivo de la fuente que en mi caso es una fuente de pc modificada.

Programacion de la placa:

Partiendo del codigo anterior nos sirve la definicion de los pines para cada led:

int ledAzul = 3;
int ledVerde = 5;
int ledRojo = 6;

Como ahora tenemos una tira RGB con la que podemos formar varios colores, vamos a trabajar con mas ciclos for, los cuales van a tener su delay como antes pero como son muchos vamos a definir los delay como variables, por si queremos cambiar el tiempo asi no tenemos que modificar todas las lineas donde los usemos.. entonces debajo de la definicion de los pines de los led agregamos:

#define fadeTime1 50 //para la espera en el aumento/decremento de luminosidad
#define fadeTime2 1500 //para el tiempo que se mantiene cada color

En el void setup() van instrucciones de inicializacion para variables, pines, etc, estados iniciales que queramos que tenga algo.. por ahora no ponemos nada

Dentro del void loop() vamos a definir tres variables para indicar con que intensidad se debe encender cada color

int r, g, b;

Y comenzamos con los ciclos for, lo que hacemos en cada uno es aumentar/decrementar la intensidad de cada color para ir formando los demas
Aca no hay mucho para explicar, es el mismo principio de los for con los tres led del principio, solo que aca vamos a ir variando de a uno por vez:

//de azul a violeta
for (r = 0 ; r < 255 ; r++)
{
analogWrite(ledRojo, r);
delay(fadeTime1);
}
delay(fadeTime2);
//de violeta a rojo
for (b = 255 ; b > 0 ; b--)
{
analogWrite(ledAzul, b);
delay(fadeTime1);
}
delay(fadeTime2);
//de rojo a amarillo
for (g = 0 ; g < 255 ; g++)
{
analogWrite(ledVerde, g);
delay(fadeTime1);
}
delay(fadeTime2);
//de amarillo a verde
for (r = 255 ; r > 0 ; r--)
{
analogWrite(ledRojo, r);
delay(fadeTime1);
}
delay(fadeTime2);
//de verde a verde-azulado
for (b = 0 ; b < 255 ; b++)
{
analogWrite(ledAzul, b);
delay(fadeTime1);
}
delay(fadeTime2);
//de verde-azulado a azul
for (g = 255 ; g > 0 ; g--)
{
analogWrite(ledVerde, g);
delay(fadeTime1);
}
delay(fadeTime2);
//fin del programa

El primer comentario dice "de azul a violeta", cuando se enciende por primera vez van a ver que solo va a ir aumentando el rojo.. eh? y porque dice azul entonces?



El ultimo comentario dice "de verde-azulado a azul", a partir de la segunda vuelta va a iniciar con azul, se le va a sumar el rojo y ahi se va a formar bien el violeta, no desesperen.. como a mi no me gustaba eso agregue una simple linea en el void setup().. no es estrictamente necesario, pero yo soy muy detallista, entonces agrego en el void setup()

analogWrite(ledAzul, 255);

Que pasa aca? void setup() se ejecuta solo una vez cuando encendemos Arduino y luego el que se mantiene ciclando es el void loop() como lo dice su nombre.
Entonces, cuando encendemos la placa, se pone el pin del led azul al maximo con el valor 255, y en el primer for se le empieza a sumar el color rojo formando correctamente el violeta desde el primer ciclo, como dije, sirve solo la primera y es porque soy muy detallista.

Recalcando el porque pusimos los delay definidos como variables.. imaginen ahora que ya no quieren una espera de 50 milisegundos entre cada ciclo sino mas lento, 70 por ejemplo, tendrian que ir y cambiar "50" por "70" en cada linea, en cambio ahora solo se cambia una vez en su definicion..

Algo parecido, supongamos que no quieren el tiempo de espera entre cada color, en vez de ir y borrar o dejar comentadas todas las lineas donde aparece ese delay, simplemente cambian su definicion por "0" y listo.

Un video para ver el efecto final:


link: Fade control LED strip con Arduino


Y creo que fue todo lo que hice y no me falto explicar nada..

Las herramientas informaticas que use son:
Para programar el Arduino: Arduino IDE
Para diseñar el circuito en protoboard: Fritzing/ (Todavia esta en Beta, pero funciona muy bien y esta bastante completo)

En mi primer post propio me gustaria recibir criticas, constructivas obviamente, estoy aprendiendo tambien y si les interesa el tema de Arduino avisenme, tengo algunos modulos con los que se pueden hacer cosas interesantes y de paso seguir aprendiendo..

Si llegaste hasta aca dejame un comentario, gracias por pasar!