Vamos a montar un arbolito de navidad con LEDs y sonido controlado por un primo de Arduino, el micro controlador Attiny85. Modificaremos un kit comercial que podremos encontrar en las tiendas de electrónica o en Internet.
El kit
Está compuesto por tres placas de circuito impreso, que será la estructura del árbol y sobre estas placas irán soldados los 19 LEDs: 7 rojos, 6 verdes y 6 amarillos, y el resto de componentes como las resistencias, transistores, condensadores, interruptor, etc.
El kit incluye un portapilas para 3 pilas de 1,5V AA que sumarían un total de 4,5V. También podemos alimentar el árbol con un cable que va incluido en el kit y que permite conectarlo a un conector USB como la de un cargador o un ordenador.
Modificaciones
Si montamos el kit tal y como viene, los LEDs de cada color se encenderán y apagarán consecutivamente, pero no tendremos ningún control sobre ello. El objetivo de este proyecto es modificar el kit para que un «primo» de Arduino pueda encender y apagar los LEDs según el programa que diseñemos. Además le añadiremos un buzzer (un pequeño altavoz) para que toque un villancico navideño cuando pulsemos un botón, que también le pondremos.
Para modificar el kit, primero debemos estudiar el esquema eléctrico y ver donde podemos intercalar nuestro Arduino.
Podemos ver que el esquema está compuesto de un bloque que se repite tres veces.
El bloque marcado con rojo corresponde a los LEDs rojos, el siguiente bloque recuadrado en amarillo es el de los LEDs amarillos y el último en verde a los LEDs de color verde.
Lo primero que haremos es quitar los condensadores de 22nF: C1, C2 y C3 así conseguiremos que cada bloque sea independiente y no dependa del anterior. Esta modificación es sencilla, basta con no soldar estos condensadores en las placas de circuito impreso. Ahora el esquema nos quedará así.
Cada bloque lleva un transistor: Q1, Q2 y Q3. Son los encargados de suministrar la corriente necesaria para encender los LEDs. A todos los efectos podemos verlos como interruptores que encienden o apagan los LEDs. Si conseguimos que Arduino controle estos interruptores conseguiremos encender y apagar los LEDs cuando queramos.
Un transistor tiene tres patillas cada una tiene un nombre: base, emisor y colector. La base es la patilla que activa o desactiva el transistor, es decir el que enciende o apaga el interruptor. Si miramos el esquema, vemos que las resistencias de 10K: R1, R3 y R5 están conectadas por un extremo a una patilla del transistor, precisamente a su base. El otro extremo de las resistencias R1, R3 y R5 es donde conectaremos nuestro Arduino, pero antes debemos desconectar ese extremo de las resistencias del resto del circuito.
Para hacer esta modificación tendremos que cortar las pistas que van a estas resistencias en el circuito impreso. Veamos primero las dos placas con forma de árbol donde tenemos estas las resistencias: R1, R3 y R5 de 10K.
La placa de circuito impreso de la izquierda, con la abertura abajo, la llamaremos pcb A y la placa que está a la derecha, con la abertura en al parte superior la llamaremos pcb B. La resistencia R1 esta recuadrado en rojo, R3 en amarillo y R5 en verde. En esta cara de los circuitos impresos no tenemos que hacer nada, así que veamos la otra cara.
Ampliamos y marcamos las pistas que tenemos que cortar de las resistencias R1, R3 y R5.
Con mucho cuidado y con un cuter o herramienta similar, procederemos a cortar estas pistas. Si todavía no puedes usar estas herramientas, pide ayuda a un adulto que lo haga por ti. Al final debe quedar algo parecido a esto en la placa A.
Y esto en la placa B.
Volviendo a esquema, vemos que la resistencia R2 controla la luminosidad de los LEDs rojos, R4 para los LEDs amarillos y R6 para los LEDs verdes.
Cuando hice el árbol y lo encendí me di cuenta que los LEDs verdes eran los que mas luminosidad tenían, los amarillos estaban mucho mas apagados y los rojos se veían bien. Así que modifique el valor de las resistencias para que los tres colores se vieran con la misma intensidad. Los valores que finalmente usé fueron: para R2 (LEDs rojos) un valor de 220 Ohms, R4 (LEDs amarillos) un valor de 330 Ohms y para R6 (LEDs verdes) el valor fue de 3K9 Ohms.
Justo a la derecha de estos tres bloques y solo para la placa B, tenemos una resistencia R7 que controla la luminosidad del LED D19, que es un LED rojo que va en la parte superior del árbol y no parpadea. Este LED está fijo y se enciende en cuanto el árbol recibe alimentación. El valor de la resistencia R7, que trae el kit, es demasiado elevado y el LED se veía muy poco. Con una R7 de un valor de 470 Ohms, obtenemos una luminosidad mucho mayor.
Montando el árbol
En este apartado soldaremos todos los componentes a las placas de circuito impreso y siguiendo unas sencillas reglas para que todo nos funcione perfectamente cuando terminemos.
Se supone que sabemos soldar, si no sabes o eres muy pequeño para hacerlo, pide a un adulto que ayude, lee primero todo este apartado y así le podrás decir donde tiene que ir cada componente.
Utilizaremos la mayoría de los componentes que vienen con el kit, aunque como hemos dicho antes, vamos a cambiar el valor de algunas resistencias para que todos los LEDs brillen por igual, además añadiremos algunos componentes como un buzzer para que toque una canción y el primo de Arduino el Attiny85. Todos esto tendremos que comprarlo aparte.
La lista de componentes que necesitamos será:
- (*) 2 resistencias de 220 Ohms (R2, tanto en la placa A y como en la B)
- 2 resistencias de 330 Ohms (R4, en placas A y B)
- (*) 2 resistencias de 3K9 Ohms (R6, tanto en placa A y como en la B)
- 6 resistencias de 10K (R1, R3 y R5, tanto en placa A y como en la B)
- (*) 1 resistencia de 470 Ohms (R7, sólo en la placa B)
- 1 resistencia de 1K ( La usaremos con Arduino )
- 13 LEDs rojos de 3mm (D1, D2, D3, D4, D5, D6, placas A y B y D19 sólo en la A)
- 12 LEDs amarillos de 3mm (D7, D8, D9, D10, D11 y D12, placas A y B )
- 12 LEDs verdes de 3mm (D13, D14, D15, D16, D17 y D18 , placas A y B )
- 6 transistores NPN S9014 ( Q1, Q2 y Q3, placas A y B )
- 1 Interruptor (S1 en la placa de la base )
- 1 conector de alimentación ( J1 en la placa de la base )
- 1 porta pilas de 3 pilas de 1,5V AA (en la placa de la base )
- (*) 20 cm de cable rígido rojo, verde y amarillo
- (*) 1 módulo Attiny85 con conector micro USB
- (*) 1 micro pulsador para circuito impreso
- (*) 1 buzzer HS-1212A
(*) Estos componentes no vienen con el kit y debemos comprarlos por nuestra cuenta.
Empezaremos soldando todas las resistencias que van en las placas A y B excepto las de 10K que las dejaremos para el final. Las resistencias son los componentes alargados de dos patillas que tienen en su cuerpo pintados 4 anillos de colores. Estos colores indican el valor de la resistencia y es muy fácil entender como van codificados utilizando la siguiente tabla:
Las tres primeras bandas indican el valor de la resistencia y la cuarta la tolerancia. Todas las resistencias de nuestro proyecto tienen la cuarta banda dorada, que corresponde a una tolerancia del 5%. Fijándonos sólo en las tres primeras bandas y dejando la cuarta banda dorada a la derecha tendríamos:
- 220 Ohms (rojo, rojo, marrón)
- 330 Ohms (naranja, naranja, marrón)
- 3K9 que son 3900 Ohms (naranja, blanco, rojo)
- 470 Ohms (amarillo, violeta, marrón)
- 1K ó 1000 Ohms ( marrón, negro, rojo )
- 10K igual 10000 Ohms (marrón, negro, naranja)
Después soldaremos los LEDs rojos amarillos y verdes, teniendo en cuenta la patilla más larga del LED es ánodo o positivo y la más corta es el cátodo o negativo. Tal y como podemos observar en este imagen
En las placas del árbol, en las posiciones donde va un LED, encontraremos un agujero cuadrado donde soldaremos la patilla más larga del LED (+) y otro agujero redondo para la patilla más corta del LED (-). Estos agujeros donde se sueldan los componentes en el circuito impreso se llaman PADs
Empezaremos por los rojos que van en las posiciones D1, D2, D3, D4, D5 y D6. Luego los amarillos que son D7, D8, D9, D10, D11 y D12. Por ultimo los verdes D13, D14, D15, D16, D17 y D18. Siempre teniendo en cuenta donde va el positivo, pad cuadrado y el negativo, pad redondo
Antes de soldar cada LED, debemos doblar sus patillas para que el LED quede en el borde de la cara del árbol y no perpendicular. Esto lo haremos en las placas que tienen forma de árbol A y B.
Después de soldar todos los LEDs y antes de cortar los terminales de cada LED observamos que las patillas más largas están a la izquierda o a la derecha dependiendo de que lado del borde del arbol estemos mirando.
A continuación soldaremos los transistores Q1, Q2 y Q3, todos ellos del mismo valor. Tienen tres patillas y haremos coincidir la forma del transistor con la silueta dibujada en las placas A y B.
El siguiente paso será soldar las resistencias R1, R3 y R5, todas de 10K, junto con un trozo de cable rígido de unos 15cm :
- Rojo para R1
- amarillo para R3
- Verde o Azul para R5
El cable se soldará en la patilla que está en la parte externa del árbol, de cada una de las tres resistencias.
Y por último soldaremos un cable negro en el pad cuadrado – y otro naranja en pad cuadrado +. Ambos en la base del árbol. El aspecto final debe quedar algo parecido a esta foto.
En este punto podemos probar si todo funciona correctamente en las placas A y B conectando los cables de cada placa del árbol a un Arduino UNO del siguiente modo:
- Cable naranja – pin +5V
- Cable negro – pin GND
- Cable rojo – pin 2
- Cable azul – pin 3
- Cable amarillo – pin 4
/*
* Sketch para probar el funcionamiento de los LEDs
* de las placas del arbol A y B
*/
// Definimos etiquetas para cada PIN
#define lED_ROJO 2 //Pin 2 (OUTPUT) --> cable rojo
#define lED_VERDE 3 //Pin 3 (OUTPUT) --> cable azul
#define lED_AMARILLO 4 //Pin 4 (OUTPUT) --> cable amarillo
void setup() {
// Definimos los pines de los LEDs como salida
pinMode(lED_ROJO, OUTPUT);
pinMode(lED_VERDE, OUTPUT);
pinMode(lED_AMARILLO, OUTPUT);
}
// Programa principal,<span style="display: inline-block; width: 0px; overflow: hidden; line-height: 0;" data-mce-type="bookmark" class="mce_SELRES_start"></span> se repite en un bucle infinito
void loop() {
// Enciende solo los LEDs rojos
digitalWrite(lED_ROJO, HIGH);
digitalWrite(lED_AMARILLO, LOW);
digitalWrite(lED_VERDE, LOW);
// 3 segundos de pausa
delay(3000);
// Enciende solo los LEDs amarillos
digitalWrite(lED_ROJO, LOW);
digitalWrite(lED_AMARILLO, HIGH);
digitalWrite(lED_VERDE, LOW);
// 3 segundos de pausa
delay(3000);
// Enciende solo los LEDs verdes
digitalWrite(lED_ROJO, LOW);
digitalWrite(lED_AMARILLO, LOW);
digitalWrite(lED_VERDE, HIGH);
// 3 segundos de pausa
delay(3000);
// Enciende todos los LEDs encendidos
digitalWrite(lED_ROJO, HIGH);
digitalWrite(lED_AMARILLO, HIGH);
digitalWrite(lED_VERDE, HIGH);
// 3 segundos de pausa
delay(3000);
// Apaga todos los LEDs
digitalWrite(lED_ROJO, LOW);
digitalWrite(lED_VERDE, LOW);
digitalWrite(lED_AMARILLO, LOW);
// 3 segundos de pausa
delay(3000);
}
Este sketch realizará el siguiente ciclo:
- Enciende todos los LEDs rojos durante tres segundos
- Enciende sólo los amarillos otros tres segundos
- Enciende solamente los LEDs verdes tres segundos
- Enciende todos los LEDs de los tres colores otros tres segundos
- Apaga todos los LEDs durante tres segundos
Cuando comprobemos que las placas A y B funcionan correctamente y que todos los LEDs se encienden, desoldaremos el cable negro y naranja de cada placa.
El siguiente paso es soldar el interruptor y el conector de alimentación en la placa cuadrada que forma la base del árbol, prestando atención a la posición del interruptor, el cual tiene una parte del pulsador blanco que tiene un pequeño surco. Este surco debe quedar mirando hacia el centro de la placa, de no hacerlo así el interruptor funcionará al revés.
El conector de alimentación sólo tiene una posición posible.
Montamos la placa A y B haciendo coincidir sus ranuras y forma así el árbol.
y lo presentamos sobre la base cuadrada, haciendo coincidir el símbolo + y – del árbol con los símbolos que hay en la base.
En este punto hay que tener especial cuidado ya que en la base cuadrada el símbolo + apunta a dos ranuras y el árbol tiene también marcado dos símbolos +, lo mismo ocurre con el -, tenemos que girar el árbol sobre la base hasta que todos los + y – estén alineados y coincidan.
Luego insertaremos el árbol en las ranuras que hay en la base y soldaremos el árbol en la base.
En la mitad de la placa A y B, veremos que hay dos cuadrados alineados que debemos soldar y así conseguir que el árbol tenga más rigidez. Hay cuatro puntos de soldadura a la misma altura, sólo debemos ir girando el árbol e ir soldando.
Del árbol a la base tenemos 6 cables: dos rojos, dos amarillos y dos azules, pero tenemos que dejar sólo tres cables, uno de cada color. Tenemos que conectar un cable rojo de una de las placas con la resistencia del cable rojo de la otra placa y esto mismo con los otros dos colores.
Es hora de montar el pequeño micro controlador Attiny85.
Cuenta con 6 puertos: P0, P1, P2, P3, P4 y P5. Y tres pines de alimentación: 5V, Gnd y VIN
El Attiny85 será el encargado de controlar los LEDs del árbol. aprovechamos para poner un pequeño buzzer (mini altavoz) y un pulsador para que reproduzca un villancico navideño cuando apretemos el pulsador.
Los puertos que se utilizarán serán los siguientes:
P0 => Pulsador
P1 => Altavoz
P2=> LEDs rojos (cable rojo)
P3 => LEDs verdes (cable azul)
P4 => LEDs amarillos (cable amarillo)
Primero empezaremos conectando el pulsador. Colocando el pulsador con las patillas mirando frente a nosotros, cortaremos la que está a la derecha, en la siguiente foto se indica que patilla debemos cortar. Después giramos el pulsador 90 grados en el sentido de las agujas del reloj y metemos la patilla que no hemos cortado en puerto P0 del modulo TINY85 (imagen de en medio). A continuación empujamos el pulsador hasta que el borde del cuerpo de interruptor quede alineado con el borde de la placa del TINY85 (última imagen). Soldamos la patilla del interruptor a P0.
Damos la vuelta al módulo y soldaremos en P1 una resistencia de 470 Ohmios y 1/4 W. En el otro extremo de la resistencia soldaremos a la patilla + del Buzzer, cuidado que este componente tiene polaridad. Y en la patilla – del buzzer un trocito de cable negro.
Utilizaremos el sobrante de la patilla que hemos cortado a la resistencia después de soldarla y haremos una especie de C invertida que la soldaremos entre el pulsador y GND, tal y como se ve en la foto.
Por último podremos los cables de alimentación. Uno rojo que soldaremos en el pad de 5V y uno negro a GND, donde tenemos la C invertida que va al pulsador.
Con una pistola de pegamento caliente o termofusible, pegamos el módulo TINY85 en la placa cuadrada del árbol, cerca del pulsador tal y como muestra la foto y asegurándonos que los cables de alimentación, rojo y negro, quedan cerca de la base del árbol.
Soldamos el cable de alimentación rojo en la base del árbol que tenemos marcado con un +, ver más arriba la foto cuando soldamos el árbol a su base. Y haremos lo mismo con el cable negro de alimentación pero lo soldaremos al – de la base del árbol.
Con un poco de paciencia guiamos los cables que bajan del árbol para que queden lo más ordenado posible y soldaremos el cable rojo a P2, el azul a P3 y amarillo a P4, cortando el sobrante antes de soldar para que los cables queden lo más planos posibles.
Por último pegaremos el buzzer con la pistola temofusible y soldaremos su cable negro en la base del árbol marcado con el símbolo –
El resultado debería ser algo similar a esto
Sólo falta cargar el programa final.
#define PULSADOR 0 //Pin 0 (INPUT) --> Pulsador
#define BUZZER 1 //Pin 1 (OUTPUT) --> buzzer PWM
#define lED_ROJO 2 //Pin 2 (OUTPUT) --> contador 1
#define lED_VERDE 3 //Pin 3 (OUTPUT) --> contador 2
#define lED_AMARILLO 4 //Pin 4 (OUTPUT) --> contador 3
int contador = 0;
int resto;
void setup() {
// Definimos los pines como entrada o salida
pinMode(PULSADOR, INPUT);
pinMode(BUZZER, OUTPUT);
pinMode(lED_ROJO, OUTPUT);
pinMode(lED_VERDE, OUTPUT);
pinMode(lED_AMARILLO, OUTPUT);
digitalWrite(PULSADOR, HIGH);
cancion();
delay(500);
cancion();
contador = 158;
}
void loopcontador() {
if (contador >= 0 && contador <= 24) { //24 resto = contador % 3; if (resto == 0) soloRojoOn(); if (resto == 1) soloAmarilloOn(); if (resto == 2) soloVerdeOn(); } if (contador >= 25 && contador <= 69) { //46 resto = (contador - 25) % 6; if (resto == 0) soloAmarilloOn(); if (resto == 1) soloVerdeOn(); if (resto == 2) soloRojoVerdeOn(); if (resto == 3) soloAmarilloVerdeOn(); if (resto == 4) todosOn(); if (resto == 5) soloRojoOn(); delay(125); } if (contador >= 70 && contador <= 93) { //24 resto = (contador - 70) % 3; if (resto == 0) soloRojoOn(); if (resto == 1) soloAmarilloOn(); if (resto == 2) soloVerdeOn(); } if (contador >= 94 && contador <= 133) { //40 resto = (contador - 94) % 8; if (resto == 0) soloRojoOn(); if (resto == 2) soloAmarilloOn(); if (resto == 4) soloVerdeOn(); if (resto == 6) soloAmarilloOn(); } if (contador >= 134 && contador <= 157) { //24 resto = (contador - 134) % 3; if (resto == 0) soloRojoOn(); if (resto == 1) soloAmarilloOn(); if (resto == 2) soloVerdeOn(); } if (contador >= 158 && contador <= 205) { //48 resto = (contador - 158) % 8; if (resto == 0) todosOn(); if (resto == 4) todosOff(); } contador = contador + 1; if (contador > 206) contador = 0;
}
void soloRojoOn() {
digitalWrite(lED_ROJO, HIGH);
digitalWrite(lED_AMARILLO, LOW);
digitalWrite(lED_VERDE, LOW);
}
void soloAmarilloOn() {
digitalWrite(lED_ROJO, LOW);
digitalWrite(lED_AMARILLO, HIGH);
digitalWrite(lED_VERDE, LOW);
}
void soloVerdeOn() {
digitalWrite(lED_ROJO, LOW);
digitalWrite(lED_AMARILLO, LOW);
digitalWrite(lED_VERDE, HIGH);
}
void soloRojoVerdeOn() {
digitalWrite(lED_ROJO, HIGH);
digitalWrite(lED_AMARILLO, LOW);
digitalWrite(lED_VERDE, HIGH);
}
void soloAmarilloVerdeOn() {
digitalWrite(lED_ROJO, LOW);
digitalWrite(lED_AMARILLO, HIGH);
digitalWrite(lED_VERDE, HIGH);
}
void todosOn() {
digitalWrite(lED_ROJO, HIGH);
digitalWrite(lED_AMARILLO, HIGH);
digitalWrite(lED_VERDE, HIGH);
}
void todosOff() {
digitalWrite(lED_ROJO, LOW);
digitalWrite(lED_VERDE, LOW);
digitalWrite(lED_AMARILLO, LOW);
}
void tonoArbol (int frecuency, float duration)
{
tone(BUZZER, frecuency, duration);
loopcontador();
if (contador > 2) contador = 0;
}
void cancion() {
delay(86.8054166667);
tonoArbol(311, 312.4995);
delay(347.221666667);
tonoArbol(415, 312.4995);
delay(347.221666667);
tonoArbol(415, 156.24975);
delay(173.610833333);
tonoArbol(466, 156.24975);
delay(173.610833333);
tonoArbol(415, 156.24975);
delay(173.610833333);
tonoArbol(391, 156.24975);
delay(173.610833333);
tonoArbol(349, 312.4995);
delay(347.221666667);
tonoArbol(349, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(349, 312.4995);
delay(347.221666667);
tonoArbol(466, 312.4995);
delay(347.221666667);
tonoArbol(466, 156.24975);
delay(173.610833333);
tonoArbol(523, 156.24975);
delay(173.610833333);
tonoArbol(466, 156.24975);
delay(173.610833333);
tonoArbol(415, 156.24975);
delay(173.610833333);
tonoArbol(391, 312.4995);
delay(347.221666667);
tonoArbol(311, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(311, 312.4995);
delay(347.221666667);
tonoArbol(523, 312.4995);
delay(347.221666667);
tonoArbol(523, 156.24975);
delay(173.610833333);
tonoArbol(554, 156.24975);
delay(173.610833333);
tonoArbol(523, 156.24975);
delay(173.610833333);
tonoArbol(466, 156.24975);
delay(173.610833333);
tonoArbol(415, 312.4995);
delay(347.221666667);
tonoArbol(349, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(311, 156.24975);
delay(173.610833333);
tonoArbol(311, 156.24975);
delay(173.610833333);
tonoArbol(349, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(466, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(391, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(415, 546.874125);
delay(607.637916667);
delay(86.8054166667);
tonoArbol(311, 312.4995);
delay(347.221666667);
tonoArbol(415, 312.4995);
delay(347.221666667);
tonoArbol(415, 312.4995);
delay(347.221666667);
tonoArbol(415, 312.4995);
delay(347.221666667);
tonoArbol(391, 624.999);
delay(694.443333333);
tonoArbol(391, 312.4995);
delay(347.221666667);
tonoArbol(415, 312.4995);
delay(347.221666667);
tonoArbol(391, 312.4995);
delay(347.221666667);
tonoArbol(349, 312.4995);
delay(347.221666667);
tonoArbol(311, 546.874125);
delay(607.637916667);
delay(86.8054166667);
tonoArbol(466, 312.4995);
delay(347.221666667);
tonoArbol(523, 312.4995);
delay(347.221666667);
tonoArbol(466, 312.4995);
delay(347.221666667);
tonoArbol(415, 312.4995);
delay(347.221666667);
tonoArbol(622, 312.4995);
delay(347.221666667);
tonoArbol(311, 312.4995);
delay(347.221666667);
tonoArbol(311, 156.24975);
delay(173.610833333);
tonoArbol(311, 156.24975);
delay(173.610833333);
tonoArbol(349, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(466, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(391, 234.374625);
delay(260.41625);
delay(86.8054166667);
tonoArbol(415, 546.874125);
delay(607.637916667);
}
// Programa principal se repite constantemente:
void loop() {
if (digitalRead(PULSADOR) == LOW) {
cancion();
delay(500);
cancion();
contador = 158;
}
loopcontador();
delay(250);
}