Sie sind auf Seite 1von 137

Introduccin

a
Arduino
Massimo Banzi

Primera edicin
Introduccin a Arduino
by Massimo Banzi

Copyright 2009 Massimo Banzi. All rights reserved. Printed in U.S.A.

Publicado por Make:Books, Una huella de Maker Media, Una divisin de OReilly Media, Inc.
1005 Gravenstein Highway North, Sebastopol, CA 95472

OReilly books Pueden ser comprados para uso educativo, comercial o de promocin de ventas. Para obtener
ms informacin, departamento de ventas corporativo / institucional: 800-998-9938 or
corporate@oreilly.com.

Historial de impresin: October 2008: First Edition

Editor: Dale Dougherty


Editor Asociado: Dan Woods
Editor ejecutivo: Brian Jepson
Director creativo: Daniel Carter
Diseador: Brian Scot
Jefe de produccin: Terry Bronson
Editor de copia: Nancy Kotary
Indexador: Patti Schiendelman
Ilustraciones: Elisa Canducci

El logotipo de O'Reilly es una marca registrada de O'Reilly Media, Inc. Las designaciones de la serie Make: Projects
y las referencias relacionadas son marcas registradas de O'Reilly Media, Inc. Las marcas comerciales de terceros
utilizadas en este trabajo son propiedad de Sus respectivos propietarios.

Mensaje importante a nuestros lectores: Su seguridad es su propia responsabilidad, incluyendo el uso apropiado
del equipo y equipo de seguridad, y determinar si usted tiene habilidad y experiencia adecuadas. La electricidad y
otros recursos utilizados para estos proyectos son peligrosos a menos que se utilicen adecuadamente y con las
precauciones adecuadas, incluido el equipo de seguridad. Algunas fotos ilustrativas no representan precauciones
o equipos de seguridad, con el fin de mostrar los pasos del proyecto con mayor claridad. Estos proyectos no estn
destinados a ser utilizados por nios.

El uso de las instrucciones y sugerencias de Introduccin a Arduino es bajo su propio riesgo. O'Reilly Media, Inc. y
el autor renuncian a toda responsabilidad por cualquier dao, lesin o gasto resultante. Es su responsabilidad
asegurarse de que sus actividades cumplen con las leyes aplicables, incluidos los derechos de autor.

ISBN: 978-0-596-15551-3
Contenido
Prefacio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v

1/ Introduccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
Audiencia deseada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . 2
Qu es la informtica fsica? . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2/ El Camino del Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5


Prototipado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Jugueteando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Remiendo. . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Curvado del Circuito. . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Teclado Hacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . 12
Nos encanta Junk! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Juguetes de Hacking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Colaboracin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3/ La Plataforma Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
El hardware de Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
El Software (IDE). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
Instalacin de Arduino en su computadora. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
Instalacin de controladores: Macintosh. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23
Instalacin de controladores: Windows. . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . .23
Identificacin de puertos: Macintosh. . . . ... . . . . . . . ... . . . . . . . . . . . . . . . . . . . . .25
Identificacin del Puerto: Windows . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . .26

4/ Realmente empezando con Arduino . . . . . . . . . . . . . . . . . . . . . . . . . 29


Sensores y Actuadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30
Parpadeando un LED. . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30
Pasame el Parmesano. . . . . . ... . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . .34
Arduino no es para Quiters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
Real Tinkerers Escribir Comentarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
El Cdigo, paso a paso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36
Lo que vamos a construir. . . . . . . ... . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . .38
Qu es la electricidad? . . . . . . . . . . . . . . . . . ... . . . . . .. . . . . . . . . . . . . . . . . . . . . . .39
Uso de un pulsador para controlar el LED. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42
Como funciona esto? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44
Un circuito, mil comportamientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45

5/ Entrada y salida avanzadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53


Prueba de otros sensores de encendido / apagado. . . . . . . . . . . . . . . . . . . . . . . . .53
Control de luz con PWM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Utilice un sensor de luz en lugar de un pulsador. . . . . . . . . . . . .. . . . . . . . . . . . . . .62 Entrada
analgica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64
Pruebe otros sensores analgicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
Comunicacin serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
Conduccin de cargas ms grandes (motores, lmparas y similares). .. . . . . . . . . .70
Sensores complejos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .70

6/ Hablando con la nube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73


Planificacin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Codificacin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Montaje del Circuito. . . . . . . . . . . ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .83
Aqu es cmo montarlo. . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .84

7/ Solucin de problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Prueba de la Junta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Prueba de su circuito de Breadboard. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
Aislar los problemas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
Problemas con el IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
Cmo obtener ayuda en lnea. . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

Apndices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Apndice A / El tablero de pan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
Apndice B / Lectura de los Reactores y Condensadores. . . . . . . . . . . . . . . . . . . . . .95
Apndice C / La referencia rpida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Apndice
D / Lectura de diagramas esquemticos. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Prefacio
Hace unos aos me dieron un reto muy interesante: ensear a los
diseadores el mnimo en la electrnica para que pudieran construir
prototipos interactivos de los objetos que estaban diseando.
Comenc a seguir un instinto subconsciente para ensear la electrnica de la misma
manera que me ensearon en la escuela. Ms tarde me di cuenta de que simplemente
no estaba funcionando tan bien como me gustara, y comenz a recordar sentado en
una clase, aburrido como el infierno, escuchando toda esa teora que se me lanz sin
ninguna aplicacin prctica para ello.

En realidad, cuando estaba en la escuela ya conoca la electrnica de una manera muy


emprica: muy poca teora, pero mucha experiencia prctica.

Empec a pensar en el proceso por el cual aprend la electrnica:

Desmont cualquier dispositivo electrnico que pudiera poner en mis manos.


Aprend lentamente cules eran todos esos componentes.
Empec a mezclar con ellos, cambiando algunas de las conexiones dentro de ellos y
viendo lo que le pas al dispositivo: normalmente algo entre una explosin y una nube
de humo.
Empec a construir algunos kits vendidos por revistas de electrnica.
Combin dispositivos que haba hackeado, y reutilizacin de kits y otros circuitos que
encontr en revistas para hacerlos hacer cosas nuevas.

Como un nio, siempre me fascin descubrir cmo funcionan las cosas; Por lo tanto,
sola separarlos. Esta pasin creci mientras apuntaba cualquier objeto no utilizado en la
casa y luego lo desmont en pedacitos. Eventualmente, la gente me trajo todo tipo de
dispositivos para diseccionar. Mis ms grandes

Prefacio v

proyectos en ese momento eran un lavavajillas y una computadora temprana que


provena de una oficina de seguros, que tena una impresora enorme, tarjetas
electrnicas, lectores de tarjetas magnticas y muchas otras partes que resultaron muy
interesantes y desafiantes para desmontar completamente.

Despus de bastante de esta diseccin, saba qu componentes electrnicos eran y ms


o menos lo que hicieron. Adems, mi casa estaba llena de viejas revistas electrnicas
que mi padre debi haber comprado a principios de los aos setenta. Pas horas
leyendo los artculos y mirando los diagramas de circuito sin entender mucho.

Este proceso de leer los artculos una y otra vez, con el beneficio del conocimiento
adquirido al desmontar circuitos, cre un crculo virtuoso lento.

Un gran avance lleg una Navidad, cuando mi pap me dio un kit que permita a los
adolescentes a aprender sobre la electrnica. Cada componente se alojaba en un cubo
de plstico que se acoplaba magnticamente con otros cubos, estableciendo una
conexin; El smbolo electrnico fue escrito en la parte superior. Poco saba yo que el
juguete era tambin un hito del diseo alemn, porque Dieter Rams lo dise en los
aos 60.

Con esta nueva herramienta, podra rpidamente montar circuitos y probarlos para ver
qu pas. El ciclo de prototipado fue cada vez ms corto.

Despus de eso, constru radios, amplificadores, circuitos que produciran ruidos


horribles y sonidos agradables, sensores de lluvia y pequeos robots.

He pasado mucho tiempo buscando una palabra en ingls que resumira esa forma de
trabajar sin un plan especfico, comenzando con una idea y terminando con un
resultado completamente inesperado. Finalmente, "juguetear" vino adelante. Reconoc
cmo esta palabra se ha utilizado en muchos otros campos para describir una forma de
operar y retratar a las personas que emprenden un camino de exploracin. Por ejemplo,
la generacin de directores franceses que dieron a luz a la "Nouvelle Vague" fueron
llamados los "tinkerers". La mejor definicin de retoque que he encontrado viene de
una exposicin que se llev a cabo en el Exploratorium en San Francisco:

Bricolaje es lo que sucede cuando se intenta algo que no saben cmo hacer, guiado por
el capricho, la imaginacin y la curiosidad. Cuando usted juguetea, no hay instrucciones,
pero tampoco hay fracasos, no hay formas correctas o incorrectas de hacer las cosas. Se
trata de averiguar cmo funcionan las cosas y volverlas a trabajar.
vi Introduccin a Arduino

Contraptions, mquinas, wildly mismatched los objetos que trabajan en armona - esto
es la materia del retoque.
El bricolaje es, en su forma ms bsica, un proceso que combina juego e investigacin.

www.exploratorium.edu/tinkering

Desde mis primeros experimentos saba cunta experiencia necesitaras para poder
crear un circuito que hara lo que queras a partir de los componentes bsicos.

Otro gran avance lleg en el verano de 1982, cuando fui a Londres con mis padres y pas
muchas horas visitando el Museo de la Ciencia. Acababan de abrir una nueva ala
dedicada a las computadoras, y siguiendo una serie de experimentos guiados, aprend
los fundamentos de la matemtica binaria y la programacin.

All me di cuenta de que en muchas aplicaciones, los ingenieros ya no estaban


construyendo circuitos a partir de componentes bsicos, sino que en su lugar
implementaban mucha inteligencia en sus productos usando microprocesadores. El
software estaba reemplazando muchas horas de diseo electrnico, y permitira un ciclo
ms corto de manipulacin.

Cuando volv empec a ahorrar dinero, porque quera comprar una computadora y
aprender a programar.

Mi primer y ms importante proyecto despus de eso fue usar mi nueva computadora


ZX81 para controlar una mquina de soldar. S que no suena como un proyecto muy
emocionante, pero haba una necesidad para l y era un gran desafo para m, porque
acababa de aprender cmo programar. En este punto, qued claro que escribir lneas de
cdigo requerira menos tiempo que modificar circuitos complejos.

Veinte aos ms tarde, me gustara pensar que esta experiencia me permite ensear a
la gente que ni siquiera recuerdo haber tomado ninguna clase de matemticas y para
infundirlos con el mismo entusiasmo y la capacidad de juguetear que tuve en mi
juventud y tener Desde entonces.

Massimo

Prefacio vii

Expresiones de gratitud

Este libro est dedicado a Luisa y Alexandra.


En primer lugar quiero agradecer a mis socios del Equipo Arduino:
David Cuartielles, David Mellis, Gianluca Martino, and Tom Igoe. Es una experiencia increble trabajar con ustedes.
Barbara Ghella, no lo sabe pero, sin su preciado consejo, Arduino y este libro tal vez no hayan pasado nunca.

Bill Verplank por haberme enseado ms que Computacin Fsica.

Gillian Crampton-Smith por darme una oportunidad y por todo lo que he aprendido de ella.

Hernando Barragn por el trabajo que ha realizado en Cableado.

Brian Jepson por ser un gran editor y entusiasta partidario todo el tiempo.

Nancy Kotary, Brian Scot, Terry Bronson y Patti Schiendelman por convertir lo que escrib en un libro terminado.

Quiero agradecer a mucha ms gente, pero Brian me dice que me estoy quedando sin espacio, as que voy a
enumerar un pequeo nmero de personas que tengo que agradecer por muchas razones:

Adam Somlai-Fisher, Ailadi Cortelletti, Alberto Pezzotti,

Alessandro Germinasi, Alessandro Masserdotti, Andrea Piccolo,

Anna Capellini, Casey Reas, Chris Anderson, Claudio Moderini,

Clementina Coppini, Conceta Capecchi, Csaba Waldhauser,

Dario Buzzini, Dario Molinari, Dario Parravicini, Donata Piccolo,

Edoardo Brambilla, Elisa Canducci, Fabio Violante, Fabio Zanola,

Fabrizio Pignoloni, Flavio Mauri, Francesca Mocellin, Francesco

Monico, Giorgio Olivero, Giovanna Gardi, Giovanni Battistini, Heather Martin, Jennifer Bove, Laura Dellamota,
Lorenzo

Parravicini, Luca Rocco, Marco Baioni, Marco Eynard, Maria

Teresa Longoni, Massimiliano Bolondi, Mateo Rivolta, Mathias

Richter, Maurizio Pirola, Michael Thorpe, Natalia Jordan,

Ombreta Banzi, Oreste Banzi, scar Zoggia, Pietro Dore,

Prof. Salvioni, Raffaella Ferrara, Renzo Giusti, Sandi Athanas, Sara Carpentieri, Sigrid Wiederhecker, Stefano Mirti,
Ubi De Feo, Veronika Bucko.

viii Introduccin a Arduino

Cmo contactarnos
Hemos verificado la informacin de este libro de la mejor manera posible,
pero puede que encuentre cosas que han cambiado (o incluso que hemos
cometido errores!). Como lector de este libro, puede ayudarnos a mejorar
futuras ediciones envindonos sus comentarios. Por favor, hganos saber
acerca de cualquier error, inexactitud, declaraciones engaosas o confusas y
errores tipogrficos que encuentre en cualquier parte de este libro.
Tambin hganos saber qu podemos hacer para que este libro sea ms til
para usted. Tomamos en serio sus comentarios y trataremos de incorporar
sugerencias razonables en futuras ediciones.

Puede escribirnos a:

Media Maker
1005 carretera de gravenstein norte
Sebastopol, CA 95472
(800) 998-9938 (en los Estados Unidos o Canad)
(707) 829-0515 (internacional / local)
(707) 829-0104 (fax)

Maker Media es una divisin de O'Reilly Media dedicada enteramente a la


creciente comunidad de personas ingeniosas que creen que si lo puedes
imaginar, puedes hacerlo. Consistiendo en la revista MAKE, la revista CRAFT,
Maker Faire, as como la serie de libros Hacks, Make: Projects y DIY Science,
Maker Media fomenta la mentalidad Do-It-Yourself proporcionando
inspiracin e instruccin creativa.

Para ms informacin sobre Maker Media, vistenos en lnea:


HACER www.makezine.com
CRAFT: www.craftzine.com
Hacer Maker: www.makerfaire.com
Hacks: www.hackszine.com

Para comentar el libro, enve un correo electrnico a


bookquestions@oreilly.com.

El sitio web de O'Reilly para Introduccin a Arduino incluye ejemplos, erratas


y planes para futuras ediciones. Puede encontrar esta pgina en
www.makezine.com/getstartedarduino.

Para obtener ms informacin sobre este libro y otros, consulte el sitio web
de O'Reilly: www.oreilly.com.

Para obtener ms informacin sobre Arduino, incluidos foros de discusin y


documentacin adicional, consulte www.arduino.cc.

Prefacio ix
1/ Introduccin

Arduino es una plataforma de computacin fsica de


cdigo abierto basada en una sencilla tarjeta de
entrada / salida (E / S) y un entorno de desarrollo
que implementa el lenguaje de procesamiento
(www.processing.org). Arduino puede usarse para
desarrollar objetos interactivos independientes o
puede conectarse al software de su computadora
(como Flash, Processing, VVVV o Max / MSP). Los
tableros se pueden montar a mano o se pueden
adquirir preensamblados; El IDE de cdigo abierto
(Integrated Development Environment) se puede
descargar gratuitamente desde www.arduino.cc.

Arduino es diferente de otras plataformas en el mercado debido a estas caractersticas:

Es un entorno multiplataforma; Puede funcionar en Windows, Macintosh y Linux.

Se basa en la programacin de procesamiento IDE, un entorno de desarrollo fcil de


usar utilizado por artistas y diseadores.

Se programa a travs de un cable USB, no de un puerto serie. Esta caracterstica es til,


porque muchas computadoras modernas no tienen puertos serie.

Se trata de hardware y software de cdigo abierto, si lo desea, puede descargar el


diagrama de circuitos, comprar todos los componentes y hacer su propio, sin pagar nada
a los fabricantes de Arduino.

Introduccin 1
El hardware es barato. La tarjeta USB cuesta unos 20 (actualmente, unos 35 dlares)
y la sustitucin de un chip quemado en la placa es fcil y cuesta no ms de 5 o 4 . As
que puedes permitirte cometer errores.

Hay una comunidad activa de usuarios, por lo que hay muchas personas que pueden
ayudarte.

El Proyecto Arduino se desarroll en un entorno educativo y por lo tanto es ideal para


los recin llegados para que las cosas funcionen rpidamente.

Este libro est diseado para ayudar a los principiantes a comprender los beneficios que
pueden obtener al aprender a usar la plataforma Arduino y adoptar su filosofa

Audiencia deseada
Este libro fue escrito para los usuarios "originales" de Arduino: diseadores y artistas.
Por lo tanto, trata de explicar las cosas de una manera que podra conducir a algunos
ingenieros locos. En realidad, uno de ellos llam a los captulos introductorios de mi
primer borrador "fluff". Ese es precisamente el punto. Seamos realistas: la mayora de
los ingenieros no son capaces de explicar lo que hacen a otro ingeniero, y mucho menos
a un ser humano normal. Ahora vamos a profundizar en la pelusa.
________________________________________________________________________
NOTA: Arduino se basa en el trabajo de tesis que Hernando Barragan hizo en la
plataforma Wiring mientras estudiaba bajo Casey Reas y yo en IDII Ivrea.

Despus de que Arduino comenz a ser popular, me di cuenta de cmo los
experimentadores, aficionados, y los hackers de todo tipo estaban empezando a
utilizarlo para crear objetos hermosos y locos. Me di cuenta de que todos ustedes son
artistas y diseadores por derecho propio, as que este libro es para ustedes tambin.

Arduino naci para ensear a Interaction Design, una disciplina de diseo que sita al
prototipo en el centro de su metodologa. Hay muchas definiciones de Interaction
Design, pero la que yo prefiero es:

Interaction Design es el diseo de cualquier experiencia interactiva.

En el mundo actual, Interaction Design se ocupa de la creacin de experiencias


significativas entre nosotros (los seres humanos) y los objetos. Es una buena manera de
explorar la creacin de experiencias hermosas -y quizs incluso polmicas- entre
nosotros y la tecnologa. Interaction Design fomenta el diseo a travs de un proceso
iterativo basado en prototipos
Introduccin a Arduino 2
De fidelidad cada vez mayor. Este enfoque, tambin parte de algunos tipos de diseo
"convencional", puede extenderse para incluir la creacin de prototipos con tecnologa;
En particular, la creacin de prototipos con electrnica.

El campo especfico de Diseo de Interaccin involucrado con Arduino es Computacin


Fsica (o Diseo de Interaccin Fsica).

Qu es la informtica fsica

Computacin fsica utiliza la electrnica para el prototipo de nuevos materiales para los
diseadores y artistas.

Implica el diseo de objetos interactivos que pueden comunicarse con humanos usando
sensores y actuadores controlados por un comportamiento implementado como un
software que se ejecuta dentro de un microcontrolador (una computadora pequea en
un solo chip).

En el pasado, usar la electrnica significaba tener que tratar con ingenieros todo el
tiempo, y construir circuitos un pequeo componente en ese momento; Estos temas
evitaban que las personas creativas jugaran con el medio directamente. La mayora de
las herramientas estaban destinadas a los ingenieros y requeran un amplio
conocimiento. En los ltimos aos, los microcontroladores se han vuelto ms baratos y
fciles de usar, permitiendo la creacin de mejores herramientas.

El progreso que hemos hecho con Arduino es acercar estas herramientas un paso ms al
novicio, permitiendo a la gente comenzar a construir cosas despus de slo dos o tres
das de un taller.

Con Arduino, un diseador o artista puede llegar a conocer los fundamentos de la


electrnica y los sensores muy rpidamente y puede comenzar a construir prototipos
con muy poca inversin.

Introduccin 3
2/ El Camino del Arduino
La filosofa de Arduino se basa en hacer diseos en
lugar de hablar sobre ellos. Es una bsqueda
constante de formas ms rpidas y ms potentes de
construir mejores prototipos. Hemos explorado
muchas tcnicas de prototipado y desarrollado
maneras de pensar con nuestras manos.

La ingeniera clsica se basa en un proceso estricto para obtener de A a B; El Camino


Arduino se deleita en la posibilidad de perderse en el camino y encontrar C en su
lugar.

Este es el proceso de bricolaje que nos encanta-jugar con el medio de una manera
abierta y encontrar lo inesperado. En esta bsqueda de maneras de construir mejores
prototipos, tambin seleccionamos una serie de paquetes de software que permiten
el proceso de manipulacin constante del software y del hardware.

Las siguientes secciones presentan algunas filosofas, acontecimientos y pioneros que


han inspirado el Camino del Arduino.

El Camino a Arduino 5
Prototipos
El prototipado est en el corazn del Camino Arduino: hacemos cosas y construimos
objetos que interactan con otros objetos, personas y redes. Nos esforzamos por
encontrar una manera ms sencilla y rpida de prototipo en la forma ms barata
posible.

Muchos de los principiantes que se acercan a la electrnica por primera vez piensan
que tienen que aprender a construir todo desde cero. Esto es una prdida de energa:
lo que quieres es poder confirmar que algo est funcionando muy rpidamente para
que puedas motivarte para dar el siguiente paso o tal vez incluso motivar a alguien a
darte mucho dinero para hacerlo.

Es por eso que desarrollamos el "prototipado oportunista": por qu gastar tiempo y


energa construyendo desde cero, un proceso que requiere tiempo y conocimiento
tcnico profundo, cuando podemos tomar dispositivos ya hechos y hackearlos para
explotar el duro trabajo realizado por grandes Empresas y buenos ingenieros?

Nuestro hroe es James Dyson, quien hizo 5127 prototipos de su aspiradora antes de
que estuviera satisfecho de que lo haba conseguido (www.international.
Dyson.com/jd/1947.asp).
Jugueteando
Creemos que es esencial jugar con la tecnologa, explorando diferentes posibilidades
directamente en hardware y software, a veces sin una meta muy definida.

La reutilizacin de la tecnologa existente es una de las mejores maneras de manipular.


Conseguir juguetes baratos o equipos viejos desechados y hackearlos para hacerlos hacer
algo nuevo es una de las mejores maneras de obtener grandes resultados.

El Camino a Arduino 7
Parche
Siempre he sido fascinado por la modularidad y la capacidad de construir sistemas
complejos mediante la conexin de dispositivos simples. Este proceso est muy bien
representado por Robert Moog y sus sintetizadores analgicos. Los msicos
construyeron sonidos, intentando combinaciones interminables "juntando" diferentes
mdulos con cables. Este enfoque hizo que el sintetizador parezca un viejo conmutador
telefnico, pero combinado con las numerosas perillas, era la plataforma perfecta para
mezclar msica sonora e innovadora. Moog lo describi como un proceso entre
"testificar y descubrir". Estoy seguro de que la mayora de los msicos al principio no
saba lo que todos esos cientos de botones, pero lo intentaron y trataron, refinando su
propio estilo sin interrupciones en el flujo.

Reducir el nmero de interrupciones en el flujo es muy importante para la creatividad:


mientras ms transparente sea el proceso, ms cambios tendrn.

Esta tcnica ha sido traducida al mundo del software por ambientes de "programacin
visual" como Max, Pure Data o VVVV. Estas herramientas pueden visualizarse como
"cajas" para las diferentes funcionalidades que proporcionan, permitiendo al usuario
construir "parches" conectando estas cajas. Estos entornos permiten al usuario
experimentar con la programacin sin la interrupcin constante tpica del ciclo habitual:
"tipo programa, compilacin, maldicin-hay un error, error de correccin, compilar,
ejecutar". Si usted es ms visual mente, le recomiendo que probarlos.
El Camino a Arduino 9
Curvado del circuito

El curvado de circuitos es una de las formas ms interesantes de manipulacin. Es el


cortocircuito creativo de los dispositivos audio electrnicos de bajo voltaje, batera-
accionados como pedales del efecto de la guitarra, juguetes de los nios, y
pequeos sintetizadores para crear los nuevos instrumentos musicales y los
generadores sanos. El corazn de este proceso es el "arte del azar". Comenz en
1966 cuando Reed Ghazala, por casualidad, cortocircuit un amplificador de
juguete contra un objeto de metal en su cajn de escritorio, lo que resulta en una
corriente de sonidos inusuales. Lo que ms me gusta de los curvadores de circuitos
es su capacidad de crear los dispositivos ms locos, alejndose con la tecnologa sin
necesariamente entender lo que estn haciendo en el lado terico.
Es un poco como el fanzine Sniffin 'Glue mostrado aqu: durante la era del punk,
conocer tres acordes en una guitarra fue suficiente para comenzar una banda. No
dejes que los expertos en un campo te digan que nunca sers uno de ellos.
Ignorarlos y sorprenderlos.

El Camino a Arduino 11
Teclado Hacks
Los teclados de computadora siguen siendo la principal forma de interactuar con
una computadora despus de ms de 60 aos. Alex Pentland, director acadmico
del MIT Media Laboratory, coment una vez: "Disculpe la expresin, pero los
urinarios de los hombres son ms inteligentes que las computadoras. Las
computadoras estn aisladas de lo que est a su alrededor ".

Como tinkerers, podemos implementar nuevas formas de interactuar con el


software sustituyendo las claves por dispositivos capaces de detectar el entorno.
Desmontar un teclado de computadora revela un dispositivo muy simple (y barato).
El corazn de ella es una tabla pequea. Normalmente es un circuito oloroso verde
o marrn con dos conjuntos de contactos va a dos capas de plstico que sostienen
las conexiones entre las diferentes teclas. Si retira el circuito y utiliza un cable para
conectar dos contactos, ver aparecer una letra en la pantalla del ordenador. Si
sales a comprar un detector de deteccin de movimiento y lo conecta a tu teclado,
vers que se presiona una tecla cada vez que alguien camina delante de la
computadora. Asigne esto a su software favorito, y usted ha hecho su computadora
tan elegante como un urinario. Aprender acerca de la piratera de teclado es un
componente clave de creacin de prototipos y computacin fsica.

Citado en Sara Reese Hedberg, "MIT Media Lab de la bsqueda de computadoras


perceptivas," Sistemas Inteligentes y sus aplicaciones, IEEE, julio / agosto 1998.
El Camino a Arduino 13

Nos encanta Junk!


La gente tira lejos mucha tecnologa actualmente: viejas impresoras,
computadoras, mquinas extraas de la oficina, equipo tcnico, e incluso
muchos de materia militar. Siempre ha habido un gran mercado para esta
tecnologa sobrante, especialmente entre los jvenes y / o los hackers ms
pobres y los que estn recin comenzando. Este mercado se hace evidente en
Ivrea, donde desarrollamos Arduino. La ciudad era la sede de la empresa
Olivetti. Haban estado haciendo computadoras desde los aos sesenta; A
mediados de los noventa, arrojaron todo en las chatarreras de la zona. Estos
estn llenos de piezas de computadora, componentes electrnicos y
dispositivos extraos de todo tipo. Pasamos innumerables horas all,
comprando todo tipo de artefactos por muy poco dinero y pirateando nuestros
prototipos. Cuando se puede comprar un millar de altavoces por muy poco
dinero, que est obligado a llegar a una idea al final. Acumular basura y pasar
.por ella antes de empezar a construir algo desde cero
Juguetes de Hacking
Los juguetes son una fantstica fuente de tecnologa barata para hackear y
reutilizar, como lo demuestra la prctica de la flexin de circuitos antes
mencionada. Con la afluencia actual de miles de juguetes de alta tecnologa muy
baratos de China, puede crear ideas rpidas con unos pocos gatos ruidosos y un par
de espadas ligeras. He estado haciendo esto por algunos aos para que mis
estudiantes comprendan que la tecnologa no es aterradora o difcil de acercarse.
Uno de mis recursos favoritos es el folleto "Low Tech Sensors and Actuators" de
Usman Haque y Adam Somlai-Fischer (lowtech.propositions.org.uk). Creo que han
descrito perfectamente esta tcnica en ese manual, y lo he estado usando desde
entonces.

Camino a Arduino 15
Colaboracin
La colaboracin entre los usuarios es uno de los principios clave en el mundo
Arduino-a travs del foro en www.arduino.cc, personas de diferentes partes del
mundo se ayudan mutuamente a aprender sobre la plataforma. El equipo de
Arduino alienta a las personas a colaborar a nivel local, as como ayudarles a crear
grupos de usuarios en cada ciudad que visiten. Tambin creamos un Wiki llamado
"Playground" (www.arduino.cc/playground) donde los usuarios documentan sus
descubrimientos. Es tan asombroso ver cunto conocimiento estas personas
vierten en la Web para que todos lo usen. Esta cultura de compartir y ayudarnos
mutuamente es una de las cosas que ms me enorgullece de Arduino.
3/ La Plataforma Arduino
Arduino se compone de dos partes principales: el
tablero de Arduino, que es la pieza de hardware en
la que trabajas cuando construyes tus objetos; Y el
Arduino IDE, el software que ejecuta en su
computadora. Utilice el IDE para crear un boceto
(un pequeo programa de computadora) que
cargue en la tarjeta Arduino. El boceto le dice al
consejo qu hacer.
No hace mucho tiempo, trabajar en hardware significaba construir circuitos desde cero,
usando cientos de componentes diferentes con nombres extraos como resistencias,
condensadores, inductores, transistores, etc.

Cada circuito fue "cableado" para hacer una aplicacin especfica, y hacer cambios
necesarios para cortar cables, conexiones de soldadura, y ms.

Con la aparicin de tecnologas digitales y microprocesadores, estas funciones, que una


vez se implementaron con cables, fueron reemplazadas por programas de software.

El software es ms fcil de modificar que el hardware. Con algunas pulsaciones de


teclas, puede cambiar radicalmente la lgica de un dispositivo y probar dos o tres
versiones en la misma cantidad de tiempo que le llevara a soldar un par de
resistencias.

El hardware de Arduino
El tablero de Arduino es un pequeo tablero del microcontrolador, que es un pequeo
circuito (el tablero) que contiene una computadora entera en un pequeo
microprocesador (el microcontrolador). Este equipo es por lo menos mil veces menos
potente que el MacBook que estoy usando para escribir esto, pero es mucho ms barato
y muy til para construir dispositivos interesantes. Mira el tablero de Arduino: vers un
chip negro con 28 "piernas" - ese chip es el ATmega168, el corazn de tu tablero.

La Plataforma Arduino 19
Nosotros (el equipo de Arduino) hemos colocado en esta placa todos los componentes
que son necesarios para que este microcontrolador funcione correctamente y para
comunicarse con su computadora. Hay muchas versiones de este tablero; El que
usaremos a lo largo de este libro es el Arduino Duemilanove, que es el ms sencillo de
usar y el mejor para aprender. Sin embargo, estas instrucciones se aplican a versiones
anteriores del tablero, incluyendo el ms reciente Arduino Diecimila y el Arduino NG
ms antiguo. La Figura 3-1 muestra el Arduino Duemilanove; La Figura 3-2 muestra el
Arduino NG.

En esas ilustraciones, ves la placa Arduino. Al principio, todos esos conectores podran
ser un poco confusos. Aqu est una explicacin de lo que hace cada elemento del
tablero:

14 pines digitales de I/O (pines 0-13)

stas pueden ser entradas o salidas, que se especifica mediante el croquis que se crea en
el IDE.

6 Pines de Entrada analgicos (pines 0-5)

Estos pines de entrada analgicos dedicados toman valores analgicos (es decir, lecturas
de tensin de un sensor) y los convierten en un nmero entre 0 y 1023.

6 Pines de Salida analgica (pines 3, 5, 6, 9, 10 y 11)

Estos son en realidad seis de los pines digitales que se pueden reprogramar para la salida
analgica utilizando el boceto que se crea en el IDE.

La placa puede ser alimentada desde el puerto USB de su computadora, la mayora de


los cargadores USB, o un adaptador de CA (recomendado de 9 voltios, punta del can
de 2,1 mm, centro positivo). Si no hay ninguna fuente de alimentacin enchufada en el
enchufe, la energa vendr de la tarjeta del USB, pero tan pronto como usted tapa una
fuente de alimentacin, la tarjeta la utilizar automticamente.

NOTA: Si est utilizando el Arduino-NG antiguo o Arduino Diecimila, deber


configurate de seleccin de potencia (denominado PWR_SEL en la placa) para
especificar la alimentacin EXT (externa) o USB. Este puente se puede encontrar entre
el enchufe para el adaptador de CA y el puerto USB.
Figura 3-1. El Arduino Duemilanove

Figura 3-2. El Arduino NG


La Plataforma Arduino 21
El Software (IDE)
El IDE (Integrated Development Environment) es un programa especial que se ejecuta
en su computadora y que le permite escribir bocetos para la placa Arduino en un
lenguaje sencillo basado en el lenguaje Processing (www.processing.org). La magia
ocurre cuando se presiona el botn que carga el boceto a la pizarra: el cdigo que se ha
escrito se traduce al lenguaje C (que generalmente es muy difcil para un principiante) y
se pasa al compilador avr-gcc , Una importante pieza de software de cdigo abierto que
hace la traduccin final al lenguaje entendido por el microcontrolador. Este ltimo paso
es muy importante, porque es donde Arduino hace su vida ms simple ocultando lejos
tanto como sea posible de las complejidades de la programacin de
microcontroladores.

El ciclo de programacin de Arduino es bsicamente el siguiente:


Conecte su tarjeta en un puerto USB de su computadora.
Escriba un bosquejo que traer el tablero a la vida.
Cargue este boceto en la placa a travs de la conexin USB y espere un par de
segundos para que la tarjeta se reinicie.
La tabla ejecuta el boceto que escribi.

NOTA: La instalacin de Arduino en Linux es algo complicada en el momento de


escribir este artculo. Consulte www.arduino.cc/playground/Learning/Linux para
obtener instrucciones completas.

Instalacin de Arduino en el equipo


Para programar la placa Arduino, primero debe descargar el entorno de desarrollo (IDE)
desde aqu: www.arduino.cc/en/Main/Software. Elija la versin correcta para su
sistema operativo.
Descargue el archivo y haga doble clic en l para descomprimirlo; Esto crear una
carpeta llamada arduino- [version], como arduino-0012. Arrastra esa carpeta a donde
quieras que sea: tu escritorio, tu carpeta / Aplicaciones (en un Mac) o tu carpeta C: \
Archivos de programa (en Windows). Ahora, siempre que desee ejecutar el IDE de
Arduino, abrir la carpeta arduino y haga doble clic en el icono de Arduino. Pero no
hagas esto todava; Hay un paso ms para realizar.
NOT
A: Si tiene problemas para ejecutar el IDE de Arduino, consulte el Captulo 7, Solucin
de problemas.

Ahora debe instalar los controladores que permiten que su computadora hable con su
tarjeta a travs del puerto USB.

Instalacin de controladores: Macintosh


Busque la carpeta Drivers dentro de la carpeta arduino-0012 y haga doble clic en el
archivo llamado FTDIUSBSerialDriver_x_x_x.dmg (x_x_x ser reemplazado por el nmero
de versin del controlador, por ejemplo FTDIUSBSerialDriver_ v2_2_9_Intel.dmg). Haga
doble clic en el archivo .dmg para montarlo.

NOTA: Si est utilizando una Mac basada en Intel, como MacBook, MacBook Pro,
MacBook Air, Mac Pro o Intel Mini-Mac o iMac, asegrese de instalar el controlador
con "Intel" en su nombre, como En FTDIUSBSerialDriver_v2_2_9_Intel.dmg. Si no est
utilizando una Mac basada en Intel, instale la que no tenga "Intel" en su nombre.

A continuacin, instale el software del paquete FTDIUSBSerialDriver haciendo doble clic


en l. Siga las instrucciones proporcionadas por el instalador y escriba la contrasea de
un usuario administrativo si se le solicita. Al final de este proceso, reinicie el equipo para
asegurarse de que los controladores estn correctamente cargados. Ahora conecte la
tarjeta en su computadora. La luz PWR de la tarjeta debe encenderse y el LED amarillo
con la etiqueta "L" debera comenzar a parpadear. Si no es as, consulte el Captulo 7,
Solucin de problemas.

Instalacin de controladores: Windows


Enchufe la tarjeta Arduino en la computadora; Cuando aparezca la ventana Asistente
para hardware nuevo encontrado, Windows intentar primero encontrar el controlador
en el sitio de Windows Update.

Windows XP le preguntar si desea comprobar Windows Update; Si no desea utilizar


Windows Update, seleccione la opcin "No, no en este momento" y haga clic en
Siguiente.

En la siguiente pantalla, elija "Instalar desde una lista o ubicacin especfica" y haga clic
en Siguiente.

La Plataforma Arduino 23
Marque la casilla "Incluir esta ubicacin en la bsqueda", haga clic en Examinar,
seleccione la carpeta donde instal Arduino y seleccione la carpeta Drivers \ FTDI USB
Drivers como ubicacin. Haga clic en Aceptar y en Siguiente.

Windows Vista primero intentar encontrar el controlador en Windows Update; Si esto


falla, puede indicarle que busque en la carpeta Drivers \ FTDI Drivers USB.

Pasar por este procedimiento dos veces, porque el equipo primero instala el
controlador de bajo nivel, luego instala un cdigo que hace que la tarjeta se vea como
un puerto serie en el equipo.

Una vez instalados los controladores, puede iniciar el IDE de Arduino y comenzar a
utilizar Arduino.

A continuacin, debe determinar qu puerto serie est asignado a su tarjeta Arduino:


necesitar esa informacin para programarla ms tarde. Las instrucciones para obtener
esta informacin se encuentran en las siguientes secciones.
Identificacin de puertos: Macintosh
En el men Herramientas del IDE de Arduino, seleccione "Puerto serie" y seleccione el
puerto que comienza con /dev/cu.usbserial-; Este es el nombre que utiliza su computadora
para referirse a la placa Arduino. La Figura 3-3 muestra la lista de puertos

Figura 3-3.
La lista de puertos serie del IDE de Arduino

La Plataforma Arduino 25
Identificacin del Puerto: Windows
En Windows, el proceso es un poco ms complicado, al menos al principio. Abra el
Administrador de dispositivos haciendo clic en el men Inicio, haga clic con el botn
secundario en Equipo (Vista) o Mi PC (XP) y seleccione Propiedades. En Windows XP,
haga clic en Hardware y elija Administrador de dispositivos. En Vista, haga clic en
Administrador de dispositivos (aparece en la lista de tareas a la izquierda de la ventana).
Busque el dispositivo Arduino en la lista bajo "Puertos (COM & LPT)". El Arduino
aparecer como un puerto serie USB y tendr un nombre como COM3, como se muestra
en la Figura 3-4.

Figura 3-4.
El Administrador de dispositivos de Windows muestra todos los puertos serie
disponibles
NOTA: En algunas mquinas Windows, el puerto COM tiene un nmero mayor que 9;
Esta numeracin crea algunos problemas cuando Arduino trata de comunicarse con l.
Consulte el Captulo 7, Solucin de problemas para obtener ayuda sobre este
problema.

Una vez que haya descubierto la asignacin de puerto COM, puede seleccionar ese
puerto en el men Herramientas> Puerto serie en el IDE de Arduino.

Ahora, el entorno de desarrollo de Arduino puede hablar con la placa Arduino y


programarlo.

La Plataforma Arduino 27
4/ Realmente empezando
con Arduino
Ahora aprender cmo crear y programar un
dispositivo interactivo.
Anatoma de un dispositivo interactivo
Todos los objetos que construiremos usando Arduino seguirn un patrn muy simple
que llamaremos "Interactive Device". El dispositivo interactivo es un circuito electrnico
que es capaz de detectar el ambiente utilizando sensores (componentes electrnicos
que convierten las mediciones del mundo real en seales elctricas). El dispositivo
procesa la informacin que recibe de los sensores con un comportamiento que se
implementa como software. El dispositivo ser capaz de interactuar con el mundo
utilizando actuadores, componentes electrnicos que pueden convertir una seal
elctrica en una accin fsica.

Sentido / percepcin

Sensores

Comportamien
to
(software )

Actuadores

Actuar /
Reaccionar

Figura 4-1.
El dispositivo interactivo

La Plataforma Arduino 29

Sensores y Actuadores
Los sensores y actuadores son componentes electrnicos que permiten que una pieza
de electrnica interacte con el mundo.

Como el microcontrolador es una computadora muy simple, slo puede procesar


seales elctricas (un poco como los impulsos elctricos que se envan entre las
neuronas de nuestro cerebro). Para que detecte luz, temperatura u otras cantidades
fsicas, necesita algo que pueda convertirlas en electricidad. En nuestro cuerpo, por
ejemplo, el ojo convierte la luz en seales que se envan al cerebro usando los nervios.
En electrnica, podemos utilizar un dispositivo simple llamado una resistencia
dependiente de la luz (un LDR o fotorresistor) que puede medir la cantidad de luz que lo
golpea y reportarlo como una seal que puede ser entendida por el microcontrolador.

Una vez que los sensores han sido ledos, el dispositivo tiene la informacin necesaria
para decidir cmo reaccionar. El proceso de toma de decisiones es manejado por el
microcontrolador, y la reaccin es realizada por actuadores. En nuestros cuerpos, por
ejemplo, los msculos reciben seales elctricas del cerebro y las convierten en un
movimiento. En el mundo electrnico, estas funciones podran ser realizadas por un
motor elctrico o un motor elctrico.

En las siguientes secciones, aprender a leer sensores de diferentes tipos y controlar


diferentes tipos de actuadores.

Parpadeando un LED
El boceto de parpadeo de LED es el primer programa que debe ejecutar para comprobar
si su tarjeta Arduino funciona y est configurada correctamente. Tambin suele ser el
primer ejercicio de programacin que alguien hace cuando aprende a programar un
microcontrolador. Un diodo emisor de luz (LED) es un pequeo componente electrnico
que es un poco como una bombilla, pero es ms eficiente y requiere voltajes ms bajos
para operar.

Su tarjeta Arduino viene con un LED preinstalado. Est marcado con "L". Tambin puede
agregar su propio LED-conectarlo como se muestra en la Figura 4-2.

K indica el ctodo (negativo), o el plomo ms corto; A indica el nodo (positivo), o el


plomo ms largo.

Una vez que el LED est conectado, necesita decirle a Arduino qu hacer. Esto se hace a
travs de cdigo, es decir, una lista de instrucciones que le damos al microcontrolador
para que haga lo que queremos.
Figura 4-2.
Conexin de un LED a Arduino

En su computadora, abra la carpeta donde copi el IDE de Arduino. Haga doble clic en el
icono de Arduino para iniciarlo. Seleccione Archivo> Nuevo y se le pedir que elija un
nombre de carpeta de boceto: aqu se almacenar su boceto Arduino. Asigne un
nombre a Blinking_LED y haga clic en Aceptar. A continuacin, escriba el siguiente texto
(Ejemplo 01) en el editor de bocetos de Arduino (la ventana principal del IDE de
Arduino). Tambin puede descargarlo desde www.makezine.com/ getstartedarduino.
Deber aparecer como se muestra en la Figura 4-3.

// Ejemplo 01: LED parpadeante

# Definir LED 13 // LED conectado a //


pin digital 13

Void setup () {
PinMode (LED, SALIDA); // establece el pin digital
como salida }

Void loop () {
DigitalWrite (LED, ALTA); // activa el retardo de encendido del LED (1000); // espera un
segundo digitalWrite (LED, LOW); // desactiva el LED (1000); // espera un segundo}

Verificar Cargar para I/O la tarjeta


Su bosquejo va aqu

Figura 4-3.
El IDE de Arduino con el primer dibujo cargado

Ahora que el cdigo est en su IDE, debe verificar que es correcto. Presione el botn
"Verificar" (la Figura 4-3 muestra su ubicacin); Si todo est correcto, aparecer el
mensaje "Done compilacin" en la parte inferior del IDE de Arduino. Este mensaje
significa que el IDE de Arduino ha traducido su boceto en un programa ejecutable que
puede ejecutar la placa, un poco como un archivo .exe en Windows o un archivo .app en
una Mac.

En este momento, puede cargarlo en la placa: presione el botn Cargar en la tarjeta de


I/O (consulte la Figura 4-3). Esto restablecer la placa, obligndola a detener lo que est
haciendo y escuchar las instrucciones procedentes del puerto USB. El IDE de Arduino
enva el boceto actual al tablero, que lo almacenar en su memoria y lo ejecutar
eventualmente.

La Plataforma Arduino 33

Ver que aparecen algunos mensajes en el rea negra en la parte inferior de la ventana
y, justo encima de esa zona, aparecer el mensaje "Finalizar la carga" para que sepa
que el proceso se ha completado correctamente. Hay dos LEDs, marcados RX y TX, en
el tablero; Estos parpadean cada vez que un byte es enviado o recibido por el tablero.
Durante el proceso de carga, siguen parpadeando.

Si no ve el parpadeo de los LEDs, o si aparece un mensaje de error en lugar de


"Finalizar la carga", hay un problema de comunicacin entre su computadora y
Arduino. Asegrese de haber seleccionado el puerto serie correcto (consulte el
Captulo 3) en el men Herramientas> Puerto serie. Adems, compruebe el men
Herramientas> Panel para confirmar que el modelo correcto de Arduino est
seleccionado all.

Si todava tiene problemas, consulte el Captulo 7, Solucin de problemas.

Una vez que el cdigo est en tu tablero de Arduino, permanecer all hasta que
pongas otro dibujo en l. El boceto sobrevivir si la tarjeta se reinicia o se apaga, un
poco como los datos en el disco duro de su computadora.

Suponiendo que el dibujo haya sido cargado correctamente, ver que el LED "L" se
enciende por un segundo y despus se apaga durante un segundo. Si instal un LED
separado como se muestra en la Figura 4-2, ese LED parpadear tambin. Lo que acaba
de escribir y ejecutar es un "programa de computadora", o esbozo, como se llaman los
programas de Arduino. Arduino, como he mencionado antes, es una computadora
pequea, y se puede programar para hacer lo que quieras. Esto se hace usando un
lenguaje de programacin para escribir una serie de instrucciones en el IDE de
Arduino, que lo convierte en un ejecutable para su placa Arduino.

Te mostrar luego cmo entender el boceto. En primer lugar, el Arduino ejecuta el


cdigo de arriba a abajo, por lo que la primera lnea en la parte superior es la primera
lectura; A continuacin, se mueve hacia abajo, un poco como la forma en la cabeza de
reproduccin de un reproductor de vdeo como QuickTime Player o Windows Media
Player se mueve de izquierda a derecha que muestra dnde en la pelcula que est.

Psame el Parmesano
Observe la presencia de corchetes, que se utilizan para agrupar lneas de cdigo. Estos
son particularmente tiles cuando se desea dar un nombre a un grupo de instrucciones.
Si ests en la cena y le preguntas a alguien: "Por favor, psame el queso parmesano",
esto inicia una serie de acciones que se resumen en la pequea frase que acabas de
decir. Como somos humanos, todo viene naturalmente, pero todas las pequeas
acciones individuales necesarias para hacer esto deben ser explicadas al Arduino,
porque no es tan poderoso como nuestro cerebro. As que para agrupar una serie de
instrucciones, se pega un {antes de su cdigo y un} despus.

Puede ver que hay dos bloques de cdigo que se definen de esta manera aqu. Ante
cada uno de ellos hay un extrao mandamiento:
void setup()
Esta lnea da un nombre a un bloque de cdigo. Si escribieras una lista de instrucciones
que enseen a Arduino cmo pasar el parmesano, escribiras void passTheParmesan ()
al principio de un bloque, y este bloque se convertira en una instruccin que puedes
llamar desde cualquier parte del cdigo de Arduino. Estos bloques se llaman funciones.
Si despus de esto escribes passTheParmesan () en cualquier parte de tu cdigo,
Arduino ejecutar esas instrucciones y continuar donde lo dej.

Arduino no es para Nios (Quitters)


Arduino espera que existan dos funciones: una llamada setup () y otra llamada loop ().

setup () es donde pone todo el cdigo que desea ejecutar una vez al principio de su
programa y loop () contiene el ncleo de su programa, que se ejecuta una y otra vez.
Esto se hace porque Arduino no es como su computadora normal: no puede ejecutar
varios programas al mismo tiempo y los programas no pueden salir. Cuando se enciende
la tarjeta, el cdigo se ejecuta; Cuando quieras parar, simplemente apgalo.

Reales Gitanos (Tinkeres) Escriben Comentarios


Cualquier texto que empiece por // es ignorado por Arduino. Estas lneas son
comentarios, que son notas que dejas en el programa por ti mismo, para que puedas
recordar lo que hiciste cuando lo escribiste, o para alguien ms, para que puedan
entender tu cdigo.

Es muy comn (lo s porque lo hago todo el tiempo) escribir un pedazo de cdigo,
subirlo al tablero, y decir "Okay-yo nunca voy a tener que tocar a este chupn de
nuevo!" Slo para Tenga en cuenta seis meses despus que necesita actualizar el cdigo
o corregir un error. En este punto, se abre el programa, y si no ha incluido ningn
comentario en el programa original, usted pensar: "Wow, qu desastre! Por dnde
empiezo? "A medida que avancemos, veremos algunos trucos para hacer que sus
programas sean ms legibles y ms fciles de mantener.

El Cdigo, paso a paso


Al principio, podras considerar innecesario este tipo de explicacin, un poco como
cuando estaba en la escuela y tuve que estudiar la Divina Commedia de Dante (todo
estudiante italiano tiene que pasar por eso, as como otro libro llamado I promessi
sposi, o The Betrothed-oh, las pesadillas). Para cada lnea de los poemas, haba cien
lneas de comentario! Sin embargo, la explicacin ser mucho ms til aqu como
usted pasa a escribir sus propios programas.

// Ejemplo 01: Blinking LED


Un comentario es una manera til para que escribamos pequeas notas. El comentario
del ttulo precedente slo nos recuerda que este programa, Ejemplo 01, parpadea un
LED.

#define LED 13 // LED conectado a


// digital pin 13
#define es como una bsqueda automtica y reemplazar por su cdigo; En este caso, le
est diciendo a Arduino que escriba el nmero 13 cada vez que aparezca la palabra
LED. El reemplazo es lo primero que hace cuando hace clic en Verificar o Cargar en la
Tarjeta de I / O (nunca ve los resultados de la sustitucin como se hace detrs de las
escenas). Estamos utilizando este comando para especificar que el LED que est
parpadeando est conectado al pin Arduino 13.

void setup()
Esta lnea indica a Arduino que el siguiente bloque de cdigo se llamar setup ().

{
Con esta abrazadera de apertura, un bloque de cdigo comienza.

pinMode(LED, OUTPUT); // establece el formato digital


// pin como salida.
Finalmente, una instruccin realmente interesante. pinMode le indica a Arduino cmo
configurar un determinado pin. Los pines digitales se pueden utilizar como INPUT o
OUTPUT. En este caso, necesitamos un pin de salida para controlar nuestro LED, por lo
que colocamos el nmero del pin y su modo dentro de los parntesis. pinMode es una
funcin, y las palabras (o nmeros) especificados dentro de los parntesis son
argumentos. INPUT y OUTPUT son constantes en el lenguaje Arduino. (Al igual que las
variables, las constantes se asignan valores, excepto que los valores constantes son
predefinidos y nunca cambian.)

}
Este cierre rizado significa el final de la funcin setup ().

void loop()
{
loop() es donde se especifica el comportamiento principal de su dispositivo interactivo.
Se repetir una y otra vez hasta que apague el tablero.

digitalWrite(LED, HIGH) ; // enciende el LED


Como dice el comentario, digitalWrite() es capaz de activar (o desactivar) cualquier pin
que se haya configurado como OUTPUT. El primer argumento (en este caso, LED)
especifica qu pasador se debe encender o apagar (recuerde que el LED es un valor
constante que se refiere al pin 13, por lo que este es el pin que ha cambiado). El
segundo argumento puede activar el pin (HIGH) o desactivarlo (LOW).
Imagine que cada pin de salida es una toma de corriente pequea, como las que tiene
en las paredes de su apartamento. Las europeas son 230 V, las americanas son 110 V, y
Arduino funciona a un 5 V. La magia aqu es cuando el software se convierte en
hardware. Cuando escriba digitalWrite(LED, HIGH), gira el pin de salida a 5 V, y si
conecta un LED, se encender. As que en este punto de su cdigo, una instruccin en
software hace que algo suceda en el mundo fsico mediante el control del flujo de
electricidad a la clavija. Encender y apagar el pin a voluntad ahora vamos a traducir
estos en algo ms visible para un ser humano; El LED es nuestro actuador.

delay(1000);. // espera un segundo


Arduino tiene una estructura muy bsica. Por lo tanto, si usted quiere que las cosas
sucedan con cierta regularidad, dgale que se siente tranquilamente y no haga nada
hasta que es hora de ir al siguiente paso. delay() bsicamente hace que el procesador
se siente all y no haga nada por la cantidad de milisegundos que pasa como
argumento. Los milisegundos son miles de segundos; Por lo tanto, 1000 milisegundos
es igual a 1 segundo. As que el LED permanece encendido por un segundo aqu.

digitalWrite (LED, LOW);. // apaga el LED

Esta instruccin ahora apaga el LED que habamos activado anteriormente. Por qu
usamos HIGH y LOW? Bueno, es una vieja convencin en electrnica digital. HIGH
significa que el pin est encendido, y en el caso de Arduino, se ajustar a 5 V. LOW
significa 0 V. Tambin puede reemplazar mentalmente estos argumentos con ON y OFF.

delay (1000); // espera un segundo

Aqu, demoramos por otro segundo. El LED se apagar durante un segundo.

}
Este cierre rizado marca el final de la funcin de bucle.

Para resumir, este programa hace esto:

Convierte el pin 13 en una salida (slo una vez al principio)

Introduce un bucle

Conecta el LED conectado a la clavija 13

Espera un segundo
Desconecta el LED conectado a la clavija 13

Espera un segundo

Retrocede al inicio del ciclo


Espero que no haya sido demasiado doloroso. Aprender ms sobre cmo programar a
medida que vaya a travs de los ejemplos posteriores.

Antes de pasar a la siguiente seccin, quiero que juegues con el cdigo. Por ejemplo,
reduzca la cantidad de retardo, usando nmeros diferentes para los pulsos de encendido
y apagado, de modo que pueda ver diferentes patrones de parpadeo. En particular,
usted debe ver lo que sucede cuando se hacen los retrasos muy pequeos, pero el uso
de diferentes retrasos para encendido y apagado. . . Hay un momento en que sucede
algo extrao; Este "algo" ser muy til cuando aprenda sobre la modulacin de ancho
de pulso ms adelante en este libro.
Lo que vamos a construir
Siempre he estado fascinado por la luz y la capacidad de controlar diferentes fuentes de
luz a travs de la tecnologa. He tenido la suerte de trabajar en algunos proyectos
interesantes que implican controlar la luz y hacerla interactuar con la gente. Arduino es
realmente bueno en esto. A lo largo de este libro, estaremos trabajando en cmo
disear "lmparas interactivas", usando Arduino como una forma de aprender los
conceptos bsicos de cmo se construyen los dispositivos interactivos.

En la siguiente seccin, voy a tratar de explicar los fundamentos de la electricidad de


una manera que aburrira a un ingeniero, pero no asustar a un nuevo programador de
Arduino.
Qu es la electricidad?

Si usted ha hecho cualquier plomera en casa, la electrnica no ser un problema para


que usted entienda. Para entender cmo funcionan los circuitos elctricos y elctricos,
la mejor manera es usar algo llamado la "analoga del agua". Tomemos un dispositivo
simple, como el ventilador porttil alimentado por batera que se muestra en la Figura
4-4.
Figura 4-4.
Un ventilador pportti

Si usted toma un ventilador aparte, usted ver que contiene una batera pequea, un
par de alambres, y un motor elctrico, y que uno de los alambres que van al motor es
interrumpido por un interruptor. Si tiene una batera nueva y encienda el interruptor, el
motor empezar a girar, proporcionando el fro necesario. Como funciona esto? Bueno,
imagnese que la batera es un depsito de agua y una bomba, el interruptor es un grifo,
y el motor es una de esas ruedas que usted ve en los molinos de agua. Al abrir el grifo, el
agua fluye de la bomba y empuja la rueda en movimiento.

En este sencillo sistema hidrulico, que se muestra en la Figura 4-5, son importantes dos
factores: la presin del agua (que se determina por la potencia de la bomba) y la
cantidad de agua que fluir en las tuberas (esto depende del tamao De las tuberas y
la resistencia que la rueda proporcionar a la corriente de agua que la golpee).

Figura 4-5.
Un sistema hidrulico

Pronto se dar cuenta de que si desea que la rueda gire ms rpido, necesita aumentar
el tamao de las tuberas (pero esto slo funciona hasta un punto) y aumentar la
presin que la bomba puede lograr. Aumentar el tamao de las tuberas permite un
mayor flujo de agua para atravesarlas; Hacindolos ms grandes, hemos reducido
eficazmente la resistencia de las pipas al flujo del agua. Este enfoque funciona hasta
cierto punto, en el que la rueda no girar ms rpido, porque la presin del agua no es
lo suficientemente fuerte. Cuando llegamos a este punto, necesitamos que la bomba
sea ms fuerte. Este mtodo de acelerar el molino de agua puede continuar hasta el
punto cuando la rueda se cae porque el flujo de agua es demasiado fuerte para l y se
destruye. Otra cosa que notar es que a medida que gira la rueda, el eje se calentar un
poco, porque no importa lo bien que hemos montado la rueda,

La friccin entre el eje y los orificios en los que est montado generar calor. Es
importante entender que en un sistema como este, no toda la energa que bombas en el
sistema se convertir en movimiento; Algunos se perdern en una serie de ineficiencias
y generalmente se mostrar como el calor que emana de algunas partes del sistema.

Cules son las partes importantes del sistema? La presin producida por la bomba es
una; La resistencia que las tuberas y la rueda ofrecen al flujo de agua, y el flujo real de
agua (digamos que esto se representa por el nmero de litros de agua que fluyen en un
segundo) son los otros. La electricidad funciona un poco como el agua. Usted tiene una
especie de bomba (cualquier fuente de electricidad, como una batera o un enchufe de
pared) que empuja las cargas elctricas (imagnelas como "gotas" de electricidad) hacia
abajo de las tuberas, que estn representadas por los cables-algunos dispositivos
pueden utilizar Estos para producir calor (manta trmica de su abuela), luz (su lmpara
de dormitorio), sonido (su estreo), movimiento (su ventilador), y mucho ms.

As que cuando lea que el voltaje de una batera es de 9 V, piense en este voltaje como
la presin del agua que potencialmente puede ser producida por esta pequea
"bomba". El voltaje se mide en voltios, llamado as por Alessandro Volta, el inventor de
la primera batera.

As como la presin del agua tiene un equivalente elctrico, el caudal de agua tambin lo
hace. Esto se llama corriente, y se mide en amperios (despus de Andr-Marie Ampre,
pionero del electromagnetismo). La relacin entre tensin y corriente se puede ilustrar
volviendo a la rueda de agua: un voltaje ms alto (presin) le deja girar una rueda ms
rpidamente; Una mayor velocidad de flujo (corriente) le permite girar una rueda ms
grande.

Finalmente, la resistencia que se opone al flujo de la corriente sobre cualquier


trayectoria que viaja se denomina -vino usted- resistencia, y se mide en ohmios
(despus del fsico alemn Georg Ohm). Herr Ohm tambin fue responsable de formular
la ley ms importante en la electricidad y la nica frmula que realmente necesita
recordar. Fue capaz de demostrar que en un circuito el voltaje, la corriente y la
resistencia estn todos relacionados entre s, y en particular que la resistencia de un
circuito determina la cantidad de corriente que fluir a travs de l, dada una cierta
fuente de voltaje .

Es muy intuitivo, si lo piensas. Tome una batera de 9 V y conctelo en un circuito simple.


Mientras mide corriente, encontrar que cuanto ms resistencias aada al circuito,
menos corriente viajar a travs de l. Volviendo a la analoga del agua que fluye en las
tuberas, dada una cierta bomba, si instalo una vlvula (que podemos relacionar con una
resistor variable en electricidad), cuanto ms cierre la vlvula aumentando la resistencia
al flujo de agua, menos agua Fluir a travs de las tuberas. Ohm resumi su ley en estas
frmulas:

R (resistencia) = V (tensin) / I (corriente)


V=R*I
I=V/R

Esta es la nica regla que realmente tienes que memorizar y aprender a usar, porque en
la mayora de tu trabajo, sta es la nica que realmente necesitars.
Uso de un pulsador para controlar el LED
Parpadeando un LED fue fcil, pero no creo que se quedara sano si su lmpara de
escritorio continuamente parpadea mientras estaba tratando de leer un libro. Por lo
tanto, usted necesita aprender cmo controlarlo. En nuestro ejemplo anterior, el LED
era nuestro actuador, y nuestro Arduino lo estaba controlando. Lo que falta para
completar la imagen es un sensor.

En este caso, vamos a utilizar la forma ms simple de sensor disponible: un pulsador.

Si desmontas un pulsador, vers que es un dispositivo muy simple: dos pedazos de metal
separados por un muelle, y un tapn de plstico que cuando se presiona pone en
contacto los dos trozos de metal. Cuando los trozos de metal estn separados, no hay
circulacin de corriente en el pulsador (un poco como cuando una vlvula de agua est
cerrada); Cuando lo presionamos, hacemos una conexin.

Para supervisar el estado de un interruptor, hay una nueva instruccin de Arduino que
usted va a aprender: la funcin digitalRead().

digitalRead() comprueba si hay algn voltaje aplicado al pin que se especifica entre
parntesis y devuelve un valor de HIGH o LOW dependiendo de sus resultados. Las otras
instrucciones que hemos usado hasta ahora no han devuelto ninguna informacin:
simplemente ejecutaron lo que les pedimos que hicieran. Pero ese tipo de funcin es un
poco limitada, porque nos obligar a seguir con secuencias de instrucciones muy
predecibles, sin la entrada del mundo exterior. Con digitalRead(), podemos "hacer una
pregunta" de Arduino y recibir una respuesta que puede ser almacenada en la memoria
en alguna parte y utilizada para tomar decisiones inmediatamente o ms tarde.

Construya el circuito mostrado en la Figura 4-6. Para construir esto, necesitar obtener
algunas partes (estas sern tiles a medida que trabaje en otros proyectos tambin):

Tablero sin soldadura: RadioShack (www.radioshack.com) nmero de pieza 276-002,


Maker Shed (www.makershed.com) nmero de pieza MKKN3. El Apndice A es una
introduccin a la plancha sin soldadura.

Juego de cables de puenteo pre-cortado: Radio Shack 276-173, Hedge Maker KKN4

Una resistencia de 10K Ohm: RadioShack 271-1335 (paquete de 5), SparkFun


(www.sparkfun.com) COM-08374

Interruptor pulsador momentneo: SparkFun COM-00097


Figura 4-6.
Conexin de un pulsador

NOTA: en lugar de comprar alambre de puente, usted tambin puede comprar alambre
de conexin de slidos de 22 AWG en pequeos carretes y cortar y pelar utilizando
cortadores de alambre y separadores de alambre.
Echemos un vistazo al cdigo que vamos a utilizar para controlar el LED con nuestro
pulsador:

// Ejemplo 02: Encender el LED mientras se pulsa el botn

#define LED 13 // el pin para el LED


#define BUTTON 7 // el pin de entrada donde
// el pulsador est conectado
int val = 0; // val se utilizar para almacenar el estado
// del pin de entrada

void setup() {
pinMode(LED, OUTPUT); // decir Arduino LED es una salida
pinMode(BUTTON, INPUT); // y BUTTON es una entrada
}

void loop(){
val = digitalRead(BUTTON); // leer el valor de entrada y almacenarlo

// Compruebe si la entrada es HIGH (botn pulsado)


if (val == HIGH) {
digitalWrite(LED, HIGH); // encender el LED ON
} else {
digitalWrite(LED, LOW);
}
}

En Arduino, seleccione Archivo> Nuevo (si tiene otro boceto abierto, puede guardarlo
primero). Cuando Arduino le pide que nombre su nueva carpeta de boceto, escriba
PushButonControl. Escriba el cdigo del ejemplo 02 en Arduino (o descrguelo desde
www.makezine.com/getstartedarduino y pguelo en el IDE de Arduino). Si todo es
correcto, el LED se encender al presionar el botnn.

Como funciona esto?

He introducido dos nuevos conceptos con este programa de ejemplo: funciones que
devuelven el resultado de su trabajo y la instruccin if.
La sentencia if es posiblemente la instruccin ms importante en un lenguaje de
programacin, ya que permite que la computadora (y recuerde, el Arduino es un
pequeo ordenador) para tomar decisiones. Despus de la palabra clave if, hay que
escribir una "pregunta" dentro de parntesis, y si la "respuesta", o resultado, es
verdadera, se ejecutar el primer bloque de cdigo; De lo contrario, se ejecutar el
bloque de cdigo despus de otro. Tenga en cuenta que he usado el smbolo == en lugar
de =. El primero se utiliza cuando se comparan dos entidades, y se devuelve TRUE o
FALSE; Este ltimo asigna un valor a una variable. Asegrese de que utiliza el correcto,
porque es muy fcil cometer ese error y usar slo =, en cuyo caso su programa nunca
funcionar. Lo s, porque despus de 25 aos de programacin, todava cometo ese
error.

Mantener el dedo en el botn durante el tiempo que necesita luz no es prctico. Aunque
te hara pensar en la cantidad de energa que ests desperdiciando cuando te alejas de
una lmpara que te quedaste en, tenemos que averiguar cmo hacer que el botn de
encendido "palo".

Un circuito, mil comportamientos

La gran ventaja de la electrnica digital y programable sobre la electrnica clsica es


ahora evidente: te mostrar cmo implementar muchos "comportamientos" diferentes
usando el mismo circuito electrnico que en la seccin anterior, simplemente
cambiando el software.

Como he mencionado antes, no es muy prctico tener que mantener el dedo en el


botn para encender la luz. Por lo tanto, debemos implementar alguna forma de
"memoria", en forma de un mecanismo de software que recordar cuando hayamos
presionado el botn y mantendr la luz encendida incluso despus de haberla liberado.

Para hacer esto, vamos a utilizar lo que se llama una variable. (Ya hemos usado uno,
pero no lo he explicado.) Una variable es un lugar en la memoria de Arduino donde
puedes almacenar datos. Piense en l como una de esas notas adhesivas que utiliza para
recordarse algo, como un nmero de telfono: usted toma uno, usted escribe "Luisa 02
555 1212" en l, y se pega a su monitor de la computadora o su refrigerador. En el
lenguaje Arduino, es igualmente sencillo: slo decide qu tipo de datos desea almacenar
(un nmero o un texto, por ejemplo), dale un nombre y cuando lo desee, puede
almacenar los datos o recuperarlos . Por ejemplo:
int val = 0;

int significa que su variable almacenar un nmero entero, val es el nombre de la


variable, y = 0 le asigna un valor inicial de cero.
Una variable, como su nombre indica, se puede modificar en cualquier parte de su
cdigo, para que ms adelante en su programa, podra escribir:
val = 112;
Que reasigna un nuevo valor, 112, a su variable.

NOTA: Ha notado que en Arduino, todas las instrucciones, con una excepcin
(#define), termina con un punto y coma? Esto se hace para que el compilador (la parte
de Arduino que convierte su boceto en un programa que el microcontrolador puede
ejecutar) sabe que su declaracin ha terminado y una nueva est comenzando.
Recuerde usarlo todo el tiempo, excluyendo cualquier lnea que comience con #define.
Los #define son reemplazados por el compilador antes de que el cdigo se traduce en
un ejecutable de Arduino.

En el programa siguiente, val se utiliza para almacenar el resultado de digitalRead(); Lo


que Arduino obtenga de la entrada termina en la variable y permanecer all hasta que
otra lnea de cdigo la cambie. Observe que las variables utilizan un tipo de memoria
llamada RAM. Es bastante rpido, pero cuando se apaga la placa, se pierden todos los
datos almacenados en la memoria RAM (lo que significa que cada variable se restablece
a su valor inicial cuando la placa se enciende de nuevo). Sus propios programas se
almacenan en memoria flash -es el mismo tipo utilizado por su telfono mvil para
almacenar nmeros de telfono- que conserva su contenido incluso cuando la tarjeta
est apagada.

Ahora vamos a usar otra variable para recordar si el LED tiene que permanecer
encendido o apagado despus de soltar el botn. El ejemplo 03A es un primer intento
de lograr:
// Ejemplo 03A: Encender el LED cuando se presiona el botn
// y mantenerlo encendido despus de que se libere

#define LED 13 // el pin para el LED


#define BUTTON 7 // el pin de entrada donde
// el pulsador est conectado
int val = 0; // val se utilizar para almacenar el estado
// del pin de entrada
int state = 0; // 0 = LED apagado mientras 1 = LED encendido

void setup() {
pinMode(LED, OUTPUT); // decir Arduino LED es una salida
pinMode(BUTTON, INPUT); // y BUTTON es una entrada
}

void loop() {
val = digitalRead(BUTTON); // leer el valor de entrada y almacenarlo

// compruebe si la entrada es ALTA (botn pulsado)


// y cambiar el estado
if (val == HIGH) {
state = 1 state;
}

if (state == 1) {
digitalWrite(LED, HIGH); // turn LED ON
} else {
digitalWrite(LED, LOW);
}
}

Ahora prueba este cdigo. Usted notar que funciona. . . algo. Usted encontrar que la
luz cambia tan rpidamente que usted no puede fijarla confiablemente encendido o
apagado con una prensa del botn.

Veamos las partes interesantes del cdigo: state es una variable que almacena 0 o 1 para
recordar si el LED est encendido o apagado. Despus de soltar el botn, lo inicializamos
a 0 (LED apagado).
Ms tarde, leemos el estado actual del botn, y si se presiona (val == HIGH), cambiamos
el estado de 0 a 1, o viceversa. Hacemos esto usando un pequeo truco, ya que el
estado puede ser solo 1 o 0. El truco que uso involucra una pequea expresin
matemtica basada en la idea de que 1 - 0 es 1 y 1 - 1 es 0:
state = 1 state;

La lnea puede no tener mucho sentido en matemticas, pero s en la programacin. El


smbolo = significa "asignar el resultado de lo que est detrs de m al nombre de la
variable antes de m"; en este caso, el nuevo valor de estado se asigna al valor de 1
menos el valor antiguo del estado.

Ms adelante en el programa, puede ver que usamos el estado para averiguar si el LED
debe estar encendido o apagado. Como mencion, esto conduce a resultados algo
escamosos.

Los resultados son escamosos debido a la forma en que leemos el botn. Arduino es
muy rpido; Ejecuta sus propias instrucciones internas a una tasa de 16 millones por
segundo, podra estar ejecutando unas pocas millones de lneas de cdigo por segundo.
As que esto significa que mientras tu dedo est presionando el botn, Arduino podra
estar leyendo la posicin del botn unos miles de veces y cambiando de estado en
consecuencia. As que los resultados terminan siendo impredecibles; Podra estar
apagado cuando usted lo quisiera encendido, o viceversa. Como incluso un reloj roto es
correcto dos veces al da, el programa puede mostrar el comportamiento correcto de
vez en cuando, pero la mayor parte del tiempo va a estar mal.

Cmo arreglamos esto? Bueno, necesitamos detectar el momento exacto en que se


presiona el botn, ese es el nico momento que tenemos que cambiar de estado. La
forma en que me gusta hacerlo es almacenar el valor de val antes de leer un nuevo; Esto
me permite comparar la posicin actual del botn con el anterior y cambiar el estado
slo cuando el botn se convierte en ALTO despus de ser LOW.

El ejemplo 03B contiene el cdigo para hacerlo:


// Example 03B: Turn on LED when the button is pressed
// and keep it on after it is released // Now with a new and
improved formula!

#define LED 13 // the pin for the LED


#define BUTTON 7 // the input pin where the //
pushbutton is connected
int val = 0; // val will be used to store the state // of the input pin
int old_val = 0; // this variable stores the previous // value of "val"
int state = 0; // 0 = LED off and 1 = LED on

void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON,
INPUT); // and BUTTON is an input }
void loop(){
val = digitalRead(BUTTON); // read input value and store it // yum, fresh

// check if there was a transition if ((val == HIGH) &&


(old_val == LOW)){ state = 1 - state; }

old_val = val; // val is now old, let's store it

if (state == 1) {
digitalWrite(LED, HIGH); // turn LED ON } else {
digitalWrite(LED, LOW);
}

Prubelo: estamos casi all!

Usted puede haber notado que este acercamiento no es enteramente perfecto, debido a
otro problema con los interruptores mecnicos. Los pulsadores son dispositivos muy
simples: dos pedazos de metal separados por un resorte. Cuando presiona el botn, los
dos contactos se unen y la electricidad puede fluir. Esto suena bien y simple, pero en la
vida real la conexin no es tan perfecta, especialmente cuando el botn no est
completamente presionado, y genera algunas seales espurias llamadas rebote.

Cuando el pulsador est rebotando, el Arduino ve una secuencia muy rpida de seales
de encendido y apagado. Hay muchas tcnicas desarrolladas para hacer de-rebote, pero
en este pedazo simple del cdigo he notado que es generalmente bastante para agregar
un retraso 10 - a 50 milisegundos cuando el cdigo detecta una transicin.

El ejemplo 03C es el cdigo final:


// Example 03C: Turn on LED when the button is pressed
// and keep it on after it is released
// including simple de-bouncing // Now with another new and
improved formula!!

#define LED 13 // the pin for the LED


#define BUTTON 7 // the input pin where the //
pushbutton is connected
int val = 0; // val will be used to store the state // of the input pin
int old_val = 0; // this variable stores the previous // value of "val"
int state = 0; // 0 = LED off and 1 = LED on

void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON,
INPUT); // and BUTTON is an input }

void loop(){
val = digitalRead(BUTTON); // read input value and store it // yum, fresh

// check if there was a transition if ((val == HIGH) &&


(old_val == LOW)){ state = 1 - state; delay(10); }

old_val = val; // val is now old, let's store it

if (state == 1) {
digitalWrite(LED, HIGH); // turn LED ON } else {
digitalWrite(LED, LOW);
}

}
5/ Entrada y salida
avanzadas
Lo que acabamos de aprender en el Captulo 4
son las operaciones ms elementales que
podemos hacer en Arduino: controlar la salida
digital y leer la entrada digital. Si Arduino fuera
algn tipo de lenguaje humano, stas seran dos
letras de su alfabeto. Teniendo en cuenta que hay
slo cinco letras en este alfabeto, se puede ver
cunto ms trabajo que tenemos que hacer antes
de que podamos escribir Arduino poesa.
Prueba de otros sensores de encendido / apagado
Ahora que ha aprendido a utilizar un pulsador, debe saber que hay muchos otros
sensores muy bsicos que funcionan de acuerdo con el mismo principio:

Interruptores

Al igual que un pulsador, pero no cambia automticamente el estado cuando se


suelta

Termostatos

Un interruptor que se abre cuando la temperatura alcanza un valor establecido

Interruptores magnticos (tambin conocidos como "rels de lmina")

Tiene dos contactos que se juntan cuando estn cerca de un imn; Utilizado por las
alarmas antirrobo para detectar cuando se abre una ventana

Interruptores de alfombra
Pequeas esteras que se pueden colocar debajo de una alfombra o un felpudo para
detectar la presencia de un ser humano (o gato pesado)

Interruptores de inclinacin

Un componente electrnico simple que contiene dos contactos y una pequea


bola de metal (o una gota de mercurio, pero no recomiendo usarlos) Un ejemplo
de un interruptor de inclinacin se llama un sensor de inclinacin. La figura 5-1
muestra el interior de un modelo tpico. Cuando el sensor est en su posicin
vertical, la bola puentea los dos contactos, y esto funciona como si hubiera
presionado un botn. Cuando inclina este sensor, la pelota se mueve y el contacto
se abre, lo cual es como si hubiese soltado un pulsador. Utilizando este
componente simple, puede implementar, por ejemplo, interfaces gestuales que
reaccionan cuando un objeto se mueve o se sacude.
Figura 5-1.
El interior de un sensor de inclinacin

Otro sensor que quizs quiera probar es el sensor de infrarrojos que se encuentra
en las alarmas antirrobo (tambin conocido como sensor infrarrojo pasivo o sensor
PIR, vea la Figura 5-2). Este pequeo dispositivo se activa cuando un ser humano (u
otro ser vivo) se mueve dentro de su proximidad. Es una forma sencilla de detectar
movimiento.
Figura 5-2.
Sensor PIR tpico

Ahora debe experimentar mirando todos los dispositivos posibles que tienen dos
contactos que se cierran, como el termostato que fija la temperatura de la
habitacin (use una vieja que ya no est conectada), o simplemente colocando dos
contactos uno al lado del otro y dejando caer agua sobre ellos.

Por ejemplo, usando el ejemplo final del Captulo 4 y un sensor PIR, usted podra
hacer que su lmpara respondiera a la presencia de seres humanos, o podra usar
un interruptor de inclinacin para construir uno que se apague cuando est
inclinado en un lado.
Control de luz con PWM
Con el conocimiento que usted ha ganado hasta ahora, podra construir una
lmpara interactiva que puede ser controlada y no slo con un aburrido
interruptor de encendido / apagado, pero tal vez de una manera que es un poco
ms elegante. Una de las limitaciones de los ejemplos de LED parpadeantes que
hemos utilizado hasta ahora es que slo se puede encender y apagar la luz. Una
lmpara interactiva de fantasa necesita ser regulable. Para resolver este problema,
podemos usar un pequeo truco que hace posible muchas cosas como TV o cine:
la persistencia de la visin.

Como he sugerido despus del primer ejemplo en el captulo 4, si cambia los


nmeros en la funcin de retardo hasta que no vea el LED parpadeando ms,
notar que el LED parece atenuado al 50% de su brillo normal. Ahora cambie los
nmeros para que el LED est encendido es un cuarto del tiempo que est
apagado. Ejecute el boceto y ver que el brillo es aproximadamente el 25%. Esta
tcnica se llama modulacin de ancho de pulso (PWM), una manera elegante de
decir que si parpadea el LED lo suficientemente rpido, no lo ve parpadear ms,
pero puede cambiar su brillo cambiando la relacin entre el tiempo de encendido y
El tiempo de apagado. La Figura 5-3 muestra cmo funciona esto.

Esta tcnica tambin funciona con dispositivos que no sean un LED. Por ejemplo,
puede cambiar la velocidad de un motor de la misma manera.

Mientras experimenta, ver que parpadear el LED poniendo retrasos en su cdigo


es un poco incmodo, porque tan pronto como quiera leer un sensor o enviar
datos en el puerto serie, el LED parpadear mientras espera que termine Lectura
del sensor. Por suerte, el procesador utilizado por la placa Arduino tiene un pedazo
de hardware que puede parpadear muy eficientemente tres LED mientras su
boceto hace otra cosa. Este hardware est implementado en los pines 9, 10 y 11,
que pueden ser controlados por la instruccin analogWrite ().
Figura 5-3.
PWM en accin.

Por ejemplo, escribir analogWrite(9,128) Ajustar el brillo de un LED conectado al


pin 9 al 50%. Por qu 128? AnalogWrite () espera un nmero entre 0 y 255 como
argumento, donde 255 significa brillo completo y 0 significa apagado.

Nota: Tener tres canales es muy bueno, porque si usted compra LeDs rojo, verde y
azul, usted puede mezclar sus luces y hacer la luz de cualquier color que te gusta!

Vamos a probarlo. Construye el circuito que ves en la Figura 5-4. Tenga en cuenta
que los LED estn polarizados: el pasador largo (positivo) debe ir a la derecha y el
pasador corto (negativo) a la izquierda. Adems, la mayora de los LED tienen un
lado negativo aplanado, como se muestra en la figura.
Figura 5-4.
LED conectado al pin PWM.

A continuacin, cree un nuevo boceto en Arduino y utilice el Ejemplo 04 (tambin


puede descargar ejemplos de cdigo de www.makezine.com/getstartedarduino):

// Example 04: Fade an LED in and out like on


// a sleeping Apple computer

#define LED 9 // the pin for the LED


int i = 0; // Well use this to count up and down

void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output }

void loop(){

for (i = 0; i < 255; i++) { // loop from 0 to 254 (fade in) analogWrite(LED, i); // set
the LED brightness delay(10); // Wait 10ms because analogWrite // is
instantaneous and we would
// not see any change }

for (i = 255; i > 0; i--) { // loop from 255 to 1 (fade out)

analogWrite(LED, i); // set the LED brightness delay(10); //


Wait 10ms }

Ahora usted tiene una copia de una caracterstica de fantasa de una computadora
porttil (tal vez es un poco de un desperdicio para utilizar Arduino para algo tan
simple). Vamos a usar este conocimiento para mejorar nuestra lmpara.

Aada el circuito que usamos para leer un botn (en el Captulo 4) a esta tabla de
pruebas. Vea si puede hacer esto sin mirar la siguiente pgina, porque quiero que
comience a pensar en el hecho de que cada circuito elemental que muestro aqu es
un "bloque de construccin" para hacer proyectos ms grandes y ms grandes. Si
necesita mirar hacia el futuro, no se preocupe; Lo ms importante es que pases un
tiempo pensando en cmo podra verse.
Para crear este circuito, tendr que combinar el circuito recin construido
(mostrado en la Figura 5-4) con el circuito de pulsador mostrado en la Figura 4-6. Si
lo desea, puede simplemente construir ambos circuitos en diferentes partes de la
placa de pruebas; Tienes un montn de espacio. Sin embargo, una de las ventajas
de la placa de pruebas (vase el apndice A) es que hay un par de rieles que se
extienden horizontalmente a travs de la parte inferior y superior. Uno est
marcado rojo (para positivo) y el otro azul o negro (para el suelo).

Estos rieles se utilizan para distribuir la energa y la tierra a donde se necesita. En el


caso del circuito que necesita construir para este ejemplo, tiene dos componentes
(ambos resistores) que deben conectarse al pin GND (tierra) del Arduino. Debido a
que el Arduino tiene dos pines GND, simplemente podra conectar estos dos
circuitos exactamente como se muestra en cada una de las dos figuras; Slo
enganchar a los dos hasta el Arduino al mismo tiempo. O bien, podra conectar un
cable del carril de tierra de la placa de panificacin a uno de los pines GND del
Arduino y, a continuacin, tomar los cables que estn conectados a GND en las
figuras y conectarlos al carril de tierra de la placa de paneles.

Si no est listo para probar esto, no se preocupe: simplemente conecte ambos


circuitos a su Arduino como se muestra en las Figuras 4-6 y 5-4. Ver un ejemplo
que usa los carriles de tabla de pruebas de tierra y positivo en el Captulo 6.

Volviendo al siguiente ejemplo, si solo tenemos un pulsador, cmo controlamos el


brillo de una lmpara? Vamos a aprender otra tcnica de diseo de interaccin:
detectar cunto tiempo se ha presionado un botn. Para hacer esto, necesito
actualizar el ejemplo 03C del captulo 4 para agregar atenuacin. La idea es
construir una "interfaz" en la que una accin de prensa y liberacin encienda y
apague la luz, y una accin de presionar y mantener cambia el brillo.

Echemos un vistazo al bosquejo:


// Example 05: Turn on LED when the button is pressed
// and keep it on after it is released // including simple
de-bouncing.
// If the button is held, brightness changes.

#define LED 9 // the pin for the LED #define BUTTON 7 // input
pin of the pushbutton

int val = 0; // stores the state of the input pin

int old_val = 0; // stores the previous value of "val" int state = 0; // 0 = LED off while
1 = LED on

int brightness = 128; // Stores the brightness value unsigned long startTime = 0; // when did we
begin pressing?

void setup() {
pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON,
INPUT); // and BUTTON is an input }

void loop() {
val = digitalRead(BUTTON); // read input value and store it // yum,
fresh

// check if there was a transition if ((val == HIGH) &&


(old_val == LOW)) {
state = 1 - state; // change the state from off to on // or vice-versa

startTime = millis(); // millis() is the Arduino clock // it returns how


many milliseconds
// have passed since the board has // been reset.

// (this line remembers when the button // was last pressed)


delay(10);
}
// check whether the button is being held down if ((val == HIGH) &&
(old_val == HIGH)) {

// If the button is held for more than 500ms. if (state == 1 && (millis() -
startTime) > 500) {

brightness++; // increment brightness by 1 delay(10); // delay to avoid


brightness going // up too fast

if (brightness > 255) { // 255 is the max brightness

brightness = 0; // if we go over 255 // lets go


back to 0
}
} }

old_val = val; // val is now old, lets store it

if (state == 1) {
analogWrite(LED, brightness); // turn LED ON at the //
current brightness level } else {
analogWrite(LED, 0); // turn LED OFF }
}

Ahora intntalo. Como puede ver, nuestro modelo de interaccin est tomando
forma. Si presiona el botn y lo suelta inmediatamente, se enciende o apaga la
lmpara. Si mantiene pulsado el botn, el brillo cambia; Slo deje ir cuando haya
alcanzado el brillo deseado.

Ahora vamos a aprender a usar algunos sensores ms interesantes.

Utilice un sensor de luz en lugar del pulsador


Ahora vamos a intentar un experimento interesante. Tome un sensor de luz, como
el que se muestra en la figura 5-5. Usted puede obtener un paquete de cinco de
estos de RadioShack (nmero de parte 276-1657).
Figura 5-5.
Resistencia dependiente de la luz (LDR).

En la oscuridad, la resistencia de una resistencia dependiente de la luz (LDR) es


bastante alta. Cuando usted brilla algo de luz en ella, la resistencia rpidamente
cae y se convierte en un conductor razonablemente bueno de la electricidad. Por
lo tanto, es una especie de interruptor activado por luz.

Construya el circuito que viene con el Ejemplo 02 (vea "Uso de un botn pulsador
para controlar el LED" en el Captulo 4), luego cargue el cdigo del Ejemplo 02 en
su Arduino.

Ahora conecte el LDR en la placa de pan en lugar del botn. Usted notar que si
usted cubre el LDR con sus manos, el LED se apaga. Descubre el LDR, y la luz
contina. Acabas de construir tu primer sensor LED impulsado por sensores. Esto
es importante porque, por primera vez en este libro, estamos utilizando un
componente electrnico que no es un simple dispositivo mecnico: es un sensor
real rico.
Entrada analgica
Como aprendi en la seccin anterior, Arduino es capaz de detectar si hay un
voltaje aplicado a uno de sus pines e informarlo a travs de la funcin
digitalRead() . Este tipo de respuesta est bien en muchas aplicaciones, pero el
sensor de luz que acabamos de usar es capaz de decirnos no slo si hay luz, sino
tambin cunta luz hay. Esta es la diferencia entre un sensor de encendido /
apagado (que nos dice si hay algo) y un sensor analgico, cuyo valor cambia
continuamente. Para leer este tipo de sensor, necesitamos un tipo de pin
diferente.

En la parte inferior derecha de la placa Arduino, vers seis pasadores marcados


con "Analog In"; Estos son pernos especiales que pueden decirnos no slo si hay
un voltaje aplicado a ellos, pero si es as, tambin su valor. Usando la funcin
analogRead() , podemos leer el voltaje aplicado a uno de los pines. Esta funcin
devuelve un nmero entre 0 y 1023, que representa voltajes entre 0 y 5 voltios.
Por ejemplo, si hay una tensin de 2,5 V aplicada al nmero de pin 0, analogRead
(0) devuelve 512.

Si ahora construye el circuito que ve en la Figura 5-6, usando una resistencia de


10k, y ejecute el cdigo listado en el Ejemplo 06A, ver el LED integrado (tambin
podra insertar su propio LED en los pines 13 y GND como Que se muestra en
"Parpadeando un LED" en el Captulo 4) parpadeando a una velocidad que
depende de la cantidad de luz que golpea el sensor.
Figura 5-6.
Un circuito sensor analgico
// Example 06A: Blink LED at a rate specified by the
// value of the analogue input

#define LED 13 // the pin for the LED

int val = 0; // variable used to store the value // coming from the
sensor void setup() {
pinMode(LED, OUTPUT); // LED is as an OUTPUT

// Note: Analogue pins are


// automatically set as inputs }

void loop() {

val = analogRead(0); // read the value from // the


sensor

digitalWrite(13, HIGH); // turn the LED on

delay(val); // stop the program for // some time

digitalWrite(13, LOW); // turn the LED off

delay(val); // stop the program for // some time


}

Ahora, pruebe el Ejemplo 06B: pero antes de hacerlo, tendr que modificar su
circuito. Eche un vistazo a la Figura 5-4 y engancha el LED hasta el pin 9 como se
muestra. Debido a que ya tienes algunas cosas en la tabla de pruebas, necesitars
encontrar un punto en la placa de pruebas donde el LED, los cables y la resistencia
no se superpongan con el circuito LDR.
// Example 06B: Set the brightness of LED to
// a brightness specified by the
// value of the analogue input

#define LED 9 // the pin for the LED

int val = 0; // variable used to store the value // coming from the
sensor

void setup() {

pinMode(LED, OUTPUT); // LED is as an OUTPUT

// Note: Analogue pins are


// automatically set as inputs }

void loop() {

val = analogRead(0); // read the value from // the


sensor
analogWrite(LED, val/4); // turn the LED on at // the
brightness set
// by the sensor
delay(10); // stop the program for // some
time
}

Nota: especificamos el brillo dividiendo val por 4, porque analogRead () devuelve


un nmero hasta 1023, y analogWrite() acepta un mximo de 255.

Pruebe otros sensores analgicos


Utilizando el mismo circuito que ha visto en la seccin anterior, puede conectar
muchos otros sensores resistivos que funcionan de forma ms o menos igual. Por
ejemplo, podra conectar un termistor, que es un dispositivo simple cuya
resistencia cambia con la temperatura. En el circuito, le he mostrado cmo los
cambios en la resistencia se convierten en cambios en el voltaje que pueden ser
medidos por Arduino.

Si trabaja con un termistor, tenga en cuenta que no existe una conexin directa
entre el valor que lee y la temperatura real medida. Si necesita una lectura exacta,
debe leer los nmeros que salen del pin analgico mientras se mide con un
termmetro real. Usted podra poner estos nmeros uno al lado del otro en una
tabla y elaborar una manera de calibrar los resultados analgicos a las
temperaturas del mundo real.

Hasta ahora, hemos utilizado un LED como dispositivo de salida, pero cmo
podemos leer los valores reales que Arduino est leyendo desde el sensor? No
podemos hacer que la pizarra parpadee los valores en cdigo Morse (bueno,
podramos, pero hay una manera ms fcil para que los humanos lean los valores).
Para ello, podemos hacer que Arduino hable con un ordenador a travs de un
puerto serie, que se describe en la siguiente seccin.

Comunicacin serial
Usted aprendi al principio de este libro que Arduino tiene una conexin USB que
es utilizada por el IDE para cargar cdigo en el procesador. La buena noticia es que
esta conexin tambin puede ser utilizada por los bocetos que escribimos en
Arduino para enviar datos de vuelta al ordenador o para recibir comandos de l.
Para este propsito, vamos a utilizar un objeto en serie (un objeto es una coleccin
de capacidades que se agrupan para la conveniencia de las personas que escriben
bocetos).

Este objeto contiene todo el cdigo que necesitamos para enviar y recibir datos.
Ahora vamos a usar el ltimo circuito que construimos con la fotorresistor y
enviamos los valores que se vuelven a leer en la computadora. Escriba este cdigo
en un nuevo boceto (tambin puede descargar el cdigo de www.makezine.com/
getstartedarduino):
// Example 07: Send to the computer the values read from
// analogue input 0
// Make sure you click on "Serial Monitor"
// after you upload

#define SENSOR 0 // select the input pin for the


// sensor resistor

int val = 0; // variable to store the value coming // from the sensor

void setup() {

Serial.begin(9600); // open the serial port to send


// data back to the computer at
// 9600 bits per second }

void loop() {

val = analogRead(SENSOR); // read the value from // the


sensor

Serial.println(val); // print the value to // the serial


port

delay(100); // wait 100ms between // each


send
}

Despus de subir el cdigo a su Arduino, presione el botn "Serial Monitor" en el


Arduino IDE (el botn ms a la derecha en la barra de herramientas); Usted ver
los nmeros que ruedan ms all en la parte inferior de la ventana. Ahora,
cualquier software que pueda leer desde el puerto serie puede hablar con Arduino.
Hay muchos lenguajes de programacin que le permiten escribir programas en su
computadora que pueden hablar con el puerto serie. Processing
(www.processing.org) es un gran complemento para Arduino, porque los lenguajes
y IDEs son tan similaresr.
Conduccin de cargas ms grandes (Motores, lmparas y
Similares)
Cada uno de los pines de una placa Arduino puede utilizarse para alimentar
dispositivos que utilizan hasta 20 miliamperios: se trata de una cantidad muy
pequea de corriente, lo suficiente para conducir un LED. Si usted intenta conducir
algo como un motor, el perno dejar de funcionar inmediatamente, y podra
quemar potencialmente el procesador entero. Para impulsar cargas ms grandes
como motores o lmparas incandescentes, necesitamos utilizar un componente
externo que pueda activar y desactivar tales cosas y que sea accionado por un pin
Arduino. Un dispositivo de este tipo se llama un transistor MOSFET-ignorar el
nombre divertido-es un interruptor electrnico que puede ser impulsado mediante
la aplicacin de un voltaje a uno de sus tres pines, cada uno de los cuales se llama
una puerta. Es algo as como el interruptor de luz que usamos en casa, donde la
accin de un dedo que enciende y apaga la luz es reemplazada por un pin en la
tarjeta Arduino enviando voltaje a la puerta del MOSFET.

Nota: MOSFET significa "metal-xido-semiconductor transistor de efecto de


campo". Es un tipo especial de transistor que opera basado en el principio de
efecto de campo. Esto significa que la electricidad fluir a travs de una pieza de
material semiconductor (entre los pines de drenaje y fuente) cuando se aplica un
voltaje al pasador de puerta. Como la puerta est aislada del resto a travs de
una capa de xido metlico, no hay corriente que fluye de Arduino en el MOSFET,
por lo que es muy fcil de interfaz. Son ideales para encender y apagar grandes
cargas a altas frecuencias.

En la Figura 5-7, puede ver cmo usara un MOSFET como el IRF520 para encender
y apagar un pequeo motor conectado a un ventilador. Usted tambin notar que
el motor toma su fuente de alimentacin desde el conector de 9 V de la tarjeta
Arduino. Este es otro beneficio del MOSFET: nos permite conducir dispositivos cuya
fuente de alimentacin difiere de la utilizada por Arduino. Como el MOSFET est
conectado al pin 9, tambin podemos usar analogWrite () para controlar la
velocidad del motor a travs de PWM.

Sensores Complejos
Definimos sensores complejos como aquellos que producen un tipo de
informacin que requiere un poco ms de un digitalRead() o una funcin
analogRead() para ser usada. Estos suelen ser pequeos circuitos con un pequeo
microcontrolador dentro que preprocesa la informacin.

Algunos de los sensores complejos disponibles incluyen guardabosques


ultrasnicos, guardabosques infrarrojos y acelermetro. Puede encontrar ejemplos
sobre cmo utilizarlos en nuestro sitio web en la seccin "Tutoriales"
(www.arduino.cc/en/ Tutorial / HomePage).

Tom Igoe's Making Things Talk (O'Reilly) tiene amplia cobertura de estos sensores y
muchos otros sensores complejos.
Figura 5-7.
Un circuito de motor para Arduino
6/ Hablando con la nube

En los captulos anteriores, aprendiste los


fundamentos de Arduino y los bloques de
construccin fundamentales disponibles para ti.
Permtanme recordarles lo que constituye el
"Alfabeto Arduino":
Salida digital
Lo usamos para controlar un LED pero, con el circuito apropiado, puede ser usado
para controlar motores, hacer sonidos, y mucho ms.
Salida analgica
Esto nos da la capacidad de controlar el brillo del LED, no slo encenderlo o
apagarlo. Incluso podemos controlar la velocidad de un motor con l.
Entrada digital
Esto nos permite leer el estado de sensores simples, como pulsadores o
interruptores de inclinacin.
Entrada analogica
Podemos leer las seales de los sensores que envan una seal continua que no slo
est encendida o apagada, como un potencimetro o un sensor de luz.
Comunicacin serial
Esto nos permite comunicarnos con una computadora e intercambiar datos o
simplemente supervisar lo que est pasando con el boceto que se est ejecutando
en el Arduino.
En este captulo, vamos a ver cmo elaborar una aplicacin de trabajo utilizando lo
aprendido en los captulos anteriores. Este captulo debe mostrar cmo cada
ejemplo puede ser utilizado como un bloque de construccin para un proyecto
complejo.
Aqu es donde el diseador de wannabe en m sale. Vamos a hacer la versin del
siglo XXI de una lmpara clsica de mi diseador italiano favorito, Joe Colombo. El
objeto que vamos a construir est inspirado en una lmpara llamada "Aton" de
1964.
Figura 6-1.
La lmpara terminada

La lmpara, como se puede ver en la figura 6-1, es una esfera sencilla sentada en
una base con un gran agujero para evitar que la esfera ruede de su escritorio. Este
diseo le permite orientar la lmpara en diferentes direcciones.

En trminos de funcionalidad, queremos construir un dispositivo que se conecte a


Internet, buscar la lista actual de artculos en el blog Make (makezine.com) y
contar cuntas veces las palabras "peace", "love", " Y "Arduino". Con estos
valores, vamos a generar un color y mostrarlo en la lmpara. La propia lmpara
tiene un botn que podemos usar para encenderlo y apagarlo, y un sensor de luz
para la activacin automtica.

Planificacin
Echemos un vistazo a lo que queremos lograr y qu trozos y piezas necesitamos.
En primer lugar, necesitamos que Arduino sea capaz de conectarse a Internet.
Como la placa Arduino tiene slo un puerto USB, no podemos conectarlo
directamente a una conexin a Internet, as que necesitamos averiguar cmo
conectar los dos. Por lo general, lo que la gente hace es ejecutar una aplicacin en
una computadora que se conecte a Internet, procese los datos y enve a Arduino un
poco de informacin destilada.
Arduino es una computadora sencilla con una pequea memoria; No puede
procesar archivos grandes fcilmente, y cuando nos conectamos a un feed RSS,
obtendremos un archivo XML muy detallado que requerira mucho ms memoria
RAM. Implementaremos un proxy para simplificar el XML usando el lenguaje de
procesamiento.

Procesamiento
El procesamiento es el origen de Arduino. Nos encanta este lenguaje y lo usamos
para ensear programacin a principiantes, as como para crear cdigo hermoso.
Procesamiento y Arduino son la combinacin perfecta. Otra ventaja es que
Processing es de cdigo abierto y se ejecuta en todas las plataformas principales
(Mac, Linux y Windows). Tambin puede generar aplicaciones independientes que
se ejecutan en esas plataformas. Lo que es ms, la comunidad de procesamiento es
animada y til, y usted puede encontrar miles de programas de ejemplo premade.
El proxy hace el siguiente trabajo para nosotros: descarga el feed RSS de
makezine.com y extrae todas las palabras del archivo XML resultante. Luego,
pasando por todos ellos, cuenta el nmero de veces que "paz", "amor" y "Arduino"
aparecen en el texto. Con estos tres nmeros, calcularemos un valor de color y lo
enviaremos a Arduino. El tablero enviar de vuelta la cantidad de luz medida por el
sensor y lo mostrar en la pantalla del ordenador.
En el lado del hardware, combinaremos el ejemplo del pulsador, el ejemplo del
sensor de luz, el control del LED PWM (multiplicado por 3!) Y la comunicacin
serial.
Como Arduino es un dispositivo simple, tendremos que codificar el color de una
manera sencilla. Usaremos la forma estndar en la que los colores se representan
en HTML: # seguido de seis dgitos hexadecimales.
Los nmeros hexadecimales son tiles, porque cada nmero de 8 bits se almacena
en exactamente dos caracteres; Con nmeros decimales vara de uno a tres
caracteres. La previsibilidad tambin hace que el cdigo sea ms sencillo:
esperamos hasta que veamos un #, luego leemos los seis caracteres que siguen en
un buffer (una variable que se usa como rea de espera temporal para los datos).
Por ltimo, convierte cada grupo de dos caracteres en un byte que representa el
brillo de uno de los tres LED.

Codificacin
Hay dos bocetos que se ejecutarn: un boceto de procesamiento y un boceto de
Arduino. Aqu est el cdigo para el boceto de Procesamiento. Puede descargarlo
desde www.makezine.com/getstartedarduino.
// Example 08A: Arduino networked lamp
// parts of the code are inspired // by a blog post by Tod E. Kurt
(todbot.com)

import processing.serial.*; String feed =

"http://blog.makezine.com/index.xml";

int interval = 10; // retrieve feed every 60 seconds; int lastTime; // the last time we
fetched the content

int love = 0; int peace =


0; int arduino = 0;

int light = 0; // light level measured by the lamp

Serial port; color c; String cs; String buffer = ""; // Accumulates characters coming from Arduino

PFont font;

void setup() { size(640,480);


frameRate(10); // we don't need fast updates

font = loadFont("HelveticaNeue-Bold-32.vlw"); fill(255);


textFont(font, 32);
// IMPORTANT NOTE:
// The first serial port retrieved by Serial.list()
// should be your Arduino. If not, uncomment the next
// line by deleting the // before it, and re-run the
// sketch to see a list of serial ports. Then, change
// the 0 in between [ and ] to the number of the port // that your Arduino is
connected to.
//println(Serial.list()); String arduinoPort = Serial.list()
[0];
port = new Serial(this, arduinoPort, 9600); // connect to Arduino

lastTime = 0;
fetchData(); }

void draw() { background( c );


int n = (interval - ((millis()-lastTime)/1000));

// Build a colour based on the 3 values c = color(peace, love,


arduino);
cs = "#" + hex(c,6); // Prepare a string to be sent to Arduino

text("Arduino Networked Lamp", 10,40); text("Reading


feed:", 10, 100); text(feed, 10, 140);

text("Next update in "+ n + " seconds",10,450); text("peace" ,10,200);


text(" " + peace, 130, 200); rect(200,172, peace, 28);

text("love ",10,240); text(" " + love, 130,


240); rect(200,212, love, 28);

text("arduino ",10,280); text(" " + arduino,


130, 280); rect(200,252, arduino, 28);

// write the colour string to the screen text("sending", 10,


340); text(cs, 200,340);
text("light level", 10, 380);
rect(200, 352,light/10.23,28); // this turns 1023 into 100

if (n <= 0) { fetchData();
lastTime = millis(); }

port.write(cs); // send data to Arduino

if (port.available() > 0) { // check if there is data waiting int inByte = port.read(); // read
one byte if (inByte != 10) { // if byte is not newline
buffer = buffer + char(inByte); // just add it to the buffer } else {

// newline reached, let's process the data


if (buffer.length() > 1) { // make sure there is enough data

// chop off the last character, it's a carriage return


// (a carriage return is the character at the end of a // line of text)
buffer = buffer.substring(0,buffer.length() -1);
// turn the buffer from string into an integer number light = int(buffer);

// clean the buffer for the next read cycle buffer = "";

// We're likely falling behind in taking readings


// from Arduino. So let's clear the backlog of
// incoming sensor readings so the next reading is // up-to-date.
port.clear(); }
}
}

}
void fetchData() { // we use these strings to parse the feed
String data;
String chunk;

// zero the counters love = 0; peace = 0; arduino = 0; try { URL url = new
URL(feed); // An object to represent the URL
// prepare a connection URLConnection conn =
url.openConnection(); conn.connect(); // now connect to the Website

// this is a bit of virtual plumbing as we connect


// the data coming from the connection to a buffered // reader that reads the data
one line at a time.
BufferedReader in = new
BufferedReader(new InputStreamReader(conn.getInputStream()));

// read each line from the feed while ((data = in.readLine()) !


= null) {

StringTokenizer st =
new StringTokenizer(data,"\"<>,.()[] ");// break it down while (st.hasMoreTokens()) {
// each chunk of data is made lowercase chunk= st.nextToken().toLowerCase() ;

if (chunk.indexOf("love") >= 0 ) // found "love"?


love++; // increment love by 1 if (chunk.indexOf("peace") >= 0) // found
"peace"?
peace++; // increment peace by 1 if (chunk.indexOf("arduino") >= 0) // found
"arduino"?
arduino++; // increment arduino by 1 }
}

// Set 64 to be the maximum number of references we care about.


if (peace > 64) peace = 64; if (love > 64)
love = 64; if (arduino > 64) arduino = 64;
peace = peace * 4; // multiply by 4 so that the max is 255, love = love * 4; // which comes
in handy when building a arduino = arduino * 4; // colour that is made of 4 bytes (ARGB) }
catch (Exception ex) { // If there was an error, stop the sketch ex.printStackTrace();
System.out.println("ERROR: "+ex.getMessage());
}

Hay dos cosas que debe hacer antes de que el boceto de procesamiento se ejecute
correctamente. En primer lugar, debe indicar a Processing que genere la fuente que
estamos utilizando para el boceto. Para ello, cree y guarde este boceto. A
continuacin, con el boceto an abierto, haga clic en el men Herramientas de
procesamiento y, a continuacin, seleccione Crear fuente. Seleccione la fuente
HelveticaNeue-Bold, elija 32 para el tamao de fuente y, a continuacin, haga clic
en Aceptar.

En segundo lugar, necesitar confirmar que el croquis utiliza el puerto serie


correcto para hablar con Arduino. Tendr que esperar hasta que haya montado el
circuito de Arduino y haya cargado el boceto de Arduino antes de confirmarlo. En la
mayora de los sistemas, este boceto de procesamiento funcionar correctamente.
Sin embargo, si no ve nada que ocurra en el Arduino y no vea ninguna informacin
del sensor de luz que aparece en pantalla, busque el comentario etiquetado "NOTA
IMPORTANTE" en el bosquejo Procesamiento y siga las instrucciones all.

Aqu est el bosquejo de Arduino (tambin disponible en www.makezine.com/


getstartedarduino):
// Example 08B: Arduino Networked Lamp
#define SENSOR 0
#define R_LED 9
#define G_LED 10
#define B_LED 11 #define
BUTTON 12

int val = 0; // variable to store the value coming from the sensor

int btn = LOW; int old_btn


= LOW; int state = 0; char
buffer[7] ; int pointer = 0;
byte inByte = 0;

byte r = 0; byte g = 0;
byte b = 0;

void setup() { Serial.begin(9600); // open the serial port


pinMode(BUTTON, INPUT); }

void loop() {
val = analogRead(SENSOR); // read the value from the sensor Serial.println(val); //
print the value to // the serial port

if (Serial.available() >0) {

// read the incoming byte: inByte = Serial.read();

// If the marker's found, next 6 characters are the colour if (inByte == '#') {

while (pointer < 6) { // accumulate 6 chars


buffer[pointer] = Serial.read(); // store in the buffer pointer++; // move the pointer forward
by 1
}
// now we have the 3 numbers stored as hex numbers // we need to decode
them into 3 bytes r, g and b r = hex2dec(buffer[1]) + hex2dec(buffer[0]) * 16;
g = hex2dec(buffer[3]) + hex2dec(buffer[2]) * 16; b = hex2dec(buffer[5]) +
hex2dec(buffer[4]) * 16;
pointer = 0; // reset the pointer so we can reuse the buffer
} }

btn = digitalRead(BUTTON); // read input value and store it

// Check if there was a transition if ((btn == HIGH) &&


(old_btn == LOW)){ state = 1 - state; }

old_btn = btn; // val is now old, let's store it

if (state == 1) { // if the lamp is on


analogWrite(R_LED, r); // turn the leds on analogWrite(G_LED,
g); // at the colour analogWrite(B_LED, b); // sent by the computer }
else {

analogWrite(R_LED, 0); // otherwise turn off analogWrite(G_LED,


0); analogWrite(B_LED, 0); }
delay(100); // wait 100ms between each send }

int hex2dec(byte c) { // converts one HEX character into a number if (c >= '0' && c <= '9') {
return c - '0'; } else if (c >= 'A' && c <= 'F') { return c - 'A' + 10; }
}
Montaje del Circuito
La figura 6-2 muestra cmo ensamblar el circuito. Es necesario usar resistores de
10K para todas las resistencias que se muestran en el diagrama, aunque se podra
escapar con valores ms bajos para las resistencias conectadas a los LEDs.

Recuerde en el ejemplo PWM en el captulo 5 que los LED estn polarizados: en


este circuito, el pasador largo (positivo) debe ir a la derecha y el pasador corto
(negativo) a la izquierda. (La mayora de los LED tienen un lado negativo aplanado,
como se muestra en la figura).

Figura 6-2.
The Arduino Networked Lamp circuit
Construya el circuito como se muestra, usando un LED rojo, verde y azul. A
continuacin, cargue los bocetos en Arduino y Processing, luego ejecute los
bocetos y prubelo. Si tiene algn problema, consulte el Captulo 7, "Solucin de
problemas".

Ahora vamos a completar la construccin mediante la colocacin de la placa de


pan en una esfera de vidrio. La forma ms sencilla y barata de hacerlo es comprar
una lmpara de mesa IKEA "FADO". Ahora est vendiendo por cerca de US $
14.99 / 14.99 / 8.99 (ahh, el lujo de ser europeo).

En lugar de utilizar tres LED separados, puede utilizar un solo LED RGB, que tiene
cuatro cables que salen de l. Usted lo conectar de la misma manera que los LEDs
mostrados en la Figura 6-2, con un cambio: en lugar de tres conexiones separadas
a la clavija de tierra en Arduino, tendr un solo cable (llamado "ctodo comn" ")
Va a la tierra.

SparkFun vende un LED RGB de 4 conductores por unos pocos dlares


(www.sparkfun.com, nmero de pieza COM-00105). Adems, a diferencia de los
LED monocromos discretos, el cable ms largo en este LED RGB es el que va a
tierra. Los tres cables ms cortos tendrn que conectarse a los pines 9, 10 y 11
de Arduino (con una resistencia entre los cables y los pines, al igual que con los
LEDs rojo, verde y azul separados).

Aqu es cmo montarlo:


Desembale la lmpara y retire el cable que va desde la parte inferior hacia la
lmpara. Ya no se tapa esto en la pared.

Correa el Arduino en un tablero de pan y caliente la plancha de pan en la parte


posterior de la lmpara.

Soldar los cables ms largos al LED RGB y pegarlo donde la bombilla sola ser.
Conecte los cables que vienen del LED a la placa de pruebas (donde se conect
antes de retirarla). Recuerde que slo necesitar una conexin a tierra si est
utilizando un LED RGB de 4 conductores.

O bien encontrar una buena pieza de madera con un agujero que se puede utilizar
como un soporte para la esfera o simplemente cortar la parte superior de la caja de
cartn que viene con la lmpara en aproximadamente 5cm (o 2 ") y hacer un
agujero con un dimetro que Cunega la lmpara Refuerce el interior de la caja de
cartn usando el pegamento caliente a lo largo de los bordes interiores, que har la
base ms estable.
Coloque la esfera en el soporte y sacar el cable USB de la parte superior y
conectarlo al ordenador.

Apague el cdigo de procesamiento, presione el botn de encendido / apagado y


observe que la lmpara cobra vida.

Como ejercicio, trate de agregar cdigo que encienda la lmpara cuando la


habitacin se oscurezca. Otras mejoras posibles son::

Agregue sensores de inclinacin para encender o apagar la lmpara girndola en


diferentes direcciones.

Agregue un pequeo sensor PIR para detectar cuando alguien est alrededor y
apguelo cuando no haya nadie para verlo.

Crear diferentes modos para que pueda obtener control manual del color o hacer
que se desvanecen a travs de muchos colores.

Piense en cosas diferentes, experimente y divirtase!


7/ Solucin de problemas
Llegar un momento en su experimentacin
cuando nada funcionar y usted tendr que
averiguar cmo arreglarlo. Solucin de problemas
y depuracin son las artes antiguas en las que hay
algunas reglas simples, pero la mayora de los
resultados se obtienen a travs de un montn de
trabajo.
Cuanto ms trabajes con la electrnica y Arduino, ms aprenders y ganars
experiencia, lo que en ltima instancia har que el proceso sea menos doloroso. No
se desanime por los problemas que usted encontrar - es todo ms fcil de lo que
parece al principio.

Como cada proyecto basado en Arduino se hace tanto de hardware como de


software, habr ms de un lugar para ver si algo sale mal. Mientras busca un error,
debe operar a lo largo de tres lneas:

Comprensin

Trate de entender lo ms posible cmo las partes que usted est usando el trabajo
y cmo se supone que deben contribuir al proyecto terminado. Este enfoque le
permitir disear alguna forma de probar cada componente por separado.

Simplificacin y segmentacin

Los antiguos romanos solan decir divide et impera: dividir y gobernar. Trate de
descomponer (mentalmente) el proyecto en sus componentes utilizando la
comprensin que tiene y averige dnde empieza y termina la responsabilidad de
cada componente.

Exclusin y certidumbre
Mientras investiga, pruebe cada componente por separado para que pueda estar
absolutamente seguro de que cada uno funciona por s mismo. Usted crear
gradualmente la confianza sobre qu partes del proyecto estn haciendo su trabajo
y cules son dudosas.

Depuracin es el trmino utilizado para describir este proceso aplicado al software.


La leyenda dice que fue utilizada por primera vez por Grace Hopper en la dcada de
1940, cuando las computadoras eran en su mayora electromecnicas, y una de
ellas dej de funcionar porque los insectos reales quedaron atrapados en los
mecanismos.

Muchos de los insectos de hoy en da ya no son fsicos: son virtuales e invisibles, al


menos en parte. Por lo tanto, requieren un proceso a veces largo y aburrido para
ser identificado.

Prueba de la Junta
Qu pasa si el primer ejemplo, "parpadea un LED", no funcion? No sera un
poco deprimente? Vamos a averiguar qu hacer.

Antes de empezar a culpar a su proyecto, debe asegurarse de que hay algunas


cosas en orden, como hacen los pilotos de lnea area cuando pasan por una lista
de comprobacin para asegurarse de que el avin estar volando correctamente
antes de despegar:

Enchufe su Arduino en un enchufe USB en su computadora.

Asegrese de que el equipo est encendido (s, suena tonto, pero ha sucedido).
Si la luz verde marcada PWR se enciende, significa que la computadora est
alimentando la tarjeta. Si el LED parece muy dbil, algo est mal con el poder:
pruebe con un cable USB diferente e inspeccione el puerto USB del ordenador
y el conector USB del Arduino para ver si hay algn dao. Si todo falla, pruebe
un puerto USB diferente en su computadora o un equipo diferente
completamente.

Si el Arduino es nuevo, el LED amarillo marcado L comenzar a parpadear en un


poco de un patrn nervioso; Este es el programa de prueba que se carg en la
fbrica para probar el tablero.
Si ha estado utilizando una fuente de alimentacin externa y est usando un
Arduino antiguo (Extreme, NG o Diecimila), asegrese de que la fuente de
alimentacin est conectada y de que el puente marcado SV1 est conectando
los dos pines ms cercanos al externo Conector de la fuente de alimentacin.

NOTA: Cuando tenga problemas con otros bocetos y necesite confirmar que el
tablero est funcionando, abra el primer ejemplo de "parpadeo de un LED" en el
IDE de Arduino y carguelo en la placa. El LED de a bordo debe parpadear en un
patrn regular.

Si ha superado todos estos pasos con xito, puede estar seguro de que su Arduino
funciona correctamente.

Prueba de su circuito de panificacin


Ahora conecte la placa a su tablero de pruebas mediante la ejecucin de un puente
de las conexiones de 5 V y GND a los carriles positivos y negativos de la placa de
pruebas. Si el LED verde PWR se apaga, retire los cables inmediatamente. Esto
significa que hay un gran error en su circuito y usted tiene un "cortocircuito" en
alguna parte. Cuando esto sucede, su tablero dibuja demasiada corriente y la
energa consigue cortada para proteger la computadora.

NOTA: Si le preocupa que pueda daar su computadora, recuerde que en muchas


computadoras, la proteccin actual es generalmente bastante buena y responde
rpidamente. Adems, la tarjeta Arduino est equipada con un "PolyFuse", un
dispositivo de proteccin de corriente que se restablece cuando se elimina el
fallo.

Si eres realmente paranoico, siempre puedes conectar la placa Arduino a travs


de un concentrador USB autoalimentado. En este caso, si todo va horriblemente
mal, el concentrador USB es el que va a empujar las margaritas, no su
computadora.

Si tiene un cortocircuito, tiene que iniciar el proceso de "simplificacin y


segmentacin". Lo que debe hacer es pasar por cada sensor en el proyecto y
conectar slo uno a la vez.
La primera cosa a partir de es siempre la fuente de alimentacin (las conexiones de
5 V y GND). Mire a su alrededor y asegrese de que cada parte del circuito se
alimenta correctamente.

Trabajar paso a paso y hacer una sola modificacin a la vez es la regla nmero uno
para arreglar cosas. Esta regla fue martillada en mi joven cabeza por mi profesor de
la escuela y primer empleador, Maurizio Pirola. Cada vez que estoy depurando algo
y las cosas no se ven bien (y cranme, sucede mucho), su cara aparece en mi
cabeza diciendo "una modificacin a la vez. . . Una modificacin a la vez "y que
suele ser cuando lo arreglo todo. Esto es muy importante, porque sabrs lo que
arregl el problema (es muy fcil perder la pista de qu modificacin realmente
resolvi el problema, por lo que es tan importante hacer uno a la vez).

Cada experiencia de depuracin acumular en su cabeza una "base de


conocimiento" de defectos y posibles correcciones. Y antes de que lo sepa, se
convertir en un experto. Esto te har ver muy bien, porque tan pronto como un
novato dice "Esto no funciona!" Le dar una mirada rpida y tener la respuesta en
una fraccin de segundo.

Problemas de aislamiento
Otra regla importante es encontrar una manera confiable de reproducir un
problema. Si su circuito se comporta de manera divertida en momentos
aleatorios, intente realmente averiguar el momento exacto en que ocurre el
problema y lo que lo causa. Este proceso le permitir pensar sobre una posible
causa. Tambin es muy til cuando necesitas explicar a alguien lo que est
pasando.

Describir el problema con la mayor precisin posible tambin es una buena manera
de encontrar una solucin. Trate de encontrar a alguien para explicar el problema-
en muchos casos, una solucin aparecer en su cabeza mientras articula el
problema. Brian W. Kernighan y Rob Pike, en The Practice of Programming
(Addison-Wesley, 1999), cuentan la historia de una universidad que "guardaba un
oso de peluche cerca del mostrador de ayuda. Los estudiantes con bichos
misteriosos tenan que explicarles al oso antes de que pudieran hablar con un
consejero humano..

Problemas con el IDE


En algunos casos, es posible que tenga un problema al utilizar el IDE de Arduino, en
particular en Windows.
Si aparece un error al hacer doble clic en el icono de Arduino, o si no ocurre nada,
haga doble clic en el archivo run.bat como mtodo alternativo para iniciar Arduino.

Los usuarios de Windows tambin pueden encontrarse con un problema si el


sistema operativo asigna un nmero de puerto COM de COM10 o superior a
Arduino. Si esto sucede, normalmente puede convencer a Windows para asignar
un nmero de puerto inferior a Arduino. En primer lugar, abra el Administrador de
dispositivos haciendo clic en el men Inicio, haga clic con el botn secundario en
Equipo (Vista) o Mi PC (XP) y seleccione Propiedades. En Windows XP, haga clic en
Hardware y elija Administrador de dispositivos. En Vista, haga clic en Administrador
de dispositivos (aparece en la lista de tareas a la izquierda de la ventana).

Busque los dispositivos serie en la lista bajo "Puertos (COM & LPT)". Busque un
dispositivo serie que no est usando que est numerado como COM9 o inferior.
Haga clic con el botn derecho en l y elija Propiedades en el men. A
continuacin, elija la ficha Configuracin del puerto y haga clic en Avanzado.
Establezca el nmero de puerto COM a COM10 o superior, haga clic en Aceptar y
vuelva a hacer clic en Aceptar para cerrar el cuadro de dilogo Propiedades.

Ahora, haga lo mismo con el dispositivo USB Serial Port que representa Arduino,
con un cambio: asigne el nmero de puerto COM (COM9 o inferior) que acaba de
liberar.

Si estas sugerencias no ayudan, o si tiene un problema que no se describe aqu,


consulte la pgina de solucin de problemas de Arduino en www.arduino.cc/es/
Gua / Solucin de problemas.

Cmo obtener ayuda en lnea


Si est atascado, no pase das corriendo solo, pida ayuda. Una de las mejores cosas
de Arduino es su comunidad. Siempre puede encontrar ayuda si puede describir
bien su problema.

Obtener el hbito de cortar y pegar cosas en un motor de bsqueda y ver si alguien


est hablando de ello. Por ejemplo, cuando el IDE de Arduino escupe un mensaje
de error repugnante, cpielo y pguelo en una bsqueda de Google y vea lo que
sale. Haz lo mismo con bits de cdigo en los que ests trabajando o con un nombre
de funcin especfico. Mira a tu alrededor: todo ya ha sido inventado y est
almacenado en alguna parte de una pgina web.
Para ms informacin, empiece desde el sitio web principal www.arduino.cc y mire
el FAQ (www.arduino.cc/en/Main/FAQ), luego vaya al patio
(www.arduino.cc/playground), a Libremente editable wiki que cualquier usuario
puede modificar para contribuir con la documentacin. Es una de las mejores
partes de toda la filosofa de cdigo abierto. La gente aporta documentacin y
ejemplos de todo lo que puedes hacer con Arduino. Antes de iniciar un proyecto,
busque en el patio de recreo y encontrar un poco de cdigo o un diagrama de
circuito para empezar.

Si todava no puede encontrar una respuesta de esa manera, busque en el foro


(www.arduino.cc/cgi-bin / yabb2 / YaBB.pl). Si eso no ayuda, publicar una pregunta
all. Escoja la tabla correcta para su problema: hay diferentes reas para problemas
de software o hardware e incluso foros en cinco idiomas diferentes. Publica toda la
informacin que puedas:

Qu tablero de Arduino est usando?

Qu sistema operativo est utilizando para ejecutar el IDE de Arduino?

D una descripcin general de lo que est tratando de hacer. Publicar enlaces a


hojas de datos de partes extraas que est utilizando.

El nmero de respuestas que obtiene depende de lo bien que formule su pregunta.

Sus posibilidades aumentan si evita estas cosas a toda costa (estas reglas son
buenas para cualquier foro en lnea, no slo para Arduino):
Escribiendo su mensaje en MAYSCULAS. Se molestan a la gente mucho y
es como caminar con "novato" tatuado en la frente (en las comunidades en
lnea, escribiendo en todos los capitales se considera "gritando").

Publicar el mismo mensaje en varias partes del foro.

"Golpear" su mensaje publicando comentarios de seguimiento preguntando


"Hey, cmo es que nadie respondi?" O peor an, simplemente publicar el
texto "bump". Si no recibi una respuesta, eche un vistazo a su publicacin.
Estaba claro el tema? Usted proporcion una descripcin bien-redactada
del problema que usted est teniendo? Eras agradable? Siempre s bueno.

Escribir mensajes como "Quiero construir un transbordador espacial usando


arduino como hago eso". Esto significa que usted quiere que la gente haga
su trabajo para usted, y este enfoque no es simplemente divertido para un
verdadero tinkerer. Es mejor explicar lo que quieres construir y luego hacer
una pregunta especfica sobre una parte del proyecto y tomarlo desde all.

Una variacin del punto anterior es cuando la pregunta es claramente algo


que el cartel del mensaje se est pagando para hacer. Si usted hace
preguntas especficas que la gente est feliz de ayudar, pero si les pide que
hagan todo su trabajo (y no comparten el dinero), la respuesta es probable
que sea menos agradable.

Publicar mensajes que parezcan sospechosos como asignaciones escolares y


pedir al foro que haga su tarea. Profesores como yo vagan por los foros y
golpean a esos estudiantes con una trucha grande.
Apndice A/
El tablero de pan
El proceso de conseguir un circuito para trabajar implica hacer muchos cambios en l
hasta que se comporte correctamente; Es un proceso muy rpido e iterativo que es
algo as como un equivalente electrnico al bosquejo. El diseo evoluciona en tus
manos mientras intentas combinaciones diferentes. Para obtener los mejores
resultados, utilice un sistema que le permita cambiar las conexiones entre los
componentes de la manera ms rpida, ms prctica y menos destructiva. Estos
requisitos claramente descartan la soldadura, que es un procedimiento que requiere
mucho tiempo y que pone a los componentes bajo tensin cada vez que los calienta y
los enfra.

La respuesta a este problema es un dispositivo muy prctico llamado la placa de soldar


sin soldadura. Como se puede ver en la Figura A-1, se trata de un pequeo tablero de
plstico lleno de agujeros, cada uno de los cuales contiene un contacto de resorte.
Usted puede empujar la pierna de un componente en uno de los agujeros, y
establecer una conexin elctrica con todos los otros agujeros en la misma columna
vertical de agujeros. Cada agujero est a una distancia de 2,54 mm de los otros.

Debido a que la mayora de los componentes tienen sus patas (conocidas por los
tcnicos como "pernos") espaciadas a esa distancia estndar, las virutas con mltiples
patas encajan perfectamente. No todos los contactos en una tabla de paneles se crean
iguales, hay algunas diferencias. Las filas superior e inferior (coloreadas en rojo y azul y
marcadas con + y -) estn conectadas horizontalmente y se utilizan para transportar la
alimentacin a travs de la placa de modo que cuando se necesita energa o tierra, se
puede proporcionar muy rpidamente con un puente Un pedazo corto de alambre
utilizado para conectar dos puntos en los circuitos). La ltima cosa que usted necesita
saber sobre breadboards es que en el medio, hay una abertura grande que sea tan
ancha como el tamao de un pequeo chip. Cada lnea vertical de agujeros se
interrumpe en el medio, de modo que cuando se conecta un chip, no se cortocircuitan
los pines que estn en los dos lados del chip. Inteligente, eh?p.
Appendix A 93
Figura A-1.
La plancha sin soldadura.

Apndice B Resistores de
lectura y condensadores.
Con el fin de utilizar las piezas electrnicas, es necesario ser capaz de identificar, que
puede ser una tarea difcil para un principiante. La mayora de las resistencias que se
encuentran en una tienda tienen un cuerpo cilndrico con dos patas que sobresalen y
tienen marcas de colores extraos a su alrededor. Cuando se hicieron las primeras
resistencias comerciales, no haba forma de imprimir nmeros lo suficientemente
pequeos como para caber en su cuerpo, por lo que ingenieros inteligentes decidieron
que slo podan representar los valores con tiras de pintura de color.

Los principiantes de hoy en da tienen que encontrar una manera de interpretar estos
signos. La "llave" es bastante simple: generalmente, hay cuatro rayas, y cada color
representa un nmero. Uno de los anillos es generalmente oro-coloreado; ste
representa la precisin de esa resistencia. Para leer las rayas en orden, mantenga la
resistencia por lo que la banda de oro (o plata en algunos casos) est a la derecha.
A continuacin, lea los colores y asignarlos a los nmeros correspondientes. En la
siguiente tabla, encontrar una traduccin entre los colores y sus valores numricos.

Colour Value
Black 0
Brown 1
Red 2
Orange 3
Yellow 4
Green 5
Blue 6
Purple 7
Grey 8
White 9
Silver 10%
Gold 5%
Por ejemplo, las marcas marrones, negras, naranjas y doradas significan 1 0 3 5%.
Fcil, verdad? No bastante, porque hay un giro: el tercer anillo representa realmente el
nmero de ceros en el valor. Por lo tanto 1 0 3 es en realidad 1 0 seguido de 3 ceros, por
lo que el resultado final es 10.000 ohmios 5%. Los geeks de la electrnica tienden a
acortar los valores expresndolos en kilo ohmios (para miles

Apndice B 95

De ohmios) y mega ohmios (para millones de ohmios), por lo que una resistencia de
10.000 ohm se acorta a 10k, mientras que 10.000.000 se convierte en 10M. Tenga en
cuenta que debido a que los ingenieros estn aficionados a optimizar todo, en algunos
diagramas esquemticos se pueden encontrar valores expresados como 4k7, lo que
significa 4.7 kilo ohmios, o 4700.

Los condensadores son un poco ms fciles: los condensadores en forma de barril


(condensadores electrolticos) generalmente tienen sus valores impresos en ellos. El
valor de un condensador se mide en farads (F), pero la mayora de los condensadores
que encuentre se medirn en micro farads (F). Tan si usted ve un condensador
etiquetado 100 F, es un condensador de 100 micro farad.

Muchos de los condensadores en forma de disco (condensadores cermicos) no tienen


sus unidades enumeradas, y utilizan un cdigo numrico de tres dgitos que indica el
nmero de faros pico (pF). Hay 1.000.000 pF en un F. Similar a los cdigos de
resistencia, se utiliza el tercer nmero para determinar el nmero de ceros a poner
despus de los dos primeros, con una diferencia: si ves 0-5, que indica el nmero de
ceros. 6 y 7 no se utilizan, y 8 y 9 se manejan de manera diferente. Si ve 8, multiplique el
nmero que forman los dos primeros dgitos por 0.01, y si ve 9, multiplquelo por 0.1.

Por lo tanto, un condensador etiquetado 104 sera 100.000 pF o 0,1 F. Un condensador


marcado 229 sera 2,2 pF.
Apndice C / Referencia
rpida de Arduino.
Esta es una explicacin rpida de todas las instrucciones estndar soportadas por
el lenguaje Arduino.

Para una referencia ms detallada, vea: arduino.cc/en/Reference/HomePage.

ESTRUCTURA
Un dibujo de Arduino se ejecuta en dos partes:

void setup()

Aqu es donde se coloca el cdigo de inicializacin: las instrucciones que

configuran la placa antes de que comience el bucle principal del boceto. void

loop()

Este contiene el cdigo principal de su boceto. Contiene un conjunto de


instrucciones que se repiten una y otra vez hasta que la tarjeta se apaga.

SMBOLOS ESPECIALES
Arduino incluye una serie de smbolos para delinear lneas de cdigo, comentarios y
bloques de cdigo.

; (punto y coma)

Cada instruccin (lnea de cdigo) se termina por un punto y coma. Esta sintaxis le
permite formatear el cdigo libremente. Incluso podras poner dos instrucciones en
la misma lnea, siempre y cuando las separes con un punto y coma. (Sin embargo,
esto hara que el cdigo sea ms difcil de leer.)

Ejemplo: delay(100);

{} (Llaves)
Esto se utiliza para marcar bloques de cdigo. Por ejemplo, cuando escribe cdigo
para la funcin loop (), tiene que usar llaves antes y despus del cdigo.
Ejemplo:
void loop() { Serial.println("ciao");
}

Comentarios
Estas son porciones de texto ignoradas por el procesador Arduino, pero son
extremadamente tiles para recordar a usted mismo (u otros) de lo que hace un
pedazo de cdigo.
Hay dos estilos de comentarios en Arduino:
// single-line: this text is ignored until the end of the line /* multiple-line: you can write a
whole poem in here */

CONTENIDOS
Arduino incluye un conjunto de palabras clave predefinidas con valores
especiales. HIGH y LOW se utilizan, por ejemplo, cuando se desea activar o
desactivar un pin Arduino. INPUT y OUTPUT se utilizan para establecer un pin
especfico para ser y entrada o una salida

Verdadero y falso indican exactamente lo que sus nombres sugieren: la verdad o


falsedad de una condicin o expresin.

VARIABLES
Las variables se denominan reas de la memoria del Arduino donde se pueden
almacenar datos que se pueden utilizar y manipular en el boceto. Como su nombre
indica, pueden ser cambiados tantas veces como quieras.

Debido a que Arduino es un procesador muy simple, cuando declara una variable,
debe especificar su tipo. Esto significa decirle al procesador el tamao del valor que
desea almacenar.

Aqu estn los tipos de datos que estn disponibles:

boolean
Puede tener uno de dos valores: verdadero o falso.

char
Tiene un solo carcter, como A. Como cualquier computadora, Arduino lo almacena
como un nmero, aunque vea texto. Cuando los caracteres se utilizan para
almacenar nmeros, pueden contener valores de -128 a 127.

NOTA: Hay dos conjuntos principales de caracteres disponibles en sistemas


informticos: ASCII y UNICODE. ASCII es un conjunto de 127 caracteres que se
utiliz para, entre otras cosas, la transmisin de texto entre terminales en serie y
sistemas de computadora compartidos en el tiempo, tales como mainframes y
minicomputadoras. UNICODE es un conjunto mucho ms grande de valores
utilizados por los sistemas operativos modernos de computadora para
representar a personajes en una amplia gama de idiomas. ASCII sigue siendo til
para el intercambio de bits cortos de informacin en idiomas como el italiano o el
ingls que utilizan caracteres latinos, nmeros arbigos y smbolos de mquina de
escribir comunes para la puntuacin y similares.

byte
Contiene un nmero entre 0 y 255. Al igual que con los caracteres, los bytes utilizan
slo un byte de memoria.

int
Utiliza 2 bytes de memoria para representar un nmero entre -32.768 y 32.767; Es
el tipo de datos ms comn usado en Arduino.

unsigned int
Como int, utiliza 2 bytes, pero el prefijo sin signo significa que no puede almacenar
nmeros negativos, por lo que su rango va de 0 a 65.535.

long
Este es el doble del tamao de un int y contiene nmeros de -2.147.483.648 a
2.147.483.647.

unsigned long
Versin sin firmar de largo; Va de 0 a 4.294.967.295.

float
Esto es bastante grande y puede contener valores de punto flotante, una manera
elegante de decir que puede usarlo para almacenar nmeros con un punto decimal
en ella. Se comen hasta 4 bytes de su memoria RAM precioso y las funciones que
pueden manejar que utilizan una gran cantidad de memoria de cdigo tambin. As
que usa flotadores con moderacin.
double
Nmero de coma flotante de doble precisin, con un valor mximo de
1.7976931348623157 x 10308. Wow, eso es enorme!

string
Un conjunto de caracteres ASCII que se utilizan para almacenar informacin textual
(puede utilizar una cadena para enviar un mensaje a travs de un puerto serie o
para mostrarlo en una pantalla LCD). Para el almacenamiento, utilizan un byte para
cada carcter en la cadena, adems de un carcter nulo para decirle a Arduino que
es el final de la cadena. Los siguientes son equivalentes:
char string1[] = "Arduino"; // 7 chars + 1 null char char string2[8] = "Arduino"; //
Same as above

array
Una lista de variables a las que se puede acceder a travs de un ndice. Se utilizan
para construir tablas de valores que se pueden acceder fcilmente. Por ejemplo, si
desea almacenar diferentes niveles de brillo que se utilizarn al atenuar un LED,
podra crear seis variables denominadas light01, light02, etc. Mejor an, usted
podra utilizar un arreglo simple como: int light[6] = {0, 20, 50, 75, 100};

La palabra "matriz" no se usa realmente en la declaracin de variables: los smbolos


[] y {} realizan el trabajo.

ESTRUCTURAS DE CONTROL
Arduino incluye palabras clave para controlar el flujo lgico de su boceto.

if . . . else
Esta estructura toma decisiones en su programa. if debe ser seguido por una
pregunta especificada como una expresin entre parntesis. Si la expresin es
verdadera, lo que sigue ser ejecutado. Si es falso, se ejecutar el bloque de cdigo
siguiente. Es posible utilizar slo if sin proporcionar una clusula else.

Ejemplo:
if (val == 1)
{ digitalWrite(LED,HIGH); }

for
Le permite repetir un bloque de cdigo un nmero especificado de veces.
Ejemplo:
for (int i = 0; i < 10; i++)
{ Serial.print("ciao"); }

switch case
Las declaraciones if son como una bifurcacin en el camino para su programa.
Switch case es como una enorme rotonda. Permite que su programa tome una
variedad de direcciones dependiendo del valor de una variable. Es muy til
mantener su cdigo ordenado, ya que reemplaza largas listas de declaraciones if.

Ejemplo:
switch (sensorValue) { case 23:
digitalWrite(13,HIGH); break; case
46: digitalWrite(12,HIGH); break;
default: // if nothing matches this is executed digitalWrite(12,LOW);
digitalWrite(13,LOW); }

while
Similar a if, Esto ejecuta un bloque de cdigo mientras que una cierta condicin es
verdadera.

Ejemplo:
// blink LED while sensor is below 512 sensorValue =
analogRead(1); while (sensorValue < 512)
{ digitalWrite(13,HIGH); delay(100);
digitalWrite(13,HIGH); delay(100);
sensorValue = analogRead(1); }

do . . . while
Slo como while, excepto que el cdigo se ejecuta justo antes de que se evale la
condicin. Esta estructura se utiliza cuando desea que el cdigo dentro de su
bloque se ejecute al menos una vez antes de comprobar la condicin.

Ejemplo:

do {
digitalWrite(13,HIGH); delay(100);
digitalWrite(13,HIGH); delay(100);
sensorValue = analogRead(1); } while
(sensorValue < 512);
break
Este trmino le permite dejar un bucle y continuar la ejecucin del cdigo que
aparece despus del bucle. Tambin se utiliza para separar las diferentes secciones
de una declaracin switch case.

Ejemplo:
// blink LED while sensor is below 512 do { // Leaves the loop
if a button is pressed if (digitalRead(7) == HIGH) break;
digitalWrite(13,HIGH); delay(100);
digitalWrite(13,HIGH); delay(100);
sensorValue = analogRead(1); } while
(sensorValue < 512);

continue
Cuando se usa dentro de un bucle, continue le permite saltar el resto del cdigo
dentro de l y forzar la condicin para ser probado de nuevo.

Ejemplo:

for (light = 0; light < 255; light++) { // skip intensities


between 140 and 200 if ((x > 140) && (x < 200))
continue;
analogWrite(PWMpin, light); delay(10);
}

return
Detiene la ejecucin de una funcin y regresa de ella. Tambin puede usar esto
para devolver un valor desde dentro de una funcin.

Por ejemplo, si tiene una funcin llamada computeTemperature() Y desea devolver


el resultado a la parte de su cdigo que invoc la funcin que escribira algo como:
int computeTemperature() { int
temperature = 0;
temperature = (analogRead(0) + 45) / 100; return temperature;
}

ARITMTICOS Y FRMULAS
Puede utilizar Arduino para realizar clculos complejos utilizando una sintaxis
especial. + Y - funciona como lo has aprendido en la escuela, y la multiplicacin se
representa con un * y la divisin con un /.
Hay un operador adicional llamado "mdulo" (%), que devuelve el resto de una
divisin entera. Puede utilizar tantos niveles de parntesis como sea necesario para
agrupar expresiones. Contrariamente a lo que usted pudo haber aprendido en la
escuela, los corchetes y los corchetes se reservan para otros propsitos (ndices de
la matriz y bloques, respectivamente).

Ejemplos:
a = 2 + 2;
light = ((12 * sensorValue) - 5 ) / 2;
remainder = 3 % 2; // returns 2 because 3 / 2 has remainder 1

OPERADORES DE COMPARACIN
Cuando especifique condiciones o pruebas para if, while, y for declaraciones, estos
son los operadores que puedes usar:

== igual a
!= no igual a
< menos que
> mas grande que
<= menos que o igual a
>= mayor qu o igual a

OPERADORES BOOLEANOS
Estos se utilizan cuando se desea combinar varias condiciones. Por ejemplo, si

desea comprobar si el valor procedente de un sensor est entre 5 y 10, escribira: if

((sensor => 5) && (sensor <=10))

Hay tres operadores: y, representados con &&; O, representado con ||; Y


finalmente no, representado con!.

OPERADORES COMPUESTOS
stos son operadores especiales usados para hacer el cdigo ms conciso para
algunas operaciones muy comunes como incrementar un valor.
Por ejemplo, para incrementar el valor en 1, escribira: value =

value +1; Pero utilizando un operador compuesto, esto se

convierte en: value++;

Incremento y decremento (- y ++)


Estos incrementan o decrementan un valor por 1. Sin embargo, tenga cuidado. Si
escribes i++ esto incrementa i por 1 y se evala al equivalente de i+1; ++i se evala
al valor de i luego incrementa i. Lo mismo se aplica a .

+= , =, *= and /=
Esto hace ms corto escribir ciertas expresiones. Las dos expresiones siguientes son
equivalentes:

a = a + 5; a += 5;

FUNCIONES DE ENTRADA Y SALIDA


Arduino incluye funciones de manejo de entrada y salida. Ya has visto algunos de
estos en los programas de ejemplo a lo largo del libro.

PinMode (pin, modo)

Reconfigura un pin digital para que se comporte como entrada o salida.

Ejemplo: pinMode(7,INPUT); // turns pin 7 into an input

digitalWrite(pin, value)
Enciende o apaga un pin digital. Los pins deben convertirse explcitamente en una
salida usando pinMode antes de digitalWrite tendr algn efecto.

Ejemplo: digitalWrite(8,HIGH); // turns on digital pin 8

int digitalRead(pin)
Lee el estado de un pin de entrada, devuelve HIGH si el pin detecta algn voltaje o
LOW si no hay voltaje aplicado.
Ejemplo:
val = digitalRead(7); // reads pin 7 into val

int analogRead(pin)
Lee el voltaje aplicado a un pin de entrada analgica y devuelve un nmero entre 0
y 1023 que representa las tensiones entre 0 y 5 V.

Ejemplo: val = analogRead(0); // reads analog input 0 into val

analogWrite(pin, value)
Cambia la frecuencia PWM en uno de los pines marcados PWM. Pin puede ser 11,
10, 9, 6, 5, 3. El valor puede ser un nmero entre 0 y 255 que representa la escala
entre 0 y 5 V de voltaje de salida.

Ejemplo: analogWrite(9,128); // Dim an LED on pin 9 to 50%

shiftOut(dataPin, clockPin, bitOrder, value)


Enva datos a un registro de desplazamiento, dispositivos que se utilizan para
expandir el nmero de salidas digitales. Este protocolo utiliza un pin para los datos
y uno para el reloj.
BitOrder indica el orden de bytes (menos significativo o ms significativo) y el valor
es el byte real que se enviar.
Ejemplo: shiftOut(dataPin, clockPin, LSBFIRST, 255);

unsigned long pulseIn(pin, value)


Mide la duracin de un pulso en una de las entradas digitales. Esto es til, por
ejemplo, para leer algunos sensores infrarrojos o acelermetros que generan su
valor como impulsos de duracin variable.

Ejemplo:
time = pulsein(7,HIGH); // measures the time the next // pulse stays
high

FUNCIONES DEL TIEMPO


Arduino incluye funciones para medir el tiempo transcurrido y tambin para
detener el boceto.

unsigned long millis()


Devuelve el nmero de milisegundos transcurridos desde el inicio del boceto.

Ejemplo:
duration = millis()-lastTime; // computes time elapsed since "lastTime"

delay(ms)
Pausa el programa por la cantidad de milisegundos especificado.

Ejemplo: delay(500); // stops the program for half a second

delayMicroseconds(us)
Detiene el programa por la cantidad dada de microsegundos.

Ejemplo:
delayMicroseconds(1000); // waits for 1 millisecond

FUNCIONES DE MATEMTICAS
Arduino incluye muchas funciones matemticas y trigonomtricas comunes:

min(x, y)
Devuelve el menor de x e y.

Ejemplo:
val = min(10,20); // val is now 10

max(x, y)
Devuelve el mayor de x e y.

Ejemplo:
val = max(10,20); // val is now 20

abs(x)
Devuelve el valor absoluto de x, que convierte los nmeros negativos en positivos.
Si x es 5, devolver 5, pero si x es -5, todava retornar 5.

Ejemplo: val = abs(-5); // val is now 5

constrain(x, a, b)
Devuelve el valor de x, restringido entre a y b. Si x es menor que a, simplemente
devolver a y si x es mayor que b, regresar b.

Ejemplo:
val = constrain(analogRead(0), 0, 255); // reject values bigger than 255

map(value, fromLow, fromHigh, toLow, toHigh)


Muestra un valor en el rango fromLow y maxLow al rango toLow y toHigh. Muy til
para procesar valores de sensores analgicos.

Ejemplo:

val = map(analogRead(0),0,1023,100, 200); // maps the value of // analog


0 to a value // between 100 and 200

double pow(base, exponent)


Devuelve el resultado de levantar un nmero (base) para un valor (exponent).

Ejemplo: double x = pow(y, 32); // sets x to y raised to the 32nd power

double sqrt(x)
Devuelve la raz cuadrada de un nmero.

Ejemplo: double a = sqrt(1138); // approximately 33.73425674438

double sin(rad)
Devuelve el seno de un ngulo especificado en radianes.

Ejemplo: double sine = sin(2); // approximately 0.90929737091

double cos(rad)
Devuelve el coseno de un ngulo especificado en radianes.

Ejemplo: double cosine = cos(2); // approximately -0.41614685058

double tan(rad)
Devuelve la tangente de un ngulo especificado en radianes.

Ejemplo:
double tangent = tan(2); // approximately -2.18503975868
FUNCIONES NUMRICAS DE RANDOM
Si necesita generar nmeros aleatorios, puede usar el generador de nmeros
pseudoaleatorios de Arduino.

randomSeed(seed)
Restablece el generador de nmeros pseudoaleatorios de Arduino. Aunque la
distribucin de los nmeros devueltos por random() Es esencialmente aleatorio, la
secuencia es predecible. Por lo tanto, debe restablecer el generador a un valor
aleatorio. Si tiene un pin analgico no conectado, captar ruido aleatorio del
entorno (ondas de radio, rayos csmicos, interferencias electromagnticas de los
telfonos celulares y luces fluorescentes, etc.).

Ejemplo: randomSeed(analogRead(5)); // randomize using noise from pin 5

long random(max)
long random(min, max)
Devuelve un valor entero largo pseudoaleatorio entre min y max - 1.
Si no se especifica min, el lmite inferior es 0.
Ejemplo:
long randnum = random(0, 100); // a number between 0 and 99 long randnum = random(11);
// a number between 0 and 10

COMUNICACIN SERIAL
Como se vio en el Captulo 5, puede comunicarse con dispositivos a travs del
puerto USB mediante un protocolo de comunicacin serie. Aqu estn las funciones
en serie.

Serial.begin(speed)
Prepara Arduino para comenzar a enviar y recibir datos en serie. En general, usar
9600 bits por segundo (bps) con el monitor en serie IDE de Arduino, pero otras
velocidades estn disponibles, generalmente no ms de 115.200 bps.

Ejemplo:
Serial.begin(9600);

Serial.print(data)
Serial.print(data, encoding)
Enva algunos datos al puerto serie. La codificacin es opcional; Si no se suministra,
los datos se tratan como texto plano como sea posible.
Ejemplos:
Serial.print(75); // Prints "75" Serial.print(75, DEC); // The same as above.
Serial.print(75, HEX); // "4B" (75 in hexadecimal)
Serial.print(75, OCT); // "113" (75 in octal)
Serial.print(75, BIN); // "1001011" (75 in binary)
Serial.print(75, BYTE); // "K" (the raw byte happens to
// be 75 in the ASCII set)

Serial.println(data)
Serial.println(data, encoding)
Igual que Serial.print(), Excepto que aade un retorno de carro y avance de lnea (\
r \ n) como si hubiera escrito los datos y luego presionado Intro o Intro.

Ejemplos:

Serial.println(75); // Prints "75\r\n" Serial.println(75, DEC); // The same as above.


Serial.println(75, HEX); // "4B\r\n"
Serial.println(75, OCT); // "113\r\n"
Serial.println(75, BIN); // "1001011\r\n" Serial.println(75, BYTE); // "K\r\n"

int Serial.available()
Devuelve cuntos bytes no ledos estn disponibles en el puerto Serial para leer a
travs de la funcin read(). Despus tienes read() todo disponible,
Serial.available() devuelve 0 hasta que lleguen nuevos datos al puerto serie.

Ejemplo: int count = Serial.available();

int Serial.read()
Obtiene un byte de los datos en serie entrantes.

Ejemplo: int data = Serial.read();

Serial.flush()
Debido a que los datos pueden llegar a travs del puerto serie ms rpido de lo que
su programa puede procesar, Arduino mantiene todos los datos entrantes en un
bfer. Si necesita borrar el bfer y dejar que se llene con datos nuevos, use la
funcin flush().

Ejemplo:
Serial.flush();
Apndice d / Diagramas
esquemticos de lectura
Hasta ahora, hemos utilizado ilustraciones muy detalladas para describir cmo
ensamblar nuestros circuitos, pero como se puede imaginar, no es exactamente
una tarea rpida dibujar una de esas para cualquier experimento que quiera
documentar.

Problemas similares surgen, tarde o temprano, en todas las disciplinas. En la


msica, despus de escribir una bonita cancin, es necesario escribirla usando la
notacin musical.

Los ingenieros, siendo gente prctica, han desarrollado una manera rpida de
capturar la esencia de un circuito para poder documentarlo y despus reconstruirlo
o pasarlo a otra persona.

En la electrnica, los diagramas esquemticos le permiten describir su circuito de


una manera que sea entendida por el resto de la comunidad. Los componentes
individuales estn representados por smbolos que son una especie de abstraccin
de la forma del componente o la esencia de ellos. Por ejemplo, el condensador
est hecho de dos placas metlicas separadas por aire o plstico; Por lo tanto, su
smbolo es:
Otro ejemplo claro es el inductor, que se construye
enrollando alambre de cobre alrededor de una forma
cilndrica; Por consiguiente el smbolo es:

Las conexiones entre los componentes se realizan


generalmente utilizando cables o pistas en la placa de
circuito impreso y se representan en el diagrama
como lneas simples. Cuando dos cables estn
conectados, la conexin se representa por un punto
grande colocado donde las dos lneas cruzan:

Esto es todo lo que necesita para comprender los esquemas bsicos. Aqu est una
lista ms completa de smbolos y sus significados:

RESISTOR CAPACITOR THERMISTOR LDR LIGHT SENSOR

DIODE LED PUSHBUTTON POTENTIOMETER

Puede encontrar variaciones en estos smbolos (por ejemplo, ambas variantes de


los smbolos de resistencia se muestran aqu). Ver en.wikipedia.org/wiki/
Electronic_symbol para una lista ms amplia de los smbolos de la electrnica. Por
convencin, los diagramas se dibujan de izquierda a derecha. Por ejemplo, una
radio se elaborar a partir de la antena a la izquierda, siguiendo el camino de la
seal de radio, ya que hace su camino hacia el altavoz (que se dibuja a la derecha).

El siguiente esquema describe el circuito pulsador mostrado anteriormente en este


libro:
+5 V

ARDUINO

PIN 7

GND GND

Appendix D 111

ndice
56-62, 73 pines, placa Arduino, 20-21, 64-67
sensores, 64-68 sintetizadores, 8 analogWrite
funcin, 56-58, 65-67, 105 y operador, 103 Pines de
E / S analgicas Arduino, 20-21, 64-67 definidos, 1
; (Punto y coma), 46, 97 Placa Diecimila, 20, 88 pines digitales IO, 20-21 Placa
// (delimitador del comentario), 34-35, 36-37, 98 Duemilanove, 20-21 Extreme board, 88 forum, 91
-92 Pines GND, 60 hardware, 19-21 IDE, descarga, 22
- (operador de decremento), 104
IDE, descripcin, 22
/ * (Delimitador de comentarios), 98
IDE, solucin de problemas, 90-91 IDE, sitio web, 1
&& (y operador), 103
instalacin, 22-27 Linux, 22 NG, 20-21, 88 vista
{} (Entre corchetes), 34-35, 97
general, 1-3
== (igual a), 44-45, 103
,,,,,,,,,,,,,,,,,,,,,,,,, 36 aritmtica, 103 matriz variable,
= (Operador de igualdad), 44-45
100 ASCII, 99 lmpara de esfera de montaje, 84-85
> (Mayor que), 103
ATmega168, 19-21
> = (Mayor o igual que), 103
Lmpara Aton, 73
++ (operador de incremento), 104
segundo
<(Menor que), 103
Barragan, Hernando, 2 circuitos de curvatura, 10-11
<= (Menor o igual que), 103
El Betrothed, 36 bitOrder, 105 LED parpadeante, 30-
% (Mdulo), 103
38, 64-67 Operadores booleanos, 103 variable, 98
! = (No igual a), 103
saltos, 49-51 soportes, rizado, 34-35 breadboard,
! (No operador), 103
43 , 60, 89-90, 93-94 estructura de control de rotura,
|| (U operador), 103 102 buffer, 76 byte variable, 99
() (Parntesis), 36 do
LED RGB de 4 conductores, 84 C lenguaje, 22 clculos, 103 condensadores de
UN lectura, 95-96 smbolo, 110, 111 conmutadores de
Ampre, Andr-Marie, 41 amperios, 41 alfombras, 53 char variable, 98 circuitos
analgicaLeer funcin, 64-67, 105 analgica (PWM), 58-60 LED controlado por pulsador, 42-43
analgicaLeer funcin, 64-67, 105 analogWrite lmpara de esfera, 83-84 smbolos, esquemas, 110-
funcin, 56-58, 65-67, 105 entrada, 64-67, 73 salida, 111 pruebas, 89 -90 clockPin, 105 cdigo. Consulte
tambin programacin de LED parpadeante, 32-38, marido
64-67 bloques, nombres, 34-35 LED controlado por Hacking circuit bending, 10-11 junk, 14 teclados, 12-
pulsador, 44-51 objetos en serie, 68-69 lmpara 13 juguetes, 15 Haque, Usman, 15 hardware,
esfera, 75-82 Arduino, 19-21 hexadecimal, 75-76 HIGH, 37, 98
Colaboracin, 16 Colombo, Joe, 73 cdigos de Hopper, Grace, 88 Codificacin de colores HTML, 75-
colores, resistencias, 95-96 colores, codificacin 76
HTML, 75-76 puertos COM, Windows, 26-27, 90-91 yo
comando, #define, 36, 46 comentarios, 35, 36 -37, I premessi sposi, 36
98 comunicacin, serie, 25 - 27, 68 - 69, 73, IDE (entorno de desarrollo integrado) descarga, 22
90-91, 108-109 operadores de comparacin, 103 informacin general, 22 solucin de problemas, 90-
compilacin de bocetos, 33, 46 sensores complejos, 91 sitio web, 1 si la estructura de control. Ver si
70-71 operadores compuestos, 103-104 conexiones, declaraciones si declaraciones, 44-45, 100, 103 si ...
smbolo, 110 constantes, 36 funcin de restriccin, otra estructura de control, 100
106 informacin de contacto, ix continuar la Igoe, Tom, 71 IKEA lmpara, 84 iMac drivers, 23
estructura de control, 102 Estructuras de control, lmparas incandescentes, conductor, 70 incremento
100-102 funcin cos, 107 herrajes, 34-35, 97 operador, 104 inductor, smbolo, 110 infrarrojos, 70-
corriente, 41-42 proteccin de corriente, 89 71 sensores infrarrojos, 55, 56 INPUT, 36, 67, 73
re digital, 36 - 38, 73
Dante, 36 Funciones, 104-108 instalacin
89-90, 88-90, 88-89, 87-90, 88-89, 68-69, 89-90, 68- Arduino, 22-27
69, data-serial, 68-69, data- 36, 46 funcin de Controladores de Macintosh, 23 controladores de
retardo, 37, 106 funcin delayMicroseconds, 106 Windows, 23-24 funcin analgicaRead, 105 int
delimitadores bloques de cdigo, 34-35 funcin digitalRead, 104 int Funcin Serial.available,
Comentario, 35 109 int Serial.read, 109 int variable, 99
Diagramas, circuitos, 110-111 Diecimila placa, 20 Entorno de Desarrollo Integrado (IDE).
digital Consulte IDE (Integrated Development
42, 64, 104 digitalWrite funcin, 37, 104 diodo, Ambiente)
smbolo, 111 divide y impera, 87 Divina Commedia, Controladores Intel, 23
107 funcin doble de la funcin del pecado, 107 Interaction Design, 2-3 Interactive Device, 29
funcin doble del pecado, 107 funcin doble del tan, lmparas interactivas, 38 pines IO, placa Arduino, 20-
107 variable doble, 99 hacen ... mientras que 21, 64-67 problemas de aislamiento, 90
estructura de control, 101 Drenan el perno, J puente, seleccin de potencia, 20 puente de
transistores del MOSFET, 70 conductores, conexin, 43-44 basura, 14
Instalacin, 23-24 conduccin de grandes cargas, 70 K
Duemilanove bordo, 20-21 Dyson, James, 6 Kernighan, Brian W., 90 teclados, hacking, 12-13
mi L lmparas Aton, 73 de conduccin, 70 interactivo,
Electricidad, 39-42 operador de igualdad, 44-45 esfera 38, 74-85
Errata, ix ejecucin de bocetos, 34 energa externa, LDRs (resistencias dependientes de la luz), 30, 63,
20 Extreme board, 88 111
F FALSO, 45 falso, 98 variable flotante, 99 carpeta, LED de 4 conductores RGB, 84 parpadeo, 30-38
almacenamiento de boceto, fuente 32, generacin, sensores de luz, 62-63 modulacin de ancho de
80 para la estructura de control, 100 para pulso (PWM), 56-62 pulsador controlado, 42-51
instrucciones, 103 frmulas, 103 foro, Arduino, 91-92 lmpara de esfera, 74-85 smbolos, 111 luz. Ver
106 analgica, 56-58, 65-67, 105 restriccin, 106 cos, tambin lmparas; (LDRs), 30, 63 que juegan con, 38
107 retardo, 106 funcin de retardo, 37 modulacin de la anchura de pulso (PWM), 56-62
retardoMicroseconds, 106 digitalRead, 42 amarillo que destella, 88 Linux, 22 cargas,
digitalWrite, 37, 104 loop, 35, 37 mapa, 107 conduciendo, funcin aleatoria larga de 70, 108
matemticas, 106-107 largos Variable, funcin del lazo 99, 35, 37
108, 108, 108, 105, 105, 105, 105, 106, 109, 108, LOW, 37, 98
109, 108, 109 Serial.available, 109 Serial.begin, 108 Sensores y actuadores de baja tecnologa, 15
Serial.flush, 109 Serial.print, 108-109 Serial.println, m
109 Serial.read, 109 configuracin, 35, 36 shiftOut, 70 funcin de mapa, 107 funciones
105 sin, 107 tan, 107 tiempo, 105-106 tipo de vaco, matemticas, 106-107 Mx, 8 funcin mxima,
36-37 106 transistor de efecto de campo de metal-
GRAMO xido-semiconductor, funcin de 70
Puertas, transistores MOSFET, 70 milisegundos, 105 min funcin, 106 mdulo,
Ghazala, Reed, 10 clavijas GND, 60 clavijas de tierra, 103
60 Interruptor pulsador momentneo, 43
Moog, Robert, 8 transistores MOSFET, 70 Funcin aleatoria, 108 funciones de nmeros
aceleradores de deteccin de movimiento, 70- aleatorios, 108 funcin de funcin aleatoria,
71 interruptores de alfombra, 53 interruptores 108 funciones serie, 108-109 objetos serie, 68-
magnticos, 53 sensores infrarrojos pasivos, 55, 69, 73 Funcin de serie, 109
56 reed rels, 53 interruptores de inclinacin, Funcin Serial.begin, 108
54, 56 motores, conduccin, 70 comentarios de Funcin Serial.flush, 109 Funcin Serial.print,
varias lneas , 98 108-109
norte Funcin Serial.println, 109 funcin Serial.read,
Nombres, bloques de cdigo, 34-35 NG bordo, 109 funcin de configuracin, 35, 36 funcin
20-21, 88 no operador, 103 shiftOut, 105 funcin sin, 107 caracteres
Nmeros aritmtica y frmulas, 103 funciones especiales, 97-98 esfera lmpara, estado 75-82,
matemticas, 106-107 funciones aleatorias, estructura 47-48, funcin 97 tan, 107 76, 46-48
108 funciones trigonomtricas, 106-107 variables, 45-46, 98-100 visual, 8 tipo de
variables, 98-100 funcin void, 36-37 prototipos, 6 proxy, 75
O generador de nmeros pseudoaleatorios, 108
Objetos, serial, 68-69, 73 Ohm, Georg, 41 modulacin de ancho de pulso (PWM), 56- 62
ohmios, 41 Ohm's Law, 41-42 pulsos, 105 Datos puros, 8 LEDs controlados
Olivetti, 14 sensores on / off, 53-56 ayuda en por pulsador, 42-51, 111
lnea, 91-92 operadores booleanos, 103 PWM (modulacin de ancho de pulso), 56-62
comparacin, 103 compuestos, 103-104 PWR_SEL, 20
Prototipacin oportunista, 6 u operador, 103 R
SALIDA, 36-37, 98 salida analgica, 56-62, 73 Reas, Casey, 2 datos de recepcin, objetos en
digital, 36-38, 73 funciones, 104-108 serie, 68-69, 73 rels de lmina, 53 registros
pag (LDR), 30, 63 lectura, 95-96 smbolo, 111
30, 56, 85, 8, 9 Pentland, Alex, 13 persistencia variable, 41 estructura de control de retorno ,
de la visin, 56-62 filosofa, Arduino, 5-16 102 LED RGB, 4 conductores, 84
fotoresistores, 30. Ver tambin LDRs (light- Fuente RSS, control de la lmpara, 75
Resistencias dependientes) S
Computacin fsica, definida, 3 Diagramas, smbolos, 110-111 seleccin de puertos,
Diseo de Interaccin Fsica, 3 Pike, Rob, 25-27 punto y coma, 46, 97 envo de datos, objetos
funcin 90 pinMode, 36, 104 pines, placa en serie, 68-69, 73 sensores acelermetros, 70-71
analgica IO Arduino, 20-21 IO digital, 20-21 analgico, 64-68 parpadeo LED, 64-67
tierra, 60 transistores MOSFET, 70 sensores PIR conmutadores de alfombra, 53 Circuitos infrarrojos,
(sensores infrarrojos pasivos), 55, 56 , 85 Pirola, 55, 56, 85 infrarrojos, 70-71 teclado cortar, 13 luz,
Maurizio, 89 62-63 interruptores magnticos, 53 encendido /
80, 90-91 potencimetro, smbolo, funcin de apagado, 53-56 resumen, 30 pulsador, 42 caa
111 pow, 107 fuentes de alimentacin, 20, 70, Rels, 53 termistores, 68 termostatos, 53, 56
88, 89 La prctica de la programacin, 90 El interruptores de inclinacin, 54, 56, 85
procesamiento, 1, 22, 69, 75-82 funcin de guardabarros ultrasnicos, serie 70-71
programacin de abs, 106 analgicaLeer Comunicacin, 25 - 27, 68 - 69, 73, 90 - 91, 108 -
funcin, 64-67, 105 analogWrite funcin, 56- 109 objetos, 68 - 69, 73
58, 65-67, 105 argumentos, 36 parpadeo LED, Puertos, 25-27, 90-91 Funcin Serial.available, 109
30-38, 36-38 operadores booleanos, 103 Funcin Serial.begin, 108
103, 103, 35, 36-37 operadores de Funcin Serial.flush, 109
comparacin, 103-104 constantes, 36, 98 Funcin Serial.print, 108-109
funcin de restriccin, 106 estructuras de 105 funcin de desplazamiento, 105 funcin de
control, 100-102 funcin de cos, 107 entre desplazamiento, 105 cortocircuitos, 89 funcin sin,
corchetes, 34-35 , 97 ciclo, 22 tipos de datos, 107 comentarios de una sola lnea, 98 bocetos
98-100 #define, 36, 46 funcin de retardo, 37, funcin abs, 106 funcin de lectura analgica, 67,
106 funcin delayMicroseconds, 106 funcin 105 funcin de analogWrite, 56-58, 65-67, 105
digitalRead, 42, 64, 104 funcin digitalWrite, argumentos, 36 LED parpadeante, 30-38, 64-67
37, 104 funciones, 34-35, 104-108 si 106 parpadear explicacin del cdigo del LED, 36-38
funcin de los milis, funcin de 105 minutos, operadores booleanos, 103 saltos, 49-51 clculos,
funcin de 106 pinMode, 36, funcin de 104 103 comentarios, 35, 36-37 operadores de
pow, 107 modulacin de la anchura de pulso comparacin, 103 compilacin, 33, 46 operadores
(PWM), 56-62 funcin de pulsacin, 105 LED compuestos, 103-104 constantes, 36, 98 funcin de
controlado por pulsador, 42-51 restriccin, 106 estructuras de control, 100-102
RAM, 46 funcin de cos, 107 corchetes, 34-35, 97 tipos de
datos, 98 -100 #define, 36, 46 funcin de retardo, 14 SV1, estructura del control del caso del
37, 106 delayMicroseconds funcin, 106 interruptor 88, 100-101
digitalRead funcin, 42, 64, 104 Conmutadores rebote, 49-51 alfombra, 53
Funcin de memoria, Funcin de memoria, magnticos, 53 transistores MOSFET, 70 on / off, 53
Funcin de memoria, Funcin de memoria digital, pulsadores, 43 reed rels, 53 tilt, 54, 56, 85
Funcin de memoria digital, Funcin 105 min, 106 smbolos programacin (Ver caracteres especiales)
sensores infrarrojos pasivos, 56-62 funcin esquemas 110-111 sintetizadores analgicos , 8
pinMode, 36, funcin 104 pow, 107 modulacin de T
anchura de pulso (PWM), 56-62 funcin pulseln, Interruptor de pulsador tctil, 43 funcin de
105 LED pulsador controlado, 42-51 bronceado, 107 programa de prueba, Arduino, 88
RAM, 46 termistores, 68, 111 termostatos, 53, 56
Funcin aleatoria, 108 funciones de nmeros interruptores de inclinacin, 54, 56, 85 funciones
aleatorios, 108 funcin de funcin aleatoria, 108 de tiempo, 105-106 retoques, 7 juguetes, hacking,
funciones serie, 108-109 objetos serie, 68-69, 73 15 transistores MOSFET , 70 funciones
Funcin de serie, 109 trigonomtricas, 106-107 solucin de problemas,
Funcin Serial.begin, 108 Funcin Serial.flush, 109 88-89 circuitos integrados, 89-90 IDE (entorno de
Funcin Serial.print, 108-109 desarrollo integrado), 90-91 ayuda en lnea, 91-92
Funcin Serial.println, 109 funcin Serial.read, 109 vista general, 87-88 problemas de reproduccin, 90
funcin de configuracin, 35, 36 funcin shiftOut, Windows, 91
105 funcin sin, 107 caracteres especiales, 97-98 Trucha, grande, 92
esfera lmpara, estado 75-82, estructura 47-48, VERDADERO, 45
funcin 97 tan, 107 Funciones de tiempo, 105-106 verdadero,98
carga, 33 val, 46-48
Variables, 45-46, 98-100 tipo de funcin vaca, 36- u
37 Guardabosques ultrasnicos, 70-71 UNICODE, 99
Somlai-Fischer, Adam, 15 sonidos, guardabosques Variable sin signo int, 99 sin signo de funcin milis
ultrasnicos, 70-71 Pines fuente, transistores largo, 105
MOSFET, 70 caracteres especiales; (Punto y coma), Cargando boceto, 33
46, 97 USB
// (delimitador del comentario), 34-35, 36-37, 98 Puertos, Windows, 26-27, 90-91 fuentes de
- (operador de decremento), 104 alimentacin, 20 objetos en serie, pruebas 68-69, 88
/ * (Delimitador de comentarios), 98 V
&& (y operador), 103 Controladores de Windows, 24 identificacin del
{} (Entre corchetes), 34-35, 97 puerto, 26-27, 90-91 solucin de problemas, 90-91
== (igual a), 44-45, 103 programacin visual, 8 funcin de vaco tipo, 36-37
> (Mayor que), 103 Volta, Alessandro, 41 tensin, 41-42 voltios, 41
> = (Mayor o igual que), 103 VVVV, 8
= (Si declaracin), 44-45 W
++ (operador de incremento), 104 Agua analoga, electricidad, 39-42 mientras que la
<(Menor que), 103 estructura de control, 101 mientras que las
% (Mdulo), 103 declaraciones, 103 Wiki, Patio, 16, 91
! = (No igual a), 103 Ventanas
! (No operador), 103 Drivers, instalacin, 23-24 identificacin de puerto,
|| (U operador), 103 () (parntesis), 36 smbolos 25, 26-27 solucin de problemas, 90-91 cable,
aritmticos, 103 ASCII, 99 puente, 43-44
UNICODE, 99 x
Lmpara de la esfera, estado 74-85, secuencia 47- XML, proxy, 75 XP, controladores de Windows, 23-24
48, estructura 99-100, bosquejo, 97, fuentes 100- identificacin de puerto, 26-27, 90-91 solucin de
102, edificio del circuito, excedente 42-44, puente problemas, 90-91
Y
Luz intermitente amarilla, 88