aclarando cosas
Estaría feo llamarle a esto manual de Arduino. Los manuales los escriben expertos, y nosotros estamos lejos de ser expertos de nada, y menos de Arduino.
Lo que tienes ahora mismo delante no es más que una recopilación, adaptación, traducción etc, etc…, con la que sólo se pretende que no pases las horas que hemos pasado nosotros buceando en internet.
Muchos de los textos los hemos sacado de la página oficial de Arduino, otros de páginas de fabricantes o distribuidores de componentes, y en la mayoría de las veces nos hemos limitado a adaptarlos al contexto de un aula de tecnologías de ESO o Bachillerato, si eso todavía existe cuando leas esto.
¿arduino?¿ qué es eso?
Arduino es una plataforma de electrónica abierta para
la creación de prototipos basada en software y hardware flexibles y fáciles de
usar. Siempre cuentan que se creó para artistas, diseñadores, aficionados y
cualquiera interesado en crear entornos u objetos interactivos que no en muchas
ocasiones no tenemos altos conocimientos de electrónica o programación.
Arduino es una placa que recoge información del
entorno por medio de sensores (pulsadores,
sensores de temperatura, de presencia, de luminosidad, micrófonos…), conectados
a sus pines (conectores) de entrada,
controlando de este modo cualquier cosa que nosotros queramos conectar a los
pines de salida, ya sean luces, motores
y otros actuadores.
pines
Cada vez que intento leer algo sobre arduino me encuentro con la palabra PIN.
No son más que conectores. Por ejemplo una placa Arduino Uno tiene 14 pines digitales y seis analógicos, aunque estos últimos se pueden configurar también como digitales.
Ahora es cuando toca recordar que una señal analógica es aquella cuyo valor varía entre un mínimo y un máximo. Por ejemplo, la medida de la temperatura, de la intensidad de luz, etc…
Una señal digital es más básica, y su valor sólo puede ser encendido (HIGH en Arduino) o apagado (LOW).
Dependiendo de lo que queramos medir y de las características de nuestro sensor, usaremos una entrada digital o analógica.
Además de éstos nuestra placa tiene otra serie de pines, como son:
Cada uno de ellos se puede configurar como entrada o salida con una sencilla instrucción. Tan simple como poniendo pinMode (13, OUTPUT) estaremos configurando el pin 13 como SALIDA.
No son más que conectores. Por ejemplo una placa Arduino Uno tiene 14 pines digitales y seis analógicos, aunque estos últimos se pueden configurar también como digitales.
Ahora es cuando toca recordar que una señal analógica es aquella cuyo valor varía entre un mínimo y un máximo. Por ejemplo, la medida de la temperatura, de la intensidad de luz, etc…
Una señal digital es más básica, y su valor sólo puede ser encendido (HIGH en Arduino) o apagado (LOW).
Dependiendo de lo que queramos medir y de las características de nuestro sensor, usaremos una entrada digital o analógica.
Además de éstos nuestra placa tiene otra serie de pines, como son:
- IOREF, un duplicado de +5v
- Reset, con el que podemos controlar un reset de nuestra placa
- 3,3 v, salida positiva de voltaje.
- 5v, salida positiva de voltaje.
- GND, pin de tierra, el negativo de nuestros montajes.
- Vin, nos permite una entrada de alimentación externa
Cada uno de ellos se puede configurar como entrada o salida con una sencilla instrucción. Tan simple como poniendo pinMode (13, OUTPUT) estaremos configurando el pin 13 como SALIDA.
proyectos realizados en el aula
Durante el presente curso se han realizado en el aula diversos e interesantes proyectos de robótica utilizando arduino...
La "yogurtería" de Ángela, Fran y Tamara, cuyo escaparate se encendía automáticamente cuando era de noche y además se acercaba alguien a verlo. Un ventilador aireaba el local si la temperatura aumentaba más de lo previsto, y la apertura y cierre de las puertas se accionaba al detectar un sonido de una determinada intensidad.
Francisco, Luis Miguel y Marcos diseñaron una vivienda inteligente en la que la puerta de la cochera y la iluminación de la misma se accionaban al detectar al vehículo, y contaba con un ascensor cuya luz se encendía al detectar presencia y su puesta en marcha atendía a ordenes por voz. Similares funciones realizaba el edificio inteligente de Miguel, Eduard y Sergio.
Salomé, Clara y Antonio diseñaron un invernadero que controlando la luz, la temperatura y la humedad de la tierra accionaba los ventanales, ventiladores y sistema de riego automático.
La "baticao" de Emma, Paula y José Angel preparaba el desayuno automáticamente. Al sentir la presencia de la taza, la gira hasta el dispensador, donde se produce el llenado hasta que el peso de la misma es el programado. A la vez controla que la temperatura del desayuno sea la prevista.
La casa para mascotas de Jorge, José Luís e Iván detectaba la presencia o no de la mascota. Dependiendo si es de noche o no, cierra las puertas y controla el sistema de calefacción, avisando al dueño si está dentro o fuera. Un sistema también robotizado se encarga de reponer tanto el agua como el pienso de la mascota.
Otros alumnos dedicaron sus esfuerzos a la robótica de competición, desarrollando robots siguelíneas.
De los primeros prototipos con los que participaron en el campus de Alcoi en la Semana de la Ciencia de la UPV y con los que consiguieron meritorias clasificaciones...
... hasta los rapidísimos robots con los que participaron en el Desafío Robot 2014 de la Ciudad de las Ciencias en Valencia
Prueba del entusiasmo con el que el alumnado acogió este tipo de actividades es que gran parte de ellas se realizaron por la tarde, fuera del horario escolar, y con asistencia voluntaria.
¿por qué arduino?
Las razones por las que utilizar Arduino pueden resumirse en:
1. Es una plataforma de Hardware y software libre. Ello supone que no dependemos de que una marca comercial decida el rumbo sino que miles de desarrolladores diseñen el futuro de arduino
2. Permite usarse bajo Windows, Mac OS x, o Linux
3. No precisa de grandes conocimientos de electrónica, ni de robótica, ni de programación.
4. Es económico. Ninguna de las placas que utilizamos en clase han costado más de 25 €.
5. Existe una inmensa y creciente comunidad en internet que nos ofrece
infinidad de programas, ejemplos, proyectos, foros, ayuda….
instalando arduino. ¿qué necesito?
Para
empezar a trabajar con Arduino sólo necesitamos una de las distintas placas
Arduino que existen, un ordenador con Windows, Mac OS X, o Linux, un cable y un
cable usb que los conecte. Ah, y dedicarle unas cuantas horas…
1. Descarga la IDE de Arduino. Para ello
visita la página
de descargas. Ya empezamos… ¿qué es eso del IDE? El IDE es
nuestro interface con el que nos comunicaremos con nuestra placa. Lo
utilizaremos para crear nuestros programas, depurarlos, compilarlos para que
los entienda nuestra placa, y enviarlos a la misma. Tiene un aspecto más o
menos así.
2. Conecta la placa Arduino a tu ordenador
usando el cable USB. El LED verde indicador de la alimentación (nombrado como
PWR en la placa) debería quedar encendido a partir de ese momento.
3. Instala los drivers. Cuando
conectas la placa, Windows debería inicializar la instalación de los drivers (siempre
y cuando no hayas utilizado ese ordenador con una placa Arduino anteriormente).
En Windows
Vista y Windows 7, los drivers deberían descargarse e instalarse
automáticamente.
En Windows
XP, se abrirá el diálogo de instalación de Nuevo Hardware:
·Cuando te pregunten: ¿Puede Windows
conectarse a Windows Update para buscar el software? selecciona No,
no esta vez. Haz click en Siguiente.
·Selecciona Instalar desde una lista o
localización específica (Avanzado) haz click en Siguiente.
·Asegúrate que Buscar los mejores drivers en
estas localizaciones esté seleccionado; deselecciona Buscar en medios
removibles; selecciona Incluye esta localización en la búsqueda y
navega al directorio drivers/FTDI USB Drivers dentro de la carpeta de
Arduino que has descomprimido previamente. (La versión más reciente de
los drivers se puede encontrar en la página web del fabricante
del chip FTDI.) Haz click en Siguiente.
·El asistente de instalación buscará los drivers y
te anunciará que encontró un "USB Serial Converter" (se traduce
por Conversor USB-Serie). Haz click en Finalizar.
·El asistente de instalación de hardware volverá
a iniciarse. Repite los mismos pasos que antes y selecciona la misma carpeta de
instalación de los drivers. Esta vez el sistema encontrará un
"USB Serial Port" (o Puerto USB-Serie).
Puedes comprobar que los drivers se
han instalado correctamente abriendo la carpeta del Administrador del
Dispositivos, en el grupo Dispositivos del panel de control
del sistema. Busca "USB Serial Port" (o Puerto USB-Serie)
en la sección de puertos; esa es tu placa Arduino.
Abrimos
nuestro IDE. Lo primero que tenemos que
hacer es una sencilla configuración que supone elegir nuestra placa y el puerto
a la que la tenemos conectada. Para ello vamos al menú HERRAMIENTAS
del que nos interesan dos pestañas, la pestaña TARJETA,
en la que después de desplegarla elegiremos la nuestra, y la pestaña PUERTO SERIAL, en la que seleccionaremos el puerto al
que tenemos nuestra placa. Si no sabemos cuál es, lo comprobaremos en la
pantalla que vemos en la imagen de arriba.
las placas
Existen infinidad de tipos de placas. Cada día salen nuevas.
Por comodidad, respeto a los creadores y por ser una de las más extendidas
nosotros vamos a usar la ARDUINO UNO
Las placas pueden ser hechas a mano o compradas montadas de fábrica; el software
puede ser descargado de forma gratuita. Los ficheros de diseño de referencia (CAD) están disponibles bajo una licencia abierta, así pues eres libre de adaptarlos a tus necesidades.
El equipo Arduino (Arduino team) es: Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, y David Mellis.
¿cómo me comunico con la placa?
Para programar el microcontrolador en la placa
Arduino en el aula usaremos el lenguaje lenguaje de programación Arduino (basado en Wiring) y el
entorno de desarrollo Arduino (basado en Processing). Los proyectos hechos con Arduino pueden ejecutarse sin necesidad
de conectar a un ordenador, si bien tienen la posibilidad de hacerlo y
comunicar con diferentes tipos de software (p.ej. Flash, Processing, MaxMSP. En educación también se
usa mucho el SCRATCH, concretamente una versión específica llamada S4A –scratch
for Arduino- un entorno gráfico muy intuitivo.
¿qué podemos hacer con arduino?
Una de las
características más interesantes de Arduino es que es lo suficientemente
intuitivo como para poder empezar a trabajar en proyectos sencillos, pero a la
vez nos permite incrementar la complejidad de los mismos de manera
prácticamente infinita. Con Arduino podemos automatizar cualquier proyecto en
el aula, hacer robots sencillos, manejar la información que genera cualquier
sensor. Pon “proyectos de arduino” en
Youtube y te darás cuenta de las infinitas posibilidades de Arduino.
nuestra primera práctica con arduino
Vamos a cargar nuestro
primer programa con Arduino. Lo encontraremos dentro del IDE del arduino, en el menu Archivo/ejemplos/basics/blink
El programa enciende
intermitentemente un LED conectado directamente a la placa de Arduino. No
necesitaremos protoboard en esta ocasión.
La estructura de todos
los programas Arduino es igual.
// Enciende un LED un
segundo y apágalo otro segundo repetidamente.
/* Aquí van
comentarios iniciales del autor. Todo lo que vaya detrás de esa barra asterisco
no participa en el programa, por tanto no es cargado en la placa. Debemos
cerrarlo con un */
/* parpadeo
*/
void setup() { //
poniendo una doble barra podemos incluir explicaciones. En este caso arrancamos
el “setup” de nuestro programa, es decir, las condiciones previas que servirán
para todo el programa y que sólo se cargarán una vez
pinMode (13, OUTPUT); // definimos el pin 13 como SALIDA. Siempre hay que decirle a
nuestra placa si un pin lo hemos definido como OUTPUT o INPUT. siempre debemos terminar la
instrucción con un ; !!!
} // como abrimos llaves
para definir el setup, debemos cerrarlas!!
// a partir de aquí creamos el bloque LOOP, el
"alma" del programa. Este bloque se reproducirá una y otra vez
mientras no digamos lo contrario
void loop() {
digitalWrite(13, HIGH); //
manda una señal digital HIGH (encendido, +5v) al pin 13. El pin 13 es el único
de nuestra placa arduino que lleva una resistencia integrada de forma que
podemos insertar un LED directamente. No utilices otro pin, ya que mandarás 5v
al LED y te lo cargarás.
delay(1000); // delay significa "espera". Con
delay 1000 esperaremos 1000 milisegundos! cuidado!
digitalWrite(13, LOW); // manda una señal LOW
(apagado) digital al pin 13
delay(1000); // vuelve a esperar un segundo
// a partir de aquí, mientras no le digamos lo
contrario nuestro programa se ejecutará infinitamente, porque el bucle no
recibe ninguna orden de stop
} // igual que antes, toda
llave abierta hay que cerrarla. Fin del programa.
Pruébame
Pruébame
A partir de aquí es
sencillo manipular el sketch a nuestro gusto.
1.
Cambia el intervalo de tiempo a 0,25 seg
2.
Cambia sólo el de apagado.
3.
Haz secuencias llamativas.
Vamos a montar lo mismo
en una protoboard. Esto nos permitirá incluir más elementos en nuestra
práctica. Recuerda que en una protoboard, los pines van conectados internamente
así:
Para usar los leds los montaremos con una resistencia en serie
de entre 220Ω y 270Ω. Algo así
Las salidas digitales 7,
8 y 9 nos darán el +5v, mientras que cerraremos cada circuito con el pin GND de
nuestra placa Arduino.
A partir de aquí ya
debes ser capaz de controlar los led. Te echo una mano al principio, pero no te
acostumbres. Intenta entender el sketch, ahora llevará menos explicaciones.
/* parpadeo de tres leds
*/
void setup() //definimos parámetros iniciales
{
pinMode (7, OUTPUT); // definimos los pines 7, 8 y 9 como
SALIDAS
pinMode (8, OUTPUT);
pinMode (9, OUTPUT);
}
void loop() {
digitalWrite(7, HIGH); // mandamos a los pines 7, 8 y 9 la señal
digital
digitalWrite(8, HIGH); // HIGH,encendido
digitalWrite(9, HIGH);
delay(1000); // esperamos 1000 milisegundos, siii, un
segundo...
digitalWrite(7, LOW); // mandamos a los pines 7, 8 y 9 la señal
digital
digitalWrite(8, LOW); //
LOW, apagado
digitalWrite(9, LOW);
delay(1000); // volvemos a esperar un segundo, y
ejecutamos de nuevo el loop
} // importante, cerramos el bucle
¿has entendido qué hace
cada instrucción? Perfecto! Si es así y has sido capaz de encender y apagar los
tres leds, ahora toca jugar. Puedes hacer combinaciones infinitas con los leds
encendidos o apagados y con los intervalos de tiempo.
1.
Prueba a simular un semáforo.
2.
Haz las luces del coche fantástico.
3.
Monta más leds y haz combinaciones llamativas. No te olvides de
las resistencias!
entradas. El pulsador
Al encender un led estamos usando
SALIDAS, es decir, nuestra placa está provocando algo en el exterior. Mediante
ellas podemos encender y apagar un led, controlar el giro de un motor, escribir
en una pantalla, activar un zumbador, y todo lo que se te ocurra.
Arduino nos permite además
configurar los pines como ENTRADAS. De está manera lo que estaremos haciendo es
obtener información del entorno.
La forma más elemental de
interactuar con él es mediante un pulsador.
Sería un error comparar esto que
acabamos de decir con un circuito eléctrico elemental mediante el cual
encendemos un led al activar un pulsador. Sin caer en fantasmadas, nuestro
proceso es mucho más complejo. A diferencia de ese circuito, en el que el
pulsador es un simple “grifo” que deja pasar o no electrones capaces de
encender a su paso un led, en nuestro proceso sucede:
Leemos el valor de una entrada. Esta puede ser:
¿No ves la diferencia? :) . Hemos elegido la forma de entrada
y salida más sencillas, pero a partir de aquí podemos complicarnos la vida todo
lo que queramos. Vamos a montar la práctica. Usaremos el sketch que viene en
ejemplos/digital llamado BUTTON. Lo cargamos y aparece en nuestro IDE así:
*/ Botón. Enciende y apaga un LED conectado al
pin 13 cuando apretamos un pulsador conectado al pin 2 */
const int buttonPin = 2;
// indica el pin del pulsador
const int ledPin = 13; // indica el pin del led
int buttonState = 0; //al poner solo int, el estado
del botón, buttonState, será una variable con valor incicial 0.
void setup() {
pinMode(ledPin,
OUTPUT); //
pin del led como SALIDA
pinMode(butttonPin, INPUT);
// pin del botón como ENTRADA
}
void loop()
buttonState =
digitalRead(buttonPin); //
lee el valor de la variable estado del botón
if (buttonState == HIGH) {
//
SI la
variable digital, es “HIGH”...:
digitalWrite(ledPin,
HIGH); // enciende el pin
}
else { //
en otro caso...:
digitalWrite(ledPin, LOW);
// apaga el LED
}
}
¿fácil? Seguro que si.
El esquema del montaje es el
siguiente:
Ahora para sacarle partido a
nuestros avances, podríamos cambiar tanto las entradas como las salidas. En
lugar de poner un sencillo pulsador vamos a poner ahora un SENSOR DE LUZ. Para
ello usaremos un LDR, Light Dependent Resistor, que para los que nos llevamos regular
con el inglés no es más que una resistencia cuyo valor varía con la luz que
incide sobre ella. Con poca luz, su resistencia es muy alta, y va bajando
conforme lo iluminamos
midiendo la cantidad de luz
Esta vez no queremos obtener valores
digitales SI/NO, sino que queremos medir el valor de la luz que llega. Por eso
usaremos entradas ANALÓGICAS. Las podemos encontrar en nuestra placa como A0,
A1…
El esquema del montaje será muy
parecido al montaje básico del pulsador (que para eso lo hemos explicado…)
Como ves, la principal diferencia es
que conectamos el LDR a un pin analógico.
Además vamos a hacer otra cosa
interesante con este nuevo sketch. Vamos a visualizar los valores que
obtengamos del sensor en nuestro ordenador a través del puerto USB. Para ello
usaremos el MONITOR SERIAL del menú HERRAMIENTAS de nuestro IDE. Si, es
bastante feo, pero es el que hay. Las instrucciones básicas que debemos conocer
del monitor son:
Serial.begin(9600) inicia la comunicación con el
monitor a 9600 bits/seg
Serial.print(“Hola Mundo!”) muestra
una línea con Hola mundo
Serial.println(Valor) muestra en la misma línea el valor de una variable
Serial.println(Valor) muestra en la misma línea el valor de una variable
Con esto nos apañamos..., de
momento.
Vamos con el ejemplo:
// Midiendo la cantidad de luz con un LDR
int LDR_pin = 2; //
vamos a leer los valores del pin 0
int LDR_val = 0; //
definimos la VARIABLE LDR_val y le damos el valor inicial = 0
void setup() {
Serial.begin(9600); // iniciamos el monitor serial.
}
void loop()
{
LDR_val = analogRead(LDR_pin); // leemos el valor que da el LDR.
Serial.print("LDR = "); // Imprimimos el texto LRD= en una línea del monitor
Serial.println(LDR_val); //
en la misma línea, a continuación, el valor leído por el sensor
delay(1000); // Paro 1 segundo. Vuelvo al bucle, mido, imprimo, espero….bucle
}
Genial, ya sabemos presentar en
nuestro ordenador datos medidos con nuestra placa arduino. Ahora, además de
leerlos y presentarlos, vamos a procesarlos.
Lo inmediato que se nos ocurre a
todos es que, a partir de un determinado valor de lectura, hagamos algo. Por
ejemplo podríamos encender automáticamente un led cuando el valor de la luz sea
inferior al que nosotros fijemos. El esquema electrónico sería:
Usando el mismo ejemplo anterior,
vamos a añadir unas líneas de código. Sólo comentaremos las líneas
añadidas.
// Encendido automático de un LED en función de la luz
int LED_pin=13; //conectamos el LED en el
pin 13
int LDR_pin = 2;
void setup() {
pinMode(LED_pin,OUTPUT); // LED del pin configurado como SALIDA
Serial .begin(9600);
}
void loop()
{
LDR_val = analogRead(LDR_pin);
Serial.print("LDR =
");
Serial.println(LDR_val);
if (LDR_val>=20) // Si hay luz, valor
mayor de 20:
{
digitalWrite(LED_pin, LOW); // Apago el LED
}
else if (LDR_val<20) // Si no hay luz, si su
valor es menor que 20…
{
digitalWrite(LED_pin, HIGH); // Encendemos el LED
delay(1000);
}
}
el sensor de temperatura
librerías
Las
librerías son pequeños programas que nos permiten usar fácilmente elementos
complejos que conectamos a nuestra placa. Arduino ya cuenta con muchas de
ellas. Las puedes encontrar en el directorio libraries,
y aparecen en el menu ejemplos.
Cuando
queramos conectar algo más “éxótico” que una LDR, como un sensor complejo, una
pantalla lcd o una controladora de motores, probablemente tengamos que instalar
también una librería para controlarlo.
El
procedimiento es sencillo. Lo primero es obtener la biblioteca del componente.
Si lo hemos adquirido en una tienda seria, y hay muchas, normalmente lo
podremos descargar desde la hoja de descripción del producto, junto con la
datasheet del mismo. También las podemos descargar de Github o de Arduino Playground.
Una vez
descargado el archivo zip, lo descomprimimos en la carpeta libraries de nuestro Arduino, nos aseguramos que la
carpeta contenga los caracteres correctos y reiniciamos el IDE. Cuando ahora mi
programa llame al principio a la librería que hemos instalado con la
instrucción #include, veremos que esta llamada
aparece en naranja, señal de que la ha reconocido correctamente.
#include
<Wire.h>
…ya te dijimos que estaba fácil