Arduino
Descripción de Arduino
Arduino es una placa de circuitos electrónicos que incorpora dos elementos interesantes:
● Un circuito integrado (chip) que incluye microprocesador, memoria ram y otra
memoria permanente (a esto se le llama generalmente "microcontrolador")
● Unas conexiones muy simples donde se pueden conectar :
○ botones, interruptores, sensores y otros dispositivos de medidas
○ luces, motores, emisores y otros circuitos que realizan algún trabajo
La utilidad de arduino es realizar montajes con circuitos simples que realicen funciones de
automatización y robótica de una forma fácil y rápida. Para ello, el usuario escribe un
programa, código, o conjunto de instrucciones que se guarda en la memoria de arduino y
que se ejecuta en el microprocesador
Algunos ejemplos de uso de arduino:
● Controlar la iluminación de un local.
● Controlar un coche teledirigido.
● Controlar un coche que se mueve evitando obstáculos
● controlar una cinta transportadora en algún proceso industrial.
● Controlar un Ascensor,
● etc.
Ejemplo de un circuito (simulado) con múltiples elementos de entrada y salida.
Una característica flexible de arduino es que las conexiones de la parte superior (etiquetadas
con la palabra "DIGITAL"), son entradas o salidas a elección del usuario que realiza el
montaje y la programación. Si necesitas una salida o una entrada, puedes elegir un pin
cualquiera y configurarlo como desees -entrada o salida-. El problema es que no hay
muchos pines disponibles, pero la mayoría los que hay son entradas o salidas a elegir.
Un aspecto cómodo de arduino es que incorpora una conexión USB con la que se
puede conectar a un ordenador normal. Así, resulta sencillo programarlo y verificar su
funcionamiento.
Simulador de arduino.
En vez de utilizar un robot real, vamos a realizar ejercicios y ejemplos con un simulador
online que se ejecuta en un navegador.
www.tinkercad.com
En este simulador, se puede colocar componentes en un tablero virtual y además realizar la
programación en un editor que incorpora la propia página. La compilación, descarga y
ejecución del código es realizado por la misma página del simulador.
Primer ejemplo con arduino
Para aprender arduino, vamos a realizar un primer circuito de ejemplo. Con el tinkercad,
obtén este circuito (usa exactamente el pin 13)
El simulador, a modo de ejemplo, genera automáticamente y sin pedírselo, el siguiente
código:
void setup()
{
pinMode(13, OUTPUT);
}
void loop()
{
digitalWrite(13, HIGH);
delay(1000); // Wait for 1000 millisecond(s)
digitalWrite(13, LOW);
delay(1000 ); // Wait for 1000 millisecond(s)
}
Analizaremos el código anterior para descubrir cómo se programa.
Lo primero que hay que observar es que aparecen dos funciones llamadas "setup" y "loop".
Cada una de ellas encierra entre llaves { } unas instrucciones que son el programa que
ejecutará arduino. El siguiente diagrama te ayudará a identificar las funciones y sus partes
En el ejemplo, estas instrucciones aparecen porque las ha puesto el simulador por su
cuenta, pero la misión del programador es escribir aquí las instrucciones de lo que se desee
ejecutar. Tú tendrás que escribir las instrucciones adecuadas para solucionar el problema
que se te plantee en el futuro.
setup()
La función setup() es una función que se ejecuta en el momento en el que se
enciende o inicia el arduino. Las instrucciones o código que escribas allí, se ejecutarán sólo
una vez, y lo harán al principio. Esta función sirve para preparar lo necesario en el momento
inicial, para establecer unas condiciones de funcionamiento concretas en el primer
momento.
Por ejemplo, supón que arduino está controlando un sensor infrarrojo que detecta
personas que pasan por un pasillo y contándolas. Al principio deberemos establecer en 0 las
personas que han pasado, y después durante el funcionamiento normal, cada persona
detectada incrementará esa cuenta.
loop()
La función loop es la función principal. Allí se escribe el programa que deberá
ejecutar arduino. Esta función se ejecuta una y otra vez indefinidamente. Cuando termina su
ejecución, vuelve a iniciarse otra vez, y así hasta que se desconecte arduino. Si el programa
va a controlar algo durante mucho tiempo (por ejemplo una puerta automática que se abre
cuando detecta la presencia de un objeto) no hace falta hacer un bucle infinito, ya que la
función loop se ejecuta una y otra vez
Funciones utilizadas
Ahora analizaremos las líneas de código escritas, explicando qué ocurre en ellas.
delay();
setup y loop, son dos funciones que debes hacer tú. Sin embargo, delay() es una
función que está completamente hecha y que se "invoca", "llama" o "ejecuta" en tu
programa. Puedes usarla escribiéndola como en el ejemplo anterior. Tan sólo has de elegir
un número y ponerlo entre paréntesis. Cuando el programa se ejecute, y llegue a la línea
donde está escrita esta función, arduino se parará por un tiempo. Todo se quedará tal como
esté en ese momento y nada cambiará ni se ejecutará la siguiente instrucción hasta que
transcurra el tiempo especificado. Después de ese tiempo, el programa seguirá
ejecutándose en la siguiente instrucción al delay. Entre paréntesis escribes el tiempo (en
milisegundos) que el programa ha de estar parado.
Así, por ejemplo:
delay(1000);
provoca una detención de 1000 milisegundos.
pinMode()
pinMode() es una función que también es llamada por el programa y que el
programador escribe cuando la necesita. Su tarea es configurar un pin para indicar que es
de entrada o de salida. Hay que pasarle dos datos a la función: el número de pin y una
indicación de si es una entrada o una salida. En nuestro caso:
pinMode(13, OUTPUT);
Estamos configurando el pin 3 como salida "OUTPUT". Normalmente esto debe hacerse
durante setup() y dejar el pin configurado para el resto del funcionamiento normal.
digitalWrite()
Esta función también es utilizada por el programador para especificar una acción a
realizar. La tarea de ella es cambiar el estado de una salida, de ahí, que se llame "Write". Y
la palabra "digital" indica que se trata de una salida digital, que puede tomar un valor de 0 o
1, verdadero o falso, si o no, alto o bajo, 0 voltios o 5 voltios…. como quieras entenderlo.
Esta función debe saber el número de pin que se va a cambiar y el valor a establecer,
Los pines son números y los valores posibles: "HIGH" o "LOW".
Ejercicio
Vamos a modificar el ejemplo anterior, haciendo que el parpadeo sea cada vez más lento.
Solución:
Algunas cosas deben cambiarse:
● No se puede hacer un delay fijo, de otra forma nada cambiará y todo seguirá igual
○ Por ello, h
ay que poner una variable y usarla en el delay
○ La variable hay que inicializarla obligatoriamente antes de usarla
● Hay que incrementar la variable cada vez
○ No hay que hacer un while… El "loop" ya es un while
○ En este momento tenemos lo siguiente:
Prueba el siguiente ejemplo y sigue con el tutorial a
unque no funcione.
void loop()
{
int retraso;
retraso = 10;
digitalWrite(13, HIGH);
delay(100+ retraso);
digitalWrite(13, LOW);
delay(100 + retraso );
retraso = retraso + 10 ;
}
La líneas
1 int retraso;
2 retraso = 10;
son :
1. la declaración de una variable llamada "retraso" que es de tipo "número entero" (se
indica con "int")
2. a asignación de un valor concreto a la variable (en este caso 100)
En la línea
delay(100+ retraso);
Se indica a arduino que debe dejar todo quieto durante un tiempo. Ese tiempo está
especificado entre paréntesis, y en esa instrucción aparece una suma. Por tanto el tiempo a
a esperar puede no ser siempre el mismo, cuanto más valga la variable "retraso" , más
tiempo estará todo detenido…. En principio pinta bien
La siguiente línea intenta provocar ese retraso cada vez mayor.
retraso = retraso + 10 ;
En la expresión anterior ocurre lo siguiente:
● Primero se suma 10 al valor de la variable retraso
● El resultado de la suma se guarda en la variable retraso
Lo que se consigue es aumentar en 10 el valor de la variable retraso, y como esa variable se
usa para establecer el retraso, ocurrirá que cada vez habrá más retraso
… pruébalo y … verás como no funciona
Depuración. Serial.println()
En el desarrollo anterior el programa funciona mal. El Led parpadea siempre con la misma
frecuencia. Tenemos una variable que usamos para indicar el retardo pero parece no
funcionar. Necesitamos saber mejor qué está pasando en el programa, m ientras el programa
está en marcha.
Arduino se conecta al computador para ser programado. Normalmente, se realiza la
programación y después se desconecta. Sin embargo, s i se mantiene conectado, es posible
enviar información al computador y verla en la pantalla de éste durante el funcionamiento.
Esto se puede simular en tinkerCad también.
Lo que pretendemos conseguir es poder d epurar el programa. Depurar es
poder ver datos internos sobre el funcionamiento del programa mientras está
en ejecución para facilitar al programador ideas de por qué está funcionando
mal.
Debemos hacer lo siguiente:
1. Inicializar la comunicación serie con el Computador en la función setup()
2. Llamar a Serial.println() cada vez que queramos mostrar algún valor
Observa las líneas resaltadas. la primera es la inicialización, la segunda es la escritura del
valor.
void setup()
{
pinMode(13, OUTPUT);
Serial.begin(9600);
}
void loop()
{
int retraso;
retraso = 10;
digitalWrite(13, HIGH);
delay(100+ retraso); // Wait for 1000 millisecond(s)
digitalWrite(13, LOW);
delay(100 + retraso ); // Wait for 1000 millisecond(s)
retraso = retraso + 10 ;
Serial.println(retraso,DEC);
}
Para realizar la simulación y ver el resultado, hay que activar el botón de "Serial Monitor" en
la parte inferior de la ventana de código.
Practica bien la depuración porque es una herramienta muy poderosa y
necesaria en el trabajo de un programador y en el arduino, además, es el único
recurso para ver información compleja.
Si pruebas este código verás que la variable siempre vale 20.
● Hay que inicializar la variable
○ Pero no en la función loop, porque en ese caso, se inicializa siempre
● Hay que declarar la variable fuera e inicializarla en setup()
○ Así sólo se inicializa la primera vez
int retraso;
void setup()
{
pinMode(13, OUTPUT);
Serial.begin(9600);
retraso = 10;
void loop()
{
digitalWrite(13, HIGH);
delay(100+ retraso); // Wait for 1000 millisecond(s)
digitalWrite(13, LOW);
delay(100 + retraso ); // Wait for 1000 millisecond(s)
retraso = retraso + 10 ;
Serial.println(retraso,DEC);
}
Ampliación con un pulsador de reset
Para completar y probar cuanto antes, un circuito que tenga entradas y salidas, vamos
ampliar el montaje anterior añadiendo un botón. Al pulsar el botón, se efectuará una
reinicialización de la frecuencia de parpadeo. El botón es un componente más complejo de lo
que parece en primer momento. Tiene dos conexiones a cada lado que están unidas
internamente entre sí. En la imagen se observa que A y B están siempre unidas entre sí. C y
D también están siempre unidos.
Sin embargo, A y B están desconectados de C y B cuando el botón no está pulsado.
Al pulsar el botón, se establece un puente entre A-B y C-D.
En Arduino el botón debe estar conectado a un pin de entrada que va a leer 0 o 5 voltios
dependiendo de si está pulsado el botón. Hemos de hacer un pequeño montaje y circuito
para alcanzar este objetivo. Observa el montaje a realizar:
Observa que el botón está conectado por una línea roja a la alimentación de 5 Voltios y por
una línea negra a masa (ground). Si quitásemos la resistencia que aparece en la línea negra,
al pulsar el botón ocurriría un cortocircuito. Esa resistencia limita la corriente cuando el
botón se pulsa.
Por otra parte, cuando el botón está pulsado, la línea verde -de entrada- está
conectado a la línea roja que está a 5 voltios. Por lo que en el pin 7 de entrada se lee un
HIGH, 1 o 5 Voltios. Sin embargo, cuando el botón está sin pulsar, la línea negra está a
0Voltios y ello se transmite a la línea verde por lo que en el pin 7 se leen 0 Voltios o LOW
Lectura de valores de entrada
Una vez montado el circuito, vamos a programar la lectura de la pulsación en el
programa. El primer paso es configurar el pin 7 de entrada. Esto se realiza en la función
setup, al igual que se ha hecho para el pin de salida.
void setup()
{
pinMode(13, OUTPUT);
pinMode(7, INPUT);
Serial.begin(9600);
retraso = 0;
}
La lectura de datos se realiza mediante una función llamada "digitalRead". Ésta debe saber
el pin del que se desea leer, por ello se le indica -como argumento- el número del pin. La
función al ejecutarse obtiene un valor que puede ser 1 o 0, HIGH o LOW. El valor debe
almacenarse en algún lugar, para lo cual necesitamos otra variable
void loop()
{
...
int botonPulsado;
botonPulsado = digitalRead(13);
...
}
El dato leído ya puede ser analizado en el programa para determinar si hay que reinicializar
el valor del retardo.
void loop()
{
int botonPulsado;
botonPulsado = digitalRead(13);
if ( botonPulsado == 1 ) reset = 10;
retraso = retraso + 20 ;
}
Ejercicio. Controlador de ascensor.
Para continuar aprendido, vamos a realizar un controlador simplificado de un
ascensor
Se trata de realizar el control de un motor de ascensor de tres plantas. El ascensor
dispone de una botonera con un botón por cada planta. Los botones exteriores de cada
puerta son los mismos que los interiores del ascensor (es decir, el botón de la tercera planta
es el mismo dentro del ascensor como el de la puerta de la tercera planta). Por lo tanto, sólo
pondremos una botonera para llamar o activar el ascensor y que suba o baje a algún piso.
Los ascensores disponen de unos sensores que se activan cuando el cajón del
ascensor llega a una planta. En nuestro montaje estos sensores serán también botones.
Pulsar un botón de estos, equivaldrá a indicar que el ascensor ya ha llegado a una planta
La misión de la programación del arduino es decidir si el motor gira para levantar el
ascensor o para hacerlo descender. En vez de poner un motor y rotarlo en una y otra
dirección, vamos a colocar dos leds para indicar el sentido de giro del motor y facilitarnos la
visualización del prototipo. El circuito es el siguiente
Con las conexiones ya hechas:
Declaramos e inicializamos los pines de sensores y leds:
const int pinBoton1 = 3;
const int pinBoton2 = 4;
const int pinBoton3 = 5;
const int pinSensor1 = 6 ;
const int pinSensor2 = 7;
const int pinSensor3 = 8;
nt pinLedSubiendo = 13;
const i
const i nt pinLedBajando = 12;
Y hago la inicialización!
La función setup se queda así:
void setup()
{
pinMode(pinBoton1,INPUT);
pinMode(pinBoton2,INPUT);
pinMode(pinBoton3,INPUT);
pinMode(pinSensor1,INPUT);
pinMode(pinSensor2,INPUT);
pinMode(pinSensor3,INPUT);
pinMode(pinLedSubiendo,OUTPUT);
pinMode(pinLedBajando,OUTPUT);
Serial.begin(9600);
}
Programación por Estados
Este problema tiene una característica especial que necesitamos describir detalladamente.
Vamos a utilizar un ejemplo simple durante la explicación. Supón que el ascensor está en
reposo en el piso 1 y ningún botón ha sido pulsado todavía.
Cuando se pulse el botón de la planta dos, el ascensor deberá empezar a subir. El botón de
llamar al ascensor, no estará pulsado todo el tiempo mientras el ascensor se mueve. Por eso
se llama "llamar al ascensor", el botón se pulsa una vez mediante una pulsación corta y el
ascensor se mueve durante un tiempo hasta llegar a la planta.
Los ascensores reales tienen unos sensores que indican que el cajón del ascensor ha
llegado a la planta. Cuando así ocurre y el sensor se activa, el control del ascensor detiene
inmediatamente el motor. En nuestro programa, nosotros hemos de reproducir esta
situación.
Recuerda otra circunstancia importante en este ejemplo: El ascensor tiene 6 entradas
(tres pulsadores y 3 sensores). Cuando estaba en reposo, los valores de cada entrada eran
los mismos que durante el tiempo en el que el ascensor ha estado moviéndose. Es decir,
para decidir si el motor debe moverse, no basta con leer los valores de las entradas, porque
como hemos visto, hay ocasiones en las que el ascensor se está moviendo y las entradas
son iguales que cuando está en reposo.
En este problema, el movimiento del ascensor no depende de los datos leídos de las
entradas, sino del estado en el que se encuentra el ascensor. Es decir, si el ascensor está
subiendo, da igual que los botones estén pulsados o no, el motor debe seguir tirando el
ascensor hacia arriba. Esa idea de que "el ascensor está subiendo" hay que programarla.
Evidentemente, el ascensor no estará subiendo eternamente, sino que en algún
momento deberá dejar de subir. Para ello están los sensores de llegada a cada planta.
Podemos pensar que "el ascensor -mientras intenta alcanzar el piso2 estará subiendo hasta
que se active el sensor de llegada al piso 2".
Estas ideas reflejan la necesidad de proporcionar una solución basada en los e
stados y
cambios de estado.
Para entender esto inicialmente, vamos a mantenernos en el escenario del ejemplo, en el
cual, podemos ver tres situaciones o estados:
1. El ascensor está en reposo en el piso 1, nadie ha pulsado todavía el botón y el
ascensor no se mueve
2. El ascensor se mueve hacia arriba porque alguien ha pulsado el botón de subir al
piso 2
3. El ascensor está ya en el piso 2 y por tanto debe volver a permanecer parado y en
reposo
Estas tres situaciones posibles reflejan tres estados que podemos dibujar de la siguiente
manera
Las flechas indican las transiciones o cambios de estado y marcan las posibilidades
existentes. Así, es posible pasar de estar en reposo en el piso 1 a estar subiendo. Pero no es
posible pasar de estar en el piso 1 a estar en el piso 2.
(normalmente hay que añadir un estado intermedio para controlar el tiempo en el
que el boton1 está pulsado, pero en este ejercicio podemos seguir sin prestarle
atención a este hecho y la solución es casi igualmente válida)
Implementación de estados
En la programación, necesitamos primero que nada indicar qué estados posibles existen.
Hay varias formas de hacer esto (por ejemplo asignar un número o código numérico a cada
estado "1": en piso1, "2": subiendo a piso 2, "3": en piso 2, etc). Nosotros vamos a utilizar
una característica del lenguaje C que simplificará muchísimo la comprensión posterior del
programa. Utilizaremos "enum" para declarar tipos de datos que pueden contener ciertos
valores indicados libremente. Observa la declaración del enum siguiente
enum estado { enPiso1,subiendoA2,enPiso2};
La línea anterior define un tipo de dato llamado "estado" que puede tener sólo los valores
"enPiso1", "subiendoA2" y "enPiso2". Ahora, es posible declarar variables con ese tipo de
datos. A continuación se declara una variable llamada "estadoActual" cuyo contenido sólo
pueden ser los valores anteriores
estado estadoActual;
Por ejemplo, podemos inicializar la variable "estado" en la función setup() para indicar que
inicialmente se está en el piso 1 de la siguiente manera:
estadoActual = enPiso1;
Modificamos la función setup con esta instrucción para inicializar el Ascensor (suponemos
por comodidad que está en la planta 1 al principio)
void setup()
{
...
estadoActual = enPiso1;
...
}
Vamos a preparar el terreno para poder ver qué hace el ascensor en cada momento. En la
función loop añadimos la comunicación serie con el simulador que nos permitirá ver el
estado del ascensor. Aquí volvemos a ver las ventajas de utilizar enum como forma de
codificar los estados del ascensor. Observa cómo se utiliza un switch para comparar el valor
de la variable "estadoActual" con los posibles valores asignables:
void loop()
{
Serial.print("Estado actual: ");
switch (estadoActual) {
case enPiso1: Serial.print("enPiso1");break;
case subiendoA2: Serial.print("subiendoA2");break;
case enPiso2: Serial.print("enPiso2");break;
}
Serial.println("");
delay(100);
}
Cambios de estado
La programación por estados consiste básicamente en determinar dos cosas:
● ¿ Cuándo se cambia de estado?
● ¿ Qué salidas se activan según el estado actual?
Generalmente, un cambio de estado ocurre puntualmente. Es fácil que durante muchos
milisegundos no ocurra nada especial y el estado de arduino se mantenga sin cambiar. Pero
en algún momento, debido a una combinación de ciertos valores de entradas y de variables
internas, se produzca un cambio de estado.
Estos cambios se programan estado por estado de forma independiente. Y siempre se
realiza en dos fases.
1. Leemos los datos de entrada que son relevantes para un estado concreto (por
ejemplo, si estamos en el estado "subiendoA2" sólo nos interesa saber si el sensor
de llegada al piso 2 está activo o no. Porque ese estado sólo se cambia cuando se
llega a ese piso, no importa si se pulsa mientras otro botón.
2. Verificamos que se está en cierto estado y que los datos de entrada indican que
debemos cambiar
Para empezar, Vamos a controlar la subida del primer piso, -que es donde nos encontramos
al principio- al segundo piso
Primero deberemos leer la entrada de los pines que nos interesan:
int boton2 = digitalRead(pinBoton2);
int sensor2 = digitalRead(pinSensor2);
Si estamos en el primer piso y el botón ha sido pulsado, entonces hay que cambiar de
estado
if (estadoActual == enPiso1 && boton2 == 1 )
estadoActual = subiendoA2;
Ya está. Hemos implementado el cambio de estado para el estado "enPiso1". Seguimos con
el resto de estados
Igualmente, si estamos subiendo y detectamos que hemos llegado a la segunda
planta, hay que cambiar de estado
if (estadoActual == subiendoA2 && sensor2 == 1 )
estadoActual = enPiso2;
Activación de salidas según estados
Como se ha dicho antes, cada estado determina unas salidas. Cuando el ascensor está en el
estado "enPiso1", todo está en reposo y el motor (o led) no debe activarse. En este ejercicio,
de momennto, el estado importante es subiendoA2. Es en ese estado cuando debe estar el
motor (o led) en marcha.
Esta parte se programa al final, después de todos los cambios de estado. La programación
suele ser muy sencilla:
if (estadoActual == subiendoA2)
digitalWrite(pinLedSubiendo,1);
El problema es que el led no se apagará después de haberse activado. Podríamos complicar
la programación con "elses" para "if" como ese, pero vamos a adoptar una estrategia astuta:
Apagaremos los led al principio y sólo los encenderemos si hace falta
digitalWrite(pinLedSubiendo,0);
if (estadoActual == subiendoA2)
digitalWrite(pinLedSubiendo,1);
Para seguir, reproducimos lo razonado para estos dos pisos en el otro piso y en los sentidos
de bajada:
enum estado { enPiso1,subiendoA2,
enPiso2,subiendoA3,
enPiso3,bajandoA2,
bajandoA1};
El código:
int boton1 = digitalRead(pinBoton1);
int sensor1 = digitalRead(pinSensor1);
int boton2 = digitalRead(pinBoton2);
int sensor2 = digitalRead(pinSensor2);
int boton3 = digitalRead(pinBoton3);
int sensor3 = digitalRead(pinSensor3);
if (estadoActual == enPiso1 && boton2 == 1 )
estadoActual = subiendoA2;
if (estadoActual == enPiso2 && boton3 =
= 1 )
estadoActual = subiendoA3;
if (estadoActual == subiendoA2 & & sensor2 == 1 )
estadoActual = enPiso2;
if (estadoActual == subiendoA3 & & sensor3 =
= 1 )
estadoActual = enPiso3;
if (estadoActual == enPiso3 && boton2 == 1 )
estadoActual = bajandoA2;
if (estadoActual == enPiso2 && boton1 =
= 1 )
estadoActual = bajandoA1;
if (estadoActual == bajandoA2 && sensor2 == 1 )
estadoActual = enPiso2;
if (estadoActual == bajandoA1 && sensor1 == 1 )
estadoActual = enPiso1;
La activación/desactivación de los led:
digitalWrite(pinLedSubiendo,0);
digitalWrite(pinLedBajando,0);
if (estadoActual == subiendoA2 ||
estadoActual == subiendoA3)
digitalWrite(pinLedSubiendo,1);
if (estadoActual == bajandoA2 ||
estadoActual == bajandoA1)
digitalWrite(pinLedBajando,1);
Fin del ejercicio.
