Quienes nos dedicamos al desarrollo de proyectos electrónicos con aplicaciones informáticas sabemos que nuestras creaciones siempre tienen pánico escénico. Esto ocurre cuando el proyecto funciona correctamente pero cuando se lo enseñas a alguien, al proyecto le entra una mezcla de miedo y vergüenza que hace que no funcione correctamente delante del público.
Por este motivo, siempre dejamos este último día para arreglar esos fallos de última hora que han surgido una vez nuestro proyecto se ha terminado y se lo hemos enseñado a nuestros amigos. Hoy vamos a reparar lo que nos quede y prepararnos para la exposición que tendrá lugar…¡¡Mañana!!
¡Buenos días! Empecemos con las soluciones a los mini-retos!! El archivo .ino donde se encuentra este código está en la sección Trabajo de Clase, en el apartado DÍA 4: Integración de componentes. Esta solución sería diseñando todos los miniretos en el mismo archivo, si los tenéis un poco diferentes, ¡no pasa nada! Es normal que vayamos haciendo ya los códigos diferentes.
void minireto_cuatro(){
pantalla.borrar();
pantalla.escribirFrase("Hola"); //Posición por defecto 0
for (int i = 0; i < nTonos; i++) {
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]); //Duranción del tono
noTone(pinBuzzer); //Apaga sonido
delay(50); //Pausa entre tonos
}
void minireto_nueve(){
String dia,mes;
dia = '0' + String(7);
mes = '0' + String(7);
pantalla.borrar();
pantalla.escribirFrase(dia+mes);
for (int i = 0; i <= 7; i++) {
// Se debe indicar: nMatriz, Fila y Columna. Utiliza la tabla proporcionada para entenderlo!
pantalla.setLed(1,i, 0);
Y ahora… ¡a conocer el último componente que nos queda! Vamos a usar un mando emisor de luz infrarroja y un sensor de luz infrarroja, a este conjunto también se le conoce como IR (infrared).
¿Cuántas cosas podéis nombrar que usen este tipo de señal? ¡En nuestro día a día usamos este tipo de comunicación varias veces! Esto nos va a permitir controlar nuestro proyecto a distancia. Hay que tener en cuenta que cada mando emite unos códigos diferentes según el dispositivo al que está dirigido. Pensad qué pasaría si queriendo encender la televisión se abre la puerta del garaje. Incluso no todos los mandos sirven para todas las teles. Por eso, cada mando emite unos valores que sólo su respectivo sensor conoce.
Lo primero que tenemos que hacer es conectar nuestro sensor y comprobar cuales son los valores que emite nuestro mando.
Para eso usaremos el siguiente código, el cual podéis encontrar en el apartado Código base de la sección DÍA 5: Mando y sensor IR:
Al igual que pasaba con la matriz de leds, el sensor infrarrojos necesita una librería para comunicarnos fácilmente con estos componentes. Para descargar la librería IRremote.h tenéis que seguir los siguientes pasos en la aplicación de Arduino:
Pestaña programa->incluir librería->administrar bibliotecas->buscar el nombre
El código es muy simple: primero indicamos el pin de Arduino al que vamos a conectar el sensor infrarrojos (y al que apuntaremos con el mando); en void setup() se indica el comando necesario para establecer comunicación con el sensor; por último en void loop() tenemos líneas que mostrarán información en el monitor serie. Cada vez que se pulse un botón, aparecerá el código asociado a él. ¡Que no se os olvide abrir el Monitor Serie!
Una forma simple de esquematizar los valores obtenidos es rellenar la siguiente tabla cambiando los valores que obtengáis, los nuestros son:
const int KEY_UP = 24;
const int KEY_LEFT = 8;
const int KEY_OK = 28;
const int KEY_RIGHT = 90;
const int KEY_DOWN = 82;
const int KEY_1 = 69;
const int KEY_2 = 70;
const int KEY_3 = 71;
const int KEY_4 = 68;
const int KEY_5 = 64;
const int KEY_6 = 67;
const int KEY_7 = 7;
const int KEY_8 = 21;
const int KEY_9 = 9;
const int KEY_0 = 25;
const int KEY_ASTERISK = 22;
const int KEY_POUND = 13;
Vamos a ver a continuación un ejemplo de programa para ver cómo funciona el mando IR con su sensor. Tras la imagen comentaremos qué hace este código.
Al principio definimos todas las variables asociadas a los pines y códigos que están asociados al sensor IR. En void setup() simplemente activamos la comunicación con Arduino y con el sensor. El código en void loop() se puede ordenar de la siguiente forma:
1. Se detecta si se ha emitido una señal desde el mando, y si ésta se ha entendido. En caso afirmativo su valor se guarda en la variable teclaPulsada.
2. Para seleccionar una u otra acción en función del botón pulsado del mando vamos a usar la función switch(). Esta función permite dar una serie de opciones (“case”), y para cada una de dichas opciones se le asignará una tarea. Por tanto, únicamente se ejecutarán las líneas de código asociadas al botón escogido. Cuando puede que ninguna de las opciones se cumpla (o si quieres una acción por defecto), se usa en vez de “case”, “default”.
3. Por último, reiniciamos el sensor IR para poder mandarle información nueva.
Y ahora… ¡a por los retos!
RETOS DIARIOS
Los retos para hoy son los siguientes:
Reto 1:
En este primer reto vamos a comprobar qué ocurre si apuntamos con otro mando, por ejemplo el de la televisión, al sensor IR que hemos empleado. Para ello, podéis usar el mismo código que hemos empleado para conocer los códigos que necesitábamos con el mando del proyecto. En este reto se entregaría la codificación que habéis obtenido con los dispositivos que tengáis por casa (captura del Monitor Serie, una tabla con los valores, ¡lo que veáis más cómodo!)
Reto 2:
Antes hemos hecho un código teniendo en cuenta qué ocurría si pulsábamos la tecla de “arriba” y “abajo”. Os proponemos que ampliéis esa idea al resto de teclas, ¿qué ocurre si pulso el número 1? En cada una de las teclas debéis añadir una funcionalidad.
Nota: podéis usar las 12 funciones generadas en el reto del día anterior para ello.
Hoy es un día muy importante, ¡vamos a acabar nuestro proyecto!
Pero antes vamos a resolver los retos. Tenéis la solución del segundo reto en Classroom, colocada en la sección DÍA 5: Mando y sensor IR.
RETO 1
La solución de esta reto no es ninguna concreta, a cada una os saldrán unos códigos diferentes. Preferimos ver qué resultados os han salido para ver que cosas más diferentes podemos obtener. ¿Nos los enseñáis?
RETO 2
Para este código, tened en cuenta que cada una habréis puesto funciones diferentes en teclas del mando diferentes. Tenedlo sólo como ejemplo y seguid usando vuestra configuración. Tampoco os lo adjuntamos completo, si no con unas cuantas teclas más, ¡para que os hagáis una idea!
Ya no te queda nada nuevo por conocer, simplemente vas a ver que eres capaz de crear un súper proyecto con todo el material que tienes.
El material básico que proponemos para el proyecto final consta de los siguientes componentes: Arduino uno, su cable de conexión, cables, un pulsador, el buzzer, la matriz de leds y los elementos IR. También puedes personalizarlo añadiendo el led RGB y el otro pulsador restante. El ejemplo que os vamos a poner es empleando todos los componentes salvo el segundo pulsador. Su función (activar la alarma) ahora la realizará la tecla “OK” del mando.
O si lo queremos con el led RGB
Para juntar TOOOOODOS los conocimientos que tenéis de estos días, hemos pensado que podéis unir las ideas del temporizador con las ideas que hemos hecho con el mando. La idea principal es ajustar el tiempo del temporizador mediante el mando, y una vez activada la alarma, que se muestre el contador disminuyendo en pantalla hasta que haga ¡BOOM!
Respecto al temporizador, hasta ahora sabemos como mostrarlo en pantalla y ver cómo disminuye. Nos falta saber escoger el tiempo mediante el mando IR
Por tanto, si la alarma la vamos a activar mediante el mando, ya sólo necesitamos un botón para desactivar la alarma. En caso de que no podamos o no nos apetezca usar el mando SÍ se puede usar el otro botón para activar el temporizador
Como complemento, no sólo nos vamos a centrar en el temporizador, sino que todos los botones los podéis a asociar a las teclas, tal y como hemos ido viendo en los retos. Esto puede hacer que se os ocurran cosas muy chulas para el proyecto final
NOTA IMPORTANTE: El proyecto final puede ser LO QUE QUERÁIS. Si no os apetece hacer el temporizador, con vuestras propias funciones pueden surgir cosas chulísimas. ¡Lo importante es la creatividad!
Nosotras, en esta clase vamos a explicar cómo unificar todo para añadir el temporizador, pero repetimos…¡Podéis hacer otras cosas!
¡Aquí va el vídeo de nuestra propuesta! Y el código lo tenéis en la sección DÍA 6: PROYECTAZO del Classroom (Trabajo de clase).
La idea sobre la que gira el código en void loop() es la misma que hemos ido viendo: comprobar si la alarma debe o no sonar en cada momento en función del temporizador y del pulsador, y al hacerlo que suene la secuencia de tonos prediseñada por nosotros. Con el mando vamos a incluir que si se pulsa la flecha de arriba o la de abajo se amplíe/disminuya el tiempo restante para la activación de la alarma (siempre y cuando esta esté desactivada). Si le damos a OK, la alarma se activará de la misma forma que cuando le dábamos con el pulsador.
La parte de definición de variables y el void setup() vais a ver que es una unión de todo lo que ya hemos visto. ¡Que no se os olvide incluir las librerías!
Las dos únicas líneas desconocidas son escribirIcono() y esperarYBorrar(). La primera de estas funciones se mostrará una flecha que va pasando por todos los leds, y posteriormente aparecerá un “Hola”. Con la segunda se borra esto último. Es decir, hemos pasado a formato función las acciones que ya hacíamos en códigos anteriores.
void escribirIcono(){
// Escribir un icono como una secuencia de bits y diciédole al método qué icono y en qué columna situarlo
pantalla.escribirBits(FLECHA_DER);
pantalla.escribirBits(FLECHA_DER, 8);
pantalla.escribirBits(FLECHA_DER, 16);
pantalla.escribirBits(FLECHA_DER, 24);
}
Ahora veamos nuestra propuesta de void loop(). Primero comprobamos si la alarma está o no activada. En función de eso se activará el temporizador y todas sus consecuencias (sonido del buzzer, mensaje en pantalla…). El mando nosotras lo vamos a usar para incrementar/decrementar el tiempo que queremos esperar para la activación de la alarma mediante las flechas superior e inferior. Si le damos a OK, la alarma se activará de la misma forma que cuando le dábamos con el pulsador.
El código para mostrar los segundos (mostrarMinutosSegundos()) es el mismo que ya vimos. Tened en cuenta que las variables min y seg se han inicializado a valor 0 para que las configuréis con el mando.
Con respecto al led RGB, este no realiza una labor esencial, pero se puede dejar conectado, por ejemplo, con la idea de un semáforo en mente, se puede añadir al temporizador y que se ilumine en función del tiempo que quede para finalizar la cuenta atrás:
//Cuando borremos la pantalla, también podemos apagar el led RGB con la función:
void apagarLeds(){
analogWrite(red,0);
analogWrite(green,0);
analogWrite(blue,0);
}
//La función asociada al semáforo se puede usar dentro del temporizador:
void lanzarTemporizador(){
while(minutos>0 || segundos>0){
mostrarMinutosSegundos();
if(segundos>0){
segundos--;
}else if(minutos>0){
segundos=59;
minutos--;
}
semaforoColor();
}
}
¡IDEA!
Habéis diseñado 12 funciones que se pueden asociar a 12 teclas, más las tres que necesitas (flecha arriba, flecha abajo, Ok) para ajustar el temporizador… ¿No sobran teclas? ¡Sí! Dos más. Os proponemos que si queréis uséis las teclas asociadas a las flechas laterales (-> y <-) para incrementar/disminuir minutos. Es la misma idea que la funcionalidad de las flecha de arriba y de abajo para ajustar los segundos, pero para minutos.
¡Y esto sería todo! Habéis conseguido implementar un temporizador que puede ser ajustado a distancia. ¡Enhorabuena! Ahora si queréis podéis personalizar el proyecto añadiendo más funcionalidades y, por supuesto, visualmente. ¿Qué diseño y/o uso quieres darle a tu proyecto? ¡¡Estamos deseando ver vuestros proyectos!!
Podéis aprovechar el día para resolver todos los problemas que se hayan podido producir en los últimos días respecto a la integración de componentes. Por otro lado, si alguien ya tiene todos los componentes funcionando proponemos GUARDAR la versión que funciona (¡sacad fotos!) y hacer una copia en la que probaremos a diseñar algún minijuego.
¡Buenos días! Resolvamos los retos de ayer, los podéis encontrar en el apartado DÍA 3: Pantalla de leds dentro de Classroom en Trabajo de Clase (Solución retos 1, 2 y 3 matrices de leds).
Reto 1: Encontrar las figuras ocultas
La figura que resultaba de rellenar las casillas de la matriz es la siguiente:
Reto 2: ¡Diseña tu propio dibujo de leds!
Para este reto, al ser totalmente personalizable, nuestra solución no tiene mucho sentido. No obstante, os adjuntamos cómo podría quedar el código si se usan funciones:
//RETO 2 : Diseñar un icono propio
mostrarDibujo();
Si tenéis dudas o queréis mostrar vuestros iconos en clase, ¡podemos echarle un vistazo!
Reto 3: Icono que se desplaza
Reto 4 (opcional)
Hoy vamos a seguir con la idea de la clase anterior, unificando los conocimientos aprendidos y usando la mayoría de los componentes que hemos usado hasta ahora. Tened a mano los dos pulsadores, el buzzer y la matriz de leds.
La idea es seguir complementando el temporizador. En este caso se va a mostrar la cuenta atrás de activación de la alarma mediante la pantalla diseñada con matrices leds. Cuando termine la cuenta atrás, el buzzer comenzará a sonar. Para pararlo, tendremos que pulsar el primer botón. Si queremos que vuelva a comenzar la cuenta atrás, se deberá pulsar el otro botón restante, y así tantas veces queramos.
Para ello, antes del bucle asociado a que el buzzer emita sonidos, añadiremos una función asociada a generar un temporizador-contador que muestre el tiempo que queda en pantalla para que la alarma suene. Ese tiempo será 10 segundos. Cuando pase dicho tiempo, se mostrará “BOOM” en pantalla y comenzará a sonar la alarma. La configuración del circuito es la siguiente:
Poco a poco vamos a diseñar el código. El primer paso es ir viendo qué variables son necesarias para inicializar los componentes (definición de pines y de variables que conozcamos):
Como veis, es unir las variables del código que ya tenemos hecho del buzzer, del pulsador y de las matriz de leds. Con respecto al void setup(), esta vez va a ser un poco más completo:
Al comenzar el programa, además de configurar los pines, se van a mostrar varias frases en la pantalla. Además, las dos funciones que hay asociadas a las interrupciones de los botones son las siguientes:
La función pararAlarma() como su nombre indica, la usaremos para controlar si queremos que la alarma continúe o no. Como cuando pulsamos el despertador por la mañana para que deje de sonar. La función activarAlarma() vendría a ser como el interruptor de la alarma, que dejamos por la noche activado para que por la mañana suene la alarma. Cuando pulsemos el botón asociado al pin pinActivarAlarma, según la interrupción la alarma se activará, y comenzará a funcionar el temporizador (que ahora después lo veremos).
Ahora vamos a analizar el void loop():
void loop() {
//Si la alarma no está OFF, es decir, la alarma está activa, lanzamos el temporizador
if (alarmaOFF == false) {
¡Qué pocas líneas! Eso es porque cada vez sabemos programar de forma más eficiente y compacta. Veamos qué significan:
1. Primero se comprueba si la alarma está activada o no. Se comprueba el valor de la variable alarmaOFF, que inicialmente la habíamos colocado como false. Ese valor cambiará cuando pulsemos el botón y se ejecute activarAlarma(). En el primer ciclo, directamente saltará la alarma sin pulsar ningún botón, al haber inicializado la variable con ese mismo valor
2. Cuando ya se haya pulsado, se cumplirá la condición y pasará a ejecutarse la siguiente línea: lanzarTemporizador(). El código asociado a esta función lo vamos a ir construyendo poco a poco (¡podéis considerarlo como un reto!), es más a priori os lo vamos a dar como plantilla para que lo rellenéis:
La idea es intentar mostrar en la pantalla una cuenta atrás del número de segundos de la alarma. Es decir, que si la alarma se pone en 10 segundos en nuestra pantalla aparezca 00:10 -> 00:09 -> 00:08 -> 00:07 -> 00:06 -> 00:05 … 00:00.
Para representar estos minutos y segundos os hemos proporcionado dos funciones mostrarMinutosSegundos() y separadorDosPuntos() que se explicaron brevemente ayer (están copiadas de nuevo aquí abajo).
La función mostrarMinutosSegundos() utiliza las dos variables declaradas (minutos y segundos) para representar sus valores en la pantalla. Es una función especial porque si los valores de minutos o segundos son más pequeños que dos cifras, los muestra siempre con dos cifras. Por ejemplo, si el número de minutos es 0 y de segundos es 7, le pone un 0 delante a ambas variables para poder mostrar 00 y 07.
La función separadorDosPuntos() dibuja » : » sobre la matriz 1 (minutos) para visualmente separar los dígitos de los minutos de los segundos.
Para resolver este reto os proponemos tres pasos:
a) Estableciendo la variable minutos a 0. Controlar los valores que tiene la variable segundos (siempre entre 59 y 0) desde la función que hace la cuenta atrás llamada lanzarTemporizador(). Es decir, en cada vuelta debes decrementar la variable segundos y llamar a la función mostrarMinutosSegundos. Por otro lado, como la pantalla funciona un poco lenta, el tiempo de espera no es 1000 ms sino algo menos porque la pantalla tarda en representar los números. Nosotras estamos utilizando 775ms, ¡pero podéis cronometrarlo para que sea más exacto! Puedes hacerlo con el bucle for de la función cuentaAtrasEnSegundos() o bien, lo que te recomendamos, hacerlo con el bucle while() que se muestra en la plantilla, que es la estructura para resolver la siguiente parte de este reto….
b) ¿Qué ocurre si ponemos más de 59 segundos? Por ejemplo 1 minuto 30 segundos. La secuencia sería algo como 01:30 -> … -> 01:01 -> 01:00 -> 00:59 -> 00:58 . ¡Fíjate qué ocurre cuando los segundos llegan a 0! Es necesario decrementar el número de minutos y entonces poner a 59 los segundos… ¡Intenta programar cómo controlarías los minutos cuando los segundos llegan a 0!
¡IDEAS!
Idea: Cuando finalice la cuenta atrás, antes de la melodía puedes mostrar por pantalla algún mensaje de alarma o explosión.
Idea 2: Alrededor del delay() puedes encender y apagar el led RGB del color que más te guste.
En nuestro ejemplo (y para hacer pruebas), el temporizador está planteado para durar 10 segundos. Dicho tiempo va a ir disminuyendo hasta que llegue el contador a 0. Como la idea es que se muestre en la pantalla el tiempo, podéis ver que usa la función “String()”, que permite que la pantalla entienda los números.
¡Sigamos con el código principal!
3. En nuestro diseño, cuando el temporizador finalice, en la pantalla aparecerá el mensaje: «BOOM»
4. Por último, se comprueba si hemos pulsado el botón para que pare la alarma o no. En caso de que no, el buzzer comenzará a sonar mediante la función sonarNota(), y los tonos se irán cambiando. Esto ya lo tenemos diseñado de días previos.
Un resumen de todo lo que hemos visto lo tenéis en el siguiente vídeo.
Y ahora…¡a por los retos! Aunque antes un pequeño recordatorio:
GRABAD Y SACAD FOTOS de todo lo que queráis mostrar en el vídeo final. ¡¡Ya tenemos casi el proyecto y hoy pueden salir cosas muy chulas!!
RETOS DIARIOS
Hoy tenemos un reto bastante completo. En vez de sólo una misión, ¡vamos a tener 12! Van a ser mini-retos que vais a implementar como funciones propias. Así os haréis una idea de cómo se pueden integrar los componentes que vamos viendo. La lista de mini-retos en la siguiente:
Encender el led durante 2 segundos de color amarillo y otros 3 segundos de color morado
Mostrar un corazón en la matriz de leds
Mostrar cuatro iconos diferentes cualesquiera en las matrices de leds, uno en cada matriz
Mostrar en la matriz led el mensaje: “Hola” mientras suena una melodía de cuatro frecuencias diferentes, durando cada una 500 ms
Diseñar un semáforo con el led RGB, mostrando primero el color verde, luego el amarillo y por último el rojo
Mostrar vuestro nombre por la matriz de leds
Mostrar en la matriz led la palabra “Azul” mientras el led está iluminado en color azul
Hacer que el led del Arduino parpadee 5 veces, después que el led RGB se ilumine de vuestro color favorito mientras se emite un sonido constante por el buzzer
Mostrar en la matriz de leds la fecha (XX/YY), siendo XX el día e YY el mes. Incluid ceros donde haga falta, así como una raya vertical | para separar ambas
Dibujar una cara sonriente en la matriz de leds y que se borre pasados 3 segundos
Iluminar el led de forma secuencial de color rojo, verde y azul, y a la misma vez que aparezca el nombre del color en la matriz de leds
Generar un contador que empiece en cero y vaya hasta 5, de forma que cada incremento ocurra cuando parpadee el led interno de Arduino, y el número por el que vaya se muestre en pantalla. Finalmente, al llegar a 5 comience a sonar el buzzer con el sonido que queráis.
¡Ánimo! Son muchos pero son cosas que ya hemos visto con vosotras. Manda sobre estos retos el vídeo que quieras por telegram a @F3l1c13n74 para publicarlo en redes sociales. Si tienes twitter o instagram añádenos tu usuario junto con el vídeo en el mensaje de telegram para que te mencionemos en la cuenta de SereIngeniera y de la OSLUGR. ¡Recuerda subir todas las tareas al Classroom!
¡Vamos a resolver los retos de ayer! Los códigos de las resoluciones están en el material Solución retos 1 y 2, y Solución reto 3 de la sección DÍA 2: 3, 2, 1… ¡¡YAAA!! de Trabajo de clase del Classroom. Aquí en el blog no os vamos a enseñar el código entero, sino las partes que debíais implementar.
RETO 1:[ ???? ] … ¡¡YA!!
RETO 2:El led parpadea con el temporizador
RETO 3:Reiniciar la alarma sin reiniciar nuestro Arduino
Hoy vamos a seguir conociendo componentes que se pueden unir a un Arduino. El componente del día es: ¡la matriz de leds!
Este componente es similar a una pantalla. Se denomina matriz porque está compuesta de minileds de color rojo repartidos en filas y columnas, los cuales hay que activar para mostrar el icono o mensaje que queramos.
Para su programación vamos a ver una de las técnicas más utilizadas en la programación hoy día que es la programación orientada a objetos, el uso de este paradigma nos permite representar objetos del mundo real como datos manipulables por un ordenador. Es decir, es una forma de programar “más cercana” a como definimos las cosas en el día a día. La ventaja, es que estos objetos tienen propiedades (atributos) y funcionalidad (métodos), lo que en la programación simplifica la abstracción del programa dándonos a entender que un objeto responde a los métodos que se le solicitan. Para definir estos objetos, primero es necesario definir en el código las clases, a partir de las cuales se pueden crear los objetos. Como ejemplo, podéis considerar como clase una receta de tableta de chocolate, los objetos serían la forma final que tiene esa tableta en función de la marca (Nestlé, Milka…). Lo mismo pasa en el mundo Pokemon, una clase sería la definición de Pikachu en la pokedex, pero los objetos serían cada uno de los pikachus que existen, los pikachus hembra su cola acaba en forma de corazón, mientras que los machos tiene forma más cuadrada. Estos conceptos son muuuuy complejos, así que no os preocupéis si no los entendéis del todo. Es más, se trata de contenido que se da en la asignatura Programación y Diseño Orientado a Objetos de 2º curso del Grado de Ingeniería Informática, para que os hagáis una idea de la dificultad de cosas que estáis aprendiendo.
Para programar las matrices hay que ser expertos en comunicaciones electrónicas a bajo nivel. ¡Pero no os preocupéis! En este campus no pretendemos reinventar la rueda por lo que las monitoras hemos creado unas librerías (programas que implementan funciones generales) para adaptar el lenguaje al campus. Igual que en días anteriores hemos usado funciones “prefabricadas” de Arduido (por ejemplo, pinMode()) y creadas por nosotros (por ejemplo, sonarNota()), estas librerías permiten usar funciones creadas por otros. Es decir, en estas librerías nos vamos a encontrar un tipo que define el objeto MatrizLed y un conjunto de funcionalidades que podemos solicitarle a nuestra Matriz de leds. ¡Va a ser muy fácil!
Normalmente las librerías se añaden en ficheros “.zip” pero esta vez vamos a proporcionaros los códigos para que podáis ver de qué se componen estas librerías y podáis bichear cómo implementan cada funcionalidad.
Se deben incluir los ficheros [MatrizLed.h] y [MatrizLed.cpp] en la misma carpeta donde se encuentra nuestro proyecto. Estos ficheros los tenéis en el Classroom juntos con las soluciones de los retos anteriores. Es decir, tendremos en una misma carpeta nuestro fichero <nombre_proyecto>.ino y otros dos ficheros, MatrizLed.h y MatrizLed.cpp. La ruta del .h sería por ejemplo /nombre_proyecto/MatrizLed.h. En el primer fichero (.h) encontraremos definidos los nombres de las funciones y los atributos de estos objetos, y en el segundo (.cpp) se implementa la funcionalidad. Estos dos ficheros los tenéis en Trabajo de clase -> DÍA 3: Pantalla de leds -> Código base matriz (donde también estará el código que vamos a ver a continuación)
Las matrices de leds que vamos a utilizar vienen conectadas internamente por lo que únicamente tenemos que conectar la primera de ellas a nuestro Arduino. Las conexiones se realizarán de la siguiente forma:
– DIN (Pin de datos) -> `Pin 12`
– CLK (Pin de frecuencia de reloj, clock) -> `Pin 11`
– CS (Pin de comunicación por el puerto serie) -> `Pin 7`
Y para comprender las posiciones de cada led en la matriz vamos a utilizar este diagrama:
Cada cuadrado de 8×8 representa cada una de las matrices leds que tenemos. En el diagrama podéis observar que cada posición (que viene a ser un led) está definida por tres coordenadas: el número de matriz, el número de columna y el número de fila. Un ejemplo de este tipo de codificación sería el juego de hundir la flota. Hay que tener cuidado ya que en vez de empezar por 1 y acabar en 8, el orden de las coordenadas va de 7 a 0 en cada matriz led. Lo mismo ocurre con el número de matriz, se empieza en 0 y la última estaría asociada al número 3. Por ejemplo, podéis ver cómo la casilla en color rojo tendría de coordenadas la matriz “1”, la fila “5” y la columna “0”.
En el siguiente enlace se pueden generar códigos para nuestros iconos de forma interactiva: [web para generar códigos binarios de Xantorohara] (https://xantorohara.github.io/led-matrix-editor/). Además, ¡es software libre!
Un ejemplo de esta web sería la imagen de abajo. En ella podéis ir seleccionando encima de la matriz las posiciones que queráis que se iluminen. Luego, le dais a “update” y así se generaría la variable asociada a ese dibujo. Para ver dicha variable en formato que entendamos (ahora después lo veremos con más detalle), activamos la opción “As byte arrays”.
Teniendo en cuenta todas estas cosas, el programa que vamos a hacer hoy nos va a permitir aprender a lanzar mensajes en las matrices leds. Siguiendo nuestro esquema habitual…
Lógica: Vamos a probar diferentes tipos de mensajes para ver cómo se muestran en las matrices leds.
Estructura: Primero vamos a definir todas las variables conocidas a priori que necesitemos, luego ajustaremos la configuración de Arduino y por último definiremos los diversos mensajes que queramos mostrar.
Materiales: la placa de Arduino uno, el cable para poder programarla, las cuatro matrices leds unidas y cables para poder conectar los componentes a los pines.
¡Comencemos a programar! En este código nos vamos a encontrar la introducción de las librerías o la forma de definir dibujos en la matriz. Ahora después lo comentaremos más en detalle.
BARRA_SONIDO y FLECHA_DER serían dos ejemplos de cómo se puede “dibujar” un elemento estático. Teniendo en cuenta que cada matriz led está compuesta por 8×8 minileds, se ponen a 1 las posiciones que queramos encender.
Dentro de la configuración hay que avisar que queremos que nuestra matriz de leds o pantalla se active, indicando la configuración que queramos. También podemos seleccionar el brillo que queramos en la pantalla y, en función de la matriz que se ha comprado, la última línea será necesaria o no. ¡Cuidado con eso! Si tenéis dudas podéis mostrarnos vuestras pantallas para comprobar qué modelo necesitáis. Un ejemplo de matriz de leds donde hay que descomentar el código sería la imagen inferior. En ella, podéis ver que los códigos laterales están en el mismo lado que pone “in” y “out”.
La imagen de la matriz en la que no hay que descomentar nada sería la siguiente. Como veis, sólo se puede leer el código lateral.
Dentro de void loop() podemos probar muchas cosas, aunque lo primero de todo es asegurarnos que la pantalla se inicialice vacía. Nos permite eliminar cualquier “residuo” que hubiera en la pantalla antes de conectar nuestro programa, por si algún led estuviera encendido sin tener que estarlo, para ello:
El icono FLECHA_DER, que hemos definido al principio, podemos desplazarlo a lo largo de las cuatro matrices:
Como hemos explicado antes, vamos de 8 en 8 ya que cada matriz led tiene 8 columnas, por eso, al indicar “16” estaremos saltando a la tercera. También podemos escribir palabras:
¡Incluso frases largas y números! Para poder leerse, estas frases irán desplazándose por la pantalla.
Por último, podemos usarlo como un reloj. Para ello primero debemos generar dos funciones propias (¡Recordad que se ponen después de void loop()!):
Ya definidas, sí podemos mostrar los dígitos en pantalla. Ahora dentro de void loop() añadimos:
Con pantalla.setLed(matriz, fila, columna) lo que hacemos es activar unas posiciones de leds concretas, que estarán iluminadas hasta que borremos lo que haya en pantalla. Un ejemplo suelto de eso sería el siguiente:
Con todo esto ya sabéis mostrar elementos en la pantalla. ¡Queda practicar!
RETOS DIARIOS
Los retos de hoy son los siguientes:
Reto 1:Encontrar las figuras ocultas
El primer reto del día va a consistir en que juguéis al “mapa del tesoro”. En la tabla inferior tenéis una tabla llena de coordenadas, las cuales indican posiciones en la matriz de led y el color con el que se activarían (físicamente se podría implementar con una matriz RGB, de la que no disponemos). Cada coordenada consta del color que se quiera colocar, la matriz, la fila y la columna. Con paciencia, podéis ir rellenando esas coordenadas de una en una en la plantilla que os adjuntamos más abajo (y que hemos usado para explicaros las conexiones). Así descubriréis qué iconos hay tras ellas. También os hemos puesto las mismas coordenadas pero desordenadas en las otras dos imágenes, para quien quiera plantearse el reto en un nivel un poco más difícil.
Reto nivel fácilReto nivel díficil. Parte 1Reto nivel díficil. Parte 2Plantilla a rellenar. La tenéis en Classroom dentro de la tarea de este reto
Reto 2:¡Diseña tu propio dibujo de leds!
Ahora vamos a hacer el proceso inverso, vosotras vais a escoger el dibujo. Podéis hacer hasta cuatro iconos diferentes para mostrar (como en el Reto 1). Tenéis que generar el código para poder mostrarlo en la pantalla de leds. Esta vez, en vez de la plantilla, podéis (¡os aconsejamos!) hacerlo en vuestra propia matriz de leds. Tened en cuenta que nosotras sólo disponemos del color rojo, así que mejor diseñarlo con él.
Ahora, vamos a intentar que el mismo icono estático del reto anterior (escoged sólo uno si habéis hecho varios) se mueva a lo largo de las cuatro matrices. Con moverse, nos referimos a que primero aparezca en la matriz de la izquierda, desaparezca, y pase a la siguiente, así hasta la última matriz. Es decir, el icono debe aparecer primero en la matriz 0, después en la matriz 1, después matriz 2 y por último matriz 3. Por tanto, debe realizar 4 acciones
Pista: echadle un vistazo a cómo hemos movido la flecha en el programa visto en clase.
Reto 4: Ampliación optativa del reto 3
Este último reto es totalmente optativo. Consiste en hacer que el icono se mueva en forma de scroll, en vez de apareciendo en cada matriz de forma secuencial.
Pista: podéis usar un bucle for() que vaya incrementando el valor de la columna de 0 a 31.
¡Ánimo! Cuando tengas estos retos manda un video funcionando por telegram a @F3l1c13n74 y ¡lo publicaremos en las redes sociales! Si tienes twitter o instagram añádenos tu usuario junto con el vídeo en el mensaje de telegram para que te mencionemos en la cuenta de SereIngeniera y de la OSLUGR. ¡Recuerda subir todas las tareas al Classroom!
Todos los días, antes de comenzar con la nueva clase vamos a resolver los retos planteados el día anterior.
El primer reto planteado consistía en iluminar el led RGB con nueve colores diferentes. Os propusimos usar los colores del arcoíris, con los cuales el código, si usamos funciones propias, podría quedar de la siguiente forma:
El segundo reto consistía en crear una melodía diferente a la de la clase, ¡a vuestro gusto! Un ejemplo podría ser el siguiente:
Ambos retos te los puedes descargar en Classroom, están en la sección Solución retos 1 y 2 en DÍA 2: 3, 2, 1… ¡¡YAAA!! de Tareas de Clase. Son los archivos con nombres «dia2_pulsador_solucion2.ino» y «dia2_pulsador_solucion2.ino«.
Recordad que en estos retos os propusimos ideas subjetivas, por lo que lo normal será que no todo sea igual, que hayáis escogido tonos diferentes o el color tenga otra tonalidad. ¡Seguid usando los vuestros!
Ya hemos solucionado los retos de ayer, así que… ¿Estáis preparadas para empezar con el proyecto?
Hoy vamos a unir conocimientos que aprendimos ayer con nuevos componentes, y así vamos a ir implementando un temporizador. Vamos a comenzar presentándoos un nuevo componente: el pulsador.
Como su nombre indica, un pulsador (o botón) es un elemento el cual al pulsarlo ocurre una determinada acción. La diferencia con un interruptor, sería que este último mantiene su posición. Por ejemplo, cuando entráis de noche a vuestro cuarto, cambiáis la posición del interruptor para encender la luz. En cambio, el pulsador solo tiene en cuenta un instante, en función de cómo se programe, ese instante será la bajada del pulsador mientras le dais (falling) o la subida cuando soltáis (rising).
Esto vamos a ir viéndolo con más detalle en nuestro código asociado a una alarma. La idea es conectar un pulsador que nos permita apagar una alarma. Igual que ayer, nos vamos a plantear las mismas preguntas:
¿qué va a hacer mi programa?
Lógica: Vamos a estar escuchando ciertos sonidos (unos tonos predefinidos) y queremos que paren cuando nosotras decidamos. Para ello, al pulsar el botón, éstos dejarán de oírse. Por tanto, una secuencia de tonos va a ir oyéndose y en el instante que pulsemos el botón esto dejará de ocurrir.
Estructura: El buzzer va a estar emitiendo nuestra melodía. Para pararlo, se debe indicar en el código que se tenga en cuenta la situación del pulsador. Pensad que la alarma es un sistema en tiempo real. Como el airbag de un coche. Todo el sistema funciona con normalidad (sonar alarma o mover el motor en caso del coche) hasta que ocurre un evento externo (pulsar botón o fuerte golpe en el coche) que hace reaccionar el sistema y ejecuta unas «instrucciones de emergencia» que bien son parar la música o lanzar un airbag. Así que vamos a tener que definir el evento físico urgente que necesita atención inmediata (pulsar botón) mediante una interrupción. Más adelante veremos en detalle en qué consisten las interrupciones.
Materiales: La placa de Arduino uno, el cable para poder programarla y cables para poder conectar los componentes a los pines. Además, en este caso necesitaremos el buzzer y un pulsador. Con respecto a los cables, os aconsejamos usar 7 cables macho-macho. También os queremos pedir que os fijéis en nuestro esquema de conexión y no miréis otros por internet, ya que hay muchos tipos de conexiones diferentes, ¡y esta funciona con nuestros materiales!
El código para descargar se encuentra en Classroom, en la tarea su nombre es «Código pulsador«. Vamos a ir viendo poco a poco cómo sería esto:
La declaración de variables sería igual que en el código del buzzer, sólo que hay que escoger un pin más de Arduino al que asociar el pulsador:
La variable botonPulsado se trata de una variable lógica, la cual va a estar como 0 o false hasta que pulsemos el botón, pasando a estar a 1 o true.
Las grandes diferencias con el código del día anterior van a estar dentro de void setup(), en el cual debemos definir toda la configuración del botón:
Con pinMode() estamos definiendo tanto el pin asociado al pulsador como su forma de conectar el circuito. Como hemos visto antes, los botones se pueden conectar de dos formas, usaremos el modo PullUp ya que Arduino incorpora componentes internos para facilitar las conexiones de botones de este modo. También vamos a utilizar una función llamada interrupción que nos permite asociar un trozo de código a la pulsación de un botón. Esta es attachInterrupt(). Las interrupciones se atienden con unas instrucciones de emergencia que se definen en una función. Por eso usamos un método que se llama «attachInterrupt» que asocia un evento físico en un pin a una función (pararAlarma).
Gracias a esta función, cuando el Arduino está ejecutando el programa, si se pulsa el botón asociado a la interrupción, el programa interrumpirá la instrucción en la que se encontraba y saltará inmediatamente a ejecutar la función asociada. ¿Cuándo vamos a utilizar esta interrupción? Mientras la melodía está sonando, si se pulsa el botón se ejecutará inmediatamente la función encargada de parar la melodía.
Como hemos definido varios tonos, éstos no pueden sonar a la vez ni todo el rato. Para controlar el funcionamiento correcto vamos a aprender un tipo de bucle que se puede usar con arduino: el condicional while. Éste permite que lo que haya dentro de él se siga ejecutando hasta que no sea cierta la condición que se le asocia.
Dentro de void loop() tendremos lo siguiente:
Aquí hemos visto por primera vez el condicional while(). En este caso, la condición que se le asocia es que el botón no haya sido pulsado. Así el buzzer va a seguir sonando hasta que el pulsador se acciona.
Dentro tenemos una función que se llama sonarNota(). ¿Qué significa? ¿Arduino tiene una función que se llame así? La respuesta es no, es una función que nosotras creamos para que el código se vea más bonito, con menos líneas. Dicha función se define debajo del loop() y en su interior están las líneas de código asociadas a ella. En este caso:
Aquí vemos que en su interior se encuentra un código muy similar a la clase anterior, con las funciones tone(), noTone(), y delay(). Es decir, cuando se llame a sonarNota(), efectivamente ¡sonará una nota! La que toque según la variable nTonoActual.
Esto sería una configuración básica que une el pulsador y el buzzer, ¡ahora a practicar!
RETOS DIARIOS
Hoy hay bastantes retos, pero no os agobiéis. ¡Vamos a hacerlo poco a poco!
Reto1: 3,2,1… ¡alarma!
Añadir una cuenta atrás utilizando una variable que actúe de temporizador. Para poder realizar el temporizador os dejamos la siguiente pista: tened en mente un contador hacia atrás, es decir, usad una estructura que permita ir disminuyendo una variable hasta que llegue a cero. ¿Hemos usado algo similar en algún código de clase?
Para poder resolver este reto te facilitamos parte del código con algunos huecos que debes rellenar tú. El código de la plantilla está en la sección Reto 1 : [ ???? ] … ¡¡YA!!
Reto2: ¡El led de Arduino parpadea!
Si no os habéis fijado, Arduino tiene un led que se ve parpadear en determinadas ocasiones…
En este reto, te proponemos usar LED_BUILTIN para que el led interno de tu Arduino parpadee mientrasse hace la cuenta atrás. Tened en cuenta que la cuenta atrás va “segundo a segundo”, por lo que habrá que dividir la actuación de este led como encendido los primeros 500ms y apagado la otra mitad.
Como pista para resolverlo, te recomendamos que mires el ejemplo del código Blink.ino del primer día (Archivo -> Ejemplos -> 01.Basics -> Blink : led del Arduino en parpadeo).
Reto3: ¿Cómo reiniciamos la alarma?
Como hemos visto en clase, las interrupciones son funciones que tienen prioridad para Arduino, de tal forma que cuando se usa esa función de interrupción, Arduino deja el programa por donde iba leyendo para ejecutar el código que tiene la función de interrupción. El código que os dimos, tiene programada la interrupción para que al pulsar el botón(A) se pare la alarma.
El reto va a consistir en añadir un segundo botón (B) que lo que hará es reiniciar la alarma.
El botón (B) se tiene que conectar al pin 3 con interrupción.
Es decir, la secuencia de nuestro programa queremos que sea:
1. Esperar a que pase el tiempo transcurrido
2. Hacer que suene la alarma
3. Pulsar el botón A para detener la alarma
4. Esperar el tiempo deseado y pulsar el botón B
5. Volver al tiempo transcurrido
Para resolver este reto, te facilitamos la plantillaen la tarea Reto 3 : Reiniciar la alarma sin reiniciar nuestro Arduino, dónde está marcado con astericos (**) el lugar donde tendrás que escribirla parte del código necesaria para poder reiniciar la alarma y realizar las comprobaciones de si está encendida o no… ¡Así que no os agobiéis y usad la plantilla!
El objetivo final de hacer estos retos es ir construyendo un programa final que tiene como misión poder establecer un tiempo de espera, encender el temporizador con un botón B, y esperar a que salte la alarma con la melodía creada el día anterior. Solo se podrá parar la alarma con el botón de parada, A. Si se desea reanudar la alarma habrá que pulsar B de nuevo.
3, 2, 1… ¡Conseguido! 😉
Cuando lo tengas manda un video funcionando por telegram a @F3l1c13n74 y ¡lo publicaremos en las redes sociales! Si tienes twitter o instagram añádenos tu usuario junto con el vídeo en el mensaje de telegram para que te mencionemos en la cuenta de SereIngeniera y de la OSLUGR.
¡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.
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);
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.
¡Voy a hacer mi primer proyecto con Arduino! Pero… ¿Por dónde empiezo?
No te preocupes, al igual que pasa con muchas otras cosas en nuestro día a día, la pregunta de ¿Por dónde empiezo? es común a la hora de ponernos a programar.
Lo bueno es que la respuesta es bien sencilla: Por el final.
¿Qué quiero que haga mi programa?
Esta es la primera pregunta que tenemos que hacernos cuando vamos a programar, y aunque la pregunta es sencilla no es fácil de responder. ¿Por qué? Porque tenemos que dejar claro absolutamente todo lo que queremos que haga el programa, cómo queremos que lo haga y cuál es la mejor forma para conseguirlo.
Después de haber elaborado un guión de todo lo que hay que hacer para que nuestro proyecto funcione solo queda ir pasito a pasito (función a función) creando nuestro código.
Descarga e instalación del IDE de Arduino
Antes de meternos en faena con la programación necesitamos la herramienta básica para poder escribir nuestro programa. Sigue los pasos del siguiente vídeo y ¡estarás lista para comenzar!
Si todo ha ido saliendo bien, para poder comenzar a trabajar ya sólo tienes que ejecutar la aplicación de Arduino y conectar el tuyo a cualquier puerto USB del ordenador.
Mañana empezaremos hablando de esto, pero por si tenéis curiosidad, aquí van algunas cuestiones básicas de programación.
¿Qué es el software?
Un software o programa es el conjunto de instrucciones que permiten controlar el flujo de su ejecución. Por tanto el software son todos los procesos no físicos que se realizan en un ordenador. Estos programas o procesos realizan una serie de instrucciones que son las que aprenderemos a programar en este campus.
Algunos de los componentes que nos proporciona el lenguaje Arduino para construir programas son:
– Funciones setup() y loop()
– Comentarios
– Definición de variables
– Estructuras de control: if-else, while y switch
¡Pero no os agobiéis! Todo esto lo iremos aprendiendo poco a poco.
También mañana veremos cómo abrir el monitor Serial para comunicarnos a través de mensajes con nuestro microcontrolador.
¿Qué es el hardware?
El hardware es el conjunto de todos los componentes físicos, tangibles, de un ordenador. Veremos cómo Arduino es un dispositivo programable que tiene la capacidad de controlar eventos físicos. Es decir, la placa de Arduino Uno es como un ordenador que nos permite, fácilmente, activar luces, motores, saber si hay botones pulsados, comprobar niveles de luz…
¡Extra, extra!
Si no podéis esperar a mañana, os proponemos probar el siguiente ejemplo que viene en la aplicación de Arduino. Sólo necesitáis tener el Arduino conectado al ordenador para hacerlo. De todas formas, como ya hemos mencionado antes, mañana empezaremos por estas cuestiones.
Archivo -> Ejemplos -> 01.Basics -> Blink : led del Arduino en parpadeo
