Durante estos días prenavideños estoy realizando un taller para los más pequeños con Arduino y que consiste en el montaje y control de unas luces de navidad con LEDs RGB controlados por Bluetooth.
Así, cuando lleguéis a casa podréis cambiar los efectos de luces a través de una aplicación y decorar a vuestro gusto la ambientación de vuestro árbol. Más adelante intentaré conectarme al equipo de música y poder reproducir villancicos, pero tiempo al tiempo.
Para empezar a montar el circuito se necesitan los siguientes elementos:
- LEDs RGB. (En principio se pueden conectar cuantos se quieran, sin sobrepasarse claro, el límite máximo está calculado en 300. Empezaremos con 10).
- 3 Transistores bipolares. Yo utilizo el 2N2222.
- Resistencias (3 de 22Ω y otras 3 de 550Ω).
- Una pila de 9V.
- Nuestra placa Arduino. Yo utilizo la Arduino Nano, pero cualquiera puede servir.
- Un módulo Bluetooth HC-05.
- Y cables de colores rojo,verde,azul y negro a ser posible.
El circuito de luces sin bluetooth es el mostrado en la figura. Aunque aparezcan solo unos LEDs se pueden añadir todos los que se quieran ya que la conexión está hecha en paralelo. Lo divertido de usar LEDs RGB es que se pueden crear combinaciones de colores muy llamativas y unos efectos ambientales muy chulos.
Explicaré la imagen para que podáis hacer lo mismo. Los LEDs RGB tienen 4 pines, que corresponden a 3 pines (Led Rojo, Led azul y Led verde) y un anodo común que es el que va conectado a tierra(osea GND, o el que siempre lleva el cable negro). Lo que haremos será conectar la salida digital 9, 10 y 11 (elegimos estos 3 por aguantar salidas PWM, que hacen efectos progresivos) a cada uno de los pines R, G o B para encender los LED.
Ahora podríamos conectar los pines directamente a nuestra placa, pero si no queremos quemarla hay que ingeniárselas un poco. Esto se debe a que nuestra placa Arduino no puede proporcionar suficiente corriente para que todos los LEDs luzcan bien. Seguramente encontraremos información en la que aparece que una placa Arduino puede aguantar 500mA, pero eso es el límite máximo que puede proporcionar en todo su conjunto, mientras que cada pin proporciona como máximo 40mA antes de que se queme.
Para encender un LED se necesitan 20mA cada uno, así que si conectamos dos, vamos justos y podemos hacer peligrar nuestra placa. Por ello vamos a usar un transistor en cada pin de salida y así reduciremos en 100 la corriente que pasa por la placa y que los LEDs se enciendan con suficiente potencia de la fuente de alimentación, osea las pilas.
Para tener una idea gráfica de lo que ocurre aquí dentro pensemos que nuestro circuito es una presa situada en una montaña y el agua baja con mucha fuerza, esto es la corriente. Nuestra placa será la que controla el paso del agua por las tuberías, pero dentro de esa tubería el agua baja con tanta fuerza que si la conectamos a nuestra placa que tiene unas tuberias más débiles, se pueden romper, salirse el agua y sálvese quien pueda.
Un transistor actua como una válvula eléctrica que deja pasar la corriente, es decir, imaginemos que en nuestra placa ahora lo que controlamos es una compuerta que abre y cierra el paso del agua. De esta manera nuestras tuberías débiles no se conectan directamente al circuito, sino que el transistor-compuerta los separa de las grandes realizando el mismo control.
Para realizar este miniproyecto he soldado unos pines a una placa de la siguiente manera.
Con esta placa haremos las conexiones necesarias para conseguir lo mismo que en la figura simulada anterior. Iremos montando paso por paso el modelo.
Primero situamos nuestra placa Arduino, en este caso he elegido un Arduino nano. Es más pequeño, más barato y hace exactamente lo mismo que la archiconocida placa Arduino UNO.
Como veis tiene unos pines a los lados que se corresponden con las salidas 9,10 y 11 que serán las que controlarán los LEDs, otros pines para suministrar el voltaje en Vin y GND y otros dos pines macho en los pines de comunicación serie TX y RX para conectar el módulo Bluetooth. El resto de pines sirven para conectar resistencias, transistores y cables.
Ahora procederemos a montar la tira de LEDs RGB. Los LEDs RGB no son nada más que tres LEDs normales rojo, verde y azul encapsulados en uno solo con una patilla común que es la que va a tierra.
Ahí que prestar atención, en los Leds normales la pata larga se corresponde con el de voltaje, mientras que aquí es al contrario. Es muy fácil diferenciarlo.
El circuito constará de varios de estos LEDs conectados a 4 cables (3 que dan la intensidad de cada led y el común de tierra) y que se pueden ir añadiendo ya que al estar en paralelo estarán al mismo nivel de tensión. Para montar la tira de LEDs solo necesitaremos cuatro cables de estos colores, cinta aislante y una chincheta. El cable ha de ser suficientemente grueso y tener varios hilos de cobre en su interior para que haya contacto continuo entre la patilla del LED y el cable.
Con la chincheta vamos haciendo agujeros en el cable para hacer pasar las patillas del LED RGB.
Vamos uno a uno conectando y acordáos de que la patilla más larga ha de ir al negro, en cuanto al resto habrá que hacer alguna prueba para localizar el rojo, verde y azul, en mi caso el azul es el primero seguido del ánodo común como se ve en la figura.
Cuando ya los hayamos introducido cortamos las patillas con unas tijeras para evitar que hagan contacto entre ellas y las cubrimos con cinta aislante.
De esta misma manera podemos seguir añadiendo LEDs por toda la tira uno detrás de otro y la conectamos a nuestra placa con 2 conectores de 2 pines que se aprietan con tornillos.
NOTA IMPORTANTE: Los LEDs Azul y Verde funcionan a un voltaje distinto (3.2V) que el del LED rojo (1.9V) según la hoja de características. Haciendo pruebas los únicos que no se pueden conectar al mismo nivel de tensión son el rojo y el azul, mientras que cualquier otra combinación sí que se encienden. Esto lo digo porque se pueden intercambiar el orden y hacer efectos variados en lugar de que todos luzcan igual.
Ahora procederemos a insertar las resistencias y los transistores.
Resistencias de 550 ohmnios
Transistores bipolares 2N2222A
Resistencias de 22 ohmnios y cables del emisor a los LEDs
Lo que puede resultar más complicado de este montaje son los transistores. Estos transistores tienen 3 patillas que se corresponden con emisor, base y colector y hay que diferenciar como están dispuestos. Si os fijáis hay un saliente que está más cercano al emisor. Pues éste ha de ir conectado directamente a la tira de LEDs con unos cables azul, verde y rojo como aparecen en la tercera figura. El colector ha de ir conectado a una resistencia de 22 Ω con el voltaje de la pila y la base ha de ir conectada a una resistencia de 550 Ω directamente a la placa. Ésta última es la encargada de abrir la compuerta del transistor y por ella circulará menor corriente de agua. Mientras que por el colector y el emisor circulará mucha más corriente para encender los LEDs.
Ya nos falta poco. Ahora solo hemos de conectar la pila al voltaje y el módulo Bluetooth.
Cuando conectemos la pila se nos tendrá que encender la lucecita y deberemos conectar los terminales de tierra con el cable negro de la tira de LEDs como se ve en la figura y el cable rojo a las resistencias de 22 Ω.
Ahora conectamos el módulo Bluetooth. Para este paso hay que conectar primero los cables al voltaje que son los Vcc y GND con los cables rojo y negro respectivamente. Y más importante los cables de comunicación TX y RX. Estos pines significan transmisión y recepción, por lo que la información que transmite el bluetooth la tiene que recibir nuestra placa. Por ello, el pin TX del Bluetooth ha de ir al RX de la placa y viceversa. En el dibujo el cable blanco es el RX del Bluetooth y está conectado al primer pin TX de la placa y el naranja es el TX del Bluetooth conectado al RX de la placa.
Hecho esto ya tendremos montado nuestro circuito y operativo para funcionar. Pero aún nos falta programar la placa. Para este paso lo que haremos será conectarnos con el Bluetooth del móvil a las luces a través de una aplicación que se llama ArduDroid disponible en Google Play.
Así que instalamos el siguiente código en nuestra placa:
#define START_CMD_CHAR '*'
#define END_CMD_CHAR '#'
#define DIV_CMD_CHAR '|'
#define CMD_DIGITALWRITE 10
#define CMD_ANALOGWRITE 11
#define CMD_TEXT 12
#define CMD_READ_ARDUDROID 13
#define MAX_COMMAND 20 // max command number code. used for error checking.
#define MIN_COMMAND 10 // minimum command number code. used for error checking.
#define IN_STRING_LENGHT 40
#define MAX_ANALOGWRITE 255
#define PIN_HIGH 3
#define PIN_LOW 2
int led_B = 9;
int led_G = 10;
int led_R = 11;
int myPins[3] = {9, 10, 11};
int PIN_index = 0;
bool repeat = false;
String inText;
void setup() {
Serial.begin(38400);
Serial.println("ArduDroid");
Serial.flush();
pinMode(led_B, OUTPUT);
pinMode(led_G, OUTPUT);
pinMode(led_R, OUTPUT);
}
void loop()
{
Serial.flush();
int ard_command = 0;
int pin_num = 0;
int pin_value = 0;
char get_char = ' '; //read serial
// wait for incoming data
if (Serial.available() < 1) return; // if serial empty, return to loop().
// parse incoming command start flag
get_char = Serial.read();
if (get_char != START_CMD_CHAR) return; // if no command start flag, return to loop().
// parse incoming command type
ard_command = Serial.parseInt(); // read the command
// parse incoming pin# and value
pin_num = Serial.parseInt(); // read the pin
pin_value = Serial.parseInt(); // read the value
// 1) GET TEXT COMMAND FROM ARDUDROID
if (ard_command == CMD_TEXT){
inText =""; //clears variable for new input
while (Serial.available()) {
char c = Serial.read(); //gets one byte from serial buffer
if (c == 1){
repeat = true;
} else if (c==0){
repeat = false;
}
if (c == 'G' || c == 'B' || c == 'R' || c == 'S' || c == 'T' ||c == 'U' || c == 'C' ){
LEDon(c);
}
delay(5);
if (c == END_CMD_CHAR) { // if we the complete string has been read
// add your code here
break;
}else {
if (c != DIV_CMD_CHAR) {
inText += c;
delay(5);
}
}
}
}
// 2) GET digitalWrite DATA FROM ARDUDROID
if (ard_command == CMD_DIGITALWRITE){
if (pin_value == PIN_LOW) pin_value = LOW;
else if (pin_value == PIN_HIGH) pin_value = HIGH;
else return; // error in pin value. return.
set_digitalwrite( pin_num, pin_value); // Uncomment this function if you wish to use
return; // return from start of loop()
}
// 3) GET analogWrite DATA FROM ARDUDROID
if (ard_command == CMD_ANALOGWRITE) {
if(pin_num == 6){
analogWrite( pin_num, pin_value );
}else{
analogWrite( pin_num, pin_value );
}
// add your code here
return; // Done. return to loop();
}
// 4) SEND DATA TO ARDUDROID
if (ard_command == CMD_READ_ARDUDROID) {
char send_to_android[] = "Place your text here." ;
Serial.println(send_to_android); // Example: Sending text
//Serial.print(" Analog 0 = ");
//Serial.println(analogRead(A0)); // Example: Read and send Analog pin value to Arduino
return; // Done. return to loop();
}
}
// 2a) select the requested pin# for DigitalWrite action
void set_digitalwrite(int pin_num, int pin_value){
switch (pin_num) {
case 13:
LEDon('W');
// add your code here
break;
case 12:
LEDon('V');
// add your code here
break;
case 11:
pinMode(11, OUTPUT);
digitalWrite(11, pin_value);
// add your code here
break;
case 10:
pinMode(10, OUTPUT);
digitalWrite(10, pin_value);
// add your code here
break;
case 9:
pinMode(9, OUTPUT);
digitalWrite(9, pin_value);
// add your code here
break;
case 8:
if (PIN_index <= 3){
Serial.print(map(analogRead(6),0,1023,0,3000)); //Es de salida y no de entrada
digitalWrite(myPins[PIN_index], HIGH);
delay(1000);
digitalWrite(myPins[PIN_index], LOW);
}else{
PIN_index=0;
}
PIN_index += 1;
// add your code here
break;
case 7:
LEDon('U');
// add your code here
break;
case 6:
LEDon('T');
// add your code here
break;
case 5:
LEDon('S');
// add your code here
break;
case 4:
LEDon('R');
// add your code here
break;
case 3:
LEDon('G');
// add your code here
break;
case 2:
LEDon('B');
// add your code here
break;
// default:
}
}
void LEDon(char colorLED){
switch (colorLED) {
case 'R':
analogLED(led_R);
break;
case 'G':
analogLED(led_G);
break;
case 'B':
analogLED(led_B);
break;
case 'S':
analogLED_up(led_R);
analogLED(led_G);
analogLED_down(led_R);
break;
case 'T':
analogLED_up(led_B);
analogLED(led_R);
analogLED_down(led_B);
break;
case 'U':
analogLED_up(led_G);
analogLED(led_B);
analogLED_down(led_G);
break;
case 'V':
analogLED_up(led_G);
analogLED(led_R);
analogLED(led_B);
analogLED_down(led_G);
break;
case 'W':
analogLED_up(led_R);
analogLED(led_B);
analogLED(led_G);
analogLED_down(led_R);
break;
}
}
void analogLED(int LEDpin){
analogLED_up(LEDpin);
analogLED_down(LEDpin);
}
void analogLED_up(int LEDpin){
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
analogWrite(LEDpin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
}
void analogLED_down(int LEDpin){
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(LEDpin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
}
Este código se basa en una abstracción entre la aplicación y la conexión Bluetooth. Entre aplicación y Bluetooth se pueden transmitir tres señales diferenciadas. Botones numerados del 2 al 13, control analógico para PWM y envío de datos por serie.
De esta manera podemos asociar controles diferentes según los botones que apretemos en la aplicación. En esta caso podremos modular la intensidad de los LEDs con los sliders analógicos, efectos de Blink con los botones y en el caso de introducir por serie datos deberemos meter el código que se corresponde con cada acción, este paso es un poco más complejo.
De todo el código se puede practicar introduciendo las funciones que nosotros queramos ejecutar, en este caso, son muy simples, pero pueden modificarse para crear lo que cada uno crea conveniente. En cuanto a la conexión Bluetooth se podría usar la librería SoftwareSerial para conseguir lo mismo, pero a través de este código se puede ver como se establece la comunicación y como se mandan información en buffer a través de la funcion Serial.
Cuando tengamos nuestra aplicación instalada solo tenemos que conectar con el dispositivo Bluetooth HC-05 y vincular el móvil con un número “PIN” que por defecto es 1234. Una vez hecho esto nos dará un mensaje de que la conexión ha sido exitosa y podremos empezar a jugar.
Eso es todo, así que Feliz Navidad y dejad a vuestros amigos impresionados con estos juegos de luces.