introduccion al arduino massimo banzi.docx

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 Scot 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 Quiters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .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

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

v

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

Expresiones de gratitud Este libro está dedicado a Luisa y Alexandra.

vii

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 Scot, 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, Conceta Capecchi, Csaba Waldhauser, Dario Buzzini, Dario Molinari, Dario Parravicini, Donata Piccolo, Edoardo Brambilla, Elisa Canducci, Fabio Violante, Fabio Zanola, Fabrizio Pignoloni, Flavio Mauri, Francesca Mocellin, Francesco Monico, Giorgio Olivero, Giovanna Gardi, Giovanni Battistini, Heather Martin, Jennifer Bove, Laura Dellamota, Lorenzo Parravicini, Luca Rocco, Marco Baioni, Marco Eynard, Maria Teresa Longoni, Massimiliano Bolondi, Mateo Rivolta, Mathias Richter, Maurizio Pirola, Michael Thorpe, Natalia Jordan, Ombreta Banzi, Oreste Banzi, Óscar Zoggia, Pietro Dore, Prof. Salvioni, Raffaella Ferrara, Renzo Giusti, Sandi Athanas, Sara Carpentieri, Sigrid Wiederhecker, Stefano Mirti, Ubi De Feo, Veronika Bucko.

viii

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.

El Camino a Arduino 7

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.

El Camino a Arduino 9

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íaaccionados 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.

El Camino a Arduino 11

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.

El Camino a Arduino 13

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

La Plataforma Arduino 21

El Software (IDE) El IDE (Integrated Development Environment) es un programa especial que se ejecuta en su computadora y que le permite escribir bocetos para la placa Arduino en un lenguaje sencillo basado en el lenguaje Processing (www.processing.org). La magia ocurre cuando se presiona el 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.

NOT A: 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. La Plataforma Arduino 23

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

La Plataforma Arduino 25

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.

La Plataforma Arduino 27

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

La Plataforma Arduino 29

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. La Plataforma Arduino 33 Verá que aparecen algunos mensajes en el área negra en la parte inferior de la ventana y, justo encima de esa zona, aparecerá el mensaje "Finalizar la carga" para que sepa

que el proceso se ha completado correctamente. Hay dos LEDs, marcados RX y TX, en el tablero; Estos parpadean cada vez que un byte es enviado o recibido por el tablero. Durante el proceso de carga, siguen parpadeando. Si no ve el parpadeo de los LEDs, o si aparece un mensaje de error en lugar de "Finalizar la carga", hay un problema de 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

int val = 0;

// val se utilizará para almacenar el estado

// el pulsador está conectado // 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 PushButonControl. 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

int state = 0;

// 0 = LED apagado mientras 1 = LED encendido

// 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 ALTA (botón pulsado) // y cambiar el estado if (val == HIGH) { state = 1 state; }

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

Ahora prueba este 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

int old_val = 0; // this variable stores the previous

// of the input pin // value of "val"

int state = 0; // 0 = LED off and 1 = LED on void setup() { pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON, INPUT); // and BUTTON is an input } void loop(){ val = digitalRead(BUTTON); // read input value and store it

// yum, fresh

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

state = 1 - state; }

old_val = val; // val is now old, let's store it if (state == 1) { digitalWrite(LED, HIGH); // turn LED ON } else { digitalWrite(LED, LOW); } }

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 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

int old_val = 0; // this variable stores the previous

// of the input pin // 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 // check if there was a transition if ((val == HIGH) && (old_val == LOW)){

state = 1 - state;

delay(10); }

old_val = val; // val is now old, let's store it if (state == 1) { digitalWrite(LED, HIGH); // turn LED ON } else { digitalWrite(LED, LOW); } }

// yum, fresh

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 #define LED 9 // the pin for the LED 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) the LED brightness

analogWrite(LED, i);

delay(10); // Wait 10ms because analogWrite

// set

// 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() { pinMode(LED, OUTPUT); // tell Arduino LED is an output pinMode(BUTTON, INPUT); // and BUTTON is an input } void loop() { val = digitalRead(BUTTON); // read input value and store it

// yum,

fresh // check if there was a transition if ((val == HIGH) && (old_val == LOW)) { state = 1 - state; // change the state from off to on startTime = millis(); // millis() is the Arduino clock

// or vice-versa // it returns how

many milliseconds // have passed since the board has // (this line remembers when the button delay(10); }

// was last pressed)

// been reset.

// 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 brightness going

delay(10);

// delay to avoid

// 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 #define LED 13 // the pin for the LED int val = 0; // variable used to store the value

// coming from the

sensor void setup() { pinMode(LED, OUTPUT); // LED is as an OUTPUT // Note: Analogue pins are // automatically set as inputs } void loop() { val = analogRead(0); // read the value from

// the

sensor digitalWrite(13, HIGH); // turn the LED on delay(val); // stop the program for

// some time

digitalWrite(13, LOW); // turn the LED off delay(val); // stop the program for

// some time

}

Ahora, pruebe el Ejemplo 06B: pero antes de hacerlo, tendrá que modificar su circuito. Eche un vistazo a la Figura 5-4 y engancha el LED hasta el pin 9 como se muestra. Debido a que ya tienes algunas cosas en la tabla de pruebas, 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 #define LED 9 // the pin for the LED int val = 0; // variable used to store the value

// coming from the

sensor void setup() { pinMode(LED, OUTPUT); // LED is as an OUTPUT // Note: Analogue pins are // automatically set as inputs } void loop() { val = analogRead(0); // read the value from

// the

sensor analogWrite(LED, val/4); // turn the LED on at

// the brightness set

// by the sensor delay(10); // stop the program for

// some

time }

Nota: especificamos el brillo dividiendo val por 4, porque analogRead () devuelve un 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"); textFont(font, 32);

fill(255);

// 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) { // check if there is data waiting one byte

int inByte = port.read(); // read

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 // clean the buffer for the next read cycle

light = int(buffer);

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 port.clear(); } } }

}

// up-to-date.

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 url.openConnection();

URLConnection conn =

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 // each chunk of data is made lowercase

while (st.hasMoreTokens()) {

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,

in handy when building a

love = love * 4;

// which comes

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 by 1 }

pointer++; // move the pointer forward

// now we have the 3 numbers stored as hex numbers them into 3 bytes r, g and b

// we need to decode

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 g); // at the colour

analogWrite(G_LED,

analogWrite(B_LED, b); // sent by the computer }

else { analogWrite(R_LED, 0); // otherwise turn off 0);

analogWrite(G_LED,

analogWrite(B_LED, 0); }

delay(100);

// wait 100ms between each send }

int hex2dec(byte c) { // converts one HEX character into a number return c - '0'; }

} else if (c >= 'A' && c = '0' && c