Intro A Arduino

Introducción
a
Arduino
Massimo Banzi
Primera edición
Introducción 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 división de O’Reilly Media, Inc.
1005 Gravenstein Highway North, Sebastopol, CA 95472
O’Reilly books Pueden ser comprados para uso educativo, comercial o de promoción de ventas. Para obtener
más información, departamento de ventas corporativo / institucional: 800-998-9938 or
[email protected].
Historial de impresión: October 2008: First Edition
Editor: Dale Dougherty

Editor Asociado: Dan Woods
Editor ejecutivo: Brian Jepson
Director creativo: Daniel Carter
Diseñador: Brian Scott
Jefe de producción: 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 están
destinados a ser utilizados por niños.
El uso de las instrucciones y sugerencias de Introducción a Arduino es bajo su propio riesgo. O'Reilly Media, Inc. y
el autor renuncian a toda responsabilidad por cualquier daño, lesión 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/ Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
Audiencia deseada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . 2
¿Qué es la informática física? . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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
Colaboración. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3/ La Plataforma Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
El hardware de Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
El Software (IDE). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
Instalación de Arduino en su computadora. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
Instalación de controladores: Macintosh. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23
Instalación de controladores: Windows. . . . . . . . . . . . . . . . . . . . . . ... . . . . . . . . . .23
Identificación de puertos: Macintosh. . . . ... . . . . . . . ... . . . . . . . . . . . . . . . . . . . . .25
Identificación 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 Quitters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
Real Tinkerers Escribir Comentarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
El Código, 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
analógica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64
Pruebe otros sensores analógicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
Comunicación serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
Conducción de cargas más grandes (motores, lámparas y similares). .. . . . . . . . . .70
Sensores complejos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .70
6/ Hablando con la nube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Planificación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Codificación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Montaje del Circuito. . . . . . . . . . . ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .83
Aquí es cómo montarlo. . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .84
7/ Solución de problemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Prueba de la Junta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Prueba de su circuito de Breadboard. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
Aislar los problemas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
Problemas con el IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
Cómo obtener ayuda en línea. . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Apéndices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Apéndice A / El tablero de pan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
Apéndice B / Lectura de los Reactores y Condensadores. . . . . . . . . . . . . . . . . . . . . .95
Apéndice C / La referencia rápida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Apéndice
D / Lectura de diagramas esquemáticos. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Prefacio
Hace unos años me dieron un reto muy interesante: enseñar a los
diseñadores el mínimo en la electrónica para que pudieran construir
prototipos interactivos de los objetos que estaban diseñando.
Comencé a seguir un instinto subconsciente para enseñar la electrónica de la misma
manera que me enseñaron en la escuela. Más tarde me di cuenta de que simplemente
no estaba funcionando tan bien como me gustaría, y comenzó a recordar sentado en
una clase, aburrido como el infierno, escuchando toda esa teoría que se me lanzó sin
ninguna aplicación práctica para ello.
En realidad, cuando estaba en la escuela ya conocía la electrónica de una manera muy

empírica: muy poca teoría, pero mucha experiencia práctica.
Empecé a pensar en el proceso por el cual aprendí la electrónica:
» Desmonté cualquier dispositivo electrónico que pudiera poner en mis manos.

» Aprendí lentamente cuáles 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 explosión y una nube
de humo.
» Empecé a construir algunos kits vendidos por revistas de electrónica.
» Combiné dispositivos que había hackeado, y reutilización de kits y otros circuitos que
encontré en revistas para hacerlos hacer cosas nuevas.
Como un niño, siempre me fascinó descubrir cómo funcionan las cosas; Por lo tanto,
solía separarlos. Esta pasión 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 más grandes
Prefacio v
proyectos en ese momento eran un lavavajillas y una computadora temprana que
provenía de una oficina de seguros, que tenía una impresora enorme, tarjetas
electrónicas, lectores de tarjetas magnéticas y muchas otras partes que resultaron muy
interesantes y desafiantes para desmontar completamente.
Después de bastante de esta disección, sabía qué componentes electrónicos eran y más
o menos lo que hicieron. Además, mi casa estaba llena de viejas revistas electrónicas
que mi padre debió haber comprado a principios de los años setenta. Pasé horas
leyendo los artículos y mirando los diagramas de circuito sin entender mucho.
Este proceso de leer los artículos una y otra vez, con el beneficio del conocimiento
adquirido al desmontar circuitos, creó un círculo virtuoso lento.
Un gran avance llegó una Navidad, cuando mi papá me dio un kit que permitía a los
adolescentes a aprender sobre la electrónica. Cada componente se alojaba en un cubo
de plástico que se acoplaba magnéticamente con otros cubos, estableciendo una
conexión; El símbolo electrónico fue escrito en la parte superior. Poco sabía yo que el
juguete era también un hito del diseño alemán, porque Dieter Rams lo diseñó en los
años 60.
Con esta nueva herramienta, podría rápidamente montar circuitos y probarlos para ver
qué pasó. El ciclo de prototipado fue cada vez más corto.
Después de eso, construí radios, amplificadores, circuitos que producirían ruidos

horribles y sonidos agradables, sensores de lluvia y pequeños robots.
He pasado mucho tiempo buscando una palabra en inglés que resumiría esa forma de
trabajar sin un plan específico, comenzando con una idea y terminando con un
resultado completamente inesperado. Finalmente, "juguetear" vino adelante. Reconocí
cómo 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 exploración. Por
ejemplo, la generación de directores franceses que dieron a luz a la "Nouvelle Vague"
fueron llamados los "tinkerers". La mejor definición de retoque que he encontrado
viene de una exposición que se llevó a cabo en el Exploratorium en San Francisco:
Bricolaje es lo que sucede cuando se intenta algo que no saben cómo hacer, guiado por
el capricho, la imaginación 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 cómo funcionan las cosas y volverlas a trabajar.
vi Introducción a Arduino
Contraptions, máquinas, wildly mismatched los objetos que trabajan en armonía - esto
es la materia del retoque.
El bricolaje es, en su forma más básica, un proceso que combina juego e investigación.
—www.exploratorium.edu/tinkering
Desde mis primeros experimentos sabía cuánta experiencia necesitarías para poder
crear un circuito que haría lo que querías a partir de los componentes básicos.
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 matemática binaria y la programación.
Allí me di cuenta de que en muchas aplicaciones, los ingenieros ya no estaban

construyendo circuitos a partir de componentes básicos, sino que en su lugar
implementaban mucha inteligencia en sus productos usando microprocesadores. El
software estaba reemplazando muchas horas de diseño electrónico, y permitiría un
ciclo más corto de manipulación.
Cuando volví empecé a ahorrar dinero, porque quería comprar una computadora y
aprender a programar.
Mi primer y más importante proyecto después de eso fue usar mi nueva computadora
ZX81 para controlar una máquina de soldar. Sé que no suena como un proyecto muy
emocionante, pero había una necesidad para él y era un gran desafío para mí, porque
acababa de aprender cómo programar. En este punto, quedó claro que escribir líneas
de código requeriría menos tiempo que modificar circuitos complejos.
Veinte años más tarde, me gustaría pensar que esta experiencia me permite enseñar a
la gente que ni siquiera recuerdo haber tomado ninguna clase de matemáticas 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 increíble 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 enseñado más que Computación Física.
Gillian Crampton-Smith por darme una oportunidad y por todo lo que he aprendido de ella.
Hernando Barragán por el trabajo que ha realizado en Cableado.
Brian Jepson por ser un gran editor y entusiasta partidario todo el tiempo.
Nancy Kotary, Brian Scott, Terry Bronson y Patti Schiendelman por convertir lo que escribí en un libro terminado.
Quiero agradecer a mucha más gente, pero Brian me dice que me estoy quedando sin espacio, así que voy a
enumerar un pequeño número 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, Concetta 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 Dellamotta,
Lorenzo
Parravicini, Luca Rocco, Marco Baioni, Marco Eynard, Maria
Teresa Longoni, Massimiliano Bolondi, Matteo Rivolta, Matthias
Richter, Maurizio Pirola, Michael Thorpe, Natalia Jordan,
Ombretta 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 Introducción a Arduino

Cómo contactarnos
Hemos verificado la información 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 enviándonos sus comentarios. Por favor, háganos saber
acerca de cualquier error, inexactitud, declaraciones engañosas o confusas y
errores tipográficos que encuentre en cualquier parte de este libro.
También háganos saber qué podemos hacer para que este libro sea más ú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 división 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
inspiración e instrucción creativa.
Para más información sobre Maker Media, visítenos en línea:

HACER www.makezine.com
CRAFT: www.craftzine.com
Hacer Maker: www.makerfaire.com
Hacks: www.hackszine.com
Para comentar el libro, envíe un correo electrónico a

[email protected].
El sitio web de O'Reilly para Introducción a Arduino incluye ejemplos, erratas

y planes para futuras ediciones. Puede encontrar esta página en
www.makezine.com/getstartedarduino.
Para obtener más información sobre este libro y otros, consulte el sitio web
de O'Reilly: www.oreilly.com.
Para obtener más información sobre Arduino, incluidos foros de discusión y

documentación adicional, consulte www.arduino.cc.
Prefacio ix
1/ Introducción
Arduino es una plataforma de computación física de

código 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 código abierto
(Integrated Development Environment) se puede
descargar gratuitamente desde www.arduino.cc.
Arduino es diferente de otras plataformas en el mercado debido a estas características:
»Es un entorno multiplataforma; Puede funcionar en Windows, Macintosh y Linux.
»Se basa en la programación de procesamiento IDE, un entorno de desarrollo fácil de

usar utilizado por artistas y diseñadores.
»Se programa a través de un cable USB, no de un puerto serie. Esta característica es útil,
porque muchas computadoras modernas no tienen puertos serie.
»Se trata de hardware y software de código 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.
Introducción 1
» El hardware es barato. La tarjeta USB cuesta unos 20 € (actualmente, unos 35
dólares) y la sustitución de un chip quemado en la placa es fácil y cuesta no más 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 recién llegados para que las cosas funcionen rápidamente.
Este libro está diseñado para ayudar a los principiantes a comprender los beneficios que
pueden obtener al aprender a usar la plataforma Arduino y adoptar su filosofía
Audiencia deseada
Este libro fue escrito para los usuarios "originales" de Arduino: diseñadores y artistas.
Por lo tanto, trata de explicar las cosas de una manera que podría conducir a algunos
ingenieros locos. En realidad, uno de ellos llamó a los capítulos introductorios de mi
primer borrador "fluff". Ese es precisamente el punto. Seamos realistas: la mayoría 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.
–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Después de que Arduino comenzó a ser popular, me di cuenta de cómo 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 diseñadores por derecho propio, así que este libro es para ustedes también.
Arduino nació para enseñar a Interaction Design, una disciplina de diseño que sitúa al
prototipo en el centro de su metodología. Hay muchas definiciones de Interaction
Design, pero la que yo prefiero es:
Interaction Design es el diseño de cualquier experiencia interactiva.
En el mundo actual, Interaction Design se ocupa de la creación de experiencias

significativas entre nosotros (los seres humanos) y los objetos. Es una buena manera de
explorar la creación de experiencias hermosas -y quizás incluso polémicas- entre
nosotros y la tecnología. Interaction Design fomenta el diseño a través de un proceso
iterativo basado en prototipos
Introducción a Arduino 2
De fidelidad cada vez mayor. Este enfoque, también parte de algunos tipos de diseño
"convencional", puede extenderse para incluir la creación de prototipos con tecnología;
En particular, la creación de prototipos con electrónica.
El campo específico de Diseño de Interacción involucrado con Arduino es Computación

Física (o Diseño de Interacción Física).
¿Qué es la informática física
Computación física utiliza la electrónica para el prototipo de nuevos materiales para los
diseñadores y artistas.
Implica el diseño 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 pequeña en
un solo chip).
En el pasado, usar la electrónica significaba tener que tratar con ingenieros todo el
tiempo, y construir circuitos un pequeño componente en ese momento; Estos temas
evitaban que las personas creativas jugaran con el medio directamente. La mayoría de
las herramientas estaban destinadas a los ingenieros y requerían un amplio
conocimiento. En los últimos años, los microcontroladores se han vuelto más baratos y
fáciles de usar, permitiendo la creación de mejores herramientas.
El progreso que hemos hecho con Arduino es acercar estas herramientas un paso más al
novicio, permitiendo a la gente comenzar a construir cosas después de sólo dos o tres
días de un taller.
Con Arduino, un diseñador o artista puede llegar a conocer los fundamentos de la

electrónica y los sensores muy rápidamente y puede comenzar a construir prototipos
con muy poca inversión.
Introducción 3
2/ El Camino del Arduino
La filosofía de Arduino se basa en hacer diseños en
lugar de hablar sobre ellos. Es una búsqueda
constante de formas más rápidas y más potentes de
construir mejores prototipos. Hemos explorado
muchas técnicas de prototipado y desarrollado
maneras de pensar con nuestras manos.
La ingeniería clásica 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 búsqueda de maneras de construir mejores
prototipos, también seleccionamos una serie de paquetes de software que permiten
el proceso de manipulación constante del software y del hardware.
Las siguientes secciones presentan algunas filosofías, acontecimientos y pioneros que

han inspirado el Camino del Arduino.
El Camino a Arduino 5
Prototipos
El prototipado está en el corazón del Camino Arduino: hacemos cosas y construimos
objetos que interactúan con otros objetos, personas y redes. Nos esforzamos por
encontrar una manera más sencilla y rápida de prototipo en la forma más barata
posible.
Muchos de los principiantes que se acercan a la electrónica por primera vez piensan
que tienen que aprender a construir todo desde cero. Esto es una pérdida de energía:
lo que quieres es poder confirmar que algo está funcionando muy rápidamente 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
energía construyendo desde cero, un proceso que requiere tiempo y conocimiento
técnico profundo, cuando podemos tomar dispositivos ya hechos y hackearlos para
explotar el duro trabajo realizado por grandes Empresas y buenos ingenieros?
Nuestro héroe es James Dyson, quien hizo 5127 prototipos de su aspiradora antes de
que estuviera satisfecho de que lo había conseguido (www.international.
Dyson.com/jd/1947.asp).
Jugueteando
Creemos que es esencial jugar con la tecnología, explorando diferentes posibilidades
directamente en hardware y software, a veces sin una meta muy definida.
La reutilización de la tecnología 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.
Parche
Siempre he sido fascinado por la modularidad y la capacidad de construir sistemas
complejos mediante la conexión de dispositivos simples. Este proceso está muy bien
representado por Robert Moog y sus sintetizadores analógicos. Los músicos
construyeron sonidos, intentando combinaciones interminables "juntando" diferentes
módulos con cables. Este enfoque hizo que el sintetizador parezca un viejo conmutador
telefónico, pero combinado con las numerosas perillas, era la plataforma perfecta para
mezclar música sonora e innovadora. Moog lo describió como un proceso entre
"testificar y descubrir". Estoy seguro de que la mayoría de los músicos al principio no
sabía lo que todos esos cientos de botones, pero lo intentaron y trataron, refinando su
propio estilo sin interrupciones en el flujo.
Reducir el número de interrupciones en el flujo es muy importante para la creatividad:

mientras más transparente sea el proceso, más cambios tendrán.
Esta técnica ha sido traducida al mundo del software por ambientes de "programación
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 programación sin la interrupción constante típica del ciclo
habitual: "tipo programa, compilación, maldición-hay un error, error de corrección,
compilar, ejecutar". Si usted es más visual mente, le recomiendo que probarlos.
Curvado del circuito
El curvado de circuitos es una de las formas más interesantes de manipulación. Es

el cortocircuito creativo de los dispositivos audio electrónicos de bajo voltaje,
batería-accionados como pedales del efecto de la guitarra, juguetes de los niños, y
pequeños sintetizadores para crear los nuevos instrumentos musicales y los
generadores sanos. El corazón 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 cajón de escritorio, lo que resulta en una
corriente de sonidos inusuales. Lo que más me gusta de los curvadores de circuitos
es su capacidad de crear los dispositivos más locos, alejándose con la tecnología sin
necesariamente entender lo que están haciendo en el lado teórico.
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 serás uno de ellos.
Ignorarlos y sorprenderlos.
Teclado Hacks
Los teclados de computadora siguen siendo la principal forma de interactuar con
una computadora después de más de 60 años. Alex Pentland, director académico
del MIT Media Laboratory, comentó una vez: "Disculpe la expresión, pero los
urinarios de los hombres son más inteligentes que las computadoras. Las
computadoras están 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 corazón de ella es una tabla pequeña. Normalmente es un circuito oloroso verde
o marrón con dos conjuntos de contactos va a dos capas de plástico 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 detección de movimiento y lo conecta a tu teclado,
verás 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 piratería de
teclado es un componente clave de creación de prototipos y computación física.
Citado en Sara Reese Hedberg, "MIT Media Lab de la búsqueda de computadoras
perceptivas," Sistemas Inteligentes y sus aplicaciones, IEEE, julio / agosto 1998.
Nos encanta Junk!

La gente tira lejos mucha tecnología actualmente: viejas impresoras,
computadoras, máquinas extrañas de la oficina, equipo técnico, e incluso
muchos de materia militar. Siempre ha habido un gran mercado para esta
tecnología sobrante, especialmente entre los jóvenes y / o los hackers más
pobres y los que están recién comenzando. Este mercado se hace evidente en
Ivrea, donde desarrollamos Arduino. La ciudad era la sede de la empresa
Olivetti. Habían estado haciendo computadoras desde los años sesenta; A
mediados de los noventa, arrojaron todo en las chatarrerías de la zona. Estos
están llenos de piezas de computadora, componentes electrónicos y
dispositivos extraños 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 fantástica fuente de tecnología barata para hackear y
reutilizar, como lo demuestra la práctica de la flexión de circuitos antes
mencionada. Con la afluencia actual de miles de juguetes de alta tecnología muy
baratos de China, puede crear ideas rápidas con unos pocos gatos ruidosos y un par
de espadas ligeras. He estado haciendo esto por algunos años para que mis
estudiantes comprendan que la tecnología no es aterradora o difícil 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 técnica en ese manual, y lo he estado usando desde
entonces.
Camino a Arduino 15
Colaboración
La colaboración entre los usuarios es uno de los principios clave en el mundo
Arduino-a través 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. También creamos un Wiki llamado
"Playground" (www.arduino.cc/playground) donde los usuarios documentan sus
descubrimientos. Es tan asombroso ver cuánto 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 más 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 pequeño 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 extraños como resistencias,
condensadores, inductores, transistores, etc.
Cada circuito fue "cableado" para hacer una aplicación específica, y hacer cambios
necesarios para cortar cables, conexiones de soldadura, y más.
Con la aparición de tecnologías digitales y microprocesadores, estas funciones, que una

vez se implementaron con cables, fueron reemplazadas por programas de software.
El software es más fácil de modificar que el hardware. Con algunas pulsaciones de

teclas, puede cambiar radicalmente la lógica de un dispositivo y probar dos o tres
versiones en la misma cantidad de tiempo que le llevaría a soldar un par de
resistencias.
El hardware de Arduino
El tablero de Arduino es un pequeño tablero del microcontrolador, que es un pequeño
circuito (el tablero) que contiene una computadora entera en un pequeño
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 más
barato y muy útil para construir dispositivos interesantes. Mira el tablero de Arduino:
verás un chip negro con 28 "piernas" - ese chip es el ATmega168, el corazón 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 más sencillo de
usar y el mejor para aprender. Sin embargo, estas instrucciones se aplican a versiones
anteriores del tablero, incluyendo el más reciente Arduino Diecimila y el Arduino NG
más 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 podrían
ser un poco confusos. Aquí está una explicación 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 analógicos (pines 0-5)
Estos pines de entrada analógicos dedicados toman valores analógicos (es decir, lecturas
de tensión de un sensor) y los convierten en un número entre 0 y 1023.
6 Pines de Salida analógica (pines 3, 5, 6, 9, 10 y 11)
Estos son en realidad seis de los pines digitales que se pueden reprogramar para la
salida analógica utilizando el boceto que se crea en el IDE.
La placa puede ser alimentada desde el puerto USB de su computadora, la mayoría de

los cargadores USB, o un adaptador de CA (recomendado de 9 voltios, punta del cañón
de 2,1 mm, centro positivo). Si no hay ninguna fuente de alimentación enchufada en el
enchufe, la energía vendrá de la tarjeta del USB, pero tan pronto como usted tapa una
fuente de alimentación, la tarjeta la utilizará automáticamente.
NOTA: Si está utilizando el Arduino-NG antiguo o Arduino Diecimila, deberá

configurañte de selección de potencia (denominado PWR_SEL en la placa) para
especificar la alimentación 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

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 botón que carga el boceto a la pizarra: el código que se
ha escrito se traduce al lenguaje C (que generalmente es muy difícil para un
principiante) y se pasa al compilador avr-gcc , Una importante pieza de software de
código abierto que hace la traducción final al lenguaje entendido por el
microcontrolador. Este último paso es muy importante, porque es donde Arduino hace
su vida más simple ocultando lejos tanto como sea posible de las complejidades de la
programación de microcontroladores.
El ciclo de programación de Arduino es básicamente 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 través de la conexión USB y espere un par de
segundos para que la tarjeta se reinicie.
» La tabla ejecuta el boceto que escribió.
NOTA: La instalación de Arduino en Linux es algo complicada en el momento de

escribir este artículo. Consulte www.arduino.cc/playground/Learning/Linux para
obtener instrucciones completas.
Instalación 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 versión 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 todavía; Hay un paso más para realizar.
NOTA: Si tiene problemas para ejecutar el IDE de Arduino, consulte el Capítulo 7,
Solución de problemas.
Ahora debe instalar los controladores que permiten que su computadora hable con su
tarjeta a través del puerto USB.
Instalación 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
número de versión 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, asegúrese 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 continuación, instale el software del paquete FTDIUSBSerialDriver haciendo doble clic

en él. Siga las instrucciones proporcionadas por el instalador y escriba la contraseña de
un usuario administrativo si se le solicita. Al final de este proceso, reinicie el equipo para
asegurarse de que los controladores están 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" debería comenzar a parpadear. Si no es así, consulte el Capítulo 7,
Solución de problemas.
Instalación 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 opción "No, no en este momento" y haga clic en
Siguiente.
En la siguiente pantalla, elija "Instalar desde una lista o ubicación específica" y haga clic
en Siguiente.
Marque la casilla "Incluir esta ubicación en la búsqueda", haga clic en Examinar,
seleccione la carpeta donde instaló Arduino y seleccione la carpeta Drivers \ FTDI USB
Drivers como ubicación. 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 código 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 continuación, debe determinar qué puerto serie está asignado a su tarjeta Arduino:
necesitará esa información para programarla más tarde. Las instrucciones para obtener
esta información se encuentran en las siguientes secciones.
Identificación 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
Identificación del Puerto: Windows
En Windows, el proceso es un poco más complicado, al menos al principio. Abra el
Administrador de dispositivos haciendo clic en el menú Inicio, haga clic con el botón
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 máquinas Windows, el puerto COM tiene un número mayor que 9;
Esta numeración crea algunos problemas cuando Arduino trata de comunicarse con él.
Consulte el Capítulo 7, Solución de problemas para obtener ayuda sobre este
problema.
Una vez que haya descubierto la asignación 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.
4/ Realmente empezando
con Arduino
Ahora aprenderá cómo crear y programar un
dispositivo interactivo.
Anatomía de un dispositivo interactivo
Todos los objetos que construiremos usando Arduino seguirán un patrón muy simple
que llamaremos "Interactive Device". El dispositivo interactivo es un circuito electrónico
que es capaz de detectar el ambiente utilizando sensores (componentes electrónicos
que convierten las mediciones del mundo real en señales eléctricas). El dispositivo
procesa la información 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 electrónicos que pueden convertir una señal
eléctrica en una acción física.
Sentido / percepción
Sensores
Comportamien
to
(software )
Actuadores
Actuar /
Reaccionar
Figura 4-1.
El dispositivo interactivo
Sensores y Actuadores
Los sensores y actuadores son componentes electrónicos que permiten que una pieza
de electrónica interactúe con el mundo.
Como el microcontrolador es una computadora muy simple, sólo puede procesar

señales eléctricas (un poco como los impulsos eléctricos que se envían entre las
neuronas de nuestro cerebro). Para que detecte luz, temperatura u otras cantidades
físicas, necesita algo que pueda convertirlas en electricidad. En nuestro cuerpo, por
ejemplo, el ojo convierte la luz en señales que se envían al cerebro usando los nervios.
En electrónica, 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 señal que puede ser entendida por el microcontrolador.
Una vez que los sensores han sido leídos, el dispositivo tiene la información necesaria
para decidir cómo reaccionar. El proceso de toma de decisiones es manejado por el
microcontrolador, y la reacción es realizada por actuadores. En nuestros cuerpos, por
ejemplo, los músculos reciben señales eléctricas del cerebro y las convierten en un
movimiento. En el mundo electrónico, estas funciones podrían ser realizadas por un
motor eléctrico o un motor eléctrico.
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. También suele ser el
primer ejercicio de programación que alguien hace cuando aprende a programar un
microcontrolador. Un diodo emisor de luz (LED) es un pequeño componente electrónico
que es un poco como una bombilla, pero es más eficiente y requiere voltajes más bajos
para operar.
Su tarjeta Arduino viene con un LED preinstalado. Está marcado con "L". También puede
agregar su propio LED-conectarlo como se muestra en la Figura 4-2.
K indica el cátodo (negativo), o el plomo más corto; A indica el ánodo (positivo), o el

plomo más largo.
Una vez que el LED está conectado, necesita decirle a Arduino qué hacer. Esto se hace a
través de código, es decir, una lista de instrucciones que le damos al microcontrolador
para que haga lo que queremos.
Figura 4-2.
Conexión 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 continuación, escriba el siguiente texto
(Ejemplo 01) en el editor de bocetos de Arduino (la ventana principal del IDE de
Arduino). También 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 código está en su IDE, debe verificar que es correcto. Presione el botón
"Verificar" (la Figura 4-3 muestra su ubicación); Si todo está correcto, aparecerá el
mensaje "Done compilación" 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 botón Cargar en la tarjeta de

I/O (consulte la Figura 4-3). Esto restablecerá la placa, obligándola a detener lo que está
haciendo y escuchar las instrucciones procedentes del puerto USB. El IDE de Arduino
envía el boceto actual al tablero, que lo almacenará en su memoria y lo ejecutará
eventualmente.
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 comunicación entre su computadora y
Arduino. Asegúrese de haber seleccionado el puerto serie correcto (consulte el
Capítulo 3) en el menú Herramientas> Puerto serie. Además, compruebe el menú
Herramientas> Panel para confirmar que el modelo correcto de Arduino está
seleccionado allí.
Si todavía tiene problemas, consulte el Capítulo 7, Solución de problemas.
Una vez que el código 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 después se apaga durante un segundo. Si instaló un LED
separado como se muestra en la Figura 4-2, ese LED parpadeará también. 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 pequeña, y se puede programar para hacer lo que quieras. Esto se hace
usando un lenguaje de programación para escribir una serie de instrucciones en el IDE
de Arduino, que lo convierte en un ejecutable para su placa Arduino.
Te mostraré luego cómo entender el boceto. En primer lugar, el Arduino ejecuta el

código de arriba a abajo, por lo que la primera línea en la parte superior es la primera
lectura; A continuación, se mueve hacia abajo, un poco como la forma en la cabeza de
reproducción de un reproductor de vídeo como QuickTime Player o Windows Media
Player se mueve de izquierda a derecha que muestra dónde en la película que está.
Pásame el Parmesano
Observe la presencia de corchetes, que se utilizan para agrupar líneas de código. Estos
son particularmente útiles cuando se desea dar un nombre a un grupo de instrucciones.
Si estás en la cena y le preguntas a alguien: "Por favor, pásame el queso parmesano",
esto inicia una serie de acciones que se resumen en la pequeña frase que acabas de
decir. Como somos humanos, todo viene naturalmente, pero todas las pequeñas
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 código y un} después.
Puede ver que hay dos bloques de código que se definen de esta manera aquí. Ante
cada uno de ellos hay un extraño mandamiento:
void setup()
Esta línea da un nombre a un bloque de código. Si escribieras una lista de instrucciones
que enseñen a Arduino cómo pasar el parmesano, escribirías void passTheParmesan ()
al principio de un bloque, y este bloque se convertiría en una instrucción que puedes
llamar desde cualquier parte del código de Arduino. Estos bloques se llaman funciones.
Si después de esto escribes passTheParmesan () en cualquier parte de tu código,
Arduino ejecutará esas instrucciones y continuará donde lo dejó.
Arduino no es para Niños (Quitters)

Arduino espera que existan dos funciones: una llamada setup () y otra llamada loop ().
setup () es donde pone todo el código que desea ejecutar una vez al principio de su
programa y loop () contiene el núcleo 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 código se ejecuta; Cuando quieras parar, simplemente apágalo.
Reales Gitanos (Tinkeres) Escriben Comentarios

Cualquier texto que empiece por // es ignorado por Arduino. Estas líneas 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 más, para que puedan
entender tu código.
Es muy común (lo sé porque lo hago todo el tiempo) escribir un pedazo de código,
subirlo al tablero, y decir "Okay-yo nunca voy a tener que tocar a este chupón de
nuevo!" Sólo para Tenga en cuenta seis meses después que necesita actualizar el código
o corregir un error. En este punto, se abre el programa, y si no ha incluido ningún
comentario en el programa original, usted pensará: "Wow, ¡qué desastre! ¿Por dónde
empiezo? "A medida que avancemos, veremos algunos trucos para hacer que sus
programas sean más legibles y más fáciles de mantener.
El Código, paso a paso

Al principio, podrías considerar innecesario este tipo de explicación, 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 línea de los poemas, había cien
líneas de comentario! Sin embargo, la explicación será mucho más útil aquí como
usted pasa a escribir sus propios programas.
// Ejemplo 01: Blinking LED

Un comentario es una manera útil para que escribamos pequeñas notas. El comentario
del título precedente sólo nos recuerda que este programa, Ejemplo 01, parpadea un
LED.
#define LED 13 // LED conectado a

// digital pin 13
#define es como una búsqueda automática y reemplazar por su código; En este caso, le
está diciendo a Arduino que escriba el número 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 sustitución como se hace detrás de las
escenas). Estamos utilizando este comando para especificar que el LED que está
parpadeando está conectado al pin Arduino 13.
void setup()
Esta línea indica a Arduino que el siguiente bloque de código se llamará setup ().
{
Con esta abrazadera de apertura, un bloque de código comienza.
pinMode(LED, OUTPUT); // establece el formato digital

// pin como salida.
Finalmente, una instrucción realmente interesante. pinMode le indica a Arduino cómo
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 número del pin y su modo dentro de los paréntesis. pinMode es una
función, y las palabras (o números) especificados dentro de los paréntesis 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 función 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 pequeña, 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 código, una instrucción en
software hace que algo suceda en el mundo físico mediante el control del flujo de
electricidad a la clavija. Encender y apagar el pin a voluntad ahora vamos a traducir
estos en algo más visible para un ser humano; El LED es nuestro actuador.
delay(1000);. // espera un segundo

Arduino tiene una estructura muy básica. Por lo tanto, si usted quiere que las cosas
sucedan con cierta regularidad, dígale que se siente tranquilamente y no haga nada
hasta que es hora de ir al siguiente paso. delay() básicamente 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 instrucción ahora apaga el LED que habíamos activado anteriormente. ¿Por qué
usamos HIGH y LOW? Bueno, es una vieja convención en electrónica digital. HIGH
significa que el pin está encendido, y en el caso de Arduino, se ajustará a 5 V. LOW
significa 0 V. También 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 función de bucle.
Para resumir, este programa hace esto:
» Convierte el pin 13 en una salida (sólo 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á más sobre cómo programar a
medida que vaya a través de los ejemplos posteriores.
Antes de pasar a la siguiente sección, quiero que juegues con el código. Por ejemplo,
reduzca la cantidad de retardo, usando números 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 pequeños,
pero el uso de diferentes retrasos para encendido y apagado. . . Hay un momento en
que sucede algo extraño; Este "algo" será muy útil cuando aprenda sobre la modulación
de ancho de pulso más 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 través de la tecnología. 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 cómo
diseñar "lámparas interactivas", usando Arduino como una forma de aprender los
conceptos básicos de cómo se construyen los dispositivos interactivos.
En la siguiente sección, voy a tratar de explicar los fundamentos de la electricidad de

una manera que aburriría a un ingeniero, pero no asustará a un nuevo programador de
Arduino.
¿Qué es la electricidad?
Si usted ha hecho cualquier plomería en casa, la electrónica no será un problema para

que usted entienda. Para entender cómo funcionan los circuitos eléctricos y eléctricos,
la mejor manera es usar algo llamado la "analogía del agua". Tomemos un dispositivo
simple, como el ventilador portátil alimentado por batería que se muestra en la Figura
4-4.
Figura 4-4.
Un ventilador pportáti
Si usted toma un ventilador aparte, usted verá que contiene una batería pequeña, un
par de alambres, y un motor eléctrico, y que uno de los alambres que van al motor es
interrumpido por un interruptor. Si tiene una batería nueva y encienda el interruptor, el
motor empezará a girar, proporcionando el frío necesario. ¿Como funciona esto?
Bueno, imagínese que la batería es un depósito 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 hidráulico, que se muestra en la Figura 4-5, son importantes dos
factores: la presión del agua (que se determina por la potencia de la bomba) y la
cantidad de agua que fluirá en las tuberías (esto depende del tamaño De las tuberías y
la resistencia que la rueda proporcionará a la corriente de agua que la golpee).
Figura 4-5.
Un sistema hidráulico
Pronto se dará cuenta de que si desea que la rueda gire más rápido, necesita aumentar
el tamaño de las tuberías (pero esto sólo funciona hasta un punto) y aumentar la
presión que la bomba puede lograr. Aumentar el tamaño de las tuberías permite un
mayor flujo de agua para atravesarlas; Haciéndolos más 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á más rápido, porque la presión del agua no es
lo suficientemente fuerte. Cuando llegamos a este punto, necesitamos que la bomba
sea más fuerte. Este método 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 fricción 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 energía que bombas en
el sistema se convertirá en movimiento; Algunos se perderán en una serie de
ineficiencias y generalmente se mostrará como el calor que emana de algunas partes
del sistema.
¿Cuáles son las partes importantes del sistema? La presión producida por la bomba es
una; La resistencia que las tuberías y la rueda ofrecen al flujo de agua, y el flujo real de
agua (digamos que esto se representa por el número 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 batería o un enchufe de
pared) que empuja las cargas eléctricas (imagínelas como "gotas" de electricidad) hacia
abajo de las tuberías, que están representadas por los cables-algunos dispositivos
pueden utilizar Estos para producir calor (manta térmica de su abuela), luz (su lámpara
de dormitorio), sonido (su estéreo), movimiento (su ventilador), y mucho más.
Así que cuando lea que el voltaje de una batería es de 9 V, piense en este voltaje como
la presión del agua que potencialmente puede ser producida por esta pequeña
"bomba". El voltaje se mide en voltios, llamado así por Alessandro Volta, el inventor de
la primera batería.
Así como la presión del agua tiene un equivalente eléctrico, el caudal de agua también
lo hace. Esto se llama corriente, y se mide en amperios (después de André-Marie
Ampère, pionero del electromagnetismo). La relación entre tensión y corriente se
puede ilustrar volviendo a la rueda de agua: un voltaje más alto (presión) le deja girar
una rueda más rápidamente; Una mayor velocidad de flujo (corriente) le permite girar
una rueda más 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
(después del físico alemán Georg Ohm). Herr Ohm también fue responsable de formular
la ley más importante en la electricidad y la única fórmula que realmente necesita
recordar. Fue capaz de demostrar que en un circuito el voltaje, la corriente y la
resistencia están todos relacionados entre sí, y en particular que la resistencia de un
circuito determina la cantidad de corriente que fluirá a través de él, dada una cierta
fuente de voltaje .
Es muy intuitivo, si lo piensas. Tome una batería de 9 V y conéctelo en un circuito

simple. Mientras mide corriente, encontrará que cuanto más resistencias añada al
circuito, menos corriente viajará a través de él. Volviendo a la analogía del agua que
fluye en las tuberías, dada una cierta bomba, si instalo una válvula (que podemos
relacionar con una resistor variable en electricidad), cuanto más cierre la válvula
aumentando la resistencia al flujo de agua, menos agua Fluirá a través de las tuberías.
Ohm resumió su ley en estas fórmulas:
R (resistencia) = V (tensión) / 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 mayoría de tu trabajo, ésta es la única que realmente necesitarás.
Uso de un pulsador para controlar el LED

Parpadeando un LED fue fácil, pero no creo que se quedaría sano si su lámpara de
escritorio continuamente parpadea mientras estaba tratando de leer un libro. Por lo
tanto, usted necesita aprender cómo 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 más simple de sensor disponible: un pulsador.
Si desmontas un pulsador, verás que es un dispositivo muy simple: dos pedazos de

metal separados por un muelle, y un tapón de plástico que cuando se presiona pone en
contacto los dos trozos de metal. Cuando los trozos de metal están separados, no hay
circulación de corriente en el pulsador (un poco como cuando una válvula de agua está
cerrada); Cuando lo presionamos, hacemos una conexión.
Para supervisar el estado de un interruptor, hay una nueva instrucción de Arduino que
usted va a aprender: la función digitalRead().
digitalRead() comprueba si hay algún voltaje aplicado al pin que se especifica entre
paréntesis y devuelve un valor de HIGH o LOW dependiendo de sus resultados. Las otras
instrucciones que hemos usado hasta ahora no han devuelto ninguna información:
simplemente ejecutaron lo que les pedimos que hicieran. Pero ese tipo de función 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 más tarde.
Construya el circuito mostrado en la Figura 4-6. Para construir esto, necesitará obtener
algunas partes (estas serán útiles a medida que trabaje en otros proyectos también):
» Tablero sin soldadura: RadioShack (www.radioshack.com) número de pieza 276-002,

Maker Shed (www.makershed.com) número de pieza MKKN3. El Apéndice A es una
introducción 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 momentáneo: SparkFun COM-00097
Figura 4-6.
Conexión de un pulsador
NOTA: en lugar de comprar alambre de puente, usted también puede comprar
alambre de conexión de sólidos de 22 AWG en pequeños carretes y cortar y pelar
utilizando cortadores de alambre y separadores de alambre.
Echemos un vistazo al código que vamos a utilizar para controlar el LED con nuestro
pulsador:
// Ejemplo 02: Encender el LED mientras se pulsa el botón
#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 (botón 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
PushButtonControl. Escriba el código del ejemplo 02 en Arduino (o descárguelo desde
www.makezine.com/getstartedarduino y péguelo en el IDE de Arduino). Si todo es
correcto, el LED se encenderá al presionar el botónn.
¿Como funciona esto?
He introducido dos nuevos conceptos con este programa de ejemplo: funciones que
devuelven el resultado de su trabajo y la instrucción if.
La sentencia if es posiblemente la instrucción más importante en un lenguaje de

programación, ya que permite que la computadora (y recuerde, el Arduino es un
pequeño ordenador) para tomar decisiones. Después de la palabra clave if, hay que
escribir una "pregunta" dentro de paréntesis, y si la "respuesta", o resultado, es
verdadera, se ejecutará el primer bloque de código; De lo contrario, se ejecutará el
bloque de código después de otro. Tenga en cuenta que he usado el símbolo == 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. Asegúrese de que utiliza el correcto,
porque es muy fácil cometer ese error y usar sólo =, en cuyo caso su programa nunca
funcionará. Lo sé, porque después de 25 años de programación, todavía cometo ese
error.
Mantener el dedo en el botón durante el tiempo que necesita luz no es práctico.

Aunque te haría pensar en la cantidad de energía que estás desperdiciando cuando te
alejas de una lámpara que te quedaste en, tenemos que averiguar cómo hacer que el
botón de encendido "palo".
Un circuito, mil comportamientos
La gran ventaja de la electrónica digital y programable sobre la electrónica clásica es

ahora evidente: te mostraré cómo implementar muchos "comportamientos" diferentes
usando el mismo circuito electrónico que en la sección anterior, simplemente
cambiando el software.
Como he mencionado antes, no es muy práctico tener que mantener el dedo en el

botón 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 botón y mantendrá la luz encendida incluso después 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 número de teléfono: 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: sólo decide qué tipo de datos desea
almacenar (un número 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 número 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

código, para que más adelante en su programa, podría escribir:
val = 112;
Que reasigna un nuevo valor, 112, a su variable.
NOTA: ¿Ha notado que en Arduino, todas las instrucciones, con una excepción
(#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 declaración ha terminado y una nueva está comenzando.
Recuerde usarlo todo el tiempo, excluyendo cualquier línea que comience con #define.
Los #define son reemplazados por el compilador antes de que el código 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 línea de código la cambie. Observe que las variables utilizan un tipo de memoria
llamada RAM. Es bastante rápido, 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 teléfono móvil para
almacenar números de teléfono- 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 después de soltar el botón. El ejemplo 03A es un primer intento
de lograr:
// Ejemplo 03A: Encender el LED cuando se presiona el botón

// y mantenerlo encendido después 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 (botón pulsado)

// y cambiar el estado
if (val == HIGH) {
state = 1 state;
}
if (state == 1) {
digitalWrite(LED, HIGH); // turn LED ON
} else {
}
}
Ahora prueba este código. Usted notará que funciona. . . algo. Usted encontrará que la
luz cambia tan rápidamente que usted no puede fijarla confiablemente encendido o
apagado con una prensa del botón.
Veamos las partes interesantes del código: state es una variable que almacena 0 o 1
para recordar si el LED está encendido o apagado. Después de soltar el botón, lo
inicializamos a 0 (LED apagado).
Más tarde, leemos el estado actual del botón, y si se presiona (val == HIGH), cambiamos
el estado de 0 a 1, o viceversa. Hacemos esto usando un pequeño truco, ya que el
estado puede ser solo 1 o 0. El truco que uso involucra una pequeña expresión
matemática basada en la idea de que 1 - 0 es 1 y 1 - 1 es 0:
state = 1 state;
La línea puede no tener mucho sentido en matemáticas, pero sí en la programación. El

símbolo = significa "asignar el resultado de lo que está detrás 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.
Más 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 botón. Arduino es
muy rápido; Ejecuta sus propias instrucciones internas a una tasa de 16 millones por
segundo, podría estar ejecutando unas pocas millones de líneas de código por segundo.
Así que esto significa que mientras tu dedo está presionando el botón, Arduino podría
estar leyendo la posición del botón unos miles de veces y cambiando de estado en
consecuencia. Así que los resultados terminan siendo impredecibles; Podría estar
apagado cuando usted lo quisiera encendido, o viceversa. Como incluso un reloj roto es
correcto dos veces al día, el programa puede mostrar el comportamiento correcto de
vez en cuando, pero la mayor parte del tiempo va a estar mal.
¿Cómo arreglamos esto? Bueno, necesitamos detectar el momento exacto en que se

presiona el botón, 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 posición actual del botón con el anterior y cambiar el
estado sólo cuando el botón se convierte en ALTO después de ser LOW.
El ejemplo 03B contiene el código 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 {
}
Pruébelo: estamos casi allí!
Usted puede haber notado que este acercamiento no es enteramente perfecto, debido
a otro problema con los interruptores mecánicos. Los pulsadores son dispositivos muy
simples: dos pedazos de metal separados por un resorte. Cuando presiona el botón, los
dos contactos se unen y la electricidad puede fluir. Esto suena bien y simple, pero en la
vida real la conexión no es tan perfecta, especialmente cuando el botón no está
completamente presionado, y genera algunas señales espurias llamadas rebote.
Cuando el pulsador está rebotando, el Arduino ve una secuencia muy rápida de señales
de encendido y apagado. Hay muchas técnicas desarrolladas para hacer de-rebote, pero
en este pedazo simple del código he notado que es generalmente bastante para agregar
un retraso 10 - a 50 milisegundos cuando el código detecta una transición.
El ejemplo 03C es el código 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 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() {
void loop(){
val = digitalRead(BUTTON); // read input value and store it // yum, fresh

(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 {
}
}
5/ Entrada y salida
avanzadas
Lo que acabamos de aprender en el Capítulo 4
son las operaciones más elementales que
podemos hacer en Arduino: controlar la salida
digital y leer la entrada digital. Si Arduino fuera
algún tipo de lenguaje humano, éstas serían dos
letras de su alfabeto. Teniendo en cuenta que hay
sólo cinco letras en este alfabeto, se puede ver
cuánto más trabajo que tenemos que hacer antes
de que podamos escribir Arduino poesía.
Prueba de otros sensores de encendido / apagado
Ahora que ha aprendido a utilizar un pulsador, debe saber que hay muchos otros
sensores muy básicos que funcionan de acuerdo con el mismo principio:
Interruptores
Al igual que un pulsador, pero no cambia automáticamente el estado cuando se

suelta
Termostatos
Un interruptor que se abre cuando la temperatura alcanza un valor establecido
Interruptores magnéticos (también conocidos como "relés de lámina")
Tiene dos contactos que se juntan cuando están cerca de un imán; Utilizado por las
alarmas antirrobo para detectar cuando se abre una ventana
Interruptores de alfombra
Pequeñas 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 inclinación
Un componente electrónico simple que contiene dos contactos y una pequeña

bola de metal (o una gota de mercurio, pero no recomiendo usarlos) Un ejemplo
de un interruptor de inclinación se llama un sensor de inclinación. La figura 5-1
muestra el interior de un modelo típico. Cuando el sensor está en su posición
vertical, la bola puentea los dos contactos, y esto funciona como si hubiera
presionado un botón. 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 inclinación
Otro sensor que quizás quiera probar es el sensor de infrarrojos que se encuentra
en las alarmas antirrobo (también conocido como sensor infrarrojo pasivo o sensor
PIR, vea la Figura 5-2). Este pequeño 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 típico
Ahora debe experimentar mirando todos los dispositivos posibles que tienen dos
contactos que se cierran, como el termostato que fija la temperatura de la
habitación (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 Capítulo 4 y un sensor PIR, usted podría
hacer que su lámpara respondiera a la presencia de seres humanos, o podría usar
un interruptor de inclinación 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, podría construir una
lámpara interactiva que puede ser controlada y no sólo con un aburrido
interruptor de encendido / apagado, pero tal vez de una manera que es un poco
más elegante. Una de las limitaciones de los ejemplos de LED parpadeantes que
hemos utilizado hasta ahora es que sólo se puede encender y apagar la luz. Una
lámpara interactiva de fantasía necesita ser regulable. Para resolver este
problema, podemos usar un pequeño truco que hace posible muchas cosas como
TV o cine: la persistencia de la visión.
Como he sugerido después del primer ejemplo en el capítulo 4, si cambia los

números en la función de retardo hasta que no vea el LED parpadeando más,
notará que el LED parece atenuado al 50% de su brillo normal. Ahora cambie los
números 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
técnica se llama modulación de ancho de pulso (PWM), una manera elegante de
decir que si parpadea el LED lo suficientemente rápido, no lo ve parpadear más,
pero puede cambiar su brillo cambiando la relación entre el tiempo de encendido
y El tiempo de apagado. La Figura 5-3 muestra cómo funciona esto.
Esta técnica también 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 código

es un poco incómodo, 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 instrucción analogWrite ().
Figura 5-3.
PWM en acción.
Por ejemplo, escribir analogWrite(9,128) Ajustará el brillo de un LED conectado al

pin 9 al 50%. ¿Por qué 128? AnalogWrite () espera un número 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 están polarizados: el pasador largo (positivo) debe ir a la derecha y el
pasador corto (negativo) a la izquierda. Además, la mayoría de los LED tienen un
lado negativo aplanado, como se muestra en la figura.
Figura 5-4.
LED conectado al pin PWM.
A continuación, cree un nuevo boceto en Arduino y utilice el Ejemplo 04 (también

puede descargar ejemplos de código de www.makezine.com/getstartedarduino):
// Example 04: Fade an LED in and out like on

// a sleeping Apple computer

int i = 0; // We’ll 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 característica de fantasía de una computadora
portátil (tal vez es un poco de un desperdicio para utilizar Arduino para algo tan
simple). Vamos a usar este conocimiento para mejorar nuestra lámpara.
Añada el circuito que usamos para leer un botón (en el Capítulo 4) a esta tabla de
pruebas. Vea si puede hacer esto sin mirar la siguiente página, porque quiero que
comience a pensar en el hecho de que cada circuito elemental que muestro aquí
es un "bloque de construcción" para hacer proyectos más grandes y más grandes.
Si necesita mirar hacia el futuro, no se preocupe; Lo más importante es que pases
un tiempo pensando en cómo podría verse.
Para crear este circuito, tendrá que combinar el circuito recién 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 montón de espacio. Sin embargo, una de las
ventajas de la placa de pruebas (véase el apéndice A) es que hay un par de rieles
que se extienden horizontalmente a través 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 energía 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 podría
conectar estos dos circuitos exactamente como se muestra en cada una de las dos
figuras; Sólo enganchar a los dos hasta el Arduino al mismo tiempo. O bien, podría
conectar un cable del carril de tierra de la placa de panificación a uno de los pines
GND del Arduino y, a continuación, tomar los cables que están 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 Capítulo 6.
Volviendo al siguiente ejemplo, si solo tenemos un pulsador, ¿cómo controlamos

el brillo de una lámpara? Vamos a aprender otra técnica de diseño de interacción:
detectar cuánto tiempo se ha presionado un botón. Para hacer esto, necesito
actualizar el ejemplo 03C del capítulo 4 para agregar atenuación. La idea es
construir una "interfaz" en la que una acción de prensa y liberación encienda y
apague la luz, y una acción 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() {
void loop() {
val = digitalRead(BUTTON); // read input value and store it // yum,
fresh

(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 // let’s go back to 0

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

if (state == 1) {
analogWrite(LED, brightness); // turn LED ON at the // current
brightness level } else {
analogWrite(LED, 0); // turn LED OFF }
}
Ahora inténtalo. Como puede ver, nuestro modelo de interacción está tomando
forma. Si presiona el botón y lo suelta inmediatamente, se enciende o apaga la
lámpara. Si mantiene pulsado el botón, el brillo cambia; Sólo deje ir cuando haya
alcanzado el brillo deseado.
Ahora vamos a aprender a usar algunos sensores más 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 (número 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 rápidamente
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 botón pulsador
para controlar el LED" en el Capítulo 4), luego cargue el código del Ejemplo 02 en
su Arduino.
Ahora conecte el LDR en la placa de pan en lugar del botón. Usted notará que si
usted cubre el LDR con sus manos, el LED se apaga. Descubre el LDR, y la luz
continúa. Acabas de construir tu primer sensor LED impulsado por sensores. Esto
es importante porque, por primera vez en este libro, estamos utilizando un
componente electrónico que no es un simple dispositivo mecánico: es un sensor
real rico.
Entrada analógica
Como aprendió en la sección anterior, Arduino es capaz de detectar si hay un
voltaje aplicado a uno de sus pines e informarlo a través de la función
digitalRead() . Este tipo de respuesta está bien en muchas aplicaciones, pero el
sensor de luz que acabamos de usar es capaz de decirnos no sólo si hay luz, sino
también cuánta luz hay. Esta es la diferencia entre un sensor de encendido /
apagado (que nos dice si hay algo) y un sensor analógico, 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, verás seis pasadores marcados

con "Analog In"; Estos son pernos especiales que pueden decirnos no sólo si hay
un voltaje aplicado a ellos, pero si es así, también su valor. Usando la función
analogRead() , podemos leer el voltaje aplicado a uno de los pines. Esta función
devuelve un número entre 0 y 1023, que representa voltajes entre 0 y 5 voltios.
Por ejemplo, si hay una tensión de 2,5 V aplicada al número 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 código listado en el Ejemplo 06A, verá el LED integrado (también
podría insertar su propio LED en los pines 13 y GND como Que se muestra en
"Parpadeando un LED" en el Capítulo 4) parpadeando a una velocidad que
depende de la cantidad de luz que golpea el sensor.
Figura 5-6.
Un circuito sensor analógico
// Example 06A: Blink LED at a rate specified by the
// value of the analogue input

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, necesitarás
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
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 número hasta 1023, y analogWrite() acepta un máximo de 255.
Pruebe otros sensores analógicos

Utilizando el mismo circuito que ha visto en la sección anterior, puede conectar
muchos otros sensores resistivos que funcionan de forma más o menos igual. Por
ejemplo, podría conectar un termistor, que es un dispositivo simple cuya
resistencia cambia con la temperatura. En el circuito, le he mostrado cómo 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 conexión directa
entre el valor que lee y la temperatura real medida. Si necesita una lectura exacta,
debe leer los números que salen del pin analógico mientras se mide con un
termómetro real. Usted podría poner estos números uno al lado del otro en una
tabla y elaborar una manera de calibrar los resultados analógicos a las
temperaturas del mundo real.
Hasta ahora, hemos utilizado un LED como dispositivo de salida, pero ¿cómo
podemos leer los valores reales que Arduino está leyendo desde el sensor? No
podemos hacer que la pizarra parpadee los valores en código Morse (bueno,
podríamos, pero hay una manera más fácil para que los humanos lean los valores).
Para ello, podemos hacer que Arduino hable con un ordenador a través de un
puerto serie, que se describe en la siguiente sección.
Comunicación serial
Usted aprendió al principio de este libro que Arduino tiene una conexión USB que
es utilizada por el IDE para cargar código en el procesador. La buena noticia es que
esta conexión también 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 propósito, vamos a utilizar un objeto en serie (un objeto es una colección
de capacidades que se agrupan para la conveniencia de las personas que escriben
bocetos).
Este objeto contiene todo el código 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
código en un nuevo boceto (también puede descargar el código 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
}
Después de subir el código a su Arduino, presione el botón "Serial Monitor" en el

Arduino IDE (el botón más a la derecha en la barra de herramientas); Usted verá
los números que ruedan más 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 programación 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.
Conducción de cargas más grandes (Motores, lámparas 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
pequeña de corriente, lo suficiente para conducir un LED. Si usted intenta conducir
algo como un motor, el perno dejará de funcionar inmediatamente, y podría
quemar potencialmente el procesador entero. Para impulsar cargas más grandes
como motores o lámparas 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 electrónico que puede ser impulsado
mediante la aplicación 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 acción 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 través 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 través de
una capa de óxido metálico, no hay corriente que fluye de Arduino en el MOSFET,
por lo que es muy fácil de interfaz. Son ideales para encender y apagar grandes
cargas a altas frecuencias.
En la Figura 5-7, puede ver cómo usaría un MOSFET como el IRF520 para encender
y apagar un pequeño motor conectado a un ventilador. Usted también notará que
el motor toma su fuente de alimentación desde el conector de 9 V de la tarjeta
Arduino. Este es otro beneficio del MOSFET: nos permite conducir dispositivos
cuya fuente de alimentación difiere de la utilizada por Arduino. Como el MOSFET
está conectado al pin 9, también podemos usar analogWrite () para controlar la
velocidad del motor a través de PWM.
Sensores Complejos
Definimos sensores complejos como aquellos que producen un tipo de
información que requiere un poco más de un digitalRead() o una función
analogRead() para ser usada. Estos suelen ser pequeños circuitos con un pequeño
microcontrolador dentro que preprocesa la información.
Algunos de los sensores complejos disponibles incluyen guardabosques

ultrasónicos, guardabosques infrarrojos y acelerómetro. Puede encontrar
ejemplos sobre cómo utilizarlos en nuestro sitio web en la sección "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 capítulos anteriores, aprendiste los

fundamentos de Arduino y los bloques de
construcción fundamentales disponibles para ti.
Permítanme 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 más.
Salida analógica
Esto nos da la capacidad de controlar el brillo del LED, no sólo 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 inclinación.
Entrada analogica
Podemos leer las señales de los sensores que envían una señal continua que no
sólo está encendida o apagada, como un potenciómetro o un sensor de luz.
Comunicación 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 capítulo, vamos a ver cómo elaborar una aplicación de trabajo utilizando lo
aprendido en los capítulos anteriores. Este capítulo debe mostrar cómo cada
ejemplo puede ser utilizado como un bloque de construcción para un proyecto
complejo.
Aquí es donde el diseñador de wannabe en mí sale. Vamos a hacer la versión del
siglo XXI de una lámpara clásica de mi diseñador italiano favorito, Joe Colombo. El
objeto que vamos a construir está inspirado en una lámpara llamada "Aton" de
1964.
Figura 6-1.
La lámpara terminada
La lámpara, 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
diseño le permite orientar la lámpara en diferentes direcciones.
En términos de funcionalidad, queremos construir un dispositivo que se conecte a

Internet, buscar la lista actual de artículos en el blog Make (makezine.com) y
contar cuántas veces las palabras "peace", "love", " Y "Arduino". Con estos
valores, vamos a generar un color y mostrarlo en la lámpara. La propia lámpara
tiene un botón que podemos usar para encenderlo y apagarlo, y un sensor de luz
para la activación automática.
Planificación
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 sólo un puerto USB, no podemos conectarlo
directamente a una conexión a Internet, así que necesitamos averiguar cómo
conectar los dos. Por lo general, lo que la gente hace es ejecutar una aplicación en
una computadora que se conecte a Internet, procese los datos y envíe a Arduino
un poco de información destilada.
Arduino es una computadora sencilla con una pequeña memoria; No puede
procesar archivos grandes fácilmente, y cuando nos conectamos a un feed RSS,
obtendremos un archivo XML muy detallado que requeriría mucho más 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 enseñar programación a principiantes, así como para crear código hermoso.
Procesamiento y Arduino son la combinación perfecta. Otra ventaja es que
Processing es de código abierto y se ejecuta en todas las plataformas principales
(Mac, Linux y Windows). También puede generar aplicaciones independientes que
se ejecutan en esas plataformas. Lo que es más, 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 número de veces que "paz", "amor" y "Arduino"
aparecen en el texto. Con estos tres números, 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 comunicación
serial.
Como Arduino es un dispositivo simple, tendremos que codificar el color de una
manera sencilla. Usaremos la forma estándar en la que los colores se representan
en HTML: # seguido de seis dígitos hexadecimales.
Los números hexadecimales son útiles, porque cada número de 8 bits se almacena
en exactamente dos caracteres; Con números decimales varía de uno a tres
caracteres. La previsibilidad también hace que el código sea más 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.
Codificación
Hay dos bocetos que se ejecutarán: un boceto de procesamiento y un boceto de
Arduino. Aquí está el código 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
continuación, con el boceto aún abierto, haga clic en el menú Herramientas de
procesamiento y, a continuación, seleccione Crear fuente. Seleccione la fuente
HelveticaNeue-Bold, elija 32 para el tamaño de fuente y, a continuación, 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 mayoría de los sistemas, este boceto de procesamiento funcionará
correctamente. Sin embargo, si no ve nada que ocurra en el Arduino y no vea
ninguna información 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 (también 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 cómo ensamblar el circuito. Es necesario usar resistores de
10K para todas las resistencias que se muestran en el diagrama, aunque se podría
escapar con valores más bajos para las resistencias conectadas a los LEDs.
Recuerde en el ejemplo PWM en el capítulo 5 que los LED están polarizados: en

este circuito, el pasador largo (positivo) debe ir a la derecha y el pasador corto
(negativo) a la izquierda. (La mayoría 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

continuación, cargue los bocetos en Arduino y Processing, luego ejecute los
bocetos y pruébelo. Si tiene algún problema, consulte el Capítulo 7, "Solución de
problemas".
Ahora vamos a completar la construcción mediante la colocación de la placa de

pan en una esfera de vidrio. La forma más sencilla y barata de hacerlo es comprar
una lámpara 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 "cátodo común" ")
Va a la tierra.
SparkFun vende un LED RGB de 4 conductores por unos pocos dólares

(www.sparkfun.com, número de pieza COM-00105). Además, a diferencia de
los LED monocromos discretos, el cable más largo en este LED RGB es el que va
a tierra. Los tres cables más cortos tendrán 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 cómo montarlo:

Desembale la lámpara y retire el cable que va desde la parte inferior hacia la
lámpara. 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 lámpara.
Soldar los cables más largos al LED RGB y pegarlo donde la bombilla solía ser.
Conecte los cables que vienen del LED a la placa de pruebas (donde se conectó
antes de retirarla). Recuerde que sólo necesitará una conexión 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
cartón que viene con la lámpara en aproximadamente 5cm (o 2 ") y hacer un
agujero con un diámetro que Cunega la lámpara Refuerce el interior de la caja de
cartón usando el pegamento caliente a lo largo de los bordes interiores, que hará
la base más estable.
Coloque la esfera en el soporte y sacar el cable USB de la parte superior y

conectarlo al ordenador.
Apague el código de procesamiento, presione el botón de encendido / apagado y

observe que la lámpara cobra vida.
Como ejercicio, trate de agregar código que encienda la lámpara cuando la
habitación se oscurezca. Otras mejoras posibles son::
» Agregue sensores de inclinación para encender o apagar la lámpara girándola en

diferentes direcciones.
» Agregue un pequeño sensor PIR para detectar cuando alguien está alrededor y
apáguelo cuando no haya nadie para verlo.
» Crear diferentes modos para que pueda obtener control manual del color o
hacer que se desvanecen a través de muchos colores.
¡Piense en cosas diferentes, experimente y diviértase!

7/ Solución de problemas
Llegará un momento en su experimentación
cuando nada funcionará y usted tendrá que
averiguar cómo arreglarlo. Solución de problemas
y depuración son las artes antiguas en las que hay
algunas reglas simples, pero la mayoría de los
resultados se obtienen a través de un montón de
trabajo.
Cuanto más trabajes con la electrónica y Arduino, más aprenderás y ganarás
experiencia, lo que en última instancia hará que el proceso sea menos doloroso.
No se desanime por los problemas que usted encontrará - es todo más fácil de lo
que parece al principio.
Como cada proyecto basado en Arduino se hace tanto de hardware como de

software, habrá más de un lugar para ver si algo sale mal. Mientras busca un error,
debe operar a lo largo de tres líneas:
Comprensión
Trate de entender lo más posible cómo las partes que usted está usando el trabajo
y cómo se supone que deben contribuir al proyecto terminado. Este enfoque le
permitirá diseñar alguna forma de probar cada componente por separado.
Simplificación y segmentación
Los antiguos romanos solían decir divide et impera: dividir y gobernar. Trate de
descomponer (mentalmente) el proyecto en sus componentes utilizando la
comprensión que tiene y averigüe dónde empieza y termina la responsabilidad de
cada componente.
Exclusión 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 están haciendo su
trabajo y cuáles son dudosas.
Depuración es el término utilizado para describir este proceso aplicado al software.

La leyenda dice que fue utilizada por primera vez por Grace Hopper en la década
de 1940, cuando las computadoras eran en su mayoría electromecánicas, y una de
ellas dejó de funcionar porque los insectos reales quedaron atrapados en los
mecanismos.
Muchos de los insectos de hoy en día ya no son físicos: 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 sería 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 línea aérea cuando pasan por una lista
de comprobación para asegurarse de que el avión estará volando correctamente
antes de despegar:
Enchufe su Arduino en un enchufe USB en su computadora.
» Asegúrese 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 débil, 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 algún daño. 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 patrón nervioso; Este es el programa de prueba que se cargó en la
fábrica para probar el tablero.
» Si ha estado utilizando una fuente de alimentación externa y está usando un
Arduino antiguo (Extreme, NG o Diecimila), asegúrese de que la fuente de
alimentación está conectada y de que el puente marcado SV1 está
conectando los dos pines más cercanos al externo Conector de la fuente de
alimentación.
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
patrón regular.
Si ha superado todos estos pasos con éxito, puede estar seguro de que su Arduino
funciona correctamente.
Prueba de su circuito de panificación

Ahora conecte la placa a su tablero de pruebas mediante la ejecución 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
energía consigue cortada para proteger la computadora.
NOTA: Si le preocupa que pueda dañar su computadora, recuerde que en muchas

computadoras, la protección actual es generalmente bastante buena y responde
rápidamente. Además, la tarjeta Arduino está equipada con un "PolyFuse", un
dispositivo de protección de corriente que se restablece cuando se elimina el
fallo.
Si eres realmente paranoico, siempre puedes conectar la placa Arduino a través

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 "simplificación y
segmentación". Lo que debe hacer es pasar por cada sensor en el proyecto y
conectar sólo uno a la vez.
La primera cosa a partir de es siempre la fuente de alimentación (las conexiones de

5 V y GND). Mire a su alrededor y asegúrese de que cada parte del circuito se
alimenta correctamente.
Trabajar paso a paso y hacer una sola modificación a la vez es la regla número 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 créanme, sucede mucho), su cara aparece en mi
cabeza diciendo "una modificación a la vez. . . Una modificación a la vez "y que
suele ser cuando lo arreglo todo. Esto es muy importante, porque sabrás lo que
arregló el problema (es muy fácil perder la pista de qué modificación realmente
resolvió el problema, por lo que es tan importante hacer uno a la vez).
Cada experiencia de depuración 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 rápida y tener la respuesta en
una fracción 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. También es muy útil cuando necesitas explicar a alguien lo que está
pasando.
Describir el problema con la mayor precisión posible también es una buena manera
de encontrar una solución. Trate de encontrar a alguien para explicar el problema-
en muchos casos, una solución 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 tenían 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 método alternativo para iniciar Arduino.
Los usuarios de Windows también pueden encontrarse con un problema si el

sistema operativo asigna un número de puerto COM de COM10 o superior a
Arduino. Si esto sucede, normalmente puede convencer a Windows para asignar
un número de puerto inferior a Arduino. En primer lugar, abra el Administrador de
dispositivos haciendo clic en el menú Inicio, haga clic con el botón 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 botón derecho en él y elija Propiedades en el menú. A
continuación, elija la ficha Configuración del puerto y haga clic en Avanzado.
Establezca el número de puerto COM a COM10 o superior, haga clic en Aceptar y
vuelva a hacer clic en Aceptar para cerrar el cuadro de diálogo Propiedades.
Ahora, haga lo mismo con el dispositivo USB Serial Port que representa Arduino,
con un cambio: asigne el número 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 página de solución de problemas de Arduino en www.arduino.cc/es/
Guía / Solución de problemas.
Cómo obtener ayuda en línea

Si está atascado, no pase días 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 hábito de cortar y pegar cosas en un motor de búsqueda y ver si alguien
está hablando de ello. Por ejemplo, cuando el IDE de Arduino escupe un mensaje
de error repugnante, cópielo y péguelo en una búsqueda de Google y vea lo que
sale. Haz lo mismo con bits de código en los que estás trabajando o con un nombre
de función específico. Mira a tu alrededor: todo ya ha sido inventado y está
almacenado en alguna parte de una página web.
Para más información, 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 documentación. Es una de las mejores
partes de toda la filosofía de código abierto. La gente aporta documentación 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 código o un diagrama de
circuito para empezar.
Si todavía 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 información que puedas:
» ¿Qué tablero de Arduino está usando?
» ¿Qué sistema operativo está utilizando para ejecutar el IDE de Arduino?
» Dé una descripción general de lo que está tratando de hacer. Publicar enlaces a

hojas de datos de partes extrañas que está utilizando.
El número 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 línea, no sólo para Arduino):
» Escribiendo su mensaje en MAYÚSCULAS. Se molestan a la gente mucho y es
como caminar con "novato" tatuado en la frente (en las comunidades en línea,
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, ¿cómo es que nadie respondió?" O peor aún, simplemente publicar el
texto "bump". Si no recibió una respuesta, eche un vistazo a su publicación.
¿Estaba claro el tema? ¿Usted proporcionó una descripción 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 específica sobre una parte del proyecto y tomarlo desde allí.
Una variación del punto anterior es cuando la pregunta es claramente algo que
» el cartel del mensaje se está pagando para hacer. Si usted hace preguntas
específicas 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.
Apéndice 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 rápido e iterativo que es
algo así como un equivalente electrónico al bosquejo. El diseño 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 más rápida, más práctica y menos destructiva. Estos
requisitos claramente descartan la soldadura, que es un procedimiento que requiere
mucho tiempo y que pone a los componentes bajo tensión cada vez que los calienta y
los enfría.
La respuesta a este problema es un dispositivo muy práctico llamado la placa de soldar

sin soldadura. Como se puede ver en la Figura A-1, se trata de un pequeño tablero de
plástico 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 conexión eléctrica 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 mayoría de los componentes tienen sus patas (conocidas por los
técnicos como "pernos") espaciadas a esa distancia estándar, las virutas con múltiples
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 -) están conectadas horizontalmente y se utilizan para transportar la
alimentación a través de la placa de modo que cuando se necesita energía o tierra, se
puede proporcionar muy rápidamente 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 tamaño de un pequeño chip. Cada línea vertical de agujeros se
interrumpe en el medio, de modo que cuando se conecta un chip, no se cortocircuitan
los pines que están en los dos lados del chip. Inteligente, ¿eh?p.
Appendix A 93
Figura A-1.
La plancha sin soldadura.
Apéndice B Resistores de
lectura y condensadores.
Con el fin de utilizar las piezas electrónicas, es necesario ser capaz de identificar, que
puede ser una tarea difícil para un principiante. La mayoría de las resistencias que se
encuentran en una tienda tienen un cuerpo cilíndrico con dos patas que sobresalen y
tienen marcas de colores extraños a su alrededor. Cuando se hicieron las primeras
resistencias comerciales, no había forma de imprimir números lo suficientemente
pequeños como para caber en su cuerpo, por lo que ingenieros inteligentes decidieron
que sólo podían representar los valores con tiras de pintura de color.
Los principiantes de hoy en día tienen que encontrar una manera de interpretar estos
signos. La "llave" es bastante simple: generalmente, hay cuatro rayas, y cada color
representa un número. Uno de los anillos es generalmente oro-coloreado; Éste
representa la precisión 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 continuación, lea los colores y asignarlos a los números correspondientes. En la
siguiente tabla, encontrará una traducción entre los colores y sus valores numéricos.
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%.
Fácil, ¿verdad? No bastante, porque hay un giro: el tercer anillo representa realmente
el número 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 electrónica tienden
a acortar los valores expresándolos en kilo ohmios (para miles
Apéndice 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 están aficionados a optimizar todo, en algunos
diagramas esquemáticos se pueden encontrar valores expresados como 4k7, lo que
significa 4.7 kilo ohmios, o 4700.
Los condensadores son un poco más fáciles: los condensadores en forma de barril
(condensadores electrolíticos) generalmente tienen sus valores impresos en ellos. El
valor de un condensador se mide en farads (F), pero la mayoría de los condensadores
que encuentre se medirán 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 cerámicos) no tienen

sus unidades enumeradas, y utilizan un código numérico de tres dígitos que indica el
número de faros pico (pF). Hay 1.000.000 pF en un μF. Similar a los códigos de
resistencia, se utiliza el tercer número para determinar el número de ceros a poner
después de los dos primeros, con una diferencia: si ves 0-5, que indica el número de
ceros. 6 y 7 no se utilizan, y 8 y 9 se manejan de manera diferente. Si ve 8, multiplique
el número que forman los dos primeros dígitos por 0.01, y si ve 9, multiplíquelo por 0.1.
Por lo tanto, un condensador etiquetado 104 sería 100.000 pF o 0,1 μF. Un condensador
marcado 229 sería 2,2 pF.
Apéndice C / Referencia
rápida de Arduino.
Esta es una explicación rápida de todas las instrucciones estándar soportadas por
el lenguaje Arduino.
Para una referencia más 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 código de inicialización: las instrucciones que
configuran la placa antes de que comience el bucle principal del boceto. void
loop()
Este contiene el código principal de su boceto. Contiene un conjunto de

instrucciones que se repiten una y otra vez hasta que la tarjeta se apaga.
SÍMBOLOS ESPECIALES
Arduino incluye una serie de símbolos para delinear líneas de código, comentarios
y bloques de código.
; (punto y coma)
Cada instrucción (línea de código) se termina por un punto y coma. Esta sintaxis le
permite formatear el código libremente. Incluso podrías poner dos instrucciones
en la misma línea, siempre y cuando las separes con un punto y coma. (Sin
embargo, esto haría que el código sea más difícil de leer.)
Ejemplo: delay(100);
{} (Llaves)
Esto se utiliza para marcar bloques de código. Por ejemplo, cuando escribe código
para la función loop (), tiene que usar llaves antes y después del código.
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 código.
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
específico para ser y entrada o una salida
Verdadero y falso indican exactamente lo que sus nombres sugieren: la verdad o

falsedad de una condición o expresión.
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 tamaño del valor
que desea almacenar.
Aquí están los tipos de datos que están disponibles:
boolean
Puede tener uno de dos valores: verdadero o falso.
char
Tiene un solo carácter, como A. Como cualquier computadora, Arduino lo almacena
como un número, aunque vea texto. Cuando los caracteres se utilizan para
almacenar números, pueden contener valores de -128 a 127.
NOTA: Hay dos conjuntos principales de caracteres disponibles en sistemas

informáticos: ASCII y UNICODE. ASCII es un conjunto de 127 caracteres que se
utilizó para, entre otras cosas, la transmisión de texto entre terminales en serie y
sistemas de computadora compartidos en el tiempo, tales como mainframes y
minicomputadoras. UNICODE es un conjunto mucho más 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 información en idiomas como el italiano o el
inglés que utilizan caracteres latinos, números arábigos y símbolos de máquina
de escribir comunes para la puntuación y similares.
byte
Contiene un número entre 0 y 255. Al igual que con los caracteres, los bytes
utilizan sólo un byte de memoria.
int
Utiliza 2 bytes de memoria para representar un número entre -32.768 y 32.767; Es
el tipo de datos más común usado en Arduino.
unsigned int
Como int, utiliza 2 bytes, pero el prefijo sin signo significa que no puede almacenar
números negativos, por lo que su rango va de 0 a 65.535.
long
Este es el doble del tamaño de un int y contiene números de -2.147.483.648 a
2.147.483.647.
unsigned long
Versión 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 números 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 código también. Así
que usa flotadores con moderación.
double
Número de coma flotante de doble precisión, con un valor máximo de
1.7976931348623157 x 10308. Wow, eso es enorme!
string
Un conjunto de caracteres ASCII que se utilizan para almacenar información textual
(puede utilizar una cadena para enviar un mensaje a través de un puerto serie o
para mostrarlo en una pantalla LCD). Para el almacenamiento, utilizan un byte para
cada carácter en la cadena, además de un carácter 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 través de un índice. Se utilizan
para construir tablas de valores que se pueden acceder fácilmente. Por ejemplo, si
desea almacenar diferentes niveles de brillo que se utilizarán al atenuar un LED,
podría crear seis variables denominadas light01, light02, etc. Mejor aún, usted
podría utilizar un arreglo simple como: int light[6] = {0, 20, 50, 75, 100};
La palabra "matriz" no se usa realmente en la declaración de variables: los

símbolos [] y {} realizan el trabajo.
ESTRUCTURAS DE CONTROL
Arduino incluye palabras clave para controlar el flujo lógico de su boceto.
if . . . else
Esta estructura toma decisiones en su programa. if debe ser seguido por una
pregunta especificada como una expresión entre paréntesis. Si la expresión es
verdadera, lo que sigue será ejecutado. Si es falso, se ejecutará el bloque de código
siguiente. Es posible utilizar sólo if sin proporcionar una cláusula else.
Ejemplo:
if (val == 1) {
digitalWrite(LED,HIGH); }
for
Le permite repetir un bloque de código un número especificado de veces.
Ejemplo:
for (int i = 0; i < 10; i++) {
Serial.print("ciao"); }
switch case
Las declaraciones if son como una bifurcación 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 código 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 código mientras que una cierta condición es
verdadera.
Ejemplo:
// blink LED while sensor is below 512 sensorValue =
analogRead(1); while (sensorValue < 512) {
digitalWrite(13,HIGH); delay(100);
sensorValue = analogRead(1); }
do . . . while
Sólo como while, excepto que el código se ejecuta justo antes de que se evalúe la
condición. Esta estructura se utiliza cuando desea que el código dentro de su
bloque se ejecute al menos una vez antes de comprobar la condición.
Ejemplo:
do {
sensorValue = analogRead(1); } while
(sensorValue < 512);
break
Este término le permite dejar un bucle y continuar la ejecución del código que
aparece después del bucle. También se utiliza para separar las diferentes secciones
de una declaración switch case.
Ejemplo:
// blink LED while sensor is below 512 do { // Leaves the loop
if a button is pressed if (digitalRead(7) == HIGH) break;
sensorValue = analogRead(1); } while
(sensorValue < 512);
continue
Cuando se usa dentro de un bucle, continue le permite saltar el resto del código
dentro de él y forzar la condición 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 ejecución de una función y regresa de ella. También puede usar esto
para devolver un valor desde dentro de una función.
Por ejemplo, si tiene una función llamada computeTemperature() Y desea devolver

el resultado a la parte de su código que invocó la función que escribiría algo como:
int computeTemperature() { int
temperature = 0;
temperature = (analogRead(0) + 45) / 100; return temperature;
}
ARITMÉTICOS Y FÓRMULAS
Puede utilizar Arduino para realizar cálculos complejos utilizando una sintaxis
especial. + Y - funciona como lo has aprendido en la escuela, y la multiplicación se
representa con un * y la división con un /.
Hay un operador adicional llamado "módulo" (%), que devuelve el resto de una
división entera. Puede utilizar tantos niveles de paréntesis 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 propósitos (í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 COMPARACIÓN
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, escribiría: 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 código más conciso para
algunas operaciones muy comunes como incrementar un valor.
Por ejemplo, para incrementar el valor en 1, escribiría: 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 evalúa al equivalente de i+1; ++i se evalúa
al valor de i luego incrementa i. Lo mismo se aplica a ––.
+= , –=, *= and /=
Esto hace más 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 explícitamente en una
salida usando pinMode antes de digitalWrite tendrá algún 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 algún 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 analógica y devuelve un número 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 número 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)

Envía datos a un registro de desplazamiento, dispositivos que se utilizan para
expandir el número 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 más significativo) y el valor
es el byte real que se enviará.
Ejemplo: shiftOut(dataPin, clockPin, LSBFIRST, 255);
unsigned long pulseIn(pin, value)

Mide la duración de un pulso en una de las entradas digitales. Esto es útil, por
ejemplo, para leer algunos sensores infrarrojos o acelerómetros que generan su
valor como impulsos de duración 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 también para
detener el boceto.
unsigned long millis()

Devuelve el número 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 MATEMÁTICAS
Arduino incluye muchas funciones matemáticas y trigonométricas 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 números negativos en positivos.
Si x es 5, devolverá 5, pero si x es -5, todavía 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 analógicos.
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 número (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 raíz cuadrada de un número.
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 NUMÉRICAS DE RANDOM

Si necesita generar números aleatorios, puede usar el generador de números
pseudoaleatorios de Arduino.
randomSeed(seed)
Restablece el generador de números pseudoaleatorios de Arduino. Aunque la
distribución de los números 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 analógico no conectado, captará ruido aleatorio del
entorno (ondas de radio, rayos cósmicos, interferencias electromagnéticas de los
teléfonos 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 límite 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
COMUNICACIÓN SERIAL
Como se vio en el Capítulo 5, puede comunicarse con dispositivos a través del
puerto USB mediante un protocolo de comunicación serie. Aquí están 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 están disponibles, generalmente no más de 115.200 bps.
Ejemplo:
Serial.begin(9600);
Serial.print(data)
Serial.print(data, encoding)
Envía algunos datos al puerto serie. La codificación 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 añade un retorno de carro y avance de línea (\
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 cuántos bytes no leídos están disponibles en el puerto Serial para leer a
través de la función read(). Después 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 través del puerto serie más rápido de lo que
su programa puede procesar, Arduino mantiene todos los datos entrantes en un
búfer. Si necesita borrar el búfer y dejar que se llene con datos nuevos, use la
función flush().
Ejemplo:
Serial.flush();
Apéndice d / Diagramas
esquemáticos de lectura
Hasta ahora, hemos utilizado ilustraciones muy detalladas para describir cómo
ensamblar nuestros circuitos, pero como se puede imaginar, no es exactamente
una tarea rápida dibujar una de esas para cualquier experimento que quiera
documentar.
Problemas similares surgen, tarde o temprano, en todas las disciplinas. En la

música, después de escribir una bonita canción, es necesario escribirla usando la
notación musical.
Los ingenieros, siendo gente práctica, han desarrollado una manera rápida de
capturar la esencia de un circuito para poder documentarlo y después
reconstruirlo o pasarlo a otra persona.
En la electrónica, los diagramas esquemáticos le permiten describir su circuito de

una manera que sea entendida por el resto de la comunidad. Los componentes
individuales están representados por símbolos que son una especie de
abstracción de la forma del componente o la esencia de ellos. Por ejemplo, el
condensador está hecho de dos placas metálicas separadas por aire o plástico;
Por lo tanto, su símbolo es:
Otro ejemplo claro es el inductor, que se construye
enrollando alambre de cobre alrededor de una forma
cilíndrica; Por consiguiente el símbolo 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 líneas simples. Cuando dos cables están
conectados, la conexión se representa por un punto
grande colocado donde las dos líneas cruzan:
Esto es todo lo que necesita para comprender los esquemas básicos. Aquí está una
lista más completa de símbolos y sus significados:
RESISTOR CAPACITOR THERMISTOR LDR LIGHT SENSOR
DIODE LED PUSHBUTTON POTENTIOMETER
Puede encontrar variaciones en estos símbolos (por ejemplo, ambas variantes de

los símbolos de resistencia se muestran aquí). Ver en.wikipedia.org/wiki/
Electronic_symbol para una lista más amplia de los símbolos de la electrónica. Por
convención, 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
señal 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
C lenguaje, 22 cálculos, 103 condensadores de
Índice lectura, 95-96 símbolo, 110, 111 conmutadores de

alfombras, 53 char variable, 98 circuitos
(PWM), 58-60 LED controlado por pulsador, 42-43
; (Punto y coma), 46, 97 lámpara de esfera, 83-84 símbolos, esquemas,
// (delimitador del comentario), 34-35, 36-37, 98 110-111 pruebas, 89 -90 clockPin, 105 código.
- (operador de decremento), 104 Consulte también programación de LED
parpadeante, 32-38, 64-67 bloques, nombres, 34-
/ * (Delimitador de comentarios), 98
35 LED controlado por pulsador, 44-51 objetos en
&& (y operador), 103
serie, 68-69 lámpara esfera, 75-82
{} (Entre corchetes), 34-35, 97
Colaboración, 16 Colombo, Joe, 73 códigos de
== (igual a), 44-45, 103
colores, resistencias, 95-96 colores, codificación
= (Operador de igualdad), 44-45
HTML, 75-76 puertos COM, Windows, 26-27, 90-
> (Mayor que), 103
91 comando, #define, 36, 46 comentarios, 35, 36 -
> = (Mayor o igual que), 103
37, 98 comunicación, serie, 25 - 27, 68 - 69, 73,
++ (operador de incremento), 104
90-91, 108-109 operadores de comparación, 103
<(Menor que), 103
compilación de bocetos, 33, 46 sensores
<= (Menor o igual que), 103
complejos, 70-71 operadores compuestos, 103-
% (Módulo), 103 104 conexiones, símbolo, 110 constantes, 36
! = (No igual a), 103 función de restricción, 106 información de
! (No operador), 103 contacto, ix continuar la estructura de control, 102
|| (U operador), 103 Estructuras de control, 100-102 función cos, 107
() (Paréntesis), 36 herrajes, 34-35, 97 corriente, 41-42 protección de
LED RGB de 4 conductores, 84 corriente, 89
UN re
Ampère, André-Marie, 41 amperios, 41 Dante, 36
analógicaLeer función, 64-67, 105 analógica 89-90, 88-90, 88-89, 87-90, 88-89, 68-69, 89-90,
analógicaLeer función, 64-67, 105 analogWrite 68-69, data-serial, 68-69, data- 36, 46 función de
función, 56-58, 65-67, 105 entrada, 64-67, 73 retardo, 37, 106 función delayMicroseconds, 106
salida, 56-62, 73 pines, placa Arduino, 20-21, 64- delimitadores bloques de código, 34-35
67 sensores, 64-68 sintetizadores, 8 analogWrite Comentario, 35
función, 56-58, 65-67, 105 y operador, 103 Pines Diagramas, circuitos, 110-111 Diecimila placa, 20
de E / S analógicas Arduino, 20-21, 64-67 digital
definidos, 1 Placa Diecimila, 20, 88 pines digitales 42, 64, 104 digitalWrite función, 37, 104 diodo,
IO, 20-21 Placa Duemilanove, 20-21 Extreme símbolo, 111 divide y impera, 87 Divina
board, 88 forum, 91 -92 Pines GND, 60 hardware, Commedia, 107 función doble de la función del
19-21 IDE, descarga, 22 pecado, 107 función doble del pecado, 107
IDE, descripción, 22 función doble del tan, 107 variable doble, 99
IDE, solución de problemas, 90-91 IDE, sitio web, hacen ... mientras que estructura de control, 101
1 instalación, 22-27 Linux, 22 NG, 20-21, 88 vista Drenan el perno, transistores del MOSFET, 70
general, 1-3 conductores, Instalación, 23-24 conducción de
,,,,,,,,,,,,,,,,,,,,,,,,, 36 aritmética, 103 matriz variable, grandes cargas, 70 Duemilanove bordo, 20-21
100 ASCII, 99 lámpara de esfera de montaje, 84-85 Dyson, James, 6
ATmega168, 19-21 mi
Lámpara Aton, 73 Electricidad, 39-42 operador de igualdad, 44-45
segundo Errata, ix ejecución de bocetos, 34 energía
Barragan, Hernando, 2 circuitos de curvatura, 10- externa, 20 Extreme board, 88
11 El Betrothed, 36 bitOrder, 105 LED F FALSO, 45 falso, 98 variable flotante, 99 carpeta,
parpadeante, 30-38, 64-67 Operadores booleanos, almacenamiento de boceto, fuente 32,
103 variable, 98 saltos, 49-51 soportes, rizado, 34- generación, 80 para la estructura de control, 100
35 breadboard, 43 , 60, 89-90, 93-94 estructura de para instrucciones, 103 fórmulas, 103 foro,
control de rotura, 102 buffer, 76 byte variable, 99 Arduino, 91-92 106 analógica, 56-58, 65-67, 105
do restricción, 106 cos, 107 retardo, 106 función de
retardo, 37 retardoMicroseconds, 106 digitalRead,
42 digitalWrite, 37, 104 loop, 35, 37 mapa, 107 62 amarillo que destella, 88 Linux, 22 cargas,
matemáticas, 106-107 conduciendo, función aleatoria larga de 70, 108
108, 108, 108, 105, 105, 105, 105, 106, 109, 108, largos Variable, función del lazo 99, 35, 37
109, 108, 109 Serial.available, 109 Serial.begin, LOW, 37, 98
108 Sensores y actuadores de baja tecnología, 15
Serial.flush, 109 Serial.print, 108-109 m
Serial.println, 109 Serial.read, 109 configuración, 70 función de mapa, 107 funciones
35, 36 shiftOut, 105 sin, 107 tan, 107 tiempo, 105- matemáticas, 106-107 Máx, 8 función
106 tipo de vacío, 36-37 máxima, 106 transistor de efecto de campo
GRAMO de metal-óxido-semiconductor, función de
Puertas, transistores MOSFET, 70 70 milisegundos, 105 min función, 106
Ghazala, Reed, 10 clavijas GND, 60 clavijas de módulo, 103
tierra, 60 Interruptor pulsador momentáneo, 43
marido Moog, Robert, 8 transistores MOSFET, 70
Hacking circuit bending, 10-11 junk, 14 teclados, aceleradores de detección de movimiento,
12-13 juguetes, 15 Haque, Usman, 15 hardware, 70-71 interruptores de alfombra, 53
Arduino, 19-21 hexadecimal, 75-76 HIGH, 37, 98 interruptores magnéticos, 53 sensores
Hopper, Grace, 88 Codificación de colores HTML, infrarrojos pasivos, 55, 56 reed relés, 53
75-76 interruptores de inclinación, 54, 56 motores,
yo conducción, 70 comentarios de varias líneas ,
I premessi sposi, 36 98
IDE (entorno de desarrollo integrado) descarga, 22 norte
información general, 22 solución de problemas, Nombres, bloques de código, 34-35 NG
90-91 sitio web, 1 si la estructura de control. Ver si bordo, 20-21, 88 no operador, 103
declaraciones si declaraciones, 44-45, 100, 103 si Números aritmética y fórmulas, 103
... otra estructura de control, 100 funciones matemáticas, 106-107 funciones
Igoe, Tom, 71 IKEA lámpara, 84 iMac drivers, 23 aleatorias, 108 funciones trigonométricas,
lámparas incandescentes, conductor, 70 106-107 variables, 98-100
incremento operador, 104 inductor, símbolo, 110 O
infrarrojos, 70-71 sensores infrarrojos, 55, 56 Objetos, serial, 68-69, 73 Ohm, Georg, 41
INPUT, 36, 67, 73 digital, 36 - 38, 73 ohmios, 41 Ohm's Law, 41-42
Funciones, 104-108 instalación Olivetti, 14 sensores on / off, 53-56 ayuda en
Arduino, 22-27 línea, 91-92 operadores booleanos, 103
Controladores de Macintosh, 23 controladores de comparación, 103 compuestos, 103-104
Windows, 23-24 función analógicaRead, 105 int Prototipación oportunista, 6 u operador, 103
función digitalRead, 104 int Función SALIDA, 36-37, 98 salida analógica, 56-62, 73
Serial.available, 109 int Serial.read, 109 int digital, 36-38, 73 funciones, 104-108
variable, 99 pag
Entorno de Desarrollo Integrado (IDE). 30, 56, 85, 8, 9 Pentland, Alex, 13
Consulte IDE (Integrated Development persistencia de la visión, 56-62 filosofía,
Ambiente) Arduino, 5-16 fotoresistores, 30. Ver
Controladores Intel, 23 también LDRs (light- Resistencias
Interaction Design, 2-3 Interactive Device, 29 dependientes)
lámparas interactivas, 38 pines IO, placa Arduino, Computación física, definida, 3
20-21, 64-67 problemas de aislamiento, 90 Diseño de Interacción Física, 3 Pike, Rob,
J puente, selección de potencia, 20 puente de función 90 pinMode, 36, 104 pines, placa
conexión, 43-44 basura, 14 analógica IO Arduino, 20-21 IO digital, 20-21
K tierra, 60 transistores MOSFET, 70 sensores
Kernighan, Brian W., 90 teclados, hacking, 12-13 PIR (sensores infrarrojos pasivos), 55, 56 , 85
L lámparas Aton, 73 de conducción, 70 interactivo, Pirola, Maurizio, 89
esfera 38, 74-85 80, 90-91 potenciómetro, símbolo, función
LDRs (resistencias dependientes de la luz), 30, 63, de 111 pow, 107 fuentes de alimentación,
111 20, 70, 88, 89 La práctica de la programación,
LED de 4 conductores RGB, 84 parpadeo, 30-38 90 El procesamiento, 1, 22, 69, 75-82 función
sensores de luz, 62-63 modulación de ancho de de programación de abs, 106 analógicaLeer
pulso (PWM), 56-62 pulsador controlado, 42-51 función, 64-67, 105 analogWrite función, 56-
lámpara de esfera, 74-85 símbolos, 111 luz. Ver 58, 65-67, 105 argumentos, 36 parpadeo
también lámparas; (LDRs), 30, 63 que juegan con, LED, 30-38, 36-38 operadores booleanos,
38 modulación de la anchura de pulso (PWM), 56- 103
103, 103, 35, 36-37 operadores de Puertos, 25-27, 90-91 Función Serial.available,
comparación, 103-104 constantes, 36, 98 109 Función Serial.begin, 108
función de restricción, 106 estructuras de Función Serial.flush, 109
control, 100-102 función de cos, 107 entre Función Serial.print, 108-109
corchetes, 34-35 , 97 ciclo, 22 tipos de datos, 105 función de desplazamiento, 105 función de
98-100 #define, 36, 46 función de retardo, desplazamiento, 105 cortocircuitos, 89 función
37, 106 función delayMicroseconds, 106 sin, 107 comentarios de una sola línea, 98
función digitalRead, 42, 64, 104 función bocetos función abs, 106 función de lectura
digitalWrite, 37, 104 funciones, 34-35, 104- analógica, 67, 105 función de analogWrite, 56-
108 si 106 función de los milis, función de 58, 65-67, 105 argumentos, 36 LED parpadeante,
105 minutos, función de 106 pinMode, 36, 30-38, 64-67 parpadear explicación del código
función de 104 pow, 107 modulación de la del LED, 36-38 operadores booleanos, 103 saltos,
anchura de pulso (PWM), 56-62 función de 49-51 cálculos, 103 comentarios, 35, 36-37
pulsación, 105 LED controlado por pulsador, operadores de comparación, 103 compilación,
42-51 33, 46 operadores compuestos, 103-104
RAM, 46 constantes, 36, 98 función de restricción, 106
Función aleatoria, 108 funciones de estructuras de control, 100-102 función de cos,
números aleatorios, 108 función de función 107 corchetes, 34-35, 97 tipos de datos, 98 -100
aleatoria, 108 funciones serie, 108-109 #define, 36, 46 función de retardo, 37, 106
objetos serie, 68-69, 73 Función de serie, 109 delayMicroseconds función, 106 digitalRead
Función Serial.begin, 108 función, 42, 64, 104
Función Serial.flush, 109 Función Serial.print, Función de memoria, Función de memoria,
108-109 Función de memoria, Función de memoria
Función Serial.println, 109 función digital, Función de memoria digital, Función 105
Serial.read, 109 función de configuración, 35, min, 106 sensores infrarrojos pasivos, 56-62
36 función shiftOut, 105 función sin, 107 función pinMode, 36, función 104 pow, 107
caracteres especiales, 97-98 esfera lámpara, modulación de anchura de pulso (PWM), 56-62
estado 75-82, estructura 47-48, función 97 función pulseln, 105 LED pulsador controlado,
tan, 107 76, 46-48 variables, 45-46, 98-100 42-51
visual, 8 tipo de función void, 36-37 RAM, 46
prototipos, 6 proxy, 75 generador de Función aleatoria, 108 funciones de números
números pseudoaleatorios, 108 modulación aleatorios, 108 función de función aleatoria, 108
de ancho de pulso (PWM), 56- 62 pulsos, 105 funciones serie, 108-109 objetos serie, 68-69, 73
Datos puros, 8 LEDs controlados por Función de serie, 109
pulsador, 42-51, 111 Función Serial.begin, 108 Función Serial.flush,
PWM (modulación de ancho de pulso), 56-62 109
PWR_SEL, 20 Función Serial.print, 108-109
R Función Serial.println, 109 función Serial.read,
Reas, Casey, 2 datos de recepción, objetos en 109 función de configuración, 35, 36 función
serie, 68-69, 73 relés de lámina, 53 registros shiftOut, 105 función sin, 107 caracteres
(LDR), 30, 63 lectura, 95-96 símbolo, 111 especiales, 97-98 esfera lámpara, estado 75-82,
variable, 41 estructura de control de retorno estructura 47-48, función 97 tan, 107 Funciones
, 102 LED RGB, 4 conductores, 84 de tiempo, 105-106 carga, 33 val, 46-48
Fuente RSS, control de la lámpara, 75 Variables, 45-46, 98-100 tipo de función vacía,
S 36-37
Diagramas, símbolos, 110-111 selección de Somlai-Fischer, Adam, 15 sonidos,
puertos, 25-27 punto y coma, 46, 97 envío de guardabosques ultrasónicos, 70-71 Pines fuente,
datos, objetos en serie, 68-69, 73 sensores transistores MOSFET, 70 caracteres especiales;
acelerómetros, 70-71 analógico, 64-68 parpadeo (Punto y coma), 46, 97
LED, 64-67 conmutadores de alfombra, 53 // (delimitador del comentario), 34-35, 36-37, 98
Circuitos infrarrojos, 55, 56, 85 infrarrojos, 70-71 - (operador de decremento), 104
teclado cortar, 13 luz, 62-63 interruptores / * (Delimitador de comentarios), 98
magnéticos, 53 encendido / apagado, 53-56 && (y operador), 103
resumen, 30 pulsador, 42 caña Relés, 53 {} (Entre corchetes), 34-35, 97
termistores, 68 termostatos, 53, 56 interruptores == (igual a), 44-45, 103
de inclinación, 54, 56, 85 guardabarros > (Mayor que), 103
ultrasónicos, serie 70-71 > = (Mayor o igual que), 103
Comunicación, 25 - 27, 68 - 69, 73, 90 - 91, 108 - = (Si declaración), 44-45
109 objetos, 68 - 69, 73 ++ (operador de incremento), 104
<(Menor que), 103 XML, proxy, 75 XP, controladores de Windows, 23-
% (Módulo), 103 24 identificación de puerto, 26-27, 90-91 solución
! = (No igual a), 103 de problemas, 90-91
! (No operador), 103 Y
|| (U operador), 103 () (paréntesis), 36 símbolos Luz intermitente amarilla, 88
aritméticos, 103 ASCII, 99
UNICODE, 99
Lámpara de la esfera, estado 74-85, secuencia
47-48, estructura 99-100, bosquejo, 97, fuentes
100-102, edificio del circuito, excedente 42-44,
puente 14 SV1, estructura del control del caso
del interruptor 88, 100-101
Conmutadores rebote, 49-51 alfombra, 53
magnéticos, 53 transistores MOSFET, 70 on / off,
53 pulsadores, 43 reed relés, 53 tilt, 54, 56, 85
símbolos programación (Ver caracteres
especiales) esquemas 110-111 sintetizadores
analógicos , 8
T
Interruptor de pulsador táctil, 43 función de
bronceado, 107 programa de prueba, Arduino,
88 termistores, 68, 111 termostatos, 53, 56
interruptores de inclinación, 54, 56, 85 funciones
de tiempo, 105-106 retoques, 7 juguetes,
hacking, 15 transistores MOSFET , 70 funciones
trigonométricas, 106-107 solución de problemas,
88-89 circuitos integrados, 89-90 IDE (entorno de
desarrollo integrado), 90-91 ayuda en línea, 91-
92 vista general, 87-88 problemas de
reproducción, 90 Windows, 91
Trucha, grande, 92
VERDADERO, 45
verdadero,98
u
Guardabosques ultrasónicos, 70-71 UNICODE, 99
Variable sin signo int, 99 sin signo de función milis
largo, 105
Cargando boceto, 33
USB
Puertos, Windows, 26-27, 90-91 fuentes de
alimentación, 20 objetos en serie, pruebas 68-69,
88
V
Controladores de Windows, 24 identificación del
puerto, 26-27, 90-91 solución de problemas, 90-91
programación visual, 8 función de vacío tipo, 36-
37 Volta, Alessandro, 41 tensión, 41-42 voltios, 41
VVVV, 8
W
Agua analogía, electricidad, 39-42 mientras que la
estructura de control, 101 mientras que las
declaraciones, 103 Wiki, Patio, 16, 91
Ventanas
Drivers, instalación, 23-24 identificación de
puerto, 25, 26-27 solución de problemas, 90-91
cable, puente, 43-44
x

Intro A Arduino

Cargado por

Copyright:

Formatos disponibles

Intro A Arduino

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Intro A Arduino

Cargado por

Copyright:

Formatos disponibles

Introducción

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

Historial de impresión: October 2008: First Edition

Editor: Dale Dougherty

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

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

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

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

En realidad, cuando estaba en la escuela ya conocía la electrónica de una manera muy

Empecé a pensar en el proceso por el cual aprendí la electrónica:

» Desmonté cualquier dispositivo electrónico que pudiera poner en mis manos.

Después de eso, construí radios, amplificadores, circuitos que producirían ruidos

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

Este libro está dedicado a Luisa y Alexandra.

En primer lugar quiero agradecer a mis socios del Equipo Arduino:

Bill Verplank por haberme enseñado más que Computación Física.

Hernando Barragán por el trabajo que ha realizado en Cableado.

Adam Somlai-Fisher, Ailadi Cortelletti, Alberto Pezzotti,

Alessandro Germinasi, Alessandro Masserdotti, Andrea Piccolo,

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

Clementina Coppini, Concetta 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

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

Teresa Longoni, Massimiliano Bolondi, Matteo Rivolta, Matthias

Richter, Maurizio Pirola, Michael Thorpe, Natalia Jordan,

Ombretta Banzi, Oreste Banzi, Óscar Zoggia, Pietro Dore,

viii Introducción a Arduino

Maker Media es una división de O'Reilly Media dedicada enteramente a la

Para más información sobre Maker Media, visítenos en línea:

Para comentar el libro, envíe un correo electrónico a

El sitio web de O'Reilly para Introducción a Arduino incluye ejemplos, erratas

Para obtener más información sobre Arduino, incluidos foros de discusión y

Arduino es una plataforma de computación física de

Arduino es diferente de otras plataformas en el mercado debido a estas características:

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

»Se basa en la programación de procesamiento IDE, un entorno de desarrollo fácil de

»Se trata de hardware y software de código abierto, si lo desea, puede descargar el

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

Interaction Design es el diseño de cualquier experiencia interactiva.

En el mundo actual, Interaction Design se ocupa de la creación de experiencias

El campo específico de Diseño de Interacción involucrado con Arduino es Computación

¿Qué es la informática física

Con Arduino, un diseñador o artista puede llegar a conocer los fundamentos de la

La ingeniería clásica se basa en un proceso estricto para obtener de A a B; El Camino

Las siguientes secciones presentan algunas filosofías, acontecimientos y pioneros que

La reutilización de la tecnología existente es una de las mejores maneras de manipular.

Reducir el número de interrupciones en el flujo es muy importante para la creatividad:

El curvado de circuitos es una de las formas más interesantes de manipulación. Es

Como tinkerers, podemos implementar nuevas formas de interactuar con el

Nos encanta Junk!

Con la aparición de tecnologías digitales y microprocesadores, estas funciones, que una

El software es más fácil de modificar que el hardware. Con algunas pulsaciones de

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

6 Pines de Entrada analógicos (pines 0-5)

6 Pines de Salida analógica (pines 3, 5, 6, 9, 10 y 11)

La placa puede ser alimentada desde el puerto USB de su computadora, la mayoría de

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