¡Buenos días! Hoy vamos a crear nuestros primeros programas de Arduino usando dos de los componentes de los que disponemos: el led RGB y el buzzer o zumbador. La idea es “jugar” con los distintos colores que puede ofrecer este tipo de led y conseguir emitir sonidos con el segundo.
Antes de eso, vamos a revisar el ejemplo que tenéis indicado en la lección anterior, así como un código de iniciación que hemos diseñado y que visteis ayer en el vídeo. Este último código tiene la forma que se muestra a continuación:
La primera parte de un código siempre es escribir las variables que conozcamos a priori, un ejemplo de ellas serían:
//Esto es un comentario simple, sirven para añadir explicaciones. No se ejecutan
/* Esto es un comentario multilínea
* Sirve para explicaciones laaaargas
*/
//Aquí se suelen crear las variables que utiliza nuestro programa
//En esta variable podré guardar un mensaje de varios( [] ) caracteres( char )
char mensaje[] = «¡¡Bienvenidas al campus de ingenieras!!»;
String mensajeStr = «¡¡Bienvenidas al campus de ingenieras!!»; //Igual! Aunque menos eficiente
//Tipos en Arduino:
bool mayorEdad = true; // Solo 2 valores: true=1 o false=0
char caracter = ‘A’; // También caracteres especiales: * – / ? …
byte enteroPequenio = 8; // Números entre -127 y 128
int enteroNormal = 18524; // Números entre -32000 y 32000
long enteroEnorme = 134567876543345;
float decimalPequenio = 3.14;
double decimalEnorme = 3.14159234565;
Como podéis ver, existen muchos tipos de variables, que si números enteros, que si números decimales, variables que pueden solo tomar de valores “true” o “false”… También se pueden hacer comentarios en el código. Estos comentarios una gran herramienta para acordarnos qué queríamos hacer ahí o explicarle a alguien nuestro código. Luego vendría un apartado para configurar el Arduino y los componentes que usemos. Esto sería la zona de void setup().
//Aquí va el código de configuración inicial. Sólo se ejecuta una vez
void setup() {
//Iniciamos la comuncicación con la pantalla
Serial.begin(9600);
Serial.println("setup");
}
En este ejemplo vemos que se usa la línea “Serial.begin(9600)”. Su misión es indicarle a Arduino “Venga, despierta!”, y así poder comunicarnos y trabajar con él. Por último, viene la parte donde escribimos las acciones que queremos que ocurran al guardar el código. Esto sería dentro del apartado denominado void loop().
//Aquí va el código que se repetirá eternamente mientras nuestro Arduino siga vivo
void loop() {
Serial.println(mensaje);
Serial.println("¡Te muestro otro mensaje!");
delay(1000); //Delay significa retrasar, esta función hace una pausar de 1000ms = 1s
}
Estas líneas nos permiten mostrar en el Monitor Serial la frase: «¡Te muestro otro mensaje!». Además, la sentencia delay(tiempo) nos permite elegir el tiempo que tarda en pasar a la siguiente línea. Esta pausa se mide en ms, por lo que 1000ms = 1s.
¡Volvamos a los componentes!
Un uso que cada vez vemos más habitual de los leds RGB es en las lámparas y/o humidificadores que van cambiando de color a lo largo de la noche, o las tiras de colores que se usan para adornar las habitaciones.
Respecto al buzzer, un posible tercer nombre sería… ¡altavoz! Así que podéis imaginaros en cuántas de las cosas que utilizamos en el día a día se encuentra: televisiones, ordenadores, móviles…
Antes de empezar a programar y usar estos componentes vamos a aprender cómo funcionan cada uno de ellos:
· ¿Qué es y cómo funciona un LED RGB?
· ¿Qué es y cómo funciona un zumbador?
¿QUÉ ES Y CÓMO FUNCIONA UN LED RGB?
Antes de comenzar a explicar el led RGB, vamos a darle un repaso a qué es un led básico. Un LED es un diodo que nos permite emitir luz.
La gran diferencia entre ellos es que mientras el led básico sólo ilumina del color que sea su carcasa, en un led RGB se puede emitir prácticamente cualquier color. Los colores principales que puede emitir son el rojo (Red), verde (Green) y el azul (Blue), siendo el resto una mezcla de estos.
Por ejemplo, en este enlace (https://www.w3schools.com/colors/colors_picker.asp) podéis ver qué código RGB se asocia a cada color (posteriormente usaremos ese código en nuestro programa). Si miráis la siguiente captura veréis que hay un hexágono con una posible paleta de colores. Según donde cliquéis luego os aparecerá abajo un código con tres números, cada uno asociado a los colores rojo, verde y azul. En este ejemplo yo he seleccionado un color celeste.
Respecto a su diseño, mientras el led normal tiene solo dos patillas (¡polarizadas!), el led RGB podéis ver que tiene más, una patilla por color R-G-B y otra que hay que conectar a tierra (GND). Las patillas asociadas a los colores se unirán a los pines del Arduino para poder indicarles cuándo y con cuánta intensidad actuar.
Respecto al software también hay diferencias. Mientras un led básico se activa de forma digital (HIGH/LOW o 1/0), el led RGB hay que activarlo de forma más “analógica” dándole un valor dentro de un rango a cada uno de los 3 colores. Cuanto mayor sea el valor, más importancia tiene en la mezcla final. Por ejemplo, si sólo le damos un valor no nulo al rojo (R), el color que se emitirá es…¡el rojo!
Un ejemplo de código empleando un led básico rojo podría ser el siguiente:
Archivo -> Ejemplos -> 01.Basics -> Fade : hacer que un led externo cambie su brillo
¿QUÉ ES Y CÓMO FUNCIONA UN BUZZER?
Los zumbadores, buzzers o altavoces pasivos permiten convertir una señal eléctrica en una onda de sonido.
Nuestro zumbador va a tener 3 patillas:
· La primera, y más cercana al dibujito de una S, es la que le manda la información al buzzer, y va a tener que estar conectada a un pin digital que tenga pwm (~).
· La siguiente es la que le proporciona energía, y va a tener que estar conectada a los 5V.
· La última es la toma a tierra (GND).
Una vez que hayamos colocado cada uno de los pines en su lugar correspondiente, nos quedará un circuito parecido a este:
¡Ya podemos ponernos a programar e implementar nuestras ideas! Primero haremos un mini-proyecto con el LED RGB y luego otros dos con el buzzer.
Lo primero que debemos preguntarnos cuando empezamos un programa es lo siguiente
¿Qué va a hacer mi programa?
PARA EL PROGRAMA CON EL LED RGB
Cuando vayamos a empezar un programa y vayamos a responder la pregunta anterior, podemos plantearnos estas tres cuestiones:
Lógica: Vamos a probar cuatro combinaciones diferentes de colores. La luz estará encendida unos segundos, luego se apagará y se encenderá la siguiente, así ininterrumpidamente hasta que desconectemos el Arduino del ordenador.
Estructura: Como las luces se van a ir encendiendo y apagando una detrás de otra lo único que tenemos que tener en cuenta de la estructura es que se definan cuatro posibles combinaciones de color, una detrás de otra.
Ya tenemos la lógica y también sabemos cómo lo vamos a hacer, toca pensar en los materiales que utilizaremos.
Materiales: Siempre vamos a necesitar la placa, en este caso Arduino uno, el cable para poder programarla, un led RGB y cables para poder conectar los componentes a los pines. Os recomendamos 3 cables macho-hembra para el led RGB (si se conecta sin protoboard) o 3 cables macho-macho si se usa, más uno macho-macho para conectar a tierra.
Ya hemos pensado suficiente cómo va a ser nuestro proyecto, es hora de implementarlo:
El primer paso es nombrar las variables que vamos a utilizar y asignarles el pin al que las hemos conectado. IMPORTANTE: Ya que les estamos poniendo nombre, vamos a intentar que estos nombres tengan sentido porque, aunque es gracioso ponerle patata a una variable, también es muy probable que se nos olvide que nos estábamos refiriendo a la variable red asociada al pin escogido para ese color.
const int red = 6;
const int green = 5;
const int blue =10;
El siguiente paso es inicializarlas dentro del setup().
Inicializamos como pines OUTPUT los pines a los que la placa les tiene que enviar información. Como ejemplo perfecto tenemos el LED, porque la placa tiene que mandarle la información de si le toca estar encendido o apagado.
Inicializamos como pines INPUT los pines de los que la placa recibe información. Un ejemplo perfecto sería un sensor, porque la placa recibe de él la información y actúa en consecuencia. En este caso no tenemos ningún componente de este tipo.
void setup()
{
pinMode(red, OUTPUT);
pinMode(green, OUTPUT);
pinMode(blue, OUTPUT);
}
Por último, vamos a crear el cuerpo del bucle. Esto se hace dentro de la parte que se denomina void loop():
void loop()
{
analogWrite(red, 0);
analogWrite(green, 255);
analogWrite(blue, 255);
delay(1000);
analogWrite(red, 255);
analogWrite(green, 0);
analogWrite(blue, 255);
delay(1000);
analogWrite(red, 255);
analogWrite(green, 255);
analogWrite(blue, 0);
//Función que para el programa durante 1 segundo
delay(1000);
analogWrite(red, 180);
analogWrite(green, 40);
analogWrite(blue, 10);
delay(1000);
}
Para encender y apagar el LED RGB utilizamos la función analogWrite(nombre_led, intensidad), esta intensidad irá de 0 a 255, según queramos ese color en la mezcla. Aquí, el delay nos permite mantener el led encendido durante X tiempo (en este caso 1000 ms).
PARA EL PROGRAMA CON EL BUZZER
Vamos a seguir el mismo esquema que en el anterior caso para plantear los programas. El primer programa va a consistir en generar pitidos mediante el buzzer y contarlos, entonces…
Lógica: Vamos a hacer que el buzzer emita un sonido constante cada cierto tiempo. Cada vez que se emita, se irá incrementando un contador que irémos visualizado por el Monitor Serie.
Estructura: Hay que definir el tono que queramos que emita el buzzer, escoger el mensaje que queramos que muestre en el monitor e incrementar el contador. Para que el buzzer emita sonidos hay que tener en cuenta las siguientes funciones que proporciona Arduino:
Un Buzzer se puede controlar con las siguientes funciones que proporciona Arduino:
- tone(pin, frecuencia); Reproduce un sonido a la frecuencia determinada (en Hz) en el dispositivo conectado al pin dado.
- tone(pin, frecuencia, duración); Igual que la anterior pero con una duración dada. Esta función se espera hasta terminar el sonido para continuar el programa. Se dice que es una función bloqueante porque hasta que no termina el tono no sale de la función.
- noTone(pin); Esta función detiene el sonido del buzzer conectado al pin.
Materiales: la placa de Arduino uno, el cable para poder programarla, el buzzer y cables para poder conectar los componentes a los pines. Respecto a los últimos, es suficiente con usar 5 cables macho-macho.
Este programa es el primero que se muestra en el vídeo de hoy.
El código es el siguiente:
// Declaramos una variable para guardar el número del pin donde hemos conectado el Buzzer
// El modificador const indica que no se puede modificar
const int pinBuzzer = 9;
//Variable contador de pitidos
int contador = 0;
//Aquí va el código de configuración inicial. Sólo se ejecuta una vez
void setup() {
//Iniciamos la comunicación con la pantalla
Serial.begin(9600);
}
//Aquí va el código que se repetirá eternamente mientras nuestro Arduino siga vivo
void loop() {
contador = contador +1;
String mensaje = "Despierta yaaa : ";
mensaje.concat(contador);
Serial.println(mensaje);
tone(pinBuzzer, 440);
delay(1000);
noTone(pinBuzzer);
delay(1500);
}
Como podéis ver, primero definimos en qué pin vamos a conectar el buzzer al Arduino. Luego, en setup() activamos la comunicación con Arduino y, por último, dentro del loop() añadimos el funcionamiento que queremos. Primero incrementamos el contador sumándole 1, ese valor se va a juntar con el mensaje que hemos escrito y ambos se mostrarán por pantalla. Por último, usaremos tone() y noTone() para hacer sonar el buzzer. Entre medias de estas dos funciones añadiremos un delay para que el sonido se mantenga un tiempo.
Ahora vamos a ver un segundo programa, el cual incrementa un poco de dificultad. Por eso, antes hay que aprender unas cuestiones básicas de programación. Como vamos a usar diferentes tonos, éstos los vamos a almacenar o escribir todos juntos. Para eso, en vez de valores numéricos como le asociamos a los pines, usamos los corchetes {} para poner en su interior una secuencia de valores. Para hacernos una idea, vamos a recordar cuando nos poníamos en fila en el patio del colegio para entrar en clase, esperando a la hora. Vendría a ser eso, “elementos” ordenados. Una explicación un poco más compleja basada en Arduino podemos verla en el siguiente enlace: https://www.youtube.com/watch?v=_QuJUOl2gcY
Lógica: Vamos a probar diferentes tonos que emitir mediante el buzzer, cada uno durante un tiempo distinto. Por tanto, tendremos que ir eligiéndolos de uno en uno y dejando un poco de tiempo entre cada uno de ellos. En esta web (https://juegosrobotica.es/musica-con-arduino/ ) podeís echarle un vistazo a qué codificación tendrían las notas musicales que veis en clase de Música.
Estructura: Como vamos a tener diferentes tonos a escoger, vamos a tener que hacer un bucle para ir seleccionandolos de uno en uno. Los pasos podrían ser estos:
1. Memorizar el número del pin donde hemos conectado el buzzer
2. Memorizar una secuencia ordenada de tonos y otra secuencia ordenada de los tiempos de cada tono.
3. Para cada tono de la secuencia reproducirlo por el altavoz durante el tiempo establecido en la secuencia de duraciones.
Materiales: la placa de Arduino uno, el cable para poder programarla, el buzzer y cables para poder conectar los componentes a los pines. Respecto a los últimos, es suficiente con usar 5 cables macho-macho.
Este programa es el segundo que se ve en el vídeo sobre el buzzer.
El código sería el siguiente. Primero añadimos todas las variables de interés que conozcamos a priori.
//Declaramos una variable para guardar el número del pin donde hemos conectado el Buzzer
const int pinBuzzer = 9;
//Tabla de 10 celdas, en cada celda un valor decimal
const float tonos[] = { 987.77, 987.77, 987.77, 1174.66, 880, 987.77, 987.77, 987.77, 1174.66, 987.77 };
//Tabla de 10 celdas que representa el tiempo de duración de cada tono de la tabla anterior. Debe coincidir en número de elementos
const float tiempos[] = {100, 50, 50, 100, 75, 50, 75, 100, 50, 50};
//Constante guarda número de elementos de la tabla
const int nTonos = 10;
Luego configuramos la comunicación con Arduino.
//Aquí va el código de configuración inicial. Sólo se ejecuta una vez
void setup() {
Serial.begin(9600);
}
//Aquí va el código que se repetirá eternamente mientras nuestro Arduino siga vivo
Por último, en la zona de ejecución vamos a ir eligiendo los tonos uno a uno. Para eso vamos a conocer un elemento condicional en programación: el bucle for(). Éste permite que se realicen tantas iteraciones como veces se cumpla la condición que haya en su interior.
void loop() {
//Bucle for. Realiza las acciones del bloque para cada valor entre 0 y nTonos (de uno en uno)
//i es una variable que nos dice el número de vuelta
for (int i = 0; i < nTonos; i++) {
Serial.println(i);
//tonos[i] nos permite acceder al tono de la posición x de la tabla -> Así vamos pasando por todos los tonos
tone(pinBuzzer, tonos[i]);
//realizamos una espera mientras suena el tono del tiempo determinado en la tabla tiempos para la posición i
delay(tiempos[i]); //Duración del tono
noTone(pinBuzzer); //Apaga sonido
delay(50); //Pausa entre tonos
}
//Al terminar la melodía parar el sonido y hacer una pausa de 3 segundos
noTone(pinBuzzer);
delay(3000);
}
Resumiendo… como antes, en primer lugar le asignamos una patilla de la placa al buzzer, mediante la cual le vamos a poder mandar las órdenes. En la variable tonos indicamos los diferentes tonos que vamos a oír, 10 en este caso. En otra variable (o array al ser varios valores seguidos) indicamos el tiempo que sonará cada uno, ¡recordad que está en ms!
Lo siguiente que aparece en el código es ya el bucle for(). En este caso, se repiten las líneas de su interior tantas veces como cantidad de tonos tengamos. Esto permite “leer” esos valores de forma seguida y automáticamente. Las funciones tone() y noTone() dan lugar a la activación/desactivación del buzzer.
¡Y estos serían los componentes de hoy! Mañana aprenderemos a usar más.
RETO(S) DIARIO(S)
Tal y como indica el nombre de este apartado cada día se propondrán uno o varios retos para que comprobéis, no solo si habéis entendido toda la explicación, sino que pongáis a prueba algo muy importante: vuestra capacidad para buscar información. Constantemente utilizamos conocimientos que otras personas aprendieron antes que nosotros y tenemos que aprovechar la gran ventaja que es tener internet para aprender cosas de forma autodidacta.
Todos los retos se resolverán a la mañana siguiente.
RETO 1
El primer reto del campus que os proponemos para este fin de semana es el siguiente:
Hoy hemos aprendido un poco de programación con Arduino y a conectar leds y hacerlos parpadear. El reto consiste en conectar el led RGB al Arduino y hacer una secuencia de mínimo 9 colores que se parezca a los colores del arcoíris, es decir, por ejemplo empezar en morado, azul oscuro, azul claro, verde, amarillo, naranja y rojo. Cada color debe durar al menos un segundo encendido y debe repetirse la secuencia continuamente.
Para que sea más divertido os dejamos un vídeo de cómo podéis hacer una tulipa para colocarla encima del led y tener una pequeña lámpara.
Cuando lo tengas manda un video funcionando por telegram a @F3l1c13n74 y ¡lo publicaremos en twitter! Si tienes twitter añádelo junto con el vídeo en el mensaje de telegram para que te mencionemos en la cuenta del campus.
Nota: tenéis como fecha límite para entregarlo hasta el domingo 4 a las 23:59.
La solución a este reto os la enseñaremos el lunes día 5 a las 9 de la mañana.
¡Ánimo! y ¡A jugar con el led RGB!
RETO 2
En esta ocasión el reto que os proponemos es crear tu propia melodía con el buzzer. Para ello tendrás que modificar tres cosas:
- El número de tonos
- la frecuencia de cada tono
- su duración (recordad ponerlo en ms y la misma cantidad que el número de tonos)
¡Sé original! ¡Queremos escuchar como suena tu melodía!, cuando lo tengas manda un video funcionando por telegram a @F3l1c13n74 y ¡lo publicaremos en twitter! Si tienes twitter añadelo junto con el vídeo en el mensaje de telegram para que te mencionemos en la cuenta del campus.
¡Vamos que no pare la fiesta!