A menudo hablamos de los microcontroladores Arduino como una de las piezas clave del mundo maker: una placa de desarrollo barata, pequeña, potente, y muy fácil de programar. Al menos, eso comentamos cada vez que anunciamos alguno de nuestros talleres de introducción a Arduino (a los que, por cierto, puedes inscribirte aquí. Pues bien, ya es hora de que lo demostremos con un caso práctico, como ya hicimos en su día con la herramienta MIT App Inventor.
Antes que nada, necesitamos saber qué queremos hacer, exactamente: identificar un problema de nuestro entorno que podamos solucionar con algo de automatización, por ejemplo… o simplemente algún experimento, dispositivo, proyecto o cacharro que nos resulte interesante. Para el ejemplo de hoy, vamos a fijarnos en algo llamado Técnica Pomodoro: un método de gestión del tiempo, que usa un temporizador de cocina para dividir el tiempo de trabajo en secciones de 25-30 minutos, con descansos de 5 minutos entre una y otra. Así, podemos por ejemplo a probar a hacer un temporizador específico para esta técnica, con una señal luminosa que nos indique los tiempos de trabajo y descanso, que utilice como núcleo un microcontrolador Arduino (para una herramienta de este tipo, usar Arduino es quizá matar moscas a cañonazos, pero es la clase de proyecto idónea para aprender a programar).
Así, necesitamos programar nuestra placa para que:
- Lleve una cuenta del tiempo transcurrido,
- Alterne entre periodos de 25 mins y 5 mins,
- Señalice el momento en el que acaba un periodo y empieza otro, y
- Indique si se trata de un periodo de trabajo o de descanso
Bueno, pues pongámonos a ello. Vamos a ver el paso a paso, y como se trata de un proyecto sencillo vamos a usar TinkerCAD, una herramienta de Autodesk que nos permite, entre otras cosas, emular el funcionamiento de una placa Arduino, con toda la circuitería asociada.
Así, nada más empezar, nuestro proyecto tendrá esta pinta:
Una placa sin nada conectado, y un programa básico (una luz que parpadea) en la sección de código. Sobre las distintas partes del código, y como empezar a programar, hablaremos en un momento, pero primero vamos a fijarnos en el hardware. La placa se compone de bastantes elementos, entre circuitos integrados, elementos de electrónica, LEDs (algunos que podremos controlar, y otros que aportan información sobre el estado del Arduino) y, lo que más nos interesa ahora mismo: una serie de puertos –que denominaremos pin– a los que conectar distintos elementos electrónicos. Se trata de los 32 “agujeros” en las partes superior e inferior de la placa, cada uno marcado con un indicador.
Bien, como ya hemos dicho, queremos mostrar cuando estamos trabajando, y cuando descansando: podemos hacerlo mediante una luz roja y otra verde, respectivamente. Así, los añadimos a nuestro proyecto, y los conectamos a dos pines digitales cualesquiera de la placa (con sendas resistencias, como siempre hace falta con los LEDs):
Si queremos refinar un poco el diseño, podemos ir añadiendo más elementos, pero para empezar esto está bien. Eso sí, no basta con conectar los LEDs: tendremos que decirle al programa que se prepare para trabajar con ellos. Vamos a ver como hacer eso, pero antes vamos a echarle un vistazo a la estructura de un programa de Arduino, al que también se suele denominar sketch.
Como lenguaje de programación, Arduino utiliza una versión de C++, muy cercana a Processing, con algunas diferencias y particularidades. Quizá la más notable es que el código tiene siempre dos partes, colocadas en dos funciones separadas: Setup() y Loop():
En el Setup, introducimos todas las ordenes que van a ejecutarse una única vez, al encenderse (o resetearse) la placa. Es donde inicializamos sensores, comenzamos a transmitir información, buscamos redes WiFi cercanas… es donde “preparamos” la placa para empezar a funcionar.
El Loop, como su propio nombre indica, es un bucle: una vez finalizado el Setup, las ordenes contenidas en la función loop() se ejecutaran una y otra vez, mientras la placa esté encendida: es el lugar donde colocaremos el núcleo del programa, lecturas de sensores, órdenes a periféricos, etc.
Bien, pues comencemos por decirle a Arduino que debe estar atento a los pines en los que hemos conectado nuestros LEDs, preparado para cambiar la señal de LOW (apagado) a HIGH (encendido), según el estado de nuestro dispositivo. Para ello, usamos la función pinMode(), en la que especificamos el número de pin, y su “modo” (entrada o salida de datos). En nuestro caso,
, ya que ambos serán salidas de datos.
Una vez establecido qué vamos a usar, nos toca indicar cómo lo vamos a usar, es decir, nos toca describir el funcionamiento del programa en sí. Puesto que ahora mismo estamos buscando que sea un programa lo más sencillo posible, vamos a limitarnos a hacer que los leds se vayan alternando, en periodos de 25 y 5 minutos. En otro momento haremos un programa algo más complejo, añadiendo elementos y funcionalidades, pero para empezar, no está mal.
Como ya hemos dicho, nuestro Arduino repetira todas las instrucciones de la función loop(), en orden, mientras esté encendido. Por tanto, vamos a ir indicando, por orden, lo que hará nuestro dispositivo:
- Primero, encenderá el LED rojo para indicar el modo “Trabajo”
- Se mantendrá en ese estado durante 25 minutos
- Pasará a mostrar solo el LED verde, para indicar el modo “Descanso”
- Mantendrá ese estado durante 5 minutos
Y vuelta a empezar (es decir, fin del bucle, la función loop()). Así que vayamos por partes: lo primero será decirle a la placa que encienda el LED rojo, es decir, escribir un valor HIGH en el pin correspondiente. Al mismo tiempo, escribiremos un valor LOW en el pin del LED verde, asegurandonos así de que que está apagado. Para ello, usamos la función digitalWrite(), indicando el número de pin (11 para rojo, 10 para verde), y el estado en el que queremos dejarlo. Además, ahora ya podemos usar la función de emulación de TinkerCAD para comprobar si el programa se comporta como queremos. Debería quedarnos algo así:
Vemos que, en efecto, el led Rojo se queda encendido. Ahora, nos interesa asegurar que se queda así durante 25 minutos. Hay varias maneras de hacer esto, aunque la más sencilla es usando la función delay(), que pausará el programa durante un determinado tiempo (expresado en milisegundos). Para 25 minutos, esto serán 1 500 000 milisegundos.
El resto del programa es básicamente el mismo: digitalWrite() para endender y apagar los LEDs correspondientes, y después un delay de 300 000 milisegundos para pausar el programa durante 5 minutos. Obviamente, no es práctico dejar esos valores de tiempo mientras estamos probando el programa, a menos que queramos esperar media hora para ver si se comporta como esperamos, así que dividimos esos valores por 10. Tendremos así nuestro programa terminado:
Con esto, ya tenemos una versión muy básica de lo que queríamos. En próximos artículos veremos como mejorar esta misma herramienta, además de mejorar un poco este mismo código, programando de una forma algo más elegante.
