Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Arduino
Arduino
9 788426 721501
Taller de Arduino
Un enfoque práctico para principiantes
ISBN: 978-84-267-2332-1
A mi hermano, Ibán Toxeiro
Índice
Prólogo ........................................................................................................... xi
Agradecimientos ............................................................................................ xv
v
Capítulo 3. TRASMISIÓN SERIE EN ARDUINO .................................................. 51
vi
6.3 Práctica 15: funcionamiento del sensor de distancia por ultrasonidos .... 120
6.4 Práctica 16: funcionamiento de un sensor de movimiento ...................... 124
vii
9.4.3 Práctica 27: control básico de un motor PAP bipolar
utilizando el L293D ............................................................................ 197
9.4.4 Práctica 28: utilizando la librería “Stepper.h” en un PAP unipolar ... 199
9.5 Funcionamiento de un servomotor (SERVO) ............................................ 201
9.5.1 Librería “Servo.h”: simplificando las cosas ....................................... 201
9.5.2 Práctica 29: control básico de un SERVO .......................................... 203
9.6 ¡Más caña con el motor brushless! ........................................................... 205
9.6.1 Práctica 30: control básico de un motor brushless ........................... 208
9.7 Haciéndolo todo más fácil con las shields ................................................. 209
9.7.1 Práctica 31: utilizando la Arduino Motor Shield ............................... 211
viii
12.1.2 Práctica 38: implementando un Arduino web Server ..................... 263
12.1.3 Práctica 39: comunicándose con Twitter ........................................ 271
12.2 Características de la Arduino wifi shield ................................................. 276
12.2.1 La librería wifi ................................................................................. 277
12.2.2 Práctica 40: escaneando tu red inalámbrica WiFi .......................... 279
12.3 El servidor de datos Xively ...................................................................... 284
12.3.1 Práctica 41: monotorizando temperaturas
con el servidor Xively ....................................................................... 288
12.4 El servidor de datos Plotly....................................................................... 293
12.4.1 Práctica 42: adquisición y visualización de datos en Plotly ............ 295
12.4.1.1 El sensor de temperatura/humedad DHT22 .............................. 295
ix
13.2 Entorno gráfico de programación LabVIEW ............................................ 340
13.2.1 Práctica 53: control simple de un LED ............................................. 346
13.2.2 Práctica 54: lectura y escritura de valores en Arduino ................... 352
13.2.3 Práctica 55: intermitencia de un LED .............................................. 354
13.2.4 Práctica 56: control de una salida analógica PWM ........................ 356
13.2.5 Práctica 57: control de la velocidad y sentido de un Motor DC ...... 357
13.2.6 Práctica 58: medida de temperatura con un LM35 ........................ 360
13.2.7 Práctica 59: control de un motor paso a paso (PAP) ...................... 361
13.2.8 Práctica 60: control de un LCD ........................................................ 362
x
Prólogo
En verano de 2013, durante el mes de agosto, haciendo el camino de Santiago por
la ruta de Levante desde Valencia, me plantearon desde la editorial la idea de
escribir un libro sobre Arduino que fuera dirigido a estudiantes de formación
profesional de grado medio. La verdad es que no existía en ese momento un texto
en castellano, sencillo y ordenado, que recogiera la inmensa información que existe
en Internet sobre este tema y que fuera lo más ameno y práctico posible para
aquellos alumnos de electrónica que quieran acercarse a la plataforma Arduino.
Por otra parte, no se trataba de realizar un texto excesivamente técnico y
riguroso, sino un libro divertido y claro que fuera accesible a estudiantes con
pocos conocimientos de electrónica. Debía constituir una auténtica guía de
autoaprendizaje que consiguiera «enganchar» a los lectores desde el principio y
les proporcionara un camino para poder desarrollar sus propios proyectos o ideas
sin perderse en la red, o en libros demasiado técnicos que en casi todos los casos
están escritos en el idioma de William Shakespeare.
David Cuartelles (uno de los padres de la criatura Arduino) mencionó una vez, en
una de sus conferencias, que la idea de la que partió todo fue la de poner en
manos de sus alumnos una herramienta de desarrollo que fuera barata y muy
sencilla de utilizar. Hasta ese momento las plataformas microprogramables para
desarrollar proyectos electrónicos eran demasiado caras y demasiado
complicadas para un estudiante que empezara de cero. Personalmente, provengo
del mundo de los microcontroladores PIC y debo reconocer que, aunque en su
momento supusieron una revolución de precios con respecto a los micros de Intel,
el lenguaje ensamblador en que se programaban resultaba bastante tedioso. Pues
bien, al poco tiempo aparecieron compiladores en lenguajes de alto nivel como C
o Basic, pero eran muy caros, y los pocos compiladores que había libres o GNU
venían «pelados», es decir, sin librerías. Con lo cual, para conectarte un PIC a un
LCD tenías que currártelo mucho; y no hablemos de conectarlo a Internet.
Cuando mi amigo Óscar González, uno de los primeros distribuidores de Arduino en
España y responsable de la empresa bricogeek (www.bricogeek.com) me ofreció, hace
unos años, las bondades de este producto, la verdad es que no le hice mucho caso, ya
que yo seguía a pie juntillas realizando mis proyectos con los famosos
xi
microcontroladores PIC de la empresa Microchip y no pensaba que esa aventura fuera a
revolucionar el mundo de los aficionados a la electrónica. Me equivocaba de lleno.
Pues algo parecido está pasando con Arduino, una plataforma de hardware libre con
una inmensa cantidad de librerías de su compilador realizadas por aficionados,
entusiastas, etc. que están disponibles en la red de redes para que las descarguemos,
utilicemos o mejoremos. De tal manera que construirse un termómetro con un
visualizador LCD sea algo sencillo al alcance de cualquiera. De ahí, la aparición de un
término tan en boga últimamente que es el DIY (Do It Yourself: ‘hazlo tú mismo’) ya
que esto es posible usando una plataforma libre como Arduino.
El libro que tienes en tus manos pretende ser una guía de autoaprendizaje que te
permita conocer básicamente lo que es Arduino a través de varios proyectos
sencillos resueltos y otros propuestos. Además, aprenderás a manejar algunos
dispositivos como ledes, sensores de diversos tipos, LCD, motores de continua,
servos, motores paso a paso (tan utilizados hoy en día en las impresoras 3D) y,
como no, adentrarte en el novedoso mundo de Internet de las cosas (IOT)
comunicando tu Arduino con Internet. Y todo ello, partiendo de unos
conocimientos muy elementales de electrónica.
Espero que esta aventura que está a punto de comenzar os ilusione lo mismo que me
sucedió a mí cuando descubrí lo que esta pequeña plaquita podía llegar a hacer.
xii
Convenciones utilizadas en este libro
A lo largo del presente libro se exponen un conjunto de prácticas ordenadas en
dificultad. Además, se proponen otras para que las realices tú mismo, mejorando
tu experiencia en la programación de Arduino. Si tienes la posibilidad de acceder
al software de simulación Proteus a través de tu instituto, universidad o a nivel
particular, podrás simular su funcionamiento porque la mayoría de los
componentes utilizados en estas prácticas están modelizados con este estupendo
software. Las prácticas sugeridas se representan de dos maneras:
xiii
Agradecimientos
En primer lugar, agradecer a Jofrer de TFORMICROS.S.A, la revisión de los códigos
de programa relativos al capítulo 12.
xiv
Marcas registradas
El nombre y el logo de Arduino son marcas registradas por el equipo de Arduino
en todos los países.
El nombre y el logo de Proteus ISIS, VSM y ARES son marcas registradas por
Labcenter Electronics en todos los países.
El nombre y el logo de S4A son marcas registradas por Citilab en todos los países.
xv
CAPÍTULO
Arduino puede tomar información y datos del entorno a través de sus pines
de entrada por medio de toda la gama de sensores que existen en el mercado. En
base a ello, puede ser usada para controlar y actuar sobre todo aquello que le
rodea; como por ejemplo luces, motores y otro tipo de actuadores. El
microcontrolador de la placa Arduino se programa mediante un sencillo lenguaje
de programación basado en C/C++ y un entorno de desarrollo (IDE) que responde
a las especificaciones de open software. Los proyectos hechos con Arduino
pueden ejecutarse sin necesidad de conectarlo a un ordenador, si bien tienen la
posibilidad de hacerlo y comunicarse con diferentes tipos de software (por
ejemplo: Flash, Processing, MaxMSP, etc.).
1
Taller de Arduino
referencia (CAD) están disponibles bajo una licencia abierta, así pues, eres libre de
adaptarlos a tus necesidades.
2
1. Inicio con Arduino desde cero
http://blog.bricogeek.com/noticias/arduino/hack-que-
permite-abrir-puertas-de-hoteles-con-arduino/
Figura 1.1
3
Taller de Arduino
4
1. Inicio con Arduino desde cero
Figura 1.2
5
Taller de Arduino
Figura 1.3
Figura 1.4
6
1. Inicio con Arduino desde cero
Figura 1.5
Figura 1.6
7
Taller de Arduino
Figura 1.7
Si utilizas Linux o Mac lo tienes muy sencillo: solo tienes que conectar el
Arduino. Este estará preparado para trabajar y no necesitaremos instalar ningún
driver. En cambio, si eres de los que no quieres renunciar a las bondades y
pantallazos azules de error de Windows, deberás seguir los siguientes pasos para
que todo vaya bien.
Figura 1.8
8
1. Inicio con Arduino desde cero
Figura 1.9
Figura 1.10
Figura 1.11
9
Taller de Arduino
Figura 1.12
Figura 1.13
Figura 1.14
10
1. Inicio con Arduino desde cero
Figura 1.15
Figura 1.16
11
Taller de Arduino
Figura 1.17
Figura 1.18
12
1. Inicio con Arduino desde cero
Figura 1.19
Figura 1.20
13
Taller de Arduino
Figura 1.21
14
1. Inicio con Arduino desde cero
void setup()
{
pinMode(led, OUTPUT);
}
15
Taller de Arduino
De esta forma tan sencilla podemos configurar todos los pines digitales del
Arduino para que actúen como entradas o salidas, dependiendo de lo que
tengamos conectados a los mismos.
digitalWrite(13, HIGH);
void loop()
{
digitalWrite (led, HIGH); // Enciende el LED
delay(1000); // Espera 1 segundo
digitalWrite (led, LOW); // Apaga el LED
delay (1000); // Espera 1 segundo
}
Delay es una función muy sencilla. Hace que toda la ejecución de Arduino
pare o se detenga durante los milisegundos que le indiquemos como parámetro.
16
1. Inicio con Arduino desde cero
Lo que nos queda por hacer ahora es subir nuestro flamante código a la
placa Arduino y ver si funciona. Para ello presionamos el botón de compilación y
subida de código indicado en la Figura 1.22. Si todo va bien veremos dos lucecitas
(dos diodos leds) serigrafiadas como TX y RX en la placa parpadear durante un
momento (Figura 1.23). Esto indica que el programa está cargándose en el
microcontrolador de Arduino. Este breve parpadeo es un importante aviso de que
las cosas van por buen camino: la placa está conectada correctamente al puerto
serie y el código del sketch no tiene errores de sintaxis. Si algo de esto fuera mal
observaríamos errores en la ventana de mensajes del entorno de desarrollo IDE
(Figura 1.24).
Figura 1.22
Figura 1.23
17
Taller de Arduino
Figura 1.24
Figura 1.25
Si te fijas en la placa, justo enfrente del pin digital número 13, tienes
un pequeño LED que tiene serigrafiada una letra «L» justo al lado. Es
un diodo que está conectado directamente al pin 13 y que no
necesita de ningún componente adicional. La manera de programarlo
es exactamente la misma que en el caso anterior. Por eso, cuando
pruebes el sketch, notarás que aparte del parpadeo del led rojo, se
producirá el mismo efecto en este led pequeñito ya que ambos están
en paralelo. Si el primer día que adquieres tu Arduino, no tienes un
led a mano, puedes utilizar ese diodo para probar el sketch anterior.
18
1. Inicio con Arduino desde cero
Figura 1.26
19
Taller de Arduino
20
1. Inicio con Arduino desde cero
Figura 1.27
http://arduino.cc/en/Guide/ArduinoLeonardoMicro?from=Guide.ArduinoLeonardo
21
Taller de Arduino
Arduino Mega 2560 REV3. Esta es la versión más reciente (Figura 1.28) de
Arduino Mega. Esta placa ha sido actualizada con un chip ATmega2560. Este chip
proporciona una memoria flash de 256 K (el doble que el modelo anterior). Otra
diferencia con su predecesora es la sustitución del chip FTDI por un chip
ATmega8U2.
Figura 1.28
22
1. Inicio con Arduino desde cero
Arduino Mega ADK es una de las placas más recientes desarrolladas por
Arduino. Esta es una placa que está basada en la Arduino Mega 2560, pero
modificada para permitir su uso con el kit de desarrollo Android Open Accessory
Development Kit (ADK) de Google. Para hacer esto posible, dispone de un puerto USB
Host como interfaz de conexión con dispositivos Android basados en el chip
MAX3421e.
Esta sería la placa ideal (Figura 1.29) para todas aquellas personas que
quieran integrar accesorios de hardware con un dispositivo Android haciendo uso
de la plataforma de Arduino. Para más información sobre cómo utilizar esta placa
con Google ADK, puedes echar un vistazo en la web oficial de Android.
Figura 1.29
23
Taller de Arduino
La alimentación recomendada es de 9 V.
54 pines de E/S (14 de ellos proporcionan PWM).
16 pines de entrada analógica.
Memoria Flash de 256 kB.
Dispone de un puerto miniUSB Host como interfaz de conexión con
dispositivos Android.
Dispone de un puerto USB para la transmisión de datos.
Dispone de un conector tipo Jack (cilíndrico) para la alimentación.
Dispone de botón de reset.
Todos los pines están desglosados en terminales hembra para
facilitar las conexiones.
Figura 1.30
24
1. Inicio con Arduino desde cero
Arduino Due (Figura 1.31) es el modelo más potente de las placas Arduino.
Está basado en un potente microcontrolador SAM3X8E ARM Cortex-M3 que
incorpora todas las funcionalidades clásicas de Arduino y añade otras nuevas.
Ofrece un total de 54 pines de entrada/salida (12 de las cuales son PWM con
resolución configurable) 12 entradas analógicas con una resolución de 12 bits, 4
puertos UART por hardware y dos conversores DAC (digital a analógico), un
resonador de cuarzo de 84 MHz, dos conexiones USB (uno de programación y otro
que puede actuar como USB Host). También incluye los pines de programación
ICSP y JTAG. El voltaje máximo de los pines es de 3,3 V por lo que hay que tener
precaución y no conectar dispositivos de 5 V ya que podrían dañar la placa.
Figura 1.31
25
Taller de Arduino
Microcontrolador: AT91SAM3X8E.
Voltaje de operación: 3,3 V.
Voltaje de entrada (recomendado): 7-12 V.
Límites de voltaje: 6-20V.
Pines I/O: 54 (12 con PWM).
Entradas analógicas: 12.
Salidas analógicas: 2 (DAC).
Salida máxima I/O: 130 mA.
Corriente máxima: 800mA.
SRAM: 96 kB (64 + 32 kB).
Memoria para programa: 512 kB.
Velocidad: 84 MHz.
Arduino Fio (Figura 1.32) es una placa desarrollada por Shigeru Kobayashi
(basándose en el diseño original de la placa LilyPad) y especialmente diseñada
para aplicaciones inalámbricas. Para programarla es necesario un cable FTDI o una
FTDI Basic breakout. También se puede reprogramar de forma inalámbrica
mediante un adaptador de USB a Xbee.
Figura 1.32
26
1. Inicio con Arduino desde cero
Arduino MINI (Figura 1.33). Las funcionalidades de esta placa son idénticas,
pero con un chip ATmega328s, que es una variante (llevada a la mínima
expresión) del chip ATmega328. Esta placa requiere de una conexión serie externa
para poder programarla. Se trata de una versión miniaturizada de Arduino para
proyectos en los que el espacio sea limitado, pero requiere de conexiones que
pueden resultar algo más complicadas que las de una placa Arduino convencional.
Figura 1.33
27
Taller de Arduino
La alimentación recomendada es de 7 V a 9 V.
14 pines de E/S (6 de ellos proporcionan PWM).
8 pines de entrada analógica.
Memoria Flash de 32 kB.
No dispone de puerto USB.
No dispone de conector para la alimentación.
No dispone de botón de reset.
Figura 1.34
28
1. Inicio con Arduino desde cero
Figura 1.35
Microcontrolador: ATmega328.
Alimentación de entrada: 2.5-12 V.
Pines digitales I/O: 14 (6 con PWM).
Entradas analógicas: 6.
Corriente por pin: 40 mA max.
Memoria Flash: 32 kB (2 kB usados por el bootloader).
SRAM: 2 kB.
EEPROM: 1 kB.
Velocidad de reloj: 16 MHz.
Módulo Bluetooth 2.1: WT11i-A-AI4.
29
Taller de Arduino
Figura 1.36
El chip Arduino está conectado al módulo Linux, por lo que es muy fácil que
se comuniquen entre ambos y delegar procesos pesados a la máquina Linux
integrada en la placa.
Conectividad
Dispone de dos conexiones de red. Una red ethernet 10/100 mbps y otra wifi
(IEEE 802.11 b/g/n, 2,4GHz) que puede montarse como cliente o como punto de
acceso.
30
1. Inicio con Arduino desde cero
Una de las ventajas más interesantes es que la placa (del lado del 32U4)
puede ser programada directamente por wifi a través del módulo Linux.
En este apartado hemos descrito la mayor parte de los tipos de Arduino que
ofrece el mercado hoy en día. Evidentemente, a estas alturas, se nos hacen
incomprensibles, dada su complejidad, muchas de sus características técnicas. No
hay de qué preocuparse, a medida que avancemos en el mundo Arduino veremos
que se van clarificando aquellos conceptos que en este momento nos suenan a
chino.
31
Taller de Arduino
Figura 1.37
Figura 1.38
32
1. Inicio con Arduino desde cero
Figura 1.39
Figura 1.40
Figura 1.41
33
Taller de Arduino
Figura 1.42
34
1. Inicio con Arduino desde cero
Figura 1.43
Y por último, si eres de los reacios a pelearte, aunque sea un rato, con un
software nuevo, existen en YouTube muchos videotutoriales que en cuestión de
minutos te explican paso a paso cómo hacerlo.
35
Taller de Arduino
Figura 1.44
Y aunque no existe una coincidencia cien por cien exacta entre lo simulado
y lo real, sí que es gratificante que nos pueda aclarar muchas dudas en cuanto a
los patillajes, conexiones y comportamiento de los circuitos. En el apéndice 1 os
muestro cómo simular Arduino bajo el entorno de Proteus.
36
CAPÍTULO
EL LENGUAJE DE
PROGRAMACIÓN DE
ARDUINO
37
Taller de Arduino
unos y ceros, por palabras o letras provenientes del inglés, codificándolas así y
creando un lenguaje de mayor nivel que se conoce como assembly o lenguaje
ensamblador. Por ejemplo, para sumar se usa la letra A de la palabra inglesa add
(sumar). En realidad, escribir en lenguaje ensamblador es básicamente lo mismo
que hacerlo en lenguaje máquina, pero las letras y palabras son bastante más
fáciles de recordar y entender que secuencias de números binarios.
38
2. El lenguaje de programación de Arduino
39
Taller de Arduino
Figura 2.1
Veamos ahora cómo traducir todo esto al lenguaje propio de Arduino. Pero
antes, hay que examinar la estructura básica de que consta un programa en
Arduino y los elementos con los que jugar.
40
2. El lenguaje de programación de Arduino
Figura 2.2
2.2.1 Estructuras
En primer lugar tenemos la estructura setup(). Lo que se escriba entre las llaves
que acompañan a su nombre, se ejecuta una única vez siempre que se encienda o
resetee la placa. El bloque o estructura setup() contendrá toda la configuración
hardware del Arduino, es decir, cómo queremos que funcionen determinados
pines del Arduino como entrada o como salida. A medida que vayamos
conociendo sus posibilidades iremos aumentando el tamaño de la configuración
de este bloque.
Variables.
Operadores matemáticos, lógicos y booleanos.
41
Taller de Arduino
2.2.2 Variables
Una variable es una manera de nombrar y almacenar un valor numérico para su
uso posterior en el programa. Como su nombre indica, las variables son números
o caracteres que se pueden variar continuamente en contra de lo que ocurre con
las constantes, cuyo valor nunca cambia. Todas las variables tienen que declararse
antes de que puedan ser utilizadas. Para declarar una variable se comienza por
definir su tipo, asignándoles siempre un nombre y, opcionalmente, un valor
inicial. Esto solo debe hacerse una vez en un programa, pero su valor se puede
cambiar en cualquier momento. Una variable puede ser declarada en cualquier
lugar del programa y en función de dónde se lleve a cabo su definición, se
determinará en qué partes del programa se podrá hacer uso de ella.
Una variable puede ser declarada al inicio del programa, a nivel local dentro
de las funciones, y, a veces, dentro de un bloque. En función del lugar de
declaración de la variable así se determinará su ámbito de aplicación y la capacidad
de ciertas partes de un programa para hacer uso de ella. Una variable global es
aquella que puede ser vista y utilizada por cualquier función y sentencia de un
programa. Esta variable se declara al comienzo del programa, antes de la estructura
setup(). Una variable local es aquella que se define dentro de una función o como
parte de un bucle. Solo es visible y solo puede utilizarse dentro de la función en la
que se declaró. El ámbito de utilización de las variables se entenderá mejor cuando
conozcamos un poco mejor los fundamentos de la programación.
42
2. El lenguaje de programación de Arduino
El tipo booleano (boolean) solo puede contener dos valores: TRUE o FALSE.
De esta manera cada una de estas condiciones ocupa 1 byte de memoria. La
siguiente sentencia define una variable de tipo booleano con el nombre
«Ventrada» y además le asigna un valor inicial verdadero o TRUE.
Existen más tipos de variables, pero para comenzar, nos llegan. A medida
que avancemos en la programación de Arduino las iremos conociendo. Si estás
interesado en adelantarte puedes visitar la siguiente página:
http://arduino.cc/en/Reference/HomePage.
43
Taller de Arduino
y = y + 3; // Suma 3 a la variable y
x = x - 7; // Resta 7 a la variable x
i = j * 6; // Realiza el producto de 6 y de la variable j
r = r / 5; // Divide la variable r entre 5
x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y
44
2. El lenguaje de programación de Arduino
If
Switch/case
For
While
If. Es una estructura (Figura 2.3) simple que se utiliza para evaluar si una
determinada condición se ha alcanzado, como, por ejemplo, determinar si un valor
analógico es igual a un valor de referencia preestablecido y ejecutar una serie de
operaciones que se escriben dentro de llaves si es cierta la condición. Si es falsa (la
condición no se cumple), el programa salta y no ejecuta las operaciones que están
dentro de las llaves. Un ejemplo de utilización es el siguiente:
if x==15
{
x=x+30;
}
x=x+1000;
Figura 2.3
45
Taller de Arduino
if x==15
{
x=x+30;
}
else
{
x=x+1000;
}
Figura 2.4
46
2. El lenguaje de programación de Arduino
switch (x)
{
case 15: x=x+30;
break;
case 67: x=x*2;
break;
default: x=x+1000;
}
Figura 2.5
47
Taller de Arduino
El sketch (Figura 2.6) hace parpadear veinte veces, y solo veinte, la patilla
13 del Arduino con un intervalo de medio segundo. En este caso, la variable de
inicialización i se pone a cero. A continuación, se comprueba (condición) el valor
de i en cada ejecución de todo lo que va entre llaves, si esta variable es menor
que el valor 20. Si es así, sigue realizando el bucle; si no es así, se sale de la
estructura for. Por último, apreciar que cada vez que se ejecuta un bucle la
variable i se incrementa en uno (expresión).
48
2. El lenguaje de programación de Arduino
Figura 2.6
Figura 2.7
49
Taller de Arduino
2.2.5 Funciones
Una función es un conjunto de líneas de código que realizan una tarea específica.
Las funciones pueden tomar parámetros que modifiquen su funcionamiento. Las
funciones son utilizadas para descomponer grandes problemas en tareas simples,
y para implementar operaciones que son comúnmente utilizadas durante un
programa y de esta manera reducir la cantidad de código. Cuando una función es
invocada se le pasa el control a la misma; una vez que esta finalizó con su tarea, el
control es devuelto al punto desde el cual la función fue llamada.
50
CAPÍTULO
TRANSMISIÓN SERIE
EN ARDUINO
Figura 3.1
51
Taller de Arduino
ambiental, estos datos se pueden observar en tiempo real en el PC. Pero ojo, no
podemos guardarlos, solo ir visualizándolos a medida que van siendo adquiridos
por el Arduino.
Figura 3.2
Serial.begin(9600);
52
3. Transmisión serie en Arduino
Figura 3.3
53
CAPÍTULO
LAS ENTRADAS Y
SALIDAS DIGITALES
Figura 4.1
54
4. Las entradas y salidas digitales
Figura 4.2
Figura 4.3
55
Taller de Arduino
Figura 4.4
donde:
R es la resistencia limitadora;
Vcc es la tensión de alimentación (valor de la batería);
Vf es la caída típica de voltaje en el LED; y
If es la corriente típica que debe pasar para que se encienda el LED.
56
4. Las entradas y salidas digitales
Figura 4.5
Figura 4.6
57
Taller de Arduino
El tipo de pulsadores que usaremos con Arduino son los de tipo llamado
mini. Se aprecia en la figura 4.7. Llevan cuatro contactos unidos dos a dos, de tal
manera que cuando pulsamos, se establece conexión eléctrica entre un lado y
otro del pulsador.
Figura 4.7
Figura 4.8
58
4. Las entradas y salidas digitales
Figura 4.9
59
Taller de Arduino
Figura 4.10
60
4. Las entradas y salidas digitales
void setup()
{
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
}
void loop()
{
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
delay(500);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
delay(500);
digitalWrite(4, LOW);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
delay(500);
digitalWrite(6, LOW);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
digitalWrite(4, HIGH);
delay(500);
digitalWrite(4, LOW);
digitalWrite(3, HIGH);
delay(500);
digitalWrite(3, LOW);
}
61
Taller de Arduino
En este programa aparecen tres funciones que hacen todo el trabajo. Las
estudiamos con detalle a continuación. ¡Prepárate porque empezamos a programar!
Estos pines tienen a nivel interno una resistencia de 20 kΩ a las que se puede
acceder mediante software. A estas resistencias se accede de la siguiente manera:
pinMode(pin, INPUT); // configura el ‘pin’ como entrada
digitalWrite(pin, HIGH); // activa las resistencias internas
62
4. Las entradas y salidas digitales
Figura 4.12
Figura 4.13
63
Taller de Arduino
Primero introduciré una variable de tipo int para poder variar el tiempo de
espera en la función delay(ms). Después reemplazaré el código principal por otro
más corto que use la potencia de la estructura for que vimos anteriormente. A
esto, los programadores experimentados lo llaman: optimizar el código.
Práctica 1.1. Mejorando el código
64
4. Las entradas y salidas digitales
digitalWrite(a, LOW);
delay(d);
}
for ( int a = 5 ; a > 1 ; a-- )
{
digitalWrite(a, HIGH);
delay(d);
digitalWrite(a, LOW);
delay(d);
}
}
El primero de los bucles for repetirá el código dentro de las llaves siempre y
cuando la condición sea verdadera. En este caso hemos utilizado una variable de
tipo entero «a» que comienza con el valor 2. Cada vez que se ejecuta el código, se
le sumará 1 a dicha variable. El bucle continuará de esta manera mientras que «a»
sea menor de 7. Una vez que sea igual o mayor que 7 se sale del bucle for y vuelve
al principio de la estructura void(loop), es decir, vuelve a iniciarse otro bucle for
desde el principio. El segundo bucle for inicializa la variable «a» con el valor 5 que
es el penúltimo LED. Ahora se va decrementando esta variable hasta llegar al valor
2 que se corresponde con el primer LED. De esta manera invertimos la secuencia
de encendido. Podéis probar otros valores de la variable «a» para comprobar si he
cometido una errata de código.
65
Taller de Arduino
Figura 4.13
Un diodo LED.
Una resistencia de 220 Ω.
Una resistencia de 10 kΩ.
Un pulsador tipo mini.
Una protoboard.
Cablecitos de conexión.
Un Arduino y un cable USB.
66
4. Las entradas y salidas digitales
Figura 4.14
67
Taller de Arduino
#define LED 12
#define BUTTON 7
void setup()
{
pinMode(LED, OUTPUT);
pinMode(BUTTON, INPUT);
}
void loop()
{
if (digitalRead(BUTTON) == HIGH)
{
digitalWrite(LED, HIGH);
delay(2000);
digitalWrite(LED, LOW);
}
}
68
4. Las entradas y salidas digitales
valor = digitalRead(4);
Figura 4.15
69
Taller de Arduino
70
4. Las entradas y salidas digitales
Figura 4.16
71
Taller de Arduino
Figura 4.17
72
4. Las entradas y salidas digitales
void setup()
{
for (int pin = 2; pin <= 7; pin++)
{
pinMode(pin,
OUTPUT);
}
}
void semaforo_1()
{
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(3, HIGH);
delay(3000);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
digitalWrite(7, LOW);
semáforo_2();
}
void semaforo_2()
{
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
73
Taller de Arduino
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(6, HIGH);
delay(3000);
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(4, LOW);
semaforo_1();
}
void loop()
{
for (int pin = 2;
pin <= 7; pin++)
{
digitalWrite(pin, LOW);
}
digitalWrite(2, HIGH);
digitalWrite(7, HIGH);
Semáforo_1();
}
74
4. Las entradas y salidas digitales
que significa «función vacía». Después de declarar el tipo de dato que devuelve la
función se debe escribir el nombre de la función y entre paréntesis se pondrán, si
es necesario, los parámetros que se deben pasar a la función para que se ejecute.
Su formato específico es el siguiente:
Para ello vamos a testear los dos pulsadores de los peatones durante la
secuencia de funcionamiento de los dos semáforos; exactamente, después del
parpadeo de la luz amarilla. Si cualquiera de los pulsadores ha sido activado se
deben poner en rojo los dos semáforos de los coches y en verde los dos
indicadores de paso de peatones.
Se han utilizado cuatro pines más para el control del paso de peatones. Por
otra parte, se han añadido cuatro luces: una roja y otra verde para el control de
paso del peatón posible en la entrada del túnel. Una más para el peatón de la
salida del túnel.
Veamos el hardware del proyecto (Figura 4.18 y Figura 4.19) para hacernos
mejor una idea de lo que tenemos entre manos.
75
Taller de Arduino
Figura 4.18
Figura 4.19
76
4. Las entradas y salidas digitales
77
Taller de Arduino
pinMode(8,INPUT);
pinMode(9,OUTPUT);
pinMode(12,OUTPUT);
pinMode(13,OUTPUT);
}
void semaforo_peatones()
{
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(4,HIGH);
digitalWrite(7,HIGH);
digitalWrite(13, LOW);
digitalWrite(12, HIGH);
delay(3000);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
digitalWrite(9, HIGH);
delay(10);
digitalWrite(9, LOW);
}
void semaforo_1()
{
digitalWrite(2, HIGH);
delay(3000);
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
delay(500);
digitalWrite(3, LOW);
delay(500);
digitalWrite(3, HIGH);
delay(500);
digitalWrite(3, LOW);
delay(500);
digitalWrite(3, HIGH);
78
4. Las entradas y salidas digitales
delay(500);
digitalWrite(3, LOW);
if(digitalRead(8)==HIGH)
{
semaforo_peatones();
}
digitalWrite(7, LOW);
digitalWrite(4,HIGH);
semaforo_2();
}
void semaforo_2()
{
digitalWrite(5, HIGH);
delay(3000);
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
delay(500);
digitalWrite(6, LOW);
delay(500);
digitalWrite(6, HIGH);
delay(500);
digitalWrite(6, LOW);
delay(500);
digitalWrite(6, HIGH);
delay(500);
digitalWrite(6, LOW);
if(digitalRead(8)==HIGH)
{
semaforo_peatones();
}
digitalWrite(7, HIGH);
digitalWrite(4, LOW);
semaforo_1();
}
79
Taller de Arduino
void loop()
{
for (int pin=2;pin<=7;pin++)
{
digitalWrite(pin, LOW);
}
digitalWrite(2, HIGH);
digitalWrite(7, HIGH);
digitalWrite(13, HIGH);
digitalWrite(9, HIGH);
delay(10);
digitalWrite(9, LOW);
semaforo_1 ();
}
Figura 4.20
80
4. Las entradas y salidas digitales
Figura 4.21
81
Taller de Arduino
Cablecitos de conexión.
Un Arduino y un cable USB.
Figura 4.22
82
4. Las entradas y salidas digitales
void loop()
{
if ( digitalRead(2) == LOW )
{
if ( digitalRead(2) ==
HIGH )
{
conta++;
Serial.println(conta);
delay (100);
}
}
if (conta==5)
{
digitalWrite(13,HIGH);
}
if (conta==8)
{
digitalWrite(13,LOW);
conta=0;
}
}
83
Taller de Arduino
Figura 4.23
84
4. Las entradas y salidas digitales
Figura 4.24
1 diodo LED.
1 resistencia de 220 Ω.
Un protoboard.
Cablecitos de conexión.
Un Arduino y un cable USB.
85
Taller de Arduino
Figura 4.25
86
4. Las entradas y salidas digitales
Los altavoces contienen una placa muy delgada dentro del soporte que se
mueve cuando se aplica corriente eléctrica. Cuando se aplica una tensión alterna
(por ejemplo: on… off… on… off… etc.) la placa vibra y generan ondas de sonido.
Figura 4.26
87
Taller de Arduino
Figura 4.27
88
4. Las entradas y salidas digitales
void loop()
{
analogWrite(PIEZO, 255);
delay(del);
analogWrite(PIEZO, 0);
delay(del);
}
En este ejercicio utilizamos una patilla 3 digital con propiedades PWM para
inyectar una señal cuadrada a un zumbador. La señal cuadrada variará entre 0 y 5
voltios con una cadencia o frecuencia marcada por el valor de la función delay(). Si
variamos dicho valor, escucharemos pitidos distintos.
Figura 4.28
89
Taller de Arduino
Figura 4.29
Figura 4.30
90
4. Las entradas y salidas digitales
1 altavoz 4 Ω.
1 resistencia de 220 Ω.
1 resistencia de 1 kΩ.
1 transistor típico 2N3904.
Un protoboard.
Cablecitos de conexión.
Un Arduino y un cable USB.
91
Taller de Arduino
92
4. Las entradas y salidas digitales
93
Taller de Arduino
Esto causará salidas impredecibles en el LED debido a que el for (que simula
un proceso lento) está en un punto indeterminado en relación a cuando el botón
es presionado. Algunas veces el LED cambia de estado inmediatamente, otras
veces nada pasa y otras veces es necesario mantener el botón presionado por un
mayor tiempo para que el estado cambie y sea reconocido.
Figura 4.31
94
4. Las entradas y salidas digitales
Mucha culpa de esto lo tiene la función delay() que paraliza siempre el micro
de Arduino impidiendo atender a las pulsaciones del pulsador en tiempo real.
95
Taller de Arduino
96
4. Las entradas y salidas digitales
Define la variable estado como volatile para que pueda ser «vista» y
modificada por la interrupción. Se inicializa en estado bajo.
void cambio_estado()
{
estado = !estado;
digitalWrite(led, estado);
}
97
Taller de Arduino
98
CAPÍTULO
LAS ENTRADAS
ANALÓGICAS
En los capítulos anteriores, hemos experimentado con botones y diodos leds que
pueden tomar solo dos estados: encendido o apagado. Si ahora queremos medir
una temperatura, una fuerza, una distancia u otro valor que variará con el tiempo,
necesitamos utilizar la potencia de las entradas analógicas que posee el Arduino.
Figura 5.1
99
Taller de Arduino
La Tabla 5.1 muestra la resolución, rango de voltaje y los pines usado para
las entradas analógica y salida del Arduino y Arduino Mega.
100
5. Las entradas analógicas
Figura 5.2
101
Taller de Arduino
Figura 5.3
Figura 5.4
1 potenciómetro 10 kΩ.
Un protoboard.
Cablecitos de conexión.
Un Arduino y un cable USB.
102
5. Las entradas analógicas
103
Taller de Arduino
Figura 5.5
Ya has visto cómo leer un valor en uno de los pines de entrada analógica. En
el siguiente apartado se va a conectar el Arduino a un transductor piezoeléctrico.
Para ello voy a necesitar algunos componentes adicionales debido a que un
104
5. Las entradas analógicas
Figura 5.6
105
Taller de Arduino
106
5. Las entradas analógicas
Figura 5.7
Figura 5.8
107
Taller de Arduino
108
5. Las entradas analógicas
Figura 5.9
109
Taller de Arduino
110
CAPÍTULO
SENSORES BÁSICOS DE
LUZ, TEMPERATURA,
DISTANCIA Y
PRESENCIA
En este capítulo veremos cómo utilizar las entradas analógicas del Arduino con
diferentes tipos de sensores. Usaremos el monitor serie para visualizar las
medidas. Sí, ya sé que es un poco cutre. No os preocupéis, ya nos queda poco
para manejar los famosos LCD (visualizadores de cristal líquido) y dotar a nuestros
proyectos de un aspecto profesional.
Figura 6.1
111
Taller de Arduino
El rango de resistencia que nos puede dar un LDR desde la total oscuridad
hasta la plena luz, nos va a variar de un modelo a otro, pero en general oscilan
entre unos 50 Ω a 1000 Ω cuando están completamente iluminadas y entre 50 kΩ
y varios MΩ cuando está completamente a oscuras.
Figura 6.2
112
6. Sensores básicos de luz, temperatura, distancia y presencia
proporciona un valor que oscila entre 500 (cuando el LDR está en la oscuridad) y
950 (cuando hay mucha luz), lo cual determina la duración de encendido y
apagado del led, por lo que la frecuencia de parpadeo aumenta con la intensidad
de la luz.
Un diodo LED.
Una resistencia de 10 kΩ.
Una LDR GL5528.
Resistencia (con luz): ~1 k Ohm.
Resistencia (oscuridad): ~10 k Ohm.
Un protoboard.
Cablecitos de conexión.
Un Arduino y un cable USB.
113
Taller de Arduino
Serial.println(rango);
digitalWrite(ledPin, HIGH);
delay(rango);
digitalWrite(ledPin, LOW);
delay(rango);
}
En este sketch nos aparece una función nueva que utilizaremos a menudo
con las entradas analógicas del Arduino. Se trata de la función de ajuste de escala
denominada map().
114
6. Sensores básicos de luz, temperatura, distancia y presencia
precisa a través de las entradas analógicas del Arduino (pines A0-A5) sin
necesidad de emplear ninguna librería específica para su programación.
Figura 6.3
Figura 6.4
Como se puede ver en las figuras 6.3, 6.4 y 6.5, es un sensor que presenta
únicamente 3 pines (VCC, GND y Data). Por ello su conexión es muy sencilla. Este
sensor tiene una salida analógica proporcional a la temperatura que registra (pin
del centro). Para conectarlo al Arduino, el pin +Vs debe conectarse al pin 5 V de la
placa. El pin VOUT, al cualquier pin de entradas analógicas y el pin GND, al
conector GND de nuestro Arduino. Además, presenta las siguientes características
eléctricas:
115
Taller de Arduino
Figura 6.5
116
6. Sensores básicos de luz, temperatura, distancia y presencia
Una protoboard.
Cablecitos de conexión.
Un Arduino y un cable USB.
Figura 6.6
El listado del sketch para visualizar las temperaturas a través del monitor
serie es el siguiente:
117
Taller de Arduino
void setup()
{
Serial.begin(9600);
}
void loop()
{
temperatura = analogRead(tempPin);
temperatura = temperatura * 0.48828125;
Serial.print("TEMPERATURA = ");
Serial.print(temperatura);
Serial.print("*C");
Serial.println();
delay(1000);
}
Figura 6.7
Pero vamos al grano y expliquemos el código del sketch anterior. Viene con
cosas nuevas que merecen nuestra atención ya que van a ser habituales en los
programas que utilicen algún tipo de sensor de tipo analógico.
118
6. Sensores básicos de luz, temperatura, distancia y presencia
Pero ahora nos sale un número con decimales (flotante) como resultado de
la primera división; por tanto, no podemos utilizar un tipo de variable entero (int)
para la temperatura. Es necesario usar otro tipo de variable denominado float.
float (nombre variable). Este tipo variable se usa para los números en coma
flotante (número decimal). Estos números son usados habitualmente para
aproximar valores analógicos debido a que ofrecen una mayor resolución que los
enteros. Las variables tipo float tienen el valor máximo 3.4028235E+38 y como
mínimo pueden alcanzar el -3.4028235E+38. Ocupan 4 bytes (32 bits). Tienen una
precisión de 6 o 7 dígitos decimales. Esto abarca el número total de dígitos, no el
número a la derecha de la coma decimal. En nuestro programa hemos definido la
variable temperatura como de tipo float.
119
Taller de Arduino
Figura 6.8
120
6. Sensores básicos de luz, temperatura, distancia y presencia
Figura 6.9
¿Cómo puede funcionar con un solo pin? ¿Acaso no necesitamos uno para
mandarle una señal y otro para recibir la respuesta? Pues no; se puede hacer todo
por el mismo y de una forma nada complicada lo que también nos servirá, de
paso, para disipar una de las dudas más comunes entre los principiantes: la
inamovilidad de la declaración de pines como entrada o salidas.
En todos los sketch que hemos ido escribiendo a lo largo de este libro
definimos los pines de Arduino o bien como entradas o bien como salidas dentro
de la estructura setup(), pensando que no se pueden cambiar. Sin embargo, esto
no es así. Podemos cambiarlos de sentido a lo largo del programa sin problema,
aunque esto no sea lo estrictamente correcto dentro de la estructura habitual de
programación en Arduino. Pero volvamos al sensor de ultrasonidos: solo tiene tres
pines, uno de alimentación, uno de masa y uno de señal. Alimentación a +5 V,
masa a GND y señal a un pin digital (por ejemplo, el 8). A través de este pin
enviaremos una señal de activación o de comienzo al sensor y para ello lo
pondremos como salida; lo activaremos durante 10 microsegundos y lo
desactivaremos. Luego cambiaremos el pin y lo dejaremos como entrada para
escuchar la señal de respuesta del sensor. Esto lo haremos cada vez que
necesitemos tomar una medida. Esta será cada segundo.
121
Taller de Arduino
También hay que tener en cuenta que ese tiempo es de ida y vuelta, por lo que
tenemos que dividirlo por la mitad a la hora de hacer el cálculo.
pulseIn(pin,valor). Lee un pulso (ya sea alto o bajo) en un pin. Por ejemplo,
si el valor es HIGH, pulseIn() espera a que el pin sea alto, empieza a cronometrar,
espera a que el pin sea LOW y entonces detiene la medida de tiempo. Devuelve la
anchura del pulso en microsegundos. Funciona correctamente en pulsos con una
anchura de 10 microsegundos a tres minutos.
Figura 6.10
Un Parallax PING.
Un protoboard.
Un Arduino.
122
6. Sensores básicos de luz, temperatura, distancia y presencia
123
Taller de Arduino
Figura 6.11
Los sensores PIR (Figura 6.12) están compuestos por dos ranuras, cada una
de ellas sensible a los infrarrojos. Cuando un cuerpo caliente pasa por delante del
campo de detección del sensor, una de las dos mitades detecta la diferencia de
calor y provoca un diferencial entre las dos mitades de las ranuras. Ocurre lo
mismo cuando el cuerpo sale de la zona de detección; la otra mitad detecta un
cambio y provoca otra diferencia de potencial igual, pero de sentido contrario. De
124
6. Sensores básicos de luz, temperatura, distancia y presencia
Figura 6.12
Figura 6.13
125
Taller de Arduino
También nos advierte, dado que el pin de alarma es de colector abierto, que
se necesita una simple resistencia Pull-Up. En nuestro caso elegiremos de 10 kΩ.
126
6. Sensores básicos de luz, temperatura, distancia y presencia
if (val == HIGH)
{
digitalWrite(ledPin, HIGH);
if (movimiento == LOW)
{
Serial.println("Movimiento detectado!");
movimiento = HIGH;
}
} else
{
digitalWrite(ledPin, LOW);
if (movimiento == HIGH)
{
Serial.println("No hay movimiento!");
movimiento = LOW;
}
}
}
127
CAPÍTULO
EXTENDIENDO
ARDUINO CON
LIBRERÍAS
En los capítulos anteriores se mostró lo que lo que Arduino puede llegar a hacer y
se construyeron algunos proyectos básicos que demostraron sus posibilidades
más elementales. Sin embargo, el Arduino es capaz de hacer mucho más y
también puede extender su funcionalidad mediante el uso de librerías de
software externas o tarjetas de expansión de hardware denominadas mochilas o
shields. En este capítulo, vamos a aprender diferentes maneras de conectar
nuestro Arduino a otros dispositivos más complejos. Veremos la utilización de
librerías externas que potenciarán, sin duda, las posibilidades de diseño de tus
futuros proyectos.
128
7. Extendiendo Arduino con librerías
Librería core.
Librería estándar.
Librerías añadidas o contributivas.
129
Taller de Arduino
#include <LiquidCrystal.h>
130
7. Extendiendo Arduino con librerías
Figura 7.1
No voy a explicaros con detalle cada una de las librerías arriba expuestas
porque sería muy largo y bastante tedioso. Simplemente, os mostraré para lo que
vale cada una. En el futuro, cuando quieras desarrollar un proyecto con una
tarjeta SD para almacenar datos, podrás acordarte de que «algo había» para
controlar esto. Buscarás en el IDE del Arduino (tal como se muestra en la Figura
7.1) y verás que existe una librería llamada: SD library. Entonces, le echarás un
vistazo a la documentación de la librería que está en la web oficial de Arduino y
sabrás por dónde empezar.
131
Taller de Arduino
Función Descripción
read Lee un byte almacenado en la memoria
write Escribe un byte en la memoria
Tabla 7.1
Librería SD. Sirve para almacenar gran cantidad de datos como, por
ejemplo, los registrados desde un GPS o en un servidor web basado en Arduino.
Las tarjetas SD (Secure Digital) presentan un formato de tarjeta de memoria
inventado por Panasonic. Se utilizan en dispositivos portátiles tales como cámaras
fotográficas digitales, PDA, teléfonos móviles, computadoras portátiles e incluso
videoconsolas (Figura 7.2).
Figura 7.2
132
7. Extendiendo Arduino con librerías
William Greiman escribió una librería para Arduino llamada SdFat que
soporta el FAT16 y FAT32 (sistemas de archivos) en tarjetas SD. Esta librería
ofrece una amplia gama de funciones: crear, borrar archivos y directorios, y la
realización de formateo básico. El equipo de Arduino se dio cuenta de que
muchos usuarios podrían tener dificultades para utilizar la librería SdFat por lo
que escribió una capa de software alrededor de ella, para hacerla más amigable
de cara al programador más inexperto. En la Tabla 7.2 os muestro las funciones
que contiene esta librería.
133
Taller de Arduino
Función Descripción
begin Establece las dimensiones del LCD en filas y columnas.
LiquidCrystal Inicializa la librería y configura los pines de conexión.
print Envía datos al LCD.
clear Limpia la pantalla del LCD.
134
7. Extendiendo Arduino con librerías
Función Descripción
setCursor Posiciona el cursor en la pantalla del LCD.
Tabla 7.3
Función Descripción
attach Se conecta el servo a un pin.
Attached Chequea el servo conectado al pin.
Detach Desconecta el servo a un pin.
Read Lee el ángulo de un servo.
Escribe el ángulo de un servo normal entre 0-180º y
write establece la velocidad de rotación en un servo de
rotación continua.
Escribe el valor, en microsegundos, en el servo, para
writeMicroseconds
ajustar el ángulo de su eje.
Tabla 7.4
Librería Stepper. Esta librería se usa para gobernar los motores llamados
paso a paso. Los veremos con detenimiento más adelante. Brevemente, un motor
paso a paso gira el eje en pasos concretos, siendo un paso definido como un
ángulo mínimo de giro. La especificación de un motor paso a paso se da a menudo
en pasos, por lo que un motor con una especificación de 200 pasos tomaría 200
pasos para girar una vuelta completa o 360º. A veces, la especificación se da en
grados, lo que puede ser fácilmente convertida a pasos dividiendo una vuelta
completa (360 grados) por el número de grados dado en la especificación. Por
ejemplo, para un motor paso a paso con una especificación de 1,5 grados, el
número de pasos por vuelta completa sería:
135
Taller de Arduino
Los motores paso a paso, por tanto, son una buena manera de controlar
dispositivos de precisión. La librería Steeper le da el control del Arduino tanto en
motores de tipo unipolares como bipolares. Con el uso de esta librería se puede
establecer la velocidad de rotación del motor, el número de pasos a seguir y la
dirección del motor. La Tabla 7.5 enumera las principales funciones
proporcionadas por la librería Stepper.
Función Descripción
Inicializa la librería y establece el número de pasos por
Stepper
vuelta.
Establece la velocidad a la que el motor debe girar, en
setSpeed
revoluciones por minuto (RPM).
Establece el número de pasos del motor que debe girar el
step motor. Los números positivos rotan en un sentido y los
números negativos en el otro.
Tabla 7.5
136
7. Extendiendo Arduino con librerías
Figura 7.3
La librería SPI proporciona funciones para interactuar con los periféricos SPI
como se muestra en Tabla 7.7.
Función Descripción
Inicializa el bus SPI y establece los pines MOSI y
begin
SCK bajos y el pin SS alto.
end Deshabilita el bus SPI.
Establece el orden en el que los bits se cargan en
setBitOrder
el bus.
Ajusta el reloj divisor del SPI como una división
setClockDivider
del reloj del sistema.
setDataMode Establece el modo de trabajo del SPI.
transfer Trasfiere 1 byte al bus.
Tabla 7.7
Aunque esto parece complicado, haciendo buen uso de la hoja de datos del
dispositivo SPI, haciendo las cosas por pasos y con cuidado, no deberías tener
problemas para comunicar un Arduino con periféricos SPI. De todas maneras, en
el capítulo 10 abordaremos este tipo de comunicación realizando una práctica
suficientemente explicativa.
137
Taller de Arduino
Librería Wire. El bus I2C, comúnmente conocido como interfaz de dos hilos
(TWI), se utiliza para comunicarse con una amplia gama de productos. Es perfecto
para aplicaciones de registros, pantallas LCD, sensores ultrasónicos para
mediciones de distancia y potenciómetros digitales cuya resistencia se puede leer
o establecer de forma remota. Curiosamente, I2C también se utiliza en
dispositivos de juego de Nintendo: la Wii Motion Plus y Wii Nunchuk. Solo se
necesitan dos pines para la interfaz del bus I2C. La Tabla 7.8 identifica estos pines
para el Arduino UNO.
Función Arduino
SDA Pin 4
SCL Pin 5
Tabla 7.8
Función Descripción
begin Inicializa la librería.
requestFrom Solicita datos desde el maestro al esclavo.
beginTransmission Comienza la trasmisión.
write Envía los datos del esclavo al maestro.
endTransmission Finaliza la trasmisión.
Tabla 7.9
Figura 7.4
138
7. Extendiendo Arduino con librerías
Figura 7.5
139
Taller de Arduino
#include <Wire.h>
#define DEV_ID 0x90 >> 1
int LED = 11
int temp = 0;
void setup()
{
pinMode(LED,OUTPUT);
Serial.begin(9600);
Wire.begin();
Wire.beginTransmission(DEV_ID); // Conectamos el ds1621
Wire.write(0xAC); // Accedemos a su configuración
Wire.write(0x02); // Establecemos una conversión continua
de temperatura
Wire.beginTransmission(DEV_ID); // Lo reseteamos
Wire.write(0xEE); // Empieza a convertir
Wire.endTransmission(); // Finalizamos la comunicación
}
void loop()
{
delay(1000); // Le damos un tiempo para convertir cada
temperatura
Wire.beginTransmission(DEV_ID);
Wire.write(0xAA);
Wire.endTransmission();
Wire.requestFrom(DEV_ID, 1);
temp = Wire.read(); // Leemos el dato de temperatura
Serial.print("TEMPERATURA: ");
Serial.print(temp); // Enviamos el dato al terminal
serie
Serial.println(" Grados Centigrados.");
digitalWrite(LED,HIGH);
delay(100);
digitalWrite(LED,LOW);
}
140
7. Extendiendo Arduino con librerías
1. Comprar el más potente Arduino MEGA, que tiene cuatro puertos serie.
2. Utilizar la librería SoftwareSerial que se distribuye con el IDE del Arduino.
Función Descripción
begin Establece el puerto y la velocidad de trasmisión.
available Cambia a ese puerto.
isListening Devuelve el puerto activo.
listen Escucha el puerto.
end Finaliza la conexión con el puerto.
read Lee datos del puerto.
write Escribe datos en el puerto.
Tabla 7.10
Esta nueva librería por emulación software crea varias instancias de los
puertos serie, lo que permite comunicarse hasta velocidades de 115.000 baudios.
Pero toda esta funcionalidad adicional tiene un precio, ya que el Arduino solo
puede escuchar o recibir datos en un puerto software o virtual serie a la vez.
141
Taller de Arduino
Cuando se utiliza esta librería con más de un puerto serie virtual, tendremos que
pensar el orden en que se reciben los datos. Veamos un ejemplo: deseamos
conectar tanto un GPS y un termómetro usando puerto serie virtuales. Los
dispositivos GPS tienden a enviar sus datos en ráfagas y a intervalos de un
segundo, por lo que empezaremos por escuchar el puerto virtual conectado al
GPS y después de que haya terminado de enviar datos, escuchar el otro puerto
serie virtual que está conectado al termómetro antes de reanudar la lectura del
puerto donde estaba enchufado en GPS. Una posible solución sería la siguiente:
#include <SoftwareSerial.h>
SoftwareSerial gpsPort(2, 3);
SoftwareSerial thermPort(4, 5);
void setup()
{
gpsPort.begin(9600);
thermPort.begin(9600);
}
void loop()
{
gpsPort.listen();
while (gpsPort.available() > 0)
{
char inByte = gpsPort.read();
}
thermPort.listen();
while (thermPort.available() > 0)
{
char inByte = thermPort.read();
}
}
142
7. Extendiendo Arduino con librerías
Figura 7.6
143
Taller de Arduino
Se denomina Arduino Motor Shield (Figura 7.7). Esta shield permite a una
placa Arduino UNO, Arduino Mega 2560, Arduino Mega ADK y Arduino Leonardo,
controlar cargas inductivas tales como, relés, solenoides, motores DC y motores
paso a paso, es decir, es extremadamente útil para interactuar físicamente con
otros equipos. Es capaz de controlar hasta dos motores DC de forma simultánea o
un motor paso a paso.
144
7. Extendiendo Arduino con librerías
Figura 7.7
Figura 7.8
145
Taller de Arduino
con facilidad la placa a nuestra red local. Lo más destacado es que dispone de un
zócalo para tarjetas de memoria micro-SD para poder almacenar ficheros o
servirlos como servidor web integrado.
Figura 7.9
146
7. Extendiendo Arduino con librerías
como un conector propio mini USB para utilizarla sin necesidad de conectarla a
una placa Arduino (actualizando el firmware).
Figura 7.10
147
Taller de Arduino
Figura 7.11
Figura 7.12
Es compatible con el Arduino UNO, Mega y Mega ADK. Con una pequeña
modificación del software se puede utilizar con Arduino Leonardo. El módulo se
entrega con una tarjeta SIM de la compañía Telefónica Digital donde se puede
comprar un plan mundial de roaming para sus aplicaciones. Sin embargo, el
módulo no está bloqueado y se puede utilizar con cualquier proveedor de
telecomunicaciones, lo que le permite adquirir un plan y la tarjeta SIM de
cualquier operador.
148
7. Extendiendo Arduino con librerías
Figura 7.13
149
CAPÍTULO
VISUALIZANDO
DATOS CON
EL LCD
Uno de las formas más sencillas para mostrar la información es con una
pantalla de cristal líquido (LCD). Podemos mostrar texto, caracteres
personalizados, datos numéricos y gráficos. Las pantallas de cristal líquido (LCD) se
han vuelto omnipresentes. Desde el momento en que nos despertamos hasta el
momento de irnos a la cama, estamos continuamente interaccionando con
pantallas LCD. Te despiertas por la mañana y, al ver la pantalla LCD de tu reloj de
alarma, te das cuenta de que vas a llegar tarde a clase y el profesor te va a echar
una bronca por el retraso. En el descanso entre clases, necesitas la pantalla del
LCD de tu reproductor MP3 para navegar hasta tu canción favorita de Eminem. Un
poco más tarde, te llaman por teléfono y le echas un vistazo a la pantalla LCD de
tu móvil y decides si contestar o no. Y finalmente, después de un día horrible,
ajustas el despertador mediante la pantalla LCD para que no te vuelvas a retrasar
al día siguiente y te expulsen definitivamente de la asignatura de electrónica
digital.
150
8. Visualizando datos con el LCD
de LCD que vamos a cubrir en este capítulo es el LCD gráfico que, como habrás
adivinado, es ideal para la elaboración de gráficos e imágenes.
151
Taller de Arduino
Los arrays son zero indexed, esto significa que, al referirse a una matriz, el
primer elemento de la matriz está en el índice 0. Por lo tanto:
minume[0] == 2, minume[1] == 4, y sucesivamente.
152
8. Visualizando datos con el LCD
Generalmente, los strings se finalizan con un carácter NULL (código ASCII: 0).
Esto permite a funciones como Serial.print(), establecer dónde está el final del string.
De otra forma, seguiría leyendo los siguientes bytes de la memoria que no forman
parte del string. Los strings siempre se definen entre comillas dobles ("Abc") y los
caracteres siempre se definen dentro de comillas simples ('A'). A menudo es
conveniente, al trabajar con grandes cantidades de texto, como proyectos con
displays o LCD, configurar un array de strings, es decir, una matriz de cadenas de
textos.
Tipo de variable String (‘S’ mayúscula). El tipo String merece toda una
explicación ya que es un poco más que un tipo de variable. De hecho, es un objeto
(en el sentido de la programación orientada a objetos). Los objetos cuentan con
propiedades y funciones especiales. Propiedades y funciones son disponibles de
forma nativa en el núcleo de Arduino y se pueden ver como una entidad
preexistente, incluso si nuestro IDE no contiene ninguna línea. Una vez más, el
núcleo de Arduino se ocupa de las cosas para nosotros y nos proporciona
funciones de gran alcance ya preparadas para utilizar directamente.
153
Taller de Arduino
¡Y ya está! La razón por la que esto funciona es porque dentro del objeto
String existe una función (también denominada método) que contiene el código
para hacer la conversión por nosotros. Solo tenemos que definir la variable como:
Así definimos una cadena denominado miDato con espacio suficiente para
99 caracteres. Para utilizar una función integrada de este tipo, escribe el nombre
de la variable seguida de un punto (llamado el operador de punto) seguida por la
función que deseas llamar.
Por ejemplo:
Función Descripción
compareTo(String two) Comprueba si dos cadenas son iguales.
concat(String two) Combina dos cadenas en una nueva cadena.
Realiza la comparación entre mayúsculas y
equals(String two)
minúsculas entre dos cadenas.
replace(String one, String Reemplaza todas las apariciones de un carácter o
two) de una subcadena por otra.
Devuelve una copia de la cadena original con
toLowerCase()
todos los caracteres en minúsculas.
length() Devuelve la longitud en caracteres de la cadena.
Devuelve una copia de la cadena original con
Trim() todos los espacios en blanco, antes y después de la
cadena, eliminados.
Tabla 8.1
154
8. Visualizando datos con el LCD
En este punto, creo que he desmitificado las diferencias entre el tipo String
y la matriz de cadenas tipo char que te vas a encontrar cuando se trabaja con
Arduino y los LCD. Ahora, y sin más preámbulos, le damos dar la bienvenida al
HD44780 de Hitachi.
Por suerte para nosotros, trabajar con los LCD basados en el chipset Hitachi
HD44780 (u otros similares) es una gozada (Figura 8.1 y Figura 8.2). Como se
mencionó anteriormente, una de las librerías estándar preinstalada en el IDE de
Arduino es la denominada LiquidCrystal(). Es compatible con configuraciones tanto
de 4 bits y 8 bits, ofreciéndonos muchas funciones útiles para controlar nuestro
LCD. La Tabla 8.2 detalla las funciones disponibles y más utilizadas de esta librería.
155
Taller de Arduino
Función Descripción
begin(int column, int row) Establece las dimensiones del LCD.
clear() Limpia la pantalla.
Establece el cursor a la parte superior izquierda
home()
de la pantalla.
setCursor(int column,int row) Coloca el cursor en la posición determinada.
Imprime el texto que puede ser un tipo: char,
print(data)
byte, int, long, o una cadena.
cursor() Muestra un subrayado en la posición actual.
noCursor() Oculta el carácter del cursor.
blink() Parpadea el carácter del cursor.
noBlink() Desactiva el parpadeo del carácter del cursor.
scrollDisplayLeft() Desplaza en el texto un espacio hacia la izquierda.
scrollDisplayRight() Desplaza en el texto un espacio hacia la derecha.
autoscroll() Desplaza automáticamente el texto.
Desactiva el desplazamiento automático del
noAutoscroll()
texto.
Establece la dirección del texto que se muestra
leftToRight()
(izq-dch).
Establece la dirección del texto que se muestra
rightToLeft()
(dch-izq).
Tabla 8.2
Figura 8.1
156
8. Visualizando datos con el LCD
Figura 8.2
Figura 8.3
157
Taller de Arduino
Los pines LED+ y LED- se pueden llevar a una resistencia limitadora si el LCD
posee estos pines para la retroiluminación. En la Figura 8.4 se observa la práctica
simulada con Proteus.
Figura 8.4
Un Arduino UNO.
Una pantalla LCD basada en HD44780 de Hitachi.
Un potenciómetro de 10 kΩ.
158
8. Visualizando datos con el LCD
159
Taller de Arduino
Figura 8.5 muestra el detalle en primer plano. Para visualizar tus propios
caracteres se debe definir cada uno, usando un array. Por ejemplo, para crear una
cara sonriente, se podría utilizar el array siguiente en que cada número en la
matriz se dirige a un píxel individual en la pantalla. Un 0 apaga un píxel y un 1 lo
activa. Los elementos de la matriz representan las filas de píxeles en la pantalla. El
elemento superior es la fila superior y el siguiente elemento es la segunda fila
hacia abajo.
byte a[8] = {B00000,
B01010,
B01010,
B00000,
B00100,
B10001,
B01110,
B00000};
Figura 8.5
160
8. Visualizando datos con el LCD
161
Taller de Arduino
Función Descripción
serLCD(int pin) Establece el pin TX de comunicación serie.
clear() Limpia la pantalla.
Establece el cursor a la parte superior izquierda de
home()
la pantalla.
162
8. Visualizando datos con el LCD
Función Descripción
clearLine(int num) Limpia una línea determinada.
Imprime el texto que puede ser un tipo: char, byte,
print(data)
int, long, o una cadena.
setBrightness(int num) Establece por software el contraste del LCD.
cursor() Muestra un subrayado en la posición actual.
noCursor() Oculta el carácter del cursor.
blink() Parpadea el carácter del cursor.
noBlink() Desactiva el parpadeo del carácter del cursor.
Establece las dos líneas que conforman la
setSplash()
«bienvenida» del LCD.
toggleSplash() Habilita o deshabilita el pantallazo de «bienvenida».
createChar(int num, byte[]
Define un caracter personalizado 5 x 8.
charData)
printCustomChar(int num) Imprime un carácter personalizado.
Tabla 8.3
Figura 8.6
Figura 8.7
163
Taller de Arduino
Un Arduino UNO.
Una pantalla LCD serie compatible.
En primer lugar incluimos las dos librerías necesarias para trabajar con este
tipo de LCD.
#include <SoftwareSerial.h>
#include <serLCD.h>
serLCD miLcd(7);
164
8. Visualizando datos con el LCD
miLcd.print("LCD funcionando");
Figura 8.8
165
Taller de Arduino
Función Descripción
GLCD.Init() Inicializa la librería.
ClearScreen() Limpia la pantalla.
Dibuja una imagen bitmap en unas coordenadas
DrawBitmap()
dadas.
GotoXY() Mueve el cursor gráfico a las coordenadas dadas.
SetDot() Establece el color de un determinado pixel.
DrawVLine() Dibuja una línea vertical.
DrawHLine() Dibuja una línea horizontal.
DrawLine() Dibuja una línea entre dos coordenadas dadas.
DrawRect() Dibuja un rectángulo.
FillRect() Rellena el interior de un rectángulo.
DrawRoundRect() Dibuja un rectángulo con esquinas redondeadas.
DrawCircle() Dibuja un círculo.
FillCircle() Rellena el interior de un círculo.
SelectFont() Establece una fuente de texto.
SetFontColor() Establece el color de la fuente de texto.
ClearArea() Limpia la actual área de texto con el color de fondo.
Borra todo el texto en la fila dada dentro del área
EraseTextLine(row) de texto y mueve el cursor a la posición de la
izquierda.
166
8. Visualizando datos con el LCD
Función Descripción
EraseTextLine() Borra el texto en la línea actual.
CursorTo() Mueve el cursor de texto a una fila y columna dadas.
CursorToXY() Mueve el cursor de texto a unas coordenadas dadas.
GLCD.print() Imprime un carácter, entero, cadena o tipo float.
Tabla 8.4
Vamos a ver ahora las conexiones entre el patillaje del Arduino y el GLCD
(Figura 8.9). Esta librería viene documentada y preparada para utilizar con el
Arduino UNO o con el Arduino MEGA. En función de que usemos uno u otro, varía
la referencia de los pines del mismo tal y como se observa en la Figura 8.9. El
esquema que se muestra a continuación (Figura 8.10) representa el conexionado
entre Arduino UNO y un GLCD.
Figura 8.9
167
Taller de Arduino
Figura 8.10
168
8. Visualizando datos con el LCD
Las dos primeras líneas del sketch incluyen la librería GLCD y la imagen
bitmap del logotipo que deseamos mostrar.
#include <glcd.h>
#include "bitmaps/ArduinoIcon.h"
GLCD.Init();
GLCD.DrawBitmap(ArduinoIcon, 32,0, BLACK);
169
Taller de Arduino
#include <glcd.h>
#include <fonts/allFonts.h>
GLCD.Init();
GLCD.SelectFont(Arial_14);
Por último, definimos las coordenadas del origen del texto en pantalla e
imprimimos la cadena de caracteres deseada.
GLCD.CursorTo(20, 1);
GLCD.print("Arduino y GLCD");
170
8. Visualizando datos con el LCD
171
Taller de Arduino
172
8. Visualizando datos con el LCD
GLCD.DrawCircle(32,31,30,BLACK);
GLCD.FillRect(92,40,16,16, WHITE);
drawSpinner(loops++,100,48);
GLCD.CursorTo(5,5);
GLCD.PrintNumber(++iter);
}
GLCD.ClearScreen();
GLCD.CursorTo(14,2);
GLCD.Puts("FPS= ");
GLCD.PrintNumber(iter);
}
Para añadir nuestros propios mapas de bits, la librería GLCD incluye una
utilidad llamada glcdMakeBitmap.pde que convierte un fichero con formato gif,
jpg, bmp, tga o png, en un archivo de encabezado que puede ser utilizado por la
librería GLCD. Este fichero, en realidad, es un programa que debe ser ejecutado en
Processing ( http://processing.org ).
173
Taller de Arduino
El sketch nos mostrará la imagen que hemos creado con la sencilla función:
GLCD.DrawBitmap(yomismo, 0,0);
174
CAPÍTULO
CONTROL DE
MOTORES CON
ARDUINO
175
Taller de Arduino
Figura 9.1
Figura 9.2
176
9. Control de motores con Arduino
motores, aunque sea a costa de su velocidad de giro. Por otra parte, el Arduino
solo puede proporcionar una pequeña cantidad de corriente, insuficiente para
excitar las bobinas del motor DC. Por ello se hace imprescindible aumentar o
amplificar dicha corriente si deseamos que nuestro motor se mueva.
Las características de un pequeño motor DC típico se pueden resumir en los
siguientes puntos:
Figura 9.3
Figura 9.4
177
Taller de Arduino
Figura 9.5
178
9. Control de motores con Arduino
En primer lugar, definimos la patilla 5 del Arduino como salida PWM para
atacar la base del transistor y hacerlo conmutar.
pinMode(5, OUTPUT);
179
Taller de Arduino
responder al motor), a la base del transistor. Con ello iremos subiendo la velocidad
del motor. Al llegar a su valor máximo, esperamos 5 segundos y entramos en otro
bucle for que hace justamente lo contario: va decreciendo el valor de la variable a y
con ello la velocidad del motor hasta llegar a pararse (a = 0).
180
9. Control de motores con Arduino
Figura 9.6
Figura 9.7
181
Taller de Arduino
Figura 9.8
Figura 9.9
Patilla Descripción
1,2 EN Habilita un puente H (12).
1A Entrada 1 del driver.
1Y Salida 1 del driver.
GND Masa.
2A Entrada 2 del driver
2Y Salida 2 del driver.
182
9. Control de motores con Arduino
Patilla Descripción
Vcc2 Alimentación del motor (hasta 36 V).
3,4 EN Habilita el otro puente H (34).
3A Entrada 3 del driver.
3Y Salida 3 del driver.
4A Entrada 4 del driver.
4Y Salida 4 del driver.
Vcc1 Alimentación del integrado (5 V).
Tabla 9.1
Un motor DC.
Una batería externa para alimentar el motor.
183
Taller de Arduino
Figura 9.10
184
9. Control de motores con Arduino
void loop()
{
digitalWrite(in1A, HIGH);
digitalWrite(in2A, LOW);
digitalWrite(enablePin, HIGH);
delay(5000);
digitalWrite(enablePin, LOW);
delay(2000);
digitalWrite(in1A, LOW);
digitalWrite(in2A, HIGH);
digitalWrite(enablePin, HIGH);
delay(5000);
digitalWrite(enablePin, LOW);
delay(2000);
}
1,2 EN 1A 2A Motor
ALTO BAJO ALTO Giro en sentido horario.
ALTO ALTO BAJO Giro en sentido antihorario.
ALTO BAJO BAJO Freno del motor.
ALTO ALTO ALTO Freno del motor.
BAJO X X Freno del motor.
Tabla 9.2
Examinando la tabla, se puede ver que para que el motor funcione la patilla
de habilitación (1,2EN) debe ser alta. Los pines 1A y 2A controlan el sentido de
giro del motor. Durante un ciclo de trabajo, se habilita el puente H estableciendo
el pin 1,2 EN (enable) en alto. Los pines in1A y in2A que están conectados a las
patillas 2 (1A) y 7 (2A) en el L293D, cambian de estado lógico en el bucle principal
de manera que el motor gira en una dirección durante cinco segundos y luego en
la otra dirección durante cinco segundos, con un intervalo de dos segundos en el
medio.
185
Taller de Arduino
Es necesario intercalar estas esperas con la función delay() para dar tiempo
al motor a reponerse ya que es un dispositivo «lento» en comparación con el
Arduino. El valor de estos retardos se puede ajustar sobre la marcha cuando
afinemos el funcionamiento del circuito.
void setup()
{
pinMode(botonD, INPUT);
pinMode(botonI, INPUT);
ppinMode(botonParo, INPUT);
pinMode(enablePin, OUTPUT);
pinMode(in1A, OUTPUT);
pinMode(in2A, OUTPUT);
}
186
9. Control de motores con Arduino
void Derecha()
{
int Velocidad = analogRead(Pot);
Velocidad = map(Velocidad, 0, 1024, 0, 256);
digitalWrite(in1A, HIGH);
digitalWrite(in2A, LOW);
digitalWrite(enablePin, HIGH);
analogWrite(enablePin, Velocidad);
delay(50);
}
void Izquierda()
{
int Velocidad = analogRead(Pot);
Velocidad = map(Velocidad, 0, 1024, 0, 256);
digitalWrite(in1A, LOW);
digitalWrite(in2A, HIGH);
digitalWrite(enablePin, HIGH);
analogWrite(enablePin, Velocidad);
delay(50);
}
void Paro()
{
digitalWrite(in1A, LOW);
digitalWrite(in2A, LOW);
digitalWrite(enablePin, LOW);
}
void loop()
{
estado1 = digitalRead(botonD);
if (estado1 == HIGH)
{
Derecha();
}
estado2 = digitalRead(botonI);
187
Taller de Arduino
if (estado2 == HIGH)
{
Izquierda();
}
estado3 = digitalRead(botonParo);
if (estado3 == HIGH)
{
Paro();
}
}
Figura 9.11
188
9. Control de motores con Arduino
189
Taller de Arduino
Figura 9.12
Unipolares Bipolares
Más sencillo de controlar. Más eficiente.
Menor coste. Mayor torque.
Cinco o seis conexiones
Cuatro conexiones de los cables.
de los cables.
Mayor velocidad de rotación Construcción más simple.
Tabla 9.3
190
9. Control de motores con Arduino
fabricante que posee un ángulo de paso de 1,8 grados y que requiere 1.2
amperios. Como tiene un ángulo de paso de 1,8 grados, podemos calcular el
número de pasos para completar una vuelta al dividir 360 grados por ese ángulo:
Sobre la base de este cálculo, el motor paso a paso necesita 200 pasos para
completar una revolución. Además, el motor cuenta con cuatro cables de
conexionado por lo deduzco que es de tipo bipolar. Por otra parte, el color de
dichos cables es fundamental para conocer a que bobinas están conectadas. En la
figura 9.13 se observa el esquema interno de este motor bipolar y la disposición
de sus dos bobinas con los colores asociados a cada terminal.
Figura 9.13
191
Taller de Arduino
Figura 9.14
Figura 9.15
192
9. Control de motores con Arduino
Figura 9.16
193
Taller de Arduino
void setup()
{
pinMode(pin1,OUTPUT);
pinMode(pin2,OUTPUT);
pinMode(pin3,OUTPUT);
pinMode(pin4,OUTPUT);
}
void loop()
{
digitalWrite(pin1,HIGH) ;
digitalWrite(pin2,HIGH) ;
digitalWrite(pin3,LOW) ;
digitalWrite(pin4,LOW) ;
cuenta++;
delay(tiempo);
digitalWrite(pin1,LOW) ;
digitalWrite(pin2,HIGH) ;
digitalWrite(pin3,HIGH) ;
digitalWrite(pin4,LOW) ;
cuenta++;
delay(tiempo);
digitalWrite(pin1,LOW) ;
digitalWrite(pin2,LOW) ;
digitalWrite(pin3,HIGH) ;
digitalWrite(pin4,HIGH) ;
cuenta++;
delay(tiempo);
digitalWrite(pin1,HIGH) ;
digitalWrite(pin2,LOW) ;
digitalWrite(pin3,LOW) ;
digitalWrite(pin4,HIGH) ;
cuenta++;
delay(tiempo);
194
9. Control de motores con Arduino
if (cuenta>=vuelta)
{
int aux=pin2;
pin2=pin4;
pin4=aux;
cuenta=0
}
}
Figura 9.17
195
Taller de Arduino
Las variables pin1, pin2, pin3 y la opcional pin4 son los pines digitales del
Arduino que se utilizan para controlar el motor. La segunda función es la
denominada setSpeed(). Esta función, que es opcional, ajusta la velocidad del
motor de giro en revoluciones por minuto (RPM). Esta función, en realidad, no
activa el motor, pero sí establece la velocidad a la que girará cuando se inicializó
con la función anterior Stepper().
setSpeed(rpm)
steps(num_steps)
196
9. Control de motores con Arduino
#include <Stepper.h>
void setup()
{
Serial.begin(9600);
}
void loop()
{
mypap.step(1);
Serial.print("pasos:" );
Serial.println(pasoCont);
pasoCont++;
delay(500);
}
197
Taller de Arduino
La primera línea del sketch carga la librería paso a paso. Ello es siempre
necesario porque incluso, aunque la librería se proporciona como parte del IDE de
Arduino, no es parte de su núcleo de librerías.
#include <Stepper.h>
Serial.begin(9600)
mypap.step(1);
Serial.print("pasos:" );
Serial.println(pasoCont);
pasoCont++;
delay(500);
198
9. Control de motores con Arduino
Figura 9.18
199
Taller de Arduino
Figura 9.19
200
9. Control de motores con Arduino
Figura 9.20
201
Taller de Arduino
Figura 9.21
Función Descripción
Servo miServo Crea un objeto miservo.
«pin» es la patilla de control desde el
arduino al servomotor. Los parámetros
attach(pin)
«min» y «max» son los valores mínimo
attach(pin,min, max)
y máximo, en microsegundos, de los
valores de la anchura del pulso.
Establece el ancho de pulso del servo en
writeMicroseconds(pulse_width)
microsegundos.
Establece el ángulo de rotación del
write(angle)
servo en grados.
Devuelve el último ancho de pulso
read()
expresado en grados.
Devuelve el último ancho de pulso
readMicroseconds()
expresado en microsegundos.
Asocia la variable Servo a un pin de
attach()
control.
Desasocia la variable Servo de su pin de
control. Si todas las variables Servo son
detach()
desasociadas, entonces los pines 9 y 10
se pueden usar para salidas PWM.
Tabla 9.4
202
9. Control de motores con Arduino
203
Taller de Arduino
void loop()
{
for(pos = 0; pos < 180; pos += 1)
{
miservo.write(pos);
delay(10);
}
for(pos = 180; pos>=1; pos-=1)
{
miservo.write(pos);
delay(10);
}
}
204
9. Control de motores con Arduino
Figura 9.22
205
Taller de Arduino
206
9. Control de motores con Arduino
utilizar baterías diseñadas para suministrar altos valores corriente. Estas pueden
ser NiCd, NiMH o de litio POLYMORE (LiPo).
Los controladores o variadores (Figura 9.25) de este tipo de motores se
denominan ESCs (electronic speed controllers) y hay que prestar atención al tipo
de motores que queremos controlar debido a que no disponemos de un
controlador universal que valga para cualquier tipo de motor.
Una de las mejores ventajas de este tipo de controladores es que pueden
ser gobernados de la misma manera que los servomotores. Esto significa que
podemos utilizar la misma librería Servo que en el apartado anterior. Al igual que
los servomotores, esperan un pulso cada 20 milisegundos con una anchura de
entre 1,0 y 2,0 milisegundos.
Figura 9.25
Con 1,0 milisegundos de pulso tendremos la velocidad más baja y con 2,0
milisegundos, la más alta. Seleccionado un pulso de 1,5 milisegundos provocamos
la parada del motor. Cuando un motor y su controlador se encienden por primera
vez, por motivos de seguridad, el motor esperará un tiempo antes de empezar a
girar. La forma de conectar el motor a Arduino se muestra en la figura 9.26. En la
figura 9.27 se observa un batería LIPO típica.
Figura 9.26
207
Taller de Arduino
Figura 9.27
Figura 9.28
208
9. Control de motores con Arduino
int pos = 0;
void setup()
{
miservo.attach(9);
miservo.write(pos);
delay(1000);
}
void loop()
{
for(pos = 0; pos < 180; pos += 1)
{
miservo.write(pos);
delay(15);
}
for(pos = 180; pos>=1; pos-=1)
{
miservo.write(pos);
delay(15);
}
}
myservo.write(pos);
delay(1000);
209
Taller de Arduino
Figura 9.29
Características
Voltaje de funcionamiento 5 V a 12 V.
Controlador del motor L298P, dos motores DC o 1 motor paso a paso.
Max 2 A por canal o 4 A máx (con fuente de alimentación externa).
Detección de corriente 1.65 V A.
Función de freno.
Esta shield tiene dos canales separados denominados A y B donde cada uno
usa 4 de los pines de Arduino para conducir y sensar el motor. Se puede utilizar
cada canal por separado para conducir dos motores DC o combinarlos para
conducir un motor paso a paso. Los cables de la figura deben conectarse bien a la
placa según el par de bobinas o según los colores que se indican: bobina 1 (cables
azul y rojo), bobina 2 (cables negro y azul). Mira en las características de tu motor
si los colores son diferentes.
210
9. Control de motores con Arduino
Los pines son divididos por cada canal y se muestran en la siguiente Tabla 9.5.
Además, tiene dos pines de alimentación exterior para el motor a los cuales
conectaremos una batería externa. La conexión ente esta placa y un motor bipolar
se muestran en la figura 9.30. En el siguiente enlace tienes toda la información
oficial de esta shield: http://arduino.cc/en/Main/ArduinoMotorShieldR3.
Figura 9.30
211
Taller de Arduino
pinMode(pwm_cha, OUTPUT);
pinMode(pwm_chb, OUTPUT);
digitalWrite(pwm_cha, HIGH);
digitalWrite(pwm_chb, HIGH);
myStepper.setSpeed(100);
Serial.begin(9600);
}
void loop()
{
Serial.println("En un Sentido");
miStepper.step(200);
delay(500);
Serial.println("En el otro");
miStepper.step(-200);
delay(500);
}
212
CAPÍTULO
BUSES DE DATOS
Figura 10.1
213
Taller de Arduino
#include <Wire.h>
Wire.begin();
Wire.beginTransmission(dirección);
Wire.write(dato);
Wire.endTransmission();
Wire.beginTransmission(dirección)
Wire.requestFrom(dirección,x)
Donde x es el número de bytes que deseamos leer. Para leer los datos que
vienen es necesario utilizar una variable de la siguiente manera:
Dentrada = Wire.read();
Wire.endTransmission();
214
10. Buses de datos
Figura 10.2
Las resistencias pull-up son necesarias siempre que utilicemos este tipo de
bus.
Antes de nada, vamos a echar un vistazo al esquema (Figura 10.6) porque
en este caso es importante estudiarlo antes de examinar el sketch.
En el circuito diseñado bajo Proteus observamos que hemos añadido dos
instrumentos virtuales que nos permiten profundizar en el funcionamiento del
bus I2C. Se trata de un instrumento virtual (Figura 10.3) para visualizar en tiempo
real el estado lógico del bus, lo que simplifica mucho su lectura. El analizador del
protocolo I2C te permite controlar e interactuar con el bus I2C. El analizador tiene
dos propósitos: primero, permitir que veamos los datos enviados por el bus I2C; y
segundo, proporciona una forma de enviar datos al bus, ya sea como maestro o
como dispositivo esclavo. Esto hace que sea muy valioso, tanto como instrumento
215
Taller de Arduino
Figura 10.3
Figura 10.4
Figura 10.5
216
10. Buses de datos
http://blogembarcado.blogspot.com.es/2012/02/
simulino-simulando-arduino.html
Te recomiendo que te los descargues y lo integres en Proteus
reemplazando la otra librería. Sin duda, está bastante bien elaborado a nivel
gráfico. Aunque nuestra EEPROM externa puede almacenar hasta 64 kB de datos,
nuestra práctica tiene solo la intención de demostrar un poco su uso, así que
vamos a almacenar y recuperar bytes solo en las primeras 20 posiciones de
memoria de la EEPROM.
Figura 10.6
217
Taller de Arduino
218
10. Buses de datos
#include <Wire.h>
#define memoria 0x50 // 0101 0000
Figura 10.7
También vemos que utiliza un bit de comienzo (Star Bit): bit que indica si
queremos leer o escribir en el dispositivo (R/W). Otro bit llamado de
reconocimiento nos indicará si la trasmisión ha ido bien (Acknowledge Bit).
Por si te pierdes un poco, o para profundizar más en este tipo de protocolo,
te recomiendo que acudas al siguiente enlace:
http://www.comunidadelectronicos.com/articulos/i2c.htm
219
Taller de Arduino
Figura 10.8
Figura 10.9
220
10. Buses de datos
Figura 10.10
Figura 10.11
221
Taller de Arduino
Figura 10.12
Wire.beginTransmission(0x20);
Wire.write(0x00); // Acceso Registro A IODIRA.
Wire.write(0x00); // Pone todos los pines del puerto A
como salidas.
Wire.endTransmission();
222
10. Buses de datos
Wire.beginTransmission(0x20);
Wire.write(0x01); // Acceso Registro B IODIRB.
Wire.write(0x00); // Pone todos los pines del puerto B
como salidas.
Wire.endTransmission();
Wire.beginTransmission(0x20);
Wire.write(0x12); // Dirección del puerto A.
Wire.write(valor); // Valor de envío.
Wire.endTransmission();
Wire.beginTransmission(0x20);
Wire.write(0x13); // Dirección del puerto B.
Wire.write(valor); // Valor de envío.
Wire.endTransmission();
223
Taller de Arduino
void ContajeBina()
{
for (byte a=0; a<256; a++)
{
Wire.beginTransmission(0x20);
Wire.write(0x12);
Wire.write(a);
Wire.endTransmission();
Wire.beginTransmission(0x20);
Wire.write(0x13);
Wire.write(a);
Wire.endTransmission();
}
}
void loop()
{
ContajeBina();
delay(500);
}
224
10. Buses de datos
Arduino tiene incorporado un reloj interno llamado millis que es utilizado por
la función millis(). Esta función solo realiza un seguimiento del tiempo transcurrido
desde la última vez que se usó Arduino. Esto significa que cuando la alimentación se
enciende, el temporizador de milisegundos se ajusta a 0. Nuestro Arduino no sabe
que es «lunes» o «09 de abril»; lo único que puede decir es «Hace 14.000
milisegundos desde la última vez que me encendí». Si deseamos ajustar la hora en
el Arduino sin tener el módulo DS1307, tendríamos que establecer y programar la
fecha y hora para que empiece a contar desde ese momento. Pero dejamos sin la
alimentación al Arduino, no nos quedaría más remedio que reajustar la hora. Al
igual que los relojes de alarma muy baratos: cada vez que pierden la alimentación
quedan parpadeando con la hora en 12:00. Si bien este tipo de cronometraje básico
está bien para algunos proyectos, algunos proyectos tales como registradores de
datos, relojes, etc. tendrán que tener un cronometraje consistente que no se
desprograme cuando dejamos al Arduino sin alimentación. El integrado RTC se
especializa en mantener la noción del tiempo. Se pueden contar años bisiestos y
saber en qué día o mes estamos. Una desventaja es que no puede registrar el
cambio de hora por el horario de verano o invierno. En la figura 10.12 y 10.13 se
muestra una plaquita que trae incorporada el integrado DS1307
(www.bricogeek.com) junto con la batería necesaria (la pila dura unos 9 años con lo
que no debemos preocuparnos demasiado por ella). Es muy útil adquirirla de esta
manera para evitar conexionado.
https://github.com/adafruit/RTClib
225
Taller de Arduino
El siguiente paso es configurar nuestro RTC con la fecha y hora actual. En este
punto, es necesario tener la fecha correcta de nuestro PC, ya que será la que se
establecerá en el RTC. Para esto, compilaremos y cargaremos el siguiente código. Es
de vital importancia que compilemos y carguemos el código con la mayor rapidez
posible entre un paso y otro, porque cuando compilamos se genera un archivo “.hex”
con su fecha de modificación y es esta fecha la que se cargará en el RTC.
226
10. Buses de datos
void setup ()
{
lcd.begin(16, 2);
Serial.begin(9600);
Wire.begin();
RTC.begin();
}
void loop ()
{
lcd.clear();
DateTime now = RTC.now();
lcd.setCursor(1,1);
lcd.print(now.year(), DEC);
lcd.print ('/');
lcd.print (now.month(), DEC);
lcd.print ('/');
lcd.print (now.day(), DEC);
lcd.print (' ');
lcd.print (now.hour(), DEC);
lcd.print (':');
lcd.print (now.minute(), DEC);
lcd.print (':');
lcd.print (now.second(), DEC);
lcd.println ();
delay(1000);
}
227
Taller de Arduino
Figura 10.14
Figura 10.15
228
10. Buses de datos
Figura 10.16
#include "SPI.h"
SPI.begin ()
SPI.setBitOrder (orden)
229
Taller de Arduino
SPI.transfer(byte)
Figura 10.17
230
10. Buses de datos
231
Taller de Arduino
delay(10);
for (int level = 0; level < 255; level++)
{
digitalPotWrite(channel, 255 - level);
delay(10);
}
}
}
void digitalPotWrite(int address, int value)
{
digitalWrite(slaveSelectPin,LOW);
SPI.transfer(address);
SPI.transfer(value);
digitalWrite(slaveSelectPin,HIGH);
}
http://ww1.microchip.com/downloads/en/DeviceDoc/21743B.pdf
232
10. Buses de datos
Figura 10.18
233
CAPÍTULO
COMUNICACIONES
INALÁMBRICAS
234
11. Comunicaciones inalámbricas
Los módulos XBee pueden tener distintos tipos de antenas (Figura 11.1), lo
cual incidirá directamente en la máxima distancia de trasmisión y recepción.
Los módulos XBee son económicos, potentes y fáciles de utilizar. Existen
dos series de estos módulos. La serie 1 y la serie 2. Los módulos de la serie 1 y la
serie 2 tienen el mismo patillaje e incluso la misma apariencia, sin embargo, NO
son compatibles entre sí, ya que utilizan distintos chipsets y trabajan con
protocolos diferentes.
Figura 11.1
235
Taller de Arduino
Figura 11.2
Figura 11.3
236
11. Comunicaciones inalámbricas
http://www.digi.com/support/productdetail?pid=3352&type=utilities
Figura 11.4
Figura 11.5
237
Taller de Arduino
Figura 11.6
En un último paso haremos que ambos módulos «se vean», es decir, que se
puedan encontrar en la red inalámbrica y se puedan comunicar punto a punto.
Para ello, presionamos la opción: modem configuración y después: read (Figura
11.7).
238
11. Comunicaciones inalámbricas
Sobre la pantalla (Figura 11.8) tenemos que modificar tres cosas: primero,
debemos elegir un identificador de la red, para ello optamos por un ID cualquiera
con la obligatoriedad que sea el mismo en los dos módulos XBee (yo he elegido
«1234»). Después, debemos escribir en cada módulo la dirección destino del otro
módulo XBee. Es decir, en la configuración del módulo XBee 1 le ponemos la
dirección destino del módulo XBee 2, y viceversa. Obsérvese que la dirección está
compuesta de dos campos: uno es la parte alta de la dirección (es la misma en las
dos XBee) y otra es la parte baja de dicha dirección completa (aquí es donde es
diferente para cada uno de los módulos).
Por último, debemos elegir cuál de los módulos va a ser el coordinador de la
red y cuál va a ser router/end de la misma. Ello se hace como se muestra en la figura
11.9 teniendo en cuenta que se debe elegir la opción AT. Es decir, en la configuración
de un módulo, pondremos: coordinator AT y en el otro: router/end AT.
Como consejo para no confundirse, es conveniente pegar una etiqueta en
cada módulo con su dirección particular y su función de coordinador o de router.
Ahora ya tenemos los dos módulos XBee conectados interna e
inalámbricamente. A nivel, por así decirlo de software, todo lo que uno de los
módulos envíe con la fución: serialprint(), lo recibirá el otro de forma serial, como
veremos más adelante en las prácticas. Por último, volvemos a insertar el
microcontrolador en su placa Arduino.
239
Taller de Arduino
Figura 11.9
240
11. Comunicaciones inalámbricas
Una resistencia de 10 k.
Una resistencia de 220 ohmios.
Los esquemas del circuito emisor y del circuito receptor se muestran en las
figuras 11.10 y 11.11, respectivamente.
Figura 11.10
Figura 11.11
241
Taller de Arduino
Figura 11.12
242
11. Comunicaciones inalámbricas
Serial.print('A')
Por ello, tras subir los diferentes sketch a los dos arduinos, es necesario
cambiar las posiciones de los jumpers al estado XBee para que se liberen los pines
TX y RX del arduino y los módulos puedan establecer dicha comunicación serie.
if(Serial.available()>0)
243
Taller de Arduino
if(Serial.read() == 'A')
{
digitalWrite(buzzer,HIGH);
delay(10);
digitalWrite(buzzer,LOW);
digitalWrite(led,HIGH);
delay(100);
digitalWrite(led,LOW);
}
Figura 11.13
244
11. Comunicaciones inalámbricas
Los esquemas del circuito emisor y del circuito receptor se muestran en las
figuras 11.14 y 11.15. El Arduino emisor está en el exterior, midiendo temperatura
que envía a través de XBee al Arduino receptor, que nos las muestra
cómodamente en un LCD.
El listado de programa de ambos Arduinos se muestra a continuación:
Figura 11.14
245
Taller de Arduino
Figura 11.15
void loop()
{
tempC = analogRead(tempPin);
tempC = (5.0 * tempC * 100.0)/1024.0;
Serial.print(tempC);
delay(5000);
}
246
11. Comunicaciones inalámbricas
247
Taller de Arduino
Figura 11.16
248
11. Comunicaciones inalámbricas
Figura 11.17
El módulo respeta los pines originales de los XBee por lo que se puede
conectar directamente como sustituto. Tiene una antena incorporada que
permite un alcance de unos 10 metros aproximadamente o hasta un máximo de
30 metros en espacio abiertos. Se comporta como un puerto serial y dispone de
comandos AT para cambiar el baudrate.
Características
Chip Bluetooth: CSR BC41714
Protocolo Bluetooth: Bluetooth v2.0 + EDR.
Protocolo USB: v1.1/2.0.
Frecuencia de funcionamiento: 2.4 ~ 2.48GHz.
Modulación: GFSK.
Potencia: 4dBm, Clase 2.
Distancia: 20 a 30 m en espacios abiertos (normalmente 10 m).
Seguridad: Autenticación y encriptación.
PIN para emparejamiento: 1234.
Alimentación: 3.3 V (50 mA).
249
Taller de Arduino
Figura 11.18
250
11. Comunicaciones inalámbricas
251
Taller de Arduino
Figura 11.21
Figura 11.22
252
11. Comunicaciones inalámbricas
Figura 11.23
Figura 11.24
253
Taller de Arduino
Figura 11.25
254
CAPÍTULO
ARDUINO Y EL
INTERNET DE
LAS COSAS
255
Taller de Arduino
del frigorífico Drink Time Sheet de la empresa JWT Brasil. Los empleados de
dicha empresa vieron cómo tomaba una nueva dimensión tener completado su
registro de horas dedicadas a sus proyectos, cuando al completarlo en su
totalidad, el frigorífico desbloqueaba su cierre y les ofrecía bebidas gratuitas
para celebrarlo.
La conexión e interacción con dispositivos es uno de los puntos fuertes de
Arduino ya que permite crear prototipos que interactúen con el ordenador, con
un smartphone, con una impresora, etc. No hace falta ser un programador o
desarrollador experimentado para utilizar nuestro Arduino en el nuevo entorno
de Internet de las cosas. Por otra parte, Internet de las cosas y la tecnología
Arduino están abriendo un cúmulo de posibilidades que aportan una nueva
dimensión a los recursos y conversaciones que generan los medios sociales.
Arduino y los medios sociales han hecho buenas migas. De hecho, muchos de los
proyectos desarrollados con tecnología de código abierto con Arduino han
incluido una parte de interacción con Twitter o Facebook.
Unos ejemplos serían, por ejemplo, una máquina expendedora de refrescos
que funciona con la publicación de un tweet o con un hashtag predeterminado
por la propia empresa de bebidas o una mano construida con Lego que se ilumina
cuando se realiza un like en Facebook. También se han creado dispositivos
orientados a negocios como la hostelería, que permiten crear vínculos con la
comunidad en medios sociales, como un dispositivo adaptado a una panadería
con el cual es posible conocer mediante Twitter cuándo salen del horno las
hornadas de pan, pasteles… El panadero selecciona cuál es el producto que ha
sido recién horneado y, al pulsar el botón correspondiente, se tuitea. De esta
forma, el cliente conoce cuándo puede comprar en su panadería preferida su
producto recién hecho.
En definitiva, el objetivo ideal de la IOT sería lograr que cualquier
objeto tenga «vida propia» y, con ello, una identidad. Si todos los objetos
cotidianos estuvieran equipados con etiquetas de radio, podrían ser
identificados y gestionados de forma automática de la misma manera que si
lo hiciesen seres humanos. Básicamente, si los objetos pasan a estar
conectados pueden interactuar en red, entre ellos o con personas, ya sea
enviando y recibiendo información o realizando determinadas acciones en
función de los datos disponibles. Algo que abre posibilidades ilimitadas, y no
solo en el marketing.
Pero regresemos al principio del tema. Empecemos por lo básico: cómo conectar
nuestro Arduino a la red utilizando una shield muy cómoda: la Ethernet shield.
256
12. Arduino y el Internet de las cosas
Término Descripción
257
Taller de Arduino
Término Descripción
Tabla 12.1
Figura 12.1
258
12. Arduino y el Internet de las cosas
Figura 12.2
259
Taller de Arduino
Figura 12.3
Para usar la shield solo hay que montarla sobre nuestro Arduino (Figura
12.3). Para cargar el sketch se conecta al ordenador por el cable USB. Una vez que
este ha sido cargado, se puede desconectar del ordenador y alimentarla desde el
exterior. También podemos conectarla a un ordenador, a un switch o a un
enrutador utilizando un cable ethernet estándar (CAT5 o CAT6 con conectores
RJ45).
Término Descripción
260
12. Arduino y el Internet de las cosas
Término Descripción
261
Taller de Arduino
Término Descripción
Tabla 12.2
Figura 12.4
262
12. Arduino y el Internet de las cosas
Figura 12.5
Figura 12.6
263
Taller de Arduino
A continuación, precisaremos de una dirección IP. Desde la versión 1.0 del IDE
de Arduino, la librería Ethernet soporta el Protocolo de Configuración Dinámica del
Host (DHCP), lo que permite a Arduino descubrir automáticamente tu dirección IP.
Ello configurará automáticamente tu dirección IP siempre y cuando el router de tu
casa esté configurado para tener el DHCP activado (lo que suele ser habitual).
Figura 12.7
264
12. Arduino y el Internet de las cosas
Ahora ya podemos escribir el sketch que nos servirá como plantilla principal
para todos los proyectos en los que diseñemos un Arduino web server. El
siguiente listado pone en práctica todo lo que hemos discutido antes mediante la
creación de un servidor en el Arduino. Al servidor se le encomendó la tarea de
aceptar conexiones de clientes entrantes (enviados a través de un navegador
web) y de responder con un mensaje personalizado.
265
Taller de Arduino
void loop()
{
EthernetClient client = server.available();
if (client)
{
boolean currentLineIsBlank = true;
while (client.connected())
{
if (client.available())
{
char c = client.read();
if (c == '\n' && currentLineIsBlank)
{
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
client.println("Funcionando el Servidor");
break;
}
if (c == '\n')
{
currentLineIsBlank = true;
}
else if (c != '\r')
{
currentLineIsBlank = false;
}
}
}
delay(1);
client.stop();
}
}
#include <SPI.h>
#include <Ethernet.h>
266
12. Arduino y el Internet de las cosas
void setup()
{
if (!Ethernet.begin(mac))
{
Ethernet.begin(mac, manualIP);
}
server.begin():
}
if (c == '\n')
{
currentLineIsBlank = true;
}
267
Taller de Arduino
Figura 12.8
Figura 12.9
268
12. Arduino y el Internet de las cosas
void setup()
{
if (!Ethernet.begin(mac))
{
Ethernet.begin(mac, manualIP);
}
server.begin();
}
void loop()
{
EthernetClient client = server.available();
if (client)
{
boolean currentLineIsBlank = true;
while (client.connected())
{
if (client.available())
{
char c = client.read();
if (c == '\n' && currentLineIsBlank)
{
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
client.print("ENTRADAS ANALOGICAS ");
client.println("<br />");
client.println("<metahttp-equiv=\"refresh\"
content=\"5\">");
for(int analogChannel = 0; analogChannel < 6;
analogChannel++)
{
int sensorReading =
analogRead(analogChannel);
client.print("Entrada analogica: ");
client.print(analogChannel);
client.print(" es ");
client.print(sensorReading);
client.println("<br />");
}
client.println("</html>");
269
Taller de Arduino
break;
}
if (c == '\n')
{
currentLineIsBlank = true;
}
else if (c != '\r')
{
currentLineIsBlank = false;
}
}
}
delay(1);
client.stop();
}
}
Figura 12.10
270
12. Arduino y el Internet de las cosas
Figura 12.11
Si aún no tienes una cuenta en Twitter, o si deseas crear una nueva para
este proyecto, vete al siguiente enlace: http://www.twitter.com y crea una.
Después, necesitaremos obtener un token especial que autorizará al Arduino para
enviar mensajes a nuestra cuenta de Twitter.
Este token es una especie de clave de seguridad que permite mediar entre
tu placa Arduino y Twitter. Para obtener tu token, es necesario acudir al siguiente
enlace:
http://arduino-tweet.appspot.com/
Primero debemos autorizar a nuestro Arduino para que utilice una cuenta
tal y como se muestra en la Figura 12.12.
271
Taller de Arduino
Figura 12.12
Figura 12.13
Función Descripción
272
12. Arduino y el Internet de las cosas
Función Descripción
Tabla 12.3
273
Taller de Arduino
if (twitter.post(msgenviar))
{
int estado = twitter.wait(&Serial);
if (estado == 200)
{
Serial.println("OK.");
}
else
{
Serial.print("fallo : code ");
Serial.println(estado);
}
}
else
{
Serial.println("La conexión ha fallado.");
}
}
void loop()
{
if(digitalRead(b1Pin) == HIGH)
{
presCt++;
enviarTweet ("Tú Casa está en llamas”);
delay(2000);
}
}
En primer lugar, tratamos de conectar el Arduino a la red Ethernet usando
DHCP (automáticamente) o mediante la dirección IP manual. Una vez conectado,
iniciamos una conexión en serie para que podamos observar los mensajes en
monitor serie del IDE. Twitter envía el código 200 si la conexión es correcta; en
caso contrario devuelve el código de error. Después, utilizamos la función
enviarTweet() para formatear y enviar tuits correctamente.
Por seguridad, he tapado parte de mi clave o token. Sustitúyela por la tuya.
Twitter twitter("124837782-TGASC1BgjexTyezzxxxxxxxxxxxxxxxx");
274
12. Arduino y el Internet de las cosas
Figura 12.14
Figura 12.15
275
Taller de Arduino
Figura 12.16
276
12. Arduino y el Internet de las cosas
Término Descripción
277
Taller de Arduino
Término Descripción
Devuelve la dirección IP
WiFi.localIP()
asignada a la shield WiFi.
Devuelve la dirección IP de
WiFi.gatewayIP()
puerta de enlace.
278
12. Arduino y el Internet de las cosas
Término Descripción
WiFiClient.print()
Imprime datos en el servidor
WiFiClient.println()
como secuencia de dígitos ASCII.
Tabla 12.4
279
Taller de Arduino
alrededor, la potencia de señal que nos llega y la dirección IP dinámica que nos
asigna nuestro enruteador. Lo primero que hacemos es abrir el ejemplo
denominado: ScanNetworks.ino que está dentro de la librería.
280
12. Arduino y el Internet de las cosas
Serial.print(mac[4], HEX);
Serial.print(":");
Serial.print(mac[3], HEX);
Serial.print(":");
Serial.print(mac[2], HEX);
Serial.print(":");
Serial.print(mac[1], HEX);
Serial.print(":");
Serial.println(mac[0], HEX);
}
void listNetworks()
{
Serial.println("** Lista de Redes **");
int numSsid = WiFi.scanNetworks();
if (numSsid == -1)
{
Serial.println("No puedo encontrar nada");
while (true);
}
Serial.print("Redes disponibles");
Serial.println(numSsid);
for (int thisNet = 0; thisNet < numSsid; thisNet++)
{
Serial.print(thisNet);
Serial.print(") ");
Serial.print(WiFi.SSID(thisNet));
Serial.print("\tSignal: ");
Serial.print(WiFi.RSSI(thisNet));
Serial.print(" dBm");
Serial.print("\tEncryption: ");
printEncryptionType(WiFi.encryptionType(thisNet));
}
}
void printEncryptionType(int thisType)
{
switch (thisType)
281
Taller de Arduino
{
case ENC_TYPE_WEP:
Serial.println("WEP");
break;
case ENC_TYPE_TKIP:
Serial.println("WPA");
break;
case ENC_TYPE_CCMP:
Serial.println("WPA2");
break;
case ENC_TYPE_NONE:
Serial.println("None");
break;
case ENC_TYPE_AUTO:
Serial.println("Auto");
break;
}
}
Las dos primeras líneas incluyen las librerías necesarias. Date cuenta del
cambio con respecto a la librería Ethernet.
#include <SPI.h>
#include <WiFi.h>
if (WiFi.status() == WL_NO_SHIELD)
String fv = WiFi.firmwareVersion();
if (fv != "1.1.0" )
Serial.println("Actualiza el firmware");
282
12. Arduino y el Internet de las cosas
http://www.dfrobot.com/community/how-to-upgrade-arduino-wifi-
shield-firmware-on- windows.html
Una vez superado este «trámite engorroso» el código realiza una espera de
diez segundos para dar tiempo a inicializarse y continúa llamando a tres funciones
que realizan todo el trabajo.
printMacAddress();
listNetworks();
printEncryptionType(int thisType);
Figura 12.17
283
Taller de Arduino
En este momento vamos a sacarle más jugo a las shields anteriores y vamos
a entrar de lleno en el Internet de las cosas para que observéis hasta qué punto
podemos llegar con la conectividad de las redes.
Lo primero que tenemos que hacer es registrarnos con una cuenta gratuita
(pero limitada) en su página web: http://www.xively.com y obtener una clave
denominada: API Key. La clave API es personal y es lo que te da acceso para crear,
eliminar, recuperar, editar y actualizar tus datos en el servidor. Por no olvidar que
es una medida de seguridad importante para que nadie usurpe tu cuenta.
284
12. Arduino y el Internet de las cosas
Una vez que hayas creado una cuenta, inicia la sesión y vete a la
configuración (settings) para generar una llave que utilizarás más adelante en tu
sketch (Figura 12.18). A continuación, observarás que te ha generado una clave
alfanumérica muy larga que debes copiar.
Figura 12.18
https://github.com/xively/xively_arduino/archive/master.zip
https://github.com/amcewen/HttpClient/archive/master.zip
285
Taller de Arduino
Figura 12.19
Con las dos nuevas librerías añadidas en nuestro IDE, ahora vamos a
agregar un nuevo dispositivo al entorno de trabajo de Xively. Comenzamos por ir
a la pestaña de desarrollo (Develop) dentro de su web (Figura 12.20).
Figura 12.20
286
12. Arduino y el Internet de las cosas
Figura 12.21
Figura 12.22
287
Taller de Arduino
Figura 12.23
288
12. Arduino y el Internet de las cosas
Figura 12.24
289
Taller de Arduino
void printWifiStatus()
{
Serial.print("SSID: ");
Serial.println(WiFi.SSID());
IPAddress ip = WiFi.localIP();
Serial.print("IP Dirección: ");
Serial.println(ip);
long rssi = WiFi.RSSI();
Serial.print("intensidad de la señal (RSSI):");
Serial.print(rssi);
Serial.println(" dBm \n");
}
void setup()
{
Serial.begin(9600);
pinMode(sensorPin, INPUT);
pinMode(ledPin, OUTPUT);
Serial.println("Conectando a wifi...");
Serial.println();
while ( status != WL_CONNECTED)
{
Serial.print("Conectada al SSID: ");
Serial.println(ssid);
status = WiFi.begin(ssid, keyIndex, pass);
delay(10000);
}
Serial.println("Connectado a wifi");
printWifiStatus();
}
void loop()
{
float tempC;
int tempPin = 0;
tempC = analogRead(tempPin);
tempC = (5.0 * tempC * 100.0)/1024.0;
datastreams[0].setFloat(tempC);
290
12. Arduino y el Internet de las cosas
Serial.print("Lee temperatura");
Serial.println(datastreams[0].getFloat());
delay(15000);
}
#include <SPI.h>
#include <WiFi.h>
#include <HttpClient.h>
#include <Xively.h>
Definimos las variables de conexión a nuestro router con los datos que solo
debemos saber nosotros. De hecho, he tapado, a propósito, parte de mi clave
WPA2. Además, debemos declarar la variable que contiene la API KEY de xively.
291
Taller de Arduino
WiFiClient client;
XivelyClient xivelyclient(client);
void printWifiStatus()
Las primeras líneas del bucle loop realmente son las que tenemos que
programar. Adquieren las temperaturas del sensor y la formatean en la variable
tempC cuyo contenido subimos a Xively.
float tempC;
int tempPin = 0;
tempC = analogRead(tempPin);
tempC = (5.0 * tempC * 100.0)/1024.0;
datastreams[0].setFloat(tempC);
292
12. Arduino y el Internet de las cosas
Figura 12.25
https://github.com/plotly/arduino-api
293
Taller de Arduino
Figura 12.26
Figura 12.27
Figura 12.28
294
12. Arduino y el Internet de las cosas
Figura 12.29
295
Taller de Arduino
Figura 12.30
https://github.com/adafruit/DHT-sensor-library/
296
12. Arduino y el Internet de las cosas
Figura 12.31
297
Taller de Arduino
298
12. Arduino y el Internet de las cosas
delay(150);
plotly.post(millis(),h);
for(int i=0; i<300; i++)
{
delay(1000);
}
}
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
float h = dht.readHumidity();
float t = dht.readTemperature();
299
Taller de Arduino
Figura 12.32
Figura 12.33
300
12. Arduino y el Internet de las cosas
Una de las primeras características es el poder cargar los sketch vía WiFi.
Esto es tremendamente útil, sobre todo si nos olvidamos el cable USB en casa. El
funcionamiento es simple:
Figura 12.34
El IDE de Arduino muestra entre los puertos disponibles la IP del YUN para
enviarle programas. En el linino, cuando se recibe la petición se levanta el proceso
que hace que el sketch sea transmitido al entorno Arduino vía el puerto serie que
los conecta. En los IDE más actuales (1.5.5), ya aparece la librería bridge que es la
encargada de gestionar de forma transparente para el usuario todos los servicios
y clases que proporcionan la conectividad.
301
Taller de Arduino
El trabajo realizado con esta librería puente o bridge es vital ya que permite
interactuar desde nuestro sketch a nivel de línea de comandos del. Se puede
interactuar a nivel de ficheros, escribiendo y leyendo datos en ficheros existentes
o crearlos. Implementa funciones de red avanzadas permitiendo el acceder a
información de la web vía servicios HTTP. También permite publicar información
vía web en este caso haciendo uso del servidor web que corre en el Linux
proporcionando, incluso por medio de REST, el acceso a los pines del Arduino
tanto para lectura como para escritura. Esta implementación posibilita conectarse
a una dirección web y desde un navegador en otra máquina distinta, interactuar
con los pines del Arduino leyendo o escribiendo información. Existen otro tipo de
recursos que da información de los procesos de la parte del Linux o que crean
clientes y servidores para compartir la información, así como clases de más bajo
nivel que se encargan de la mensajería. Por último, y no menos importante,
proporciona ejemplos de interacción de alto nivel con plataformas como Temboo
(lo veremos más adelante en profundidad) o Xively, para leer o publicar
información de sensores de todo tipo.
302
12. Arduino y el Internet de las cosas
303
Taller de Arduino
La primera vez que lo encendamos, y tras unos instantes, se creará una red
WiFi llamada ArduinoYun-XXXXXXXXXXXX. Debemos conectar nuestro ordenador
a esa red (Figura 12.35). Claro está, nos desconectaremos de Internet (no
podemos tener todo).
Figura 12.35
Figura 12.36
304
12. Arduino y el Internet de las cosas
Figura 12.37
Figura 12.38
La primera cosa que tenemos que hacer tan pronto entramos en esta
ventana es cambiar la clave por otra personal y reiniciar el YUN (Figura 12.37 y
Figura 12.38). Si algún aciago día, no recuerdas el password, siempre puedes
recuperar la configuración por defecto de fábrica presionando el botón de reset
de WiFi durante unos 30 segundos (Figura 12.39). El siguiente paso es seleccionar
la red WiFi a la que conectaremos el YUN. Elegimos, claro está, el router de
nuestra casa o trabajo, y escribimos la contraseña que posee este router. De esta
forma, el YUN accederá sin problemas al router (Figura 12.40). Autómaticamente,
y tras un reseteo del Arduino, conecta de nuevo nuestro ordenador al router y
volvemos a disponer de conexión a Internet si este fuera el caso.
Cuando nuestro YUN esté en la misma red que el ordenador, podemos
conectarnos de manera inalámbrica y programarlo. Para comprobarlo, abrimos el
IDE y bajo el menú Herramientas > Puerto, deberíamos observar el nombre de
YUN y su dirección IP. En el menú placa, seleccionamos Arduino YUN (Figura
12.41).
Hagamos una prueba. Abrimos el ejemplo Blink (Archivo > Ejemplos >
01Basics > Blink) y cargamos el sketch. Se nos pedirá una contraseña de
administrador. Utilizamos la que escribimos en la pantalla de configuración. Una
305
Taller de Arduino
Figura 12.39
Figura 12.40
Figura 12.41
306
12. Arduino y el Internet de las cosas
Figura 12.42
Figura 12.43
Temboo hace que sea sencillo y fácil para el Arduino Yun conectarse a más
de 100 recursos y servicios (por ejemplo, Facebook, Dropbox, Gmail, etc.)
mediante la estandarización de la forma de interactuar con sus interfaces de
programación de aplicaciones (API). No te preocupes si no estás familiarizado con
la programación de APIs; con Temboo no tienes que preocuparte por los detalles.
307
Taller de Arduino
Un Arduino Yun.
Un sensor de temperatura LM35.
Conexión a Internet.
308
12. Arduino y el Internet de las cosas
Serial.println(tempC);
if (tempC>35)
{
Serial.println("Empezando con SendAnEmail...");
TembooChoreo SendEmailChoreo;
SendEmailChoreo.begin();
SendEmailChoreo.setAccountName(TEMBOO_ACCOUNT);
SendEmailChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
SendEmailChoreo.setAppKey(TEMBOO_APP_KEY);
SendEmailChoreo.setChoreo("/Library/Google/Gmail/
SendEmail");
SendEmailChoreo.addInput("Username",
GMAIL_USER_NAME);
SendEmailChoreo.addInput("Password",
GMAIL_PASSWORD);
SendEmailChoreo.addInput("ToAddress",
TO_EMAIL_ADDRESS);
SendEmailChoreo.addInput("Subject","Alarma");
SendEmailChoreo.addInput(“MessageBody",
"Tu casa está ardiendo”);
unsigned int returnCode = SendEmailChoreo.run();
if (returnCode == 0)
{
Serial.println("El Email se ha enviado");
success = true;
}
else
{
while (SendEmailChoreo.available())
{
char c = SendEmailChoreo.read();
Serial.print(c);
}
}
SendEmailChoreo.close();
delay(60000);
}
}
}
309
Taller de Arduino
Las primeras líneas del código incluyen las librerías necesarias y definen los
datos de tu cuenta de correo electrónico en Gmail y la dirección de correo a quien
deseas enviar el mensaje. En este caso a mí mismo.
#include <Bridge.h>
#include <Temboo.h>
#include "TembooAccount.h"
const String GMAIL_USER_NAME = "germantojeiro@gmail.com";
const String GMAIL_PASSWORD = "xxxxxxxxxx";
const String TO_EMAIL_ADDRESS = "germantojeiro@gmail.com";
void setup()
{
Serial.begin(9600);
delay(4000);
while(!Serial);
Bridge.begin();
}
TembooChoreo SendEmailChoreo;
SendEmailChoreo.begin();
SendEmailChoreo.setAccountName(TEMBOO_ACCOUNT);
SendEmailChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
SendEmailChoreo.setAppKey(TEMBOO_APP_KEY);
Estos datos personales son accesibles una vez que nos hemos logeado en
Temboo. Debemos crear un fichero.h con el siguiente contenido:
310
12. Arduino y el Internet de las cosas
float tempC;
tempC = analogRead(LM35);
tempC = (5.0 * tempC * 100.0)/1024.0;
if (tempC>35)
SendEmailChoreo.setChoreo("/Library/Google/Gmail/SendEmail");
SendEmailChoreo.addInput("Username", GMAIL_USER_NAME);
SendEmailChoreo.addInput("Password", GMAIL_PASSWORD);
SendEmailChoreo.addInput("ToAddress", TO_EMAIL_ADDRESS);
SendEmailChoreo.addInput("Subject","Alarma");
SendEmailChoreo.addInput(“MessageBody","Tú casa está ardiendo”);
311
Taller de Arduino
else
{
while (SendEmailChoreo.available())
{
char c = SendEmailChoreo.read();
Serial.print(c);
}
}
Figura 12.44
Figura 12.45
312
12. Arduino y el Internet de las cosas
Figura 12.46
313
Taller de Arduino
Figura 12.47
Un Arduino Yun.
Un sensor de Humedad/temperatura DHT22.
Conexión a Internet.
314
12. Arduino y el Internet de las cosas
void setup()
{
Serial.begin(9600);
delay(4000);
while(!Serial);
Serial.print("Incializando...");
Bridge.begin();
Serial.println("Hecho");
float h = dht.readHumidity();
float t = dht.readTemperature();
}
void loop()
{
unsigned long now = millis();
if (now - lastRun >= RUN_INTERVAL_MILLIS)
{
lastRun = now;
Serial.println("Adquiriendo valores del sensor...");
unsigned long sensorValue = getSensorValue();
Serial.println("Añadiendo valores a la hoja de
cálculo...");
TembooChoreo AppendRowChoreo;
AppendRowChoreo.begin();
AppendRowChoreo.setAccountName(TEMBOO_ACCOUNT);
AppendRowChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
AppendRowChoreo.setAppKey(TEMBOO_APP_KEY);
}
AppendRowChoreo.setChoreo("/Library/Google/Spreadsheets/
AppendRow");
AppendRowChoreo.addInput("nombre usuario", GOOGLE_USERNAME);
AppendRowChoreo.addInput("contraseña", GOOGLE_PASSWORD);
AppendRowChoreo.addInput("SpreadsheetTitle", SPREADSHEET_TITLE);
String rowData(now);
rowData += ",";
rowData += sensorValue;
315
Taller de Arduino
AppendRowChoreo.addInput("RowData", rowData);
unsigned int returnCode = AppendRowChoreo.run();
if (returnCode == 0)
{
Serial.println("Listo! Appended " + rowData);
Serial.println("");
}
else
{
while (AppendRowChoreo.available())
{
char c = AppendRowChoreo.read();
Serial.print(c);
}
}
AppendRowChoreo.close();
}
unsigned long getSensorValue()
{
return dht.readHumidity();
return dht.readTemperature();
}
Ahora, asignamos una IP fija al Arduino Yun. Para poner una IP fija debemos
acceder a su panel de configuración, en concreto, al panel avanzado, llamado Luci.
316
12. Arduino y el Internet de las cosas
Figura 12.48
317
Taller de Arduino
YunServer server;
void setup()
{
pinMode(13, OUTPUT);
digitalWrite(13, LOW);
Bridge.begin();
digitalWrite(13, HIGH);
server.listenOnLocalhost();
server.begin();
}
void loop()
{
YunClient client = server.accept();
if (client)
{
process(client);
client.stop();
}
delay(50);
}
void process(YunClient client)
{
String command = client.readStringUntil('/');
if (command == "digital")
{
digitalCommand(client);
}
if (command == "analog")
{
analogCommand(client);
}
if (command == "mode")
{
modeCommand(client);
}
}
318
12. Arduino y el Internet de las cosas
319
Taller de Arduino
else
{
value = analogRead(pin);
client.print(F("Pin A"));
client.print(pin);
client.print(F(" lee analogico "));
client.println(value);
String key = "A";
key += pin;
Bridge.put(key, String(value));
}
}
void modeCommand(YunClient client)
{
int pin;
pin = client.parseInt();
if (client.read() != '/')
{
client.println(F("error"));
return;
}
String mode = client.readStringUntil('\r');
if (mode == "input")
{
pinMode(pin, INPUT);
client.print(F("Pin D"));
client.print(pin);
client.print(F(" configurado como ENTRADA!"));
return;
}
if (mode == "output")
{
pinMode(pin, OUTPUT);
client.print(F("Pin D"));
client.print(pin);
client.print(F(" configurado como SALIDA!"));
320
12. Arduino y el Internet de las cosas
return;
}
client.print(F("error: mode INVÁLIDO"));
client.print(mode);
}
Vamos a analizar el código fuente del sketch Bridge un poco más de cerca.
El skech utiliza tres librerías.
#include <Bridge.h>
#include <YunServer.h>
#include <YunClient.h>
Una vez compilado y subido el sketch que por defecto tiene el control del
pin 13, pero podemos cambiarlo si queremos, abrimos el navegador web y
escribimos cualquiera de estas DIRECCIONES:
http://rastman.local/arduino/digital/13
Obtendrás la siguiente información: “Pin D13 a 1”.
http://rastman.local/arduino/digital/13/1
El led 13 se enciende.
http://rastman.local/arduino/digital/13/0
El led se apaga.
321
Taller de Arduino
Figura 12.49
Figura 12.50
322
12. Arduino y el Internet de las cosas
Figura 12.51
Figura 12.52
323
Taller de Arduino
A estas alturas ya debemos saber identificar lo que nos pide esta pantalla
de configuración. A continuación, solo debemos generar el código (generate),
copiarlo, añadir las líneas de código relativas a la gestión del sensor LM35, y
subirlo al YUN.
Figura 12.53
324
CAPÍTULO
ENTORNOS DE
PROGRAMACIÓN
GRÁFICA
Figura 13.1
325
Taller de Arduino
Figura 13.2
326
13. Entornos de programación gráfica
Figura 13.3
327
Taller de Arduino
Figura 13.6
328
13. Entornos de programación gráfica
Figura 13.7
Figura 13.8
329
Taller de Arduino
Figura 13.11
330
13. Entornos de programación gráfica
El valor leído del canal Analog0 se divide por 2000 con el fin de reducir el
rango de variación de la variable frecuencia. En este caso, podemos deducir que el
valor de frecuencia es:
Figura 13.12
331
Taller de Arduino
Figura 13.13
332
13. Entornos de programación gráfica
333
Taller de Arduino
Es importante que cojas práctica con el manejo del entorno, porque aunque
al principio puede parecer complicado, es realmente sencillo cuando lleves
algunas horas trasteando con él.
Figura 13.20
334
13. Entornos de programación gráfica
Se han creado tres disfraces (figura para representar los tres estados del
semáforo). Estos se irán mostrando de acuerdo a la secuencia de encendido de las
salidas:
335
Taller de Arduino
Figura 13.23
Figura 13.24
336
13. Entornos de programación gráfica
Figura 13.25
Figura 13.26
337
Taller de Arduino
• Motor apagado.
• Motor dirección horario/antihorario.
En esta práctica gobernamos el motor mediante tres letras del teclado del
ordenador. Tecla «a»: apagado. Tecla «b»: giro en sentido horario. Tecla «c»: giro
en sentido antihorario.
Figura 13.27
338
13. Entornos de programación gráfica
339
Taller de Arduino
340
13. Entornos de programación gráfica
interactúe con el programa durante la ejecución del mismo. LabVIEW ofrece una
serie de funciones específicas (Figura 13.34) para tal cometido, contenidas en la
paleta de herramientas Controls, y accesible únicamente desde el panel frontal.
Figura 13.32
Figura 13.33
341
Taller de Arduino
Figura 13.34
http://www.ni.com/trylabview/esa/
http://www.ni.com/download/ni-visa-5.0.3/2251/en/
Hay que apuntar que son paquetes pesados en tamaño, por lo que nos
llevará su tiempo bajarlos de la red.
342
13. Entornos de programación gráfica
Después abrimos una utilidad llamada VI Package Manager (VIPM) que nos
permite instalar los Toolkits (kits de herramientas) que utilizan aplicaciones o
dispositivos externos que no están incluidos, por defecto, en labVIEW. Desde
VIPM buscamos con la palabra «arduino», la última versión de su conjunto de
herramientas, tal y como se muestra en la figura 13.35.
Figura 13.35
Figura 13.36
343
Taller de Arduino
Figura 13.37
Figura 13.38
344
13. Entornos de programación gráfica
Figura 13.39
Figura 13.40
Por último, al igual que hicimos con SA4, debemos subir al Arduino el
firmware apropiado de conexión con labVIEW. Este se encuentra en la ruta o path
mostrado en las figuras 13.41 y 13.42.
Figura 13.41
345
Taller de Arduino
Figura 13.42
http://www.ni.com/academic/
346
13. Entornos de programación gráfica
Figura 13.43
Figura 13.44
347
Taller de Arduino
Puerto de comunicación.
Velocidad de transmisión.
Tipo de tarjeta Arduino.
Numero de bits de los paquetes de comunicación.
348
13. Entornos de programación gráfica
derecho del ratón, podemos seleccionar el control a añadir con la opción Create
(Constante, Control, Indicador). Si pinchamos dos veces en el icono Init
desplegamos una ventana que permite realizar todo lo anterior de otra manera
(Figura 13.48).
Figura 13.47
Figura 13.48
Figura 13.49
349
Taller de Arduino
Figura 13.50
Figura 13.51
Figura 13.52
350
13. Entornos de programación gráfica
Figura 13.53
Figura 13.54
Figura 13.55
351
Taller de Arduino
Figura 13.56
352
13. Entornos de programación gráfica
Figura 13.57
Figura 13.58
Figura 13.59
Figura 13.60
353
Taller de Arduino
Figura 13.61
Finalmente, ya fuera del bucle colocamos el bloque de cierre del canal Close
y el bloque de tratamiento de error (Figura 13.62), que nos permita mostrar en la
pantalla una ventana con información sobre los posibles errores que se
produzcan.
Figura 13.62
Dentro del bucle while colocamos el bloque escritura Digital Write Pin. Este
bloque recibe la señal digital de la estructura que constituye la intermitencia de
frecuencia variable. El panel frontal diseñado se muestra en la figura 13.63.
354
13. Entornos de programación gráfica
sistemáticamente cada cierto tiempo (el indicado en el control: Tiempo del panel
frontal) la operación que hay dentro del bucle. Se trata de sacar TRUE y FALSE a
través de la señal de Reloj.
Figura 13.63
Figura 13.64
355
Taller de Arduino
Figura 13.65
Figura 13.66
356
13. Entornos de programación gráfica
• El Pin 1 (CHIP INHIBIT 1) sirve para activar el motor. Si este pin está
conectado a una salida de Arduino del tipo PWM, se puede variar la
velocidad del motor haciendo variar el valor de esta patilla.
• Los Pines 2 (INPUT 1) y 7 (INPUT 2) permiten fijar el sentido de giro
del motor o la parada. Los pines 3 (OUT 1) y 6 (OUT 2) son los pines
de salida de potencia del motor.
Figura 13.67
357
Taller de Arduino
como salida sentido Derecha y el PIN 9 como salida sentido Izquierda. Dentro del
bucle se ha colocado una estructura tipo Case Estructure que se encargará del
gobierno del motor. La ejecución del bucle se realiza en intervalos de 200 ms.
Figura 13.68
358
13. Entornos de programación gráfica
Figura 13.69
Figura 13.70
359
Taller de Arduino
Figura 13.71
Figura 13.72
360
13. Entornos de programación gráfica
http://www.youtube.com/watch?v=AHPQvV_AkqY
Para excitar suficientemente las bobinas del motor utilizo una Arduino
shield motor, como se observa en la figura 13.73.
Figura 13.73
Figura 13.74
Esta shield utiliza los dos pines 12 y 13 para el control del motor. La
alimentación del motor es de 9 V. El panel frontal es muy sencillo y se muestra en
la figura 13.74. Realmente solo controlamos la velocidad del motor y el número
de pasos que debe dar el motor. El diagrama de bloques correspondiente se
muestra completo en la figura 13.75.
361
Taller de Arduino
En primer lugar, definimos los pines del Arduino que van a controlar el
motor. La utilización de la shield nos obliga a usar los pines 13 y 12. También
establecemos cuántos cables posee nuestro motor, que, en este caso, como es
bipolar, tiene 4 hilos. El siguiente bloque simplemente obedece a los controles del
panel frontal y gira el número de pasos a la velocidad que le indiquemos. Es
importante reseñar que el motor solo realiza una acción y para; si quisiésemos
que se controlara continuamente, habría que utilizar una estructura while.
Figura 13.75
http://www.youtube.com/watch?v=oFl85qnZuTM
362
13. Entornos de programación gráfica
Figura 13.76
Figura 13.77
Figura 13.78
363
Taller de Arduino
Figura 13.79
Figura 13.80
Figura 13.81
364
13. Entornos de programación gráfica
That’s all!!! Ahora, tienes una visión profunda de las posibilidades actuales
de Arduino. Este será tu punto de partida para empezar a desarrollar proyectos
propios. Aspectos como Android y Processing podrían ser perfectamente temas
interesantes en los que podrías embarcarte de ahora en adelante. De todas
maneras, el mundo Arduino está en constante y vertiginoso crecimiento, por lo
que no te faltarán áreas donde practicar. Suerte en lo que sean tus próximas
“arduinoaventuras”.
365
APÉNDICE
PROTEUS Y
ARDUINO
366
Apéndice 1. Proteus y Arduino
La versión más actual de este producto es 8.1 que trae integrado el modelo
de Arduino para poder simular y depurar nuestros diseños. Sin embargo, se puede
utilizar Arduino en versiones anteriores de Proteus descargando gratuitamente un
modelo del mismo:
http://blogembarcado.blogspot.com.es/2012/02/simulino-simulando-
arduino.html.
Figura A1
367
Taller de Arduino
Figura A2
Figura A3
368