Introduccion Al Arduino Massimo Banzidocx

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.


Parche Siempre he sido fascinado por la modularidad y la capacidad de construir sistemas complejos mediante la conexión de dispositivos simples. Este proceso está muy bien representado por Robert Moog y sus sintetizadores analógicos. Los músicos construyeron sonidos, intentando combinaciones interminables "juntando" diferentes módulos con cables. Este enfoque hizo que el sintetizador parezca un viejo conmutador telefónico, pero combinado con las numerosas perillas, era la plataforma perfecta para mezclar música sonora e innovadora. Moog lo describió como un proceso entre "testificar y descubrir". Estoy seguro de que la mayoría de los músicos al principio no sabía lo que todos esos cientos de botones, pero lo intentaron y trataron, refinando su propio estilo sin interrupciones en el flujo. Reducir el número de interrupciones en el flujo es muy importante para la creatividad: mientras más transparente sea el proceso, más cambios tendrán. Esta técnica ha sido traducida al mundo del software por ambientes de "programación visual" como Max, Pure Data o VVVV. Estas herramientas pueden visualizarse como "cajas" para las diferentes funcionalidades que proporcionan, permitiendo al usuario construir "parches" conectando estas cajas. Estos entornos permiten al usuario experimentar con la programación sin la interrupción constante típica del ciclo habitual: "tipo programa, compilación, maldición-hay un error, error de corrección, compilar, ejecutar". Si usted es más visual mente, le recomiendo que probarlos.


Curvado del circuito

El curvado de circuitos es una de las formas más interesantes de manipulación. Es el cortocircuito creativo de los dispositivos audio electrónicos de bajo voltaje, baterí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.


Teclado Hacks

Los teclados de computadora siguen siendo la principal forma de interactuar con una computadora después de más de 60 años. Alex Pentland, director académico del MIT Media Laboratory, comentó una vez: "Disculpe la expresión, pero los urinarios de los hombres son más inteligentes que las computadoras. Las computadoras están aisladas de lo que está a su alrededor ". Como tinkerers, podemos implementar nuevas formas de interactuar con el software sustituyendo las claves por dispositivos capaces de detectar el entorno. Desmontar un teclado de computadora revela un dispositivo muy simple (y barato). El corazón de ella es una tabla pequeña. Normalmente es un circuito oloroso verde o marrón con dos conjuntos de contactos va a dos capas de plástico que sostienen las conexiones entre las diferentes teclas. Si retira el circuito y utiliza un cable para conectar dos contactos, verá aparecer una letra en la pantalla del ordenador. Si sales a comprar un detector de detección de movimiento y lo conecta a tu teclado, verás que se presiona una tecla cada vez que alguien camina delante de la computadora. Asigne esto a su software favorito, y usted ha hecho su computadora tan elegante como un urinario. Aprender acerca de la piratería de teclado es un componente clave de creación de prototipos y computación física.

Citado en Sara Reese Hedberg, "MIT Media Lab de la búsqueda de computadoras perceptivas," Sistemas Inteligentes y sus aplicaciones, IEEE, julio / agosto 1998.


Nos encanta Junk! La gente tira lejos mucha tecnología actualmente: viejas impresoras, computadoras, máquinas extrañas de la oficina, equipo técnico, e incluso muchos de materia militar. Siempre ha habido un gran mercado para esta tecnología sobrante, especialmente entre los jóvenes y / o los hackers más pobres y los que están recién comenzando. Este mercado se hace evidente en Ivrea, donde desarrollamos Arduino. La ciudad era la sede de la empresa Olivetti. Habían estado haciendo computadoras desde los años sesenta; A mediados de los noventa, arrojaron todo en las chatarrerías de la zona. Estos están llenos de piezas de computadora, componentes electrónicos y dispositivos extraños de todo tipo. Pasamos innumerables horas allí, comprando todo tipo de artefactos por muy poco dinero y pirateando nuestros prototipos. Cuando se puede comprar un millar de altavoces por muy poco dinero, que está obligado a llegar a una idea al final. Acumular basura y pasar .por ella antes de empezar a construir algo desde cero

Juguetes de Hacking Los juguetes son una fantástica fuente de tecnología barata para hackear y reutilizar, como lo demuestra la práctica de la flexión de circuitos antes mencionada. Con la afluencia actual de miles de juguetes de alta tecnología muy baratos de China, puede crear ideas rápidas con unos pocos gatos ruidosos y un par de espadas ligeras. He estado haciendo esto por algunos años para que mis estudiantes comprendan que la tecnología no es aterradora o difícil de acercarse. Uno de mis recursos favoritos es el folleto "Low Tech Sensors and Actuators" de Usman Haque y Adam Somlai-Fischer (lowtech.propositions.org.uk). Creo que han descrito perfectamente esta técnica en ese manual, y lo he estado usando desde entonces.

Camino a Arduino

15

Colaboración La colaboración entre los usuarios es uno de los principios clave en el mundo Arduino-a través del foro en www.arduino.cc, personas de diferentes partes del mundo se ayudan mutuamente a aprender sobre la plataforma. El equipo de Arduino alienta a las personas a colaborar a nivel local, así como ayudarles a crear grupos de usuarios en cada ciudad que visiten. También creamos un Wiki llamado "Playground" (www.arduino.cc/playground) donde los usuarios documentan sus descubrimientos. Es tan asombroso ver cuánto conocimiento estas personas vierten en la Web para que todos lo usen. Esta cultura de compartir y ayudarnos mutuamente es una de las cosas que más me enorgullece de Arduino.

3/ La Plataforma Arduino Arduino se compone de dos partes principales: el tablero de Arduino, que es la pieza de hardware en la que trabajas cuando construyes tus objetos; Y el Arduino IDE, el software que ejecuta en su computadora. Utilice el IDE para crear un boceto (un pequeño programa de computadora) que cargue en la tarjeta Arduino. El boceto le dice al consejo qué hacer. No hace mucho tiempo, trabajar en hardware significaba construir circuitos desde cero, usando cientos de componentes diferentes con nombres extraños como resistencias, condensadores, inductores, transistores, etc. Cada circuito fue "cableado" para hacer una aplicación específica, y hacer cambios necesarios para cortar cables, conexiones de soldadura, y más. Con la aparición de tecnologías digitales y microprocesadores, estas funciones, que una vez se implementaron con cables, fueron reemplazadas por programas de software. El software es más fácil de modificar que el hardware. Con algunas pulsaciones de teclas, puede cambiar radicalmente la lógica de un dispositivo y probar dos o tres versiones en la misma cantidad de tiempo que le llevaría a soldar un par de resistencias.

El hardware de Arduino El tablero de Arduino es un pequeño tablero del microcontrolador, que es un pequeño circuito (el tablero) que contiene una computadora entera en un pequeño microprocesador (el microcontrolador). Este equipo es por lo menos mil veces menos potente que el MacBook que estoy usando para escribir esto, pero es mucho más barato y muy útil para construir dispositivos interesantes. Mira el tablero de Arduino: verás un chip negro con 28 "piernas" - ese chip es el ATmega168, el corazón de tu tablero. La Plataforma Arduino 19

Nosotros (el equipo de Arduino) hemos colocado en esta placa todos los componentes que son necesarios para que este microcontrolador funcione correctamente y para comunicarse con su computadora. Hay muchas versiones de este tablero; El que usaremos a lo largo de este libro es el Arduino Duemilanove, que es el más sencillo de usar y el mejor para aprender. Sin embargo, estas instrucciones se aplican a versiones anteriores del tablero, incluyendo el más reciente Arduino Diecimila y el Arduino NG más antiguo. La Figura 3-1 muestra el Arduino Duemilanove; La Figura 3-2 muestra el Arduino NG. En esas ilustraciones, ves la placa Arduino. Al principio, todos esos conectores podrían ser un poco confusos. Aquí está una explicación de lo que hace cada elemento del tablero: 14 pines digitales de I/O (pines 0-13) Éstas pueden ser entradas o salidas, que se especifica mediante el croquis que se crea en el IDE. 6 Pines de Entrada analógicos (pines 0-5) Estos pines de entrada analógicos dedicados toman valores analógicos (es decir, lecturas de tensión de un sensor) y los convierten en un número entre 0 y 1023. 6 Pines de Salida analógica (pines 3, 5, 6, 9, 10 y 11) Estos son en realidad seis de los pines digitales que se pueden reprogramar para la salida analógica utilizando el boceto que se crea en el IDE. La placa puede ser alimentada desde el puerto USB de su computadora, la mayoría de los cargadores USB, o un adaptador de CA (recomendado de 9 voltios, punta del cañón de 2,1 mm, centro positivo). Si no hay ninguna fuente de alimentación enchufada en el enchufe, la energía vendrá de la tarjeta del USB, pero tan pronto como usted tapa una fuente de alimentación, la tarjeta la utilizará automáticamente. NOTA: Si está utilizando el Arduino-NG antiguo o Arduino Diecimila, deberá configurañte de selección de potencia (denominado PWR_SEL en la placa) para especificar la alimentación EXT (externa) o USB. Este puente se puede encontrar entre el enchufe para el adaptador de CA y el puerto USB.

Figura 3-1. El Arduino Duemilanove

Figura 3-2. El Arduino NG

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


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

Figura 3-4. El Administrador de dispositivos de Windows muestra todos los puertos serie disponibles

NOTA: En algunas máquinas Windows, el puerto COM tiene un número mayor que 9; Esta numeración crea algunos problemas cuando Arduino trata de comunicarse con él. Consulte el Capítulo 7, Solución de problemas para obtener ayuda sobre este problema.

Una vez que haya descubierto la asignación de puerto COM, puede seleccionar ese puerto en el menú Herramientas> Puerto serie en el IDE de Arduino. Ahora, el entorno de desarrollo de Arduino puede hablar con la placa Arduino y programarlo.


4/ Realmente empezando con Arduino Ahora aprenderá cómo crear y programar un dispositivo interactivo. Anatomía de un dispositivo interactivo Todos los objetos que construiremos usando Arduino seguirán un patrón muy simple que llamaremos "Interactive Device". El dispositivo interactivo es un circuito electrónico que es capaz de detectar el ambiente utilizando sensores (componentes electrónicos que convierten las mediciones del mundo real en señales eléctricas). El dispositivo procesa la información que recibe de los sensores con un comportamiento que se implementa como software. El dispositivo será capaz de interactuar con el mundo utilizando actuadores, componentes electrónicos que pueden convertir una señal eléctrica en una acción física. Sentido / percepción

Sensores

Comportamien to (software )

Actuadores

Actuar / Reaccionar Figura 4-1. El dispositivo interactivo


Sensores y Actuadores

Los sensores y actuadores son componentes electrónicos que permiten que una pieza de electrónica interactúe con el mundo. Como el microcontrolador es una computadora muy simple, sólo puede procesar señales eléctricas (un poco como los impulsos eléctricos que se envían entre las neuronas de nuestro cerebro). Para que detecte luz, temperatura u otras cantidades físicas, necesita algo que pueda convertirlas en electricidad. En nuestro cuerpo, por ejemplo, el ojo convierte la luz en señales que se envían al cerebro usando los nervios. En electrónica, podemos utilizar un dispositivo simple llamado una resistencia dependiente de la luz (un LDR o fotorresistor) que puede medir la cantidad de luz que lo golpea y reportarlo como una señal que puede ser entendida por el microcontrolador. Una vez que los sensores han sido leídos, el dispositivo tiene la información necesaria para decidir cómo reaccionar. El proceso de toma de decisiones es manejado por el microcontrolador, y la reacción es realizada por actuadores. En nuestros cuerpos, por ejemplo, los músculos reciben señales eléctricas del cerebro y las convierten en un movimiento. En el mundo electrónico, estas funciones podrían ser realizadas por un motor eléctrico o un motor eléctrico. En las siguientes secciones, aprenderá a leer sensores de diferentes tipos y controlar diferentes tipos de actuadores.

Parpadeando un LED El boceto de parpadeo de LED es el primer programa que debe ejecutar para comprobar si su tarjeta Arduino funciona y está configurada correctamente. También suele ser el primer ejercicio de programación que alguien hace cuando aprende a programar un microcontrolador. Un diodo emisor de luz (LED) es un pequeño componente electrónico que es un poco como una bombilla, pero es más eficiente y requiere voltajes más bajos para operar. Su tarjeta Arduino viene con un LED preinstalado. Está marcado con "L". También puede agregar su propio LED-conectarlo como se muestra en la Figura 4-2. K indica el cátodo (negativo), o el plomo más corto; A indica el ánodo (positivo), o el plomo más largo. Una vez que el LED está conectado, necesita decirle a Arduino qué hacer. Esto se hace a través de código, es decir, una lista de instrucciones que le damos al microcontrolador para que haga lo que queremos.

Figura 4-2. Conexión de un LED a Arduino

En su computadora, abra la carpeta donde copió el IDE de Arduino. Haga doble clic en el icono de Arduino para iniciarlo. Seleccione Archivo> Nuevo y se le pedirá que elija un nombre de carpeta de boceto: aquí se almacenará su boceto Arduino. Asigne un nombre a Blinking_LED y haga clic en Aceptar. A continuación, escriba el siguiente texto (Ejemplo 01) en el editor de bocetos de Arduino (la ventana principal del IDE de

Arduino). También puede descargarlo desde www.makezine.com/ getstartedarduino. Deberá aparecer como se muestra en la Figura 4-3.

// Ejemplo 01: LED parpadeante # Definir LED 13 // LED conectado a // pin digital 13

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

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

Verificar

Cargar para I/O la tarjeta

Su bosquejo va aquí Figura 4-3. El IDE de Arduino con el primer dibujo cargado

Ahora que el código está en su IDE, debe verificar que es correcto. Presione el botón "Verificar" (la Figura 4-3 muestra su ubicación); Si todo está correcto, aparecerá el mensaje "Done compilación" en la parte inferior del IDE de Arduino. Este mensaje significa que el IDE de Arduino ha traducido su boceto en un programa ejecutable que puede ejecutar la placa, un poco como un archivo .exe en Windows o un archivo .app en una Mac. En este momento, puede cargarlo en la placa: presione el botón Cargar en la tarjeta de I/O (consulte la Figura 4-3). Esto restablecerá la placa, obligándola a detener lo que está haciendo y escuchar las instrucciones procedentes del puerto USB. El IDE de Arduino envía el boceto actual al tablero, que lo almacenará en su memoria y lo ejecutará eventualmente. 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) {

fetchData();

lastTime = millis(); } port.write(cs); // send data to Arduino if (port.available() > 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 <= 'F') {

if (c >= '0' && c <= '9') {

return c - 'A' + 10;

}

Montaje del Circuito La figura 6-2 muestra cómo ensamblar el circuito. Es necesario usar resistores de 10K para todas las resistencias que se muestran en el diagrama, aunque se podría escapar con valores más bajos para las resistencias conectadas a los LEDs. Recuerde en el ejemplo PWM en el capítulo 5 que los LED están polarizados: en este circuito, el pasador largo (positivo) debe ir a la derecha y el pasador corto (negativo) a la izquierda. (La mayoría de los LED tienen un lado negativo aplanado, como se muestra en la figura).

Figura 6-2. The “Arduino Networked Lamp” circuit

Construya el circuito como se muestra, usando un LED rojo, verde y azul. A continuación, cargue los bocetos en Arduino y Processing, luego ejecute los bocetos y pruébelo. Si tiene algún problema, consulte el Capítulo 7, "Solución de problemas". Ahora vamos a completar la construcción mediante la colocación de la placa de pan en una esfera de vidrio. La forma más sencilla y barata de hacerlo es comprar una lámpara de mesa IKEA "FADO". Ahora está vendiendo por cerca de US $ 14.99 / € 14.99 / £ 8.99 (ahh, el lujo de ser europeo). En lugar de utilizar tres LED separados, puede utilizar un solo LED RGB, que tiene cuatro cables que salen de él. Usted lo conectará de la misma manera que los LEDs mostrados en la Figura 6-2, con un cambio: en lugar de tres conexiones separadas a la clavija de tierra en Arduino, tendrá un solo cable (llamado "cátodo común" ") Va a la tierra. SparkFun vende un LED RGB de 4 conductores por unos pocos dólares (www.sparkfun.com, número de pieza COM-00105). Además, a diferencia de los LED monocromos discretos, el cable más largo en este LED RGB es el que va a tierra. Los tres cables más cortos tendrán que conectarse a los pines 9, 10 y 11 de Arduino (con una resistencia entre los cables y los pines, al igual que con los LEDs rojo, verde y azul separados).

Aquí es cómo montarlo: Desembale la lámpara y retire el cable que va desde la parte inferior hacia la lámpara. Ya no se tapa esto en la pared. Correa el Arduino en un tablero de pan y caliente la plancha de pan en la parte posterior de la lámpara. Soldar los cables más largos al LED RGB y pegarlo donde la bombilla solía ser. Conecte los cables que vienen del LED a la placa de pruebas (donde se conectó antes de retirarla). Recuerde que sólo necesitará una conexión a tierra si está utilizando un LED RGB de 4 conductores. O bien encontrar una buena pieza de madera con un agujero que se puede utilizar como un soporte para la esfera o simplemente cortar la parte superior de la caja de cartón que viene con la lámpara en aproximadamente 5cm (o 2 ") y hacer un agujero con un diámetro que Cunega la lámpara Refuerce el interior de la caja de cartón usando el pegamento caliente a lo largo de los bordes interiores, que hará la base más estable.

Coloque la esfera en el soporte y sacar el cable USB de la parte superior y conectarlo al ordenador. Apague el código de procesamiento, presione el botón de encendido / apagado y observe que la lámpara cobra vida.

Como ejercicio, trate de agregar código que encienda la lámpara cuando la habitación se oscurezca. Otras mejoras posibles son::

» Agregue sensores de inclinación para encender o apagar la lámpara girándola en diferentes direcciones.

» Agregue un pequeño sensor PIR para detectar cuando alguien está alrededor y apáguelo cuando no haya nadie para verlo.

» Crear diferentes modos para que pueda obtener control manual del color o hacer que se desvanecen a través de muchos colores. ¡Piense en cosas diferentes, experimente y diviértase!

7/ Solución de problemas Llegará un momento en su experimentación cuando nada funcionará y usted tendrá que averiguar cómo arreglarlo. Solución de problemas y depuración son las artes antiguas en las que hay algunas reglas simples, pero la mayoría de los resultados se obtienen a través de un montón de trabajo. Cuanto más trabajes con la electrónica y Arduino, más aprenderás y ganarás experiencia, lo que en última instancia hará que el proceso sea menos doloroso. No se desanime por los problemas que usted encontrará - es todo más fácil de lo que parece al principio. Como cada proyecto basado en Arduino se hace tanto de hardware como de software, habrá más de un lugar para ver si algo sale mal. Mientras busca un error, debe operar a lo largo de tres líneas: Comprensión Trate de entender lo más posible cómo las partes que usted está usando el trabajo y cómo se supone que deben contribuir al proyecto terminado. Este enfoque le permitirá diseñar alguna forma de probar cada componente por separado. Simplificación y segmentación Los antiguos romanos solían decir divide et impera: dividir y gobernar. Trate de descomponer (mentalmente) el proyecto en sus componentes utilizando la comprensión que tiene y averigüe dónde empieza y termina la responsabilidad de cada componente. Exclusión y certidumbre

Mientras investiga, pruebe cada componente por separado para que pueda estar absolutamente seguro de que cada uno funciona por sí mismo. Usted creará gradualmente la confianza sobre qué partes del proyecto están haciendo su trabajo y cuáles son dudosas. Depuración es el término utilizado para describir este proceso aplicado al software. La leyenda dice que fue utilizada por primera vez por Grace Hopper en la década de 1940, cuando las computadoras eran en su mayoría electromecánicas, y una de ellas dejó de funcionar porque los insectos reales quedaron atrapados en los mecanismos. Muchos de los insectos de hoy en día ya no son físicos: son virtuales e invisibles, al menos en parte. Por lo tanto, requieren un proceso a veces largo y aburrido para ser identificado.

Prueba de la Junta ¿Qué pasa si el primer ejemplo, "parpadea un LED", no funcionó? ¿No sería un poco deprimente? Vamos a averiguar qué hacer. Antes de empezar a culpar a su proyecto, debe asegurarse de que hay algunas cosas en orden, como hacen los pilotos de línea aérea cuando pasan por una lista de comprobación para asegurarse de que el avión estará volando correctamente antes de despegar: Enchufe su Arduino en un enchufe USB en su computadora.

» Asegúrese de que el equipo está encendido (sí, suena tonto, pero ha sucedido). Si la luz verde marcada PWR se enciende, significa que la computadora está alimentando la tarjeta. Si el LED parece muy débil, algo está mal con el poder: pruebe con un cable USB diferente e inspeccione el puerto USB del ordenador y el conector USB del Arduino para ver si hay algún daño. Si todo falla, pruebe un puerto USB diferente en su computadora o un equipo diferente completamente.

» Si el Arduino es nuevo, el LED amarillo marcado L comenzará a parpadear en un poco de un patrón nervioso; Este es el programa de prueba que se cargó en la fábrica para probar el tablero.

» Si ha estado utilizando una fuente de alimentación externa y está usando un Arduino antiguo (Extreme, NG o Diecimila), asegúrese de que la fuente de alimentación está conectada y de que el puente marcado SV1 está conectando los dos pines más cercanos al externo Conector de la fuente de alimentación.

NOTA: Cuando tenga problemas con otros bocetos y necesite confirmar que el tablero está funcionando, abra el primer ejemplo de "parpadeo de un LED" en el IDE de Arduino y carguelo en la placa. El LED de a bordo debe parpadear en un patrón regular. Si ha superado todos estos pasos con éxito, puede estar seguro de que su Arduino funciona correctamente.

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

NOTA: Si le preocupa que pueda dañar su computadora, recuerde que en muchas computadoras, la protección actual es generalmente bastante buena y responde rápidamente. Además, la tarjeta Arduino está equipada con un "PolyFuse", un dispositivo de protección de corriente que se restablece cuando se elimina el fallo. Si eres realmente paranoico, siempre puedes conectar la placa Arduino a través de un concentrador USB autoalimentado. En este caso, si todo va horriblemente mal, el concentrador USB es el que va a empujar las margaritas, no su computadora.

Si tiene un cortocircuito, tiene que iniciar el proceso de "simplificación y segmentación". Lo que debe hacer es pasar por cada sensor en el proyecto y conectar sólo uno a la vez.

La primera cosa a partir de es siempre la fuente de alimentación (las conexiones de 5 V y GND). Mire a su alrededor y asegúrese de que cada parte del circuito se alimenta correctamente. Trabajar paso a paso y hacer una sola modificación a la vez es la regla número uno para arreglar cosas. Esta regla fue martillada en mi joven cabeza por mi profesor de la escuela y primer empleador, Maurizio Pirola. Cada vez que estoy depurando algo y las cosas no se ven bien (y créanme, sucede mucho), su cara aparece en mi cabeza diciendo "una modificación a la vez. . . Una modificación a la vez "y que suele ser cuando lo arreglo todo. Esto es muy importante, porque sabrás lo que arregló el problema (es muy fácil perder la pista de qué modificación realmente resolvió el problema, por lo que es tan importante hacer uno a la vez). Cada experiencia de depuración acumulará en su cabeza una "base de conocimiento" de defectos y posibles correcciones. Y antes de que lo sepa, se convertirá en un experto. Esto te hará ver muy bien, porque tan pronto como un novato dice "Esto no funciona!" Le dará una mirada rápida y tener la respuesta en una fracción de segundo.

Problemas de aislamiento Otra regla importante es encontrar una manera confiable de reproducir un problema. Si su circuito se comporta de manera divertida en momentos aleatorios, intente realmente averiguar el momento exacto en que ocurre el problema y lo que lo causa. Este proceso le permitirá pensar sobre una posible causa. También es muy útil cuando necesitas explicar a alguien lo que está pasando. Describir el problema con la mayor precisión posible también es una buena manera de encontrar una solución. Trate de encontrar a alguien para explicar el problemaen muchos casos, una solución aparecerá en su cabeza mientras articula el problema. Brian W. Kernighan y Rob Pike, en The Practice of Programming (Addison-Wesley, 1999), cuentan la historia de una universidad que "guardaba un oso de peluche cerca del mostrador de ayuda. Los estudiantes con bichos misteriosos tenían que explicarles al oso antes de que pudieran hablar con un consejero humano..

Problemas con el IDE En algunos casos, es posible que tenga un problema al utilizar el IDE de Arduino, en particular en Windows.

Si aparece un error al hacer doble clic en el icono de Arduino, o si no ocurre nada, haga doble clic en el archivo run.bat como método alternativo para iniciar Arduino. Los usuarios de Windows también pueden encontrarse con un problema si el sistema operativo asigna un número de puerto COM de COM10 o superior a Arduino. Si esto sucede, normalmente puede convencer a Windows para asignar un número de puerto inferior a Arduino. En primer lugar, abra el Administrador de dispositivos haciendo clic en el menú Inicio, haga clic con el botón secundario en Equipo (Vista) o Mi PC (XP) y seleccione Propiedades. En Windows XP, haga clic en Hardware y elija Administrador de dispositivos. En Vista, haga clic en Administrador de dispositivos (aparece en la lista de tareas a la izquierda de la ventana). Busque los dispositivos serie en la lista bajo "Puertos (COM & LPT)". Busque un dispositivo serie que no esté usando que esté numerado como COM9 o inferior. Haga clic con el botón derecho en él y elija Propiedades en el menú. A continuación, elija la ficha Configuración del puerto y haga clic en Avanzado. Establezca el número de puerto COM a COM10 o superior, haga clic en Aceptar y vuelva a hacer clic en Aceptar para cerrar el cuadro de diálogo Propiedades. Ahora, haga lo mismo con el dispositivo USB Serial Port que representa Arduino, con un cambio: asigne el número de puerto COM (COM9 o inferior) que acaba de liberar. Si estas sugerencias no ayudan, o si tiene un problema que no se describe aquí, consulte la página de solución de problemas de Arduino en www.arduino.cc/es/ Guía / Solución de problemas.

Cómo obtener ayuda en línea Si está atascado, no pase días corriendo solo, pida ayuda. Una de las mejores cosas de Arduino es su comunidad. Siempre puede encontrar ayuda si puede describir bien su problema. Obtener el hábito de cortar y pegar cosas en un motor de búsqueda y ver si alguien está hablando de ello. Por ejemplo, cuando el IDE de Arduino escupe un mensaje de error repugnante, cópielo y péguelo en una búsqueda de Google y vea lo que sale. Haz lo mismo con bits de código en los que estás trabajando o con un nombre de función específico. Mira a tu alrededor: todo ya ha sido inventado y está almacenado en alguna parte de una página web.

Para más información, empiece desde el sitio web principal www.arduino.cc y mire el FAQ (www.arduino.cc/en/Main/FAQ), luego vaya al patio (www.arduino.cc/playground), a Libremente editable wiki que cualquier usuario puede modificar para contribuir con la documentación. Es una de las mejores partes de toda la filosofía de código abierto. La gente aporta documentación y ejemplos de todo lo que puedes hacer con Arduino. Antes de iniciar un proyecto, busque en el patio de recreo y encontrará un poco de código o un diagrama de circuito para empezar. Si todavía no puede encontrar una respuesta de esa manera, busque en el foro (www.arduino.cc/cgi-bin / yabb2 / YaBB.pl). Si eso no ayuda, publicar una pregunta allí. Escoja la tabla correcta para su problema: hay diferentes áreas para problemas de software o hardware e incluso foros en cinco idiomas diferentes. Publica toda la información que puedas:

» ¿Qué tablero de Arduino está usando? » ¿Qué sistema operativo está utilizando para ejecutar el IDE de Arduino? » Dé una descripción general de lo que está tratando de hacer. Publicar enlaces a hojas de datos de partes extrañas que está utilizando. El número de respuestas que obtiene depende de lo bien que formule su pregunta. Sus posibilidades aumentan si evita estas cosas a toda costa (estas reglas son buenas para cualquier foro en línea, no sólo para Arduino):

»

Escribiendo su mensaje en MAYÚSCULAS. Se molestan a la gente mucho y es como caminar con "novato" tatuado en la frente (en las comunidades en línea, escribiendo en todos los capitales se considera "gritando").

»

Publicar el mismo mensaje en varias partes del foro.

»

»

"Golpear" su mensaje publicando comentarios de seguimiento preguntando "Hey, ¿cómo es que nadie respondió?" O peor aún, simplemente publicar el texto "bump". Si no recibió una respuesta, eche un vistazo a su publicación. ¿Estaba claro el tema? ¿Usted proporcionó una descripción bien-redactada del problema que usted está teniendo? ¿Eras agradable? Siempre sé bueno. Escribir mensajes como "Quiero construir un transbordador espacial usando arduino como hago eso". Esto significa que usted quiere que la gente haga su trabajo para usted, y este enfoque no es simplemente divertido para un verdadero tinkerer. Es mejor explicar lo que quieres construir y luego hacer una pregunta específica sobre una parte del proyecto y tomarlo desde allí.

»

Una variación del punto anterior es cuando la pregunta es claramente algo que el cartel del mensaje se está pagando para hacer. Si usted hace preguntas específicas que la gente está feliz de ayudar, pero si les pide que hagan todo su trabajo (y no comparten el dinero), la respuesta es probable que sea menos agradable.

»

Publicar mensajes que parezcan sospechosos como asignaciones escolares y pedir al foro que haga su tarea. Profesores como yo vagan por los foros y golpean a esos estudiantes con una trucha grande.

Apéndice A/ El tablero de pan El proceso de conseguir un circuito para trabajar implica hacer muchos cambios en él hasta que se comporte correctamente; Es un proceso muy rápido e iterativo que es algo así como un equivalente electrónico al bosquejo. El diseño evoluciona en tus manos mientras intentas combinaciones diferentes. Para obtener los mejores resultados, utilice un sistema que le permita cambiar las conexiones entre los componentes de la manera más rápida, más práctica y menos destructiva. Estos requisitos claramente descartan la soldadura, que es un procedimiento que requiere mucho tiempo y que pone a los componentes bajo tensión cada vez que los calienta y los enfría. La respuesta a este problema es un dispositivo muy práctico llamado la placa de soldar sin soldadura. Como se puede ver en la Figura A-1, se trata de un pequeño tablero de plástico lleno de agujeros, cada uno de los cuales contiene un contacto de resorte. Usted puede empujar la pierna de un componente en uno de los agujeros, y establecerá una conexión eléctrica con todos los otros agujeros en la misma columna vertical de agujeros. Cada agujero está a una distancia de 2,54 mm de los otros. Debido a que la mayoría de los componentes tienen sus patas (conocidas por los técnicos como "pernos") espaciadas a esa distancia estándar, las virutas con múltiples patas encajan perfectamente. No todos los contactos en una tabla de paneles se crean iguales, hay algunas diferencias. Las filas superior e inferior (coloreadas en rojo y azul y marcadas con + y -) están conectadas horizontalmente y se utilizan para transportar la alimentación a través de la placa de modo que cuando se necesita energía o tierra, se puede proporcionar muy rápidamente con un puente Un pedazo corto de alambre utilizado para conectar dos puntos en los circuitos). La última cosa que usted necesita saber sobre breadboards es que en el medio, hay una abertura grande que sea tan ancha como el tamaño de un pequeño chip. Cada línea vertical de agujeros se interrumpe en el medio, de modo que cuando se conecta un chip, no se cortocircuitan los pines que están en los dos lados del chip. Inteligente, ¿eh?p. Appendix A

93

Figura A-1. La plancha sin soldadura.

Apéndice B Resistores de lectura y condensadores.

Con el fin de utilizar las piezas electrónicas, es necesario ser capaz de identificar, que puede ser una tarea difícil para un principiante. La mayoría de las resistencias que se encuentran en una tienda tienen un cuerpo cilíndrico con dos patas que sobresalen y tienen marcas de colores extraños a su alrededor. Cuando se hicieron las primeras resistencias comerciales, no había forma de imprimir números lo suficientemente pequeños como para caber en su cuerpo, por lo que ingenieros inteligentes decidieron que sólo podían representar los valores con tiras de pintura de color. Los principiantes de hoy en día tienen que encontrar una manera de interpretar estos signos. La "llave" es bastante simple: generalmente, hay cuatro rayas, y cada color representa un número. Uno de los anillos es generalmente oro-coloreado; Éste representa la precisión de esa resistencia. Para leer las rayas en orden, mantenga la resistencia por lo que la banda de oro (o plata en algunos casos) está a la derecha.

A continuación, lea los colores y asignarlos a los números correspondientes. En la siguiente tabla, encontrará una traducción entre los colores y sus valores numéricos. Colour

Value

Black

0

Brown

1

Red

2

Orange

3

Yellow

4

Green

5

Blue

6

Purple

7

Grey

8

White

9

Silver

10%

Gold

5%

Por ejemplo, las marcas marrones, negras, naranjas y doradas significan 1 0 3 ± 5%. Fácil, ¿verdad? No bastante, porque hay un giro: el tercer anillo representa realmente el número de ceros en el valor. Por lo tanto 1 0 3 es en realidad 1 0 seguido de 3 ceros, por lo que el resultado final es 10.000 ohmios ± 5%. Los geeks de la electrónica tienden a acortar los valores expresándolos en kilo ohmios (para miles Apéndice B 95 De ohmios) y mega ohmios (para millones de ohmios), por lo que una resistencia de 10.000 ohm se acorta a 10k, mientras que 10.000.000 se convierte en 10M. Tenga en cuenta que debido a que los ingenieros están aficionados a optimizar todo, en algunos diagramas esquemáticos se pueden encontrar valores expresados como 4k7, lo que significa 4.7 kilo ohmios, o 4700. Los condensadores son un poco más fáciles: los condensadores en forma de barril (condensadores electrolíticos) generalmente tienen sus valores impresos en ellos. El valor de un condensador se mide en farads (F), pero la mayoría de los condensadores que encuentre se medirán en micro farads (μF). Tan si usted ve un condensador etiquetado 100 μF, es un condensador de 100 micro farad. Muchos de los condensadores en forma de disco (condensadores cerámicos) no tienen sus unidades enumeradas, y utilizan un código numérico de tres dígitos que indica el número de faros pico (pF). Hay 1.000.000 pF en un μF. Similar a los códigos de resistencia, se utiliza el tercer número para determinar el número de ceros a poner

después de los dos primeros, con una diferencia: si ves 0-5, que indica el número de ceros. 6 y 7 no se utilizan, y 8 y 9 se manejan de manera diferente. Si ve 8, multiplique el número que forman los dos primeros dígitos por 0.01, y si ve 9, multiplíquelo por 0.1. Por lo tanto, un condensador etiquetado 104 sería 100.000 pF o 0,1 μF. Un condensador marcado 229 sería 2,2 pF.

Apéndice C / Referencia rápida de Arduino.

Esta es una explicación rápida de todas las instrucciones estándar soportadas por el lenguaje Arduino. Para una referencia más detallada, vea: arduino.cc/en/Reference/HomePage.

ESTRUCTURA Un dibujo de Arduino se ejecuta en dos partes: void setup()

Aquí es donde se coloca el código de inicialización: las instrucciones que configuran la placa antes de que comience el bucle principal del boceto.

void

loop()

Este contiene el código principal de su boceto. Contiene un conjunto de instrucciones que se repiten una y otra vez hasta que la tarjeta se apaga.

SÍMBOLOS ESPECIALES Arduino incluye una serie de símbolos para delinear líneas de código, comentarios y bloques de código. ; (punto y coma) Cada instrucción (línea de código) se termina por un punto y coma. Esta sintaxis le permite formatear el código libremente. Incluso podrías poner dos instrucciones en la misma línea, siempre y cuando las separes con un punto y coma. (Sin embargo, esto haría que el código sea más difícil de leer.) Ejemplo: delay(100); {} (Llaves) Esto se utiliza para marcar bloques de código. Por ejemplo, cuando escribe código para la función loop (), tiene que usar llaves antes y después del código.

Ejemplo: void loop() {

Serial.println("ciao");

}

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

CONTENIDOS Arduino incluye un conjunto de palabras clave predefinidas con valores especiales. HIGH y LOW se utilizan, por ejemplo, cuando se desea activar o desactivar un pin Arduino. INPUT y OUTPUT se utilizan para establecer un pin específico para ser y entrada o una salida Verdadero y falso indican exactamente lo que sus nombres sugieren: la verdad o falsedad de una condición o expresión.

VARIABLES Las variables se denominan áreas de la memoria del Arduino donde se pueden almacenar datos que se pueden utilizar y manipular en el boceto. Como su nombre indica, pueden ser cambiados tantas veces como quieras. Debido a que Arduino es un procesador muy simple, cuando declara una variable, debe especificar su tipo. Esto significa decirle al procesador el tamaño del valor que desea almacenar. Aquí están los tipos de datos que están disponibles: boolean Puede tener uno de dos valores: verdadero o falso. char

Tiene un solo carácter, como A. Como cualquier computadora, Arduino lo almacena como un número, aunque vea texto. Cuando los caracteres se utilizan para almacenar números, pueden contener valores de -128 a 127. NOTA: Hay dos conjuntos principales de caracteres disponibles en sistemas informáticos: ASCII y UNICODE. ASCII es un conjunto de 127 caracteres que se utilizó para, entre otras cosas, la transmisión de texto entre terminales en serie y sistemas de computadora compartidos en el tiempo, tales como mainframes y minicomputadoras. UNICODE es un conjunto mucho más grande de valores utilizados por los sistemas operativos modernos de computadora para representar a personajes en una amplia gama de idiomas. ASCII sigue siendo útil para el intercambio de bits cortos de información en idiomas como el italiano o el inglés que utilizan caracteres latinos, números arábigos y símbolos de máquina de escribir comunes para la puntuación y similares.

byte Contiene un número entre 0 y 255. Al igual que con los caracteres, los bytes utilizan sólo un byte de memoria. int Utiliza 2 bytes de memoria para representar un número entre -32.768 y 32.767; Es el tipo de datos más común usado en Arduino. unsigned int Como int, utiliza 2 bytes, pero el prefijo sin signo significa que no puede almacenar números negativos, por lo que su rango va de 0 a 65.535. long Este es el doble del tamaño de un int y contiene números de -2.147.483.648 a 2.147.483.647. unsigned long Versión sin firmar de largo; Va de 0 a 4.294.967.295. float Esto es bastante grande y puede contener valores de punto flotante, una manera elegante de decir que puede usarlo para almacenar números con un punto decimal en ella. Se comen hasta 4 bytes de su memoria RAM precioso y las funciones que pueden manejar que utilizan una gran cantidad de memoria de código también. Así que usa flotadores con moderación.

double Número de coma flotante de doble precisión, con un valor máximo de 1.7976931348623157 x 10308. Wow, eso es enorme! string Un conjunto de caracteres ASCII que se utilizan para almacenar información textual (puede utilizar una cadena para enviar un mensaje a través de un puerto serie o para mostrarlo en una pantalla LCD). Para el almacenamiento, utilizan un byte para cada carácter en la cadena, además de un carácter nulo para decirle a Arduino que es el final de la cadena. Los siguientes son equivalentes: char string1[] = "Arduino"; // 7 chars + 1 null char char string2[8] = "Arduino"; // Same as above

array Una lista de variables a las que se puede acceder a través de un índice. Se utilizan para construir tablas de valores que se pueden acceder fácilmente. Por ejemplo, si desea almacenar diferentes niveles de brillo que se utilizarán al atenuar un LED, podría crear seis variables denominadas light01, light02, etc. Mejor aún, usted podría utilizar un arreglo simple como: int light[6] = {0, 20, 50, 75, 100}; La palabra "matriz" no se usa realmente en la declaración de variables: los símbolos [] y {} realizan el trabajo.

ESTRUCTURAS DE CONTROL Arduino incluye palabras clave para controlar el flujo lógico de su boceto. if . . . else Esta estructura toma decisiones en su programa. if debe ser seguido por una pregunta especificada como una expresión entre paréntesis. Si la expresión es verdadera, lo que sigue será ejecutado. Si es falso, se ejecutará el bloque de código siguiente. Es posible utilizar sólo if sin proporcionar una cláusula else. Ejemplo: if (val == 1) { digitalWrite(LED,HIGH); }

for Le permite repetir un bloque de código un número especificado de veces.

Ejemplo: for (int i = 0; i < 10; i++) {

Serial.print("ciao"); }

switch case Las declaraciones if son como una bifurcación en el camino para su programa. Switch case es como una enorme rotonda. Permite que su programa tome una variedad de direcciones dependiendo del valor de una variable. Es muy útil mantener su código ordenado, ya que reemplaza largas listas de declaraciones if. Ejemplo: switch (sensorValue) { digitalWrite(13,HIGH); 46:

case 23: break;

digitalWrite(12,HIGH);

case break;

default: // if nothing matches this is executed

digitalWrite(12,LOW);

digitalWrite(13,LOW); }

while Similar a if, Esto ejecuta un bloque de código mientras que una cierta condición es verdadera. Ejemplo: // blink LED while sensor is below 512 sensorValue = analogRead(1); while (sensorValue < 512) { digitalWrite(13,HIGH); delay(100); digitalWrite(13,HIGH);

delay(100);

sensorValue = analogRead(1); }

do . . . while Sólo como while, excepto que el código se ejecuta justo antes de que se evalúe la condición. Esta estructura se utiliza cuando desea que el código dentro de su bloque se ejecute al menos una vez antes de comprobar la condición. Ejemplo: do { digitalWrite(13,HIGH); delay(100); digitalWrite(13,HIGH); delay(100); sensorValue = analogRead(1); } while (sensorValue < 512);

break Este término le permite dejar un bucle y continuar la ejecución del código que aparece después del bucle. También se utiliza para separar las diferentes secciones de una declaración switch case. Ejemplo: // blink LED while sensor is below 512 do { if a button is pressed

// Leaves the loop

if (digitalRead(7) == HIGH)

break;

digitalWrite(13,HIGH); delay(100); digitalWrite(13,HIGH);

delay(100);

sensorValue = analogRead(1); } while (sensorValue < 512);

continue Cuando se usa dentro de un bucle, continue le permite saltar el resto del código dentro de él y forzar la condición para ser probado de nuevo. Ejemplo: for (light = 0; light < 255; light++) { // skip intensities between 140 and 200 if ((x > 140) && (x < 200)) continue; analogWrite(PWMpin, light); delay(10); }

return Detiene la ejecución de una función y regresa de ella. También puede usar esto para devolver un valor desde dentro de una función. Por ejemplo, si tiene una función llamada computeTemperature() Y desea devolver el resultado a la parte de su código que invocó la función que escribiría algo como: int computeTemperature() {

int

temperature = 0; temperature = (analogRead(0) + 45) / 100;

return temperature;

}

ARITMÉTICOS Y FÓRMULAS Puede utilizar Arduino para realizar cálculos complejos utilizando una sintaxis especial. + Y - funciona como lo has aprendido en la escuela, y la multiplicación se representa con un * y la división con un /.

Hay un operador adicional llamado "módulo" (%), que devuelve el resto de una división entera. Puede utilizar tantos niveles de paréntesis como sea necesario para agrupar expresiones. Contrariamente a lo que usted pudo haber aprendido en la escuela, los corchetes y los corchetes se reservan para otros propósitos (índices de la matriz y bloques, respectivamente). Ejemplos: a = 2 + 2; light = ((12 * sensorValue) - 5 ) / 2; remainder = 3 % 2; // returns 2 because 3 / 2 has remainder 1

OPERADORES DE COMPARACIÓN Cuando especifique condiciones o pruebas para if, while, y for declaraciones, estos son los operadores que puedes usar: == igual a != no igual a < menos que > mas grande que <= menos que o igual a >= mayor qué o igual a

OPERADORES BOOLEANOS Estos se utilizan cuando se desea combinar varias condiciones. Por ejemplo, si desea comprobar si el valor procedente de un sensor está entre 5 y 10, escribiría: ((sensor => 5) && (sensor <=10))

Hay tres operadores: y, representados con &&; O, representado con ||; Y finalmente no, representado con!.

OPERADORES COMPUESTOS Éstos son operadores especiales usados para hacer el código más conciso para algunas operaciones muy comunes como incrementar un valor.

if

Por ejemplo, para incrementar el valor en 1, escribiría: value = value +1;

Pero utilizando un operador compuesto, esto se

convierte en: value++; Incremento y decremento (- y ++) Estos incrementan o decrementan un valor por 1. Sin embargo, tenga cuidado. Si escribes i++ esto incrementa i por 1 y se evalúa al equivalente de i+1; ++i se evalúa al valor de i luego incrementa i. Lo mismo se aplica a ––. += , –=, *= and /= Esto hace más corto escribir ciertas expresiones. Las dos expresiones siguientes son equivalentes: a = a + 5; a += 5;

FUNCIONES DE ENTRADA Y SALIDA Arduino incluye funciones de manejo de entrada y salida. Ya has visto algunos de estos en los programas de ejemplo a lo largo del libro. PinMode (pin, modo) Reconfigura un pin digital para que se comporte como entrada o salida. Ejemplo: pinMode(7,INPUT); // turns pin 7 into an input digitalWrite(pin, value) Enciende o apaga un pin digital. Los pins deben convertirse explícitamente en una salida usando pinMode antes de digitalWrite tendrá algún efecto. Ejemplo: digitalWrite(8,HIGH); // turns on digital pin 8 int digitalRead(pin) Lee el estado de un pin de entrada, devuelve HIGH si el pin detecta algún voltaje o LOW si no hay voltaje aplicado.

Ejemplo: val = digitalRead(7); // reads pin 7 into val

int analogRead(pin) Lee el voltaje aplicado a un pin de entrada analógica y devuelve un número entre 0 y 1023 que representa las tensiones entre 0 y 5 V. Ejemplo: val = analogRead(0); // reads analog input 0 into val analogWrite(pin, value) Cambia la frecuencia PWM en uno de los pines marcados PWM. Pin puede ser 11, 10, 9, 6, 5, 3. El valor puede ser un número entre 0 y 255 que representa la escala entre 0 y 5 V de voltaje de salida. Ejemplo: analogWrite(9,128); // Dim an LED on pin 9 to 50% shiftOut(dataPin, clockPin, bitOrder, value) Envía datos a un registro de desplazamiento, dispositivos que se utilizan para expandir el número de salidas digitales. Este protocolo utiliza un pin para los datos y uno para el reloj. BitOrder indica el orden de bytes (menos significativo o más significativo) y el valor es el byte real que se enviará. Ejemplo: shiftOut(dataPin, clockPin, LSBFIRST, 255); unsigned long pulseIn(pin, value) Mide la duración de un pulso en una de las entradas digitales. Esto es útil, por ejemplo, para leer algunos sensores infrarrojos o acelerómetros que generan su valor como impulsos de duración variable. Ejemplo: time = pulsein(7,HIGH); // measures the time the next

// pulse stays

high

FUNCIONES DEL TIEMPO Arduino incluye funciones para medir el tiempo transcurrido y también para detener el boceto. unsigned long millis()

Devuelve el número de milisegundos transcurridos desde el inicio del boceto. Ejemplo: duration = millis()-lastTime; // computes time elapsed since "lastTime"

delay(ms) Pausa el programa por la cantidad de milisegundos especificado. Ejemplo: delay(500); // stops the program for half a second delayMicroseconds(us) Detiene el programa por la cantidad dada de microsegundos. Ejemplo: delayMicroseconds(1000); // waits for 1 millisecond

FUNCIONES DE MATEMÁTICAS Arduino incluye muchas funciones matemáticas y trigonométricas comunes: min(x, y) Devuelve el menor de x e y. Ejemplo: val = min(10,20); // val is now 10

max(x, y) Devuelve el mayor de x e y. Ejemplo: val = max(10,20); // val is now 20

abs(x) Devuelve el valor absoluto de x, que convierte los números negativos en positivos. Si x es 5, devolverá 5, pero si x es -5, todavía retornará 5. Ejemplo: val = abs(-5); // val is now 5 constrain(x, a, b)

Devuelve el valor de x, restringido entre a y b. Si x es menor que a, simplemente devolverá a y si x es mayor que b, regresará b. Ejemplo: val = constrain(analogRead(0), 0, 255); // reject values bigger than 255

map(value, fromLow, fromHigh, toLow, toHigh) Muestra un valor en el rango fromLow y maxLow al rango toLow y toHigh. Muy útil para procesar valores de sensores analógicos. Ejemplo: val = map(analogRead(0),0,1023,100, 200); // maps the value of 0 to a value

// analog

// between 100 and 200

double pow(base, exponent) Devuelve el resultado de levantar un número (base) para un valor (exponent). Ejemplo: double x = pow(y, 32); // sets x to y raised to the 32nd power double sqrt(x) Devuelve la raíz cuadrada de un número. Ejemplo: double a = sqrt(1138); // approximately 33.73425674438 double sin(rad) Devuelve el seno de un ángulo especificado en radianes. Ejemplo: double sine = sin(2); // approximately 0.90929737091 double cos(rad) Devuelve el coseno de un ángulo especificado en radianes. Ejemplo: double cosine = cos(2); // approximately -0.41614685058 double tan(rad) Devuelve la tangente de un ángulo especificado en radianes. Ejemplo: double tangent = tan(2); // approximately -2.18503975868

FUNCIONES NUMÉRICAS DE RANDOM Si necesita generar números aleatorios, puede usar el generador de números pseudoaleatorios de Arduino. randomSeed(seed) Restablece el generador de números pseudoaleatorios de Arduino. Aunque la distribución de los números devueltos por random() Es esencialmente aleatorio, la secuencia es predecible. Por lo tanto, debe restablecer el generador a un valor aleatorio. Si tiene un pin analógico no conectado, captará ruido aleatorio del entorno (ondas de radio, rayos cósmicos, interferencias electromagnéticas de los teléfonos celulares y luces fluorescentes, etc.). Ejemplo: randomSeed(analogRead(5)); // randomize using noise from pin 5 long random(max) long random(min, max) Devuelve un valor entero largo pseudoaleatorio entre min y max - 1. Si no se especifica min, el límite inferior es 0. Ejemplo: long randnum = random(0, 100); // a number between 0 and 99 long randnum = random(11); // a number between 0 and 10

COMUNICACIÓN SERIAL Como se vio en el Capítulo 5, puede comunicarse con dispositivos a través del puerto USB mediante un protocolo de comunicación serie. Aquí están las funciones en serie. Serial.begin(speed) Prepara Arduino para comenzar a enviar y recibir datos en serie. En general, usará 9600 bits por segundo (bps) con el monitor en serie IDE de Arduino, pero otras velocidades están disponibles, generalmente no más de 115.200 bps. Ejemplo: Serial.begin(9600);

Serial.print(data) Serial.print(data, encoding) Envía algunos datos al puerto serie. La codificación es opcional; Si no se suministra, los datos se tratan como texto plano como sea posible.

Ejemplos: Serial.print(75);

// Prints "75" Serial.print(75, DEC); // The same as above.

Serial.print(75, HEX); // "4B" (75 in hexadecimal) Serial.print(75, OCT); // "113" (75 in octal) Serial.print(75, BIN); // "1001011" (75 in binary) Serial.print(75, BYTE); // "K" (the raw byte happens to // be 75 in the ASCII set)

Serial.println(data) Serial.println(data, encoding) Igual que Serial.print(), Excepto que añade un retorno de carro y avance de línea (\ r \ n) como si hubiera escrito los datos y luego presionado Intro o Intro. Ejemplos: Serial.println(75);

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

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

int Serial.available() Devuelve cuántos bytes no leídos están disponibles en el puerto Serial para leer a través de la función read(). Después tienes read() todo disponible, Serial.available() devuelve 0 hasta que lleguen nuevos datos al puerto serie. Ejemplo: int count = Serial.available(); int Serial.read() Obtiene un byte de los datos en serie entrantes. Ejemplo: int data = Serial.read(); Serial.flush() Debido a que los datos pueden llegar a través del puerto serie más rápido de lo que su programa puede procesar, Arduino mantiene todos los datos entrantes en un búfer. Si necesita borrar el búfer y dejar que se llene con datos nuevos, use la función flush(). Ejemplo: Serial.flush();

Apéndice d / Diagramas esquemáticos de lectura Hasta ahora, hemos utilizado ilustraciones muy detalladas para describir cómo ensamblar nuestros circuitos, pero como se puede imaginar, no es exactamente una tarea rápida dibujar una de esas para cualquier experimento que quiera documentar. Problemas similares surgen, tarde o temprano, en todas las disciplinas. En la música, después de escribir una bonita canción, es necesario escribirla usando la notación musical. Los ingenieros, siendo gente práctica, han desarrollado una manera rápida de capturar la esencia de un circuito para poder documentarlo y después reconstruirlo o pasarlo a otra persona. En la electrónica, los diagramas esquemáticos le permiten describir su circuito de una manera que sea entendida por el resto de la comunidad. Los componentes individuales están representados por símbolos que son una especie de abstracción de la forma del componente o la esencia de ellos. Por ejemplo, el condensador está hecho de dos placas metálicas separadas por aire o plástico; Por lo tanto, su símbolo es:

Otro ejemplo claro es el inductor, que se construye enrollando alambre de cobre alrededor de una forma cilíndrica; Por consiguiente el símbolo es:

Las conexiones entre los componentes se realizan generalmente utilizando cables o pistas en la placa de circuito impreso y se representan en el diagrama como líneas simples. Cuando dos cables están conectados, la conexión se representa por un punto grande colocado donde las dos líneas cruzan:

Esto es todo lo que necesita para comprender los esquemas básicos. Aquí está una lista más completa de símbolos y sus significados:

RESISTOR

DIODE

CAPACITOR

LED

THERMISTOR

PUSHBUTTON

LDR LIGHT SENSOR

POTENTIOMETER

Puede encontrar variaciones en estos símbolos (por ejemplo, ambas variantes de los símbolos de resistencia se muestran aquí). Ver en.wikipedia.org/wiki/ Electronic_symbol para una lista más amplia de los símbolos de la electrónica. Por

convención, los diagramas se dibujan de izquierda a derecha. Por ejemplo, una radio se elaborará a partir de la antena a la izquierda, siguiendo el camino de la señal de radio, ya que hace su camino hacia el altavoz (que se dibuja a la derecha). El siguiente esquema describe el circuito pulsador mostrado anteriormente en este libro: +5 V ARDUINO PIN 7

GND

GND

Appendix D

Índice ; (Punto y coma), 46, 97 // (delimitador del comentario), 34-35, 36-37, 98 - (operador de decremento), 104 / * (Delimitador de comentarios), 98 && (y operador), 103 {} (Entre corchetes), 34-35, 97 == (igual a), 44-45, 103 = (Operador de igualdad), 44-45 > (Mayor que), 103 > = (Mayor o igual que), 103 ++ (operador de incremento), 104 <(Menor que), 103 <= (Menor o igual que), 103 % (Módulo), 103 ! = (No igual a), 103 ! (No operador), 103 || (U operador), 103 () (Paréntesis), 36 LED RGB de 4 conductores, 84 UN Ampère, André-Marie, 41 amperios, 41 analógicaLeer función, 64-67, 105 analógica analógicaLeer función, 64-67, 105 analogWrite función, 56-58, 65-67, 105 entrada, 64-67, 73 salida,

111

56-62, 73 pines, placa Arduino, 20-21, 64-67 sensores, 64-68 sintetizadores, 8 analogWrite función, 56-58, 65-67, 105 y operador, 103 Pines de E / S analógicas Arduino, 20-21, 64-67 definidos, 1 Placa Diecimila, 20, 88 pines digitales IO, 20-21 Placa Duemilanove, 20-21 Extreme board, 88 forum, 91 -92 Pines GND, 60 hardware, 19-21 IDE, descarga, 22 IDE, descripción, 22 IDE, solución de problemas, 90-91 IDE, sitio web, 1 instalación, 22-27 Linux, 22 NG, 20-21, 88 vista general, 1-3 ,,,,,,,,,,,,,,,,,,,,,,,,, 36 aritmética, 103 matriz variable, 100 ASCII, 99 lámpara de esfera de montaje, 84-85 ATmega168, 19-21 Lámpara Aton, 73 segundo Barragan, Hernando, 2 circuitos de curvatura, 10-11 El Betrothed, 36 bitOrder, 105 LED parpadeante, 3038, 64-67 Operadores booleanos, 103 variable, 98 saltos, 49-51 soportes, rizado, 34-35 breadboard, 43 , 60, 89-90, 93-94 estructura de control de rotura, 102 buffer, 76 byte variable, 99 do C lenguaje, 22 cálculos, 103 condensadores de lectura, 95-96 símbolo, 110, 111 conmutadores de alfombras, 53 char variable, 98 circuitos (PWM), 58-60 LED controlado por pulsador, 42-43 lámpara de esfera, 83-84 símbolos, esquemas, 110111 pruebas, 89 -90 clockPin, 105 código. Consulte

también programación de LED parpadeante, 32-38, 64-67 bloques, nombres, 34-35 LED controlado por pulsador, 44-51 objetos en serie, 68-69 lámpara esfera, 75-82 Colaboración, 16 Colombo, Joe, 73 códigos de colores, resistencias, 95-96 colores, codificación HTML, 75-76 puertos COM, Windows, 26-27, 90-91 comando, #define, 36, 46 comentarios, 35, 36 -37, 98 comunicación, serie, 25 - 27, 68 - 69, 73, 90-91, 108-109 operadores de comparación, 103 compilación de bocetos, 33, 46 sensores complejos, 70-71 operadores compuestos, 103-104 conexiones, símbolo, 110 constantes, 36 función de restricción, 106 información de contacto, ix continuar la estructura de control, 102 Estructuras de control, 100-102 función cos, 107 herrajes, 34-35, 97 corriente, 41-42 protección de corriente, 89 re Dante, 36 89-90, 88-90, 88-89, 87-90, 88-89, 68-69, 89-90, 6869, data-serial, 68-69, data- 36, 46 función de retardo, 37, 106 función delayMicroseconds, 106 delimitadores bloques de código, 34-35 Comentario, 35 Diagramas, circuitos, 110-111 Diecimila placa, 20 digital 42, 64, 104 digitalWrite función, 37, 104 diodo, símbolo, 111 divide y impera, 87 Divina Commedia, 107 función doble de la función del pecado, 107 función doble del pecado, 107 función doble del tan, 107 variable doble, 99 hacen ... mientras que estructura de control, 101 Drenan el perno, transistores del MOSFET, 70 conductores, Instalación, 23-24 conducción de grandes cargas, 70 Duemilanove bordo, 20-21 Dyson, James, 6 mi Electricidad, 39-42 operador de igualdad, 44-45 Errata, ix ejecución de bocetos, 34 energía externa, 20 Extreme board, 88 F FALSO, 45 falso, 98 variable flotante, 99 carpeta, almacenamiento de boceto, fuente 32, generación, 80 para la estructura de control, 100 para instrucciones, 103 fórmulas, 103 foro, Arduino, 91-92 106 analógica, 56-58, 65-67, 105 restricción, 106 cos, 107 retardo, 106 función de retardo, 37 retardoMicroseconds, 106 digitalRead, 42 digitalWrite, 37, 104 loop, 35, 37 mapa, 107 matemáticas, 106-107 108, 108, 108, 105, 105, 105, 105, 106, 109, 108, 109, 108, 109 Serial.available, 109 Serial.begin, 108 Serial.flush, 109 Serial.print, 108-109 Serial.println, 109 Serial.read, 109 configuración, 35, 36 shiftOut, 105 sin, 107 tan, 107 tiempo, 105-106 tipo de vacío, 36-37 GRAMO Puertas, transistores MOSFET, 70 Ghazala, Reed, 10 clavijas GND, 60 clavijas de tierra, 60

marido Hacking circuit bending, 10-11 junk, 14 teclados, 1213 juguetes, 15 Haque, Usman, 15 hardware, Arduino, 19-21 hexadecimal, 75-76 HIGH, 37, 98 Hopper, Grace, 88 Codificación de colores HTML, 7576 yo I premessi sposi, 36 IDE (entorno de desarrollo integrado) descarga, 22 información general, 22 solución de problemas, 9091 sitio web, 1 si la estructura de control. Ver si declaraciones si declaraciones, 44-45, 100, 103 si ... otra estructura de control, 100 Igoe, Tom, 71 IKEA lámpara, 84 iMac drivers, 23 lámparas incandescentes, conductor, 70 incremento operador, 104 inductor, símbolo, 110 infrarrojos, 7071 sensores infrarrojos, 55, 56 INPUT, 36, 67, 73 digital, 36 - 38, 73 Funciones, 104-108 instalación Arduino, 22-27 Controladores de Macintosh, 23 controladores de Windows, 23-24 función analógicaRead, 105 int función digitalRead, 104 int Función Serial.available, 109 int Serial.read, 109 int variable, 99 Entorno de Desarrollo Integrado (IDE). Consulte IDE (Integrated Development Ambiente) Controladores Intel, 23 Interaction Design, 2-3 Interactive Device, 29 lámparas interactivas, 38 pines IO, placa Arduino, 2021, 64-67 problemas de aislamiento, 90 J puente, selección de potencia, 20 puente de conexión, 43-44 basura, 14 K Kernighan, Brian W., 90 teclados, hacking, 12-13 L lámparas Aton, 73 de conducción, 70 interactivo, esfera 38, 74-85 LDRs (resistencias dependientes de la luz), 30, 63, 111 LED de 4 conductores RGB, 84 parpadeo, 30-38 sensores de luz, 62-63 modulación de ancho de pulso (PWM), 56-62 pulsador controlado, 42-51 lámpara de esfera, 74-85 símbolos, 111 luz. Ver también lámparas; (LDRs), 30, 63 que juegan con, 38 modulación de la anchura de pulso (PWM), 56-62 amarillo que destella, 88 Linux, 22 cargas, conduciendo, función aleatoria larga de 70, 108 largos Variable, función del lazo 99, 35, 37 LOW, 37, 98 Sensores y actuadores de baja tecnología, 15 m 70 función de mapa, 107 funciones matemáticas, 106-107 Máx, 8 función máxima, 106 transistor de efecto de campo de metalóxido-semiconductor, función de 70 milisegundos, 105 min función, 106 módulo, 103 Interruptor pulsador momentáneo, 43

Moog, Robert, 8 transistores MOSFET, 70 aceleradores de detección de movimiento, 7071 interruptores de alfombra, 53 interruptores magnéticos, 53 sensores infrarrojos pasivos, 55, 56 reed relés, 53 interruptores de inclinación, 54, 56 motores, conducción, 70 comentarios de varias líneas , 98 norte Nombres, bloques de código, 34-35 NG bordo, 20-21, 88 no operador, 103 Números aritmética y fórmulas, 103 funciones matemáticas, 106-107 funciones aleatorias, 108 funciones trigonométricas, 106-107 variables, 98-100 O Objetos, serial, 68-69, 73 Ohm, Georg, 41 ohmios, 41 Ohm's Law, 41-42 Olivetti, 14 sensores on / off, 53-56 ayuda en línea, 91-92 operadores booleanos, 103 comparación, 103 compuestos, 103-104 Prototipación oportunista, 6 u operador, 103 SALIDA, 36-37, 98 salida analógica, 56-62, 73 digital, 36-38, 73 funciones, 104-108 pag 30, 56, 85, 8, 9 Pentland, Alex, 13 persistencia de la visión, 56-62 filosofía, Arduino, 5-16 fotoresistores, 30. Ver también LDRs (lightResistencias dependientes) Computación física, definida, 3 Diseño de Interacción Física, 3 Pike, Rob, función 90 pinMode, 36, 104 pines, placa analógica IO Arduino, 20-21 IO digital, 20-21 tierra, 60 transistores MOSFET, 70 sensores PIR (sensores infrarrojos pasivos), 55, 56 , 85 Pirola, Maurizio, 89 80, 90-91 potenciómetro, símbolo, función de 111 pow, 107 fuentes de alimentación, 20, 70, 88, 89 La práctica de la programación, 90 El procesamiento, 1, 22, 69, 75-82 función de programación de abs, 106 analógicaLeer función, 64-67, 105 analogWrite función, 5658, 65-67, 105 argumentos, 36 parpadeo LED, 30-38, 36-38 operadores booleanos, 103 103, 103, 35, 36-37 operadores de comparación, 103-104 constantes, 36, 98 función de restricción, 106 estructuras de control, 100-102 función de cos, 107 entre corchetes, 34-35 , 97 ciclo, 22 tipos de datos, 98-100 #define, 36, 46 función de retardo, 37, 106 función delayMicroseconds, 106 función digitalRead, 42, 64, 104 función digitalWrite, 37, 104 funciones, 34-35, 104-108 si 106 función de los milis, función de 105 minutos, función de 106 pinMode, 36, función de 104 pow, 107 modulación de la anchura de pulso (PWM), 56-62 función de pulsación, 105 LED controlado por pulsador, 42-51 RAM, 46

Función aleatoria, 108 funciones de números aleatorios, 108 función de función aleatoria, 108 funciones serie, 108-109 objetos serie, 6869, 73 Función de serie, 109 Función Serial.begin, 108 Función Serial.flush, 109 Función Serial.print, 108-109 Función Serial.println, 109 función Serial.read, 109 función de configuración, 35, 36 función shiftOut, 105 función sin, 107 caracteres especiales, 97-98 esfera lámpara, estado 75-82, estructura 47-48, función 97 tan, 107 76, 46-48 variables, 45-46, 98-100 visual, 8 tipo de función void, 36-37 prototipos, 6 proxy, 75 generador de números pseudoaleatorios, 108 modulación de ancho de pulso (PWM), 56- 62 pulsos, 105 Datos puros, 8 LEDs controlados por pulsador, 42-51, 111 PWM (modulación de ancho de pulso), 56-62 PWR_SEL, 20 R Reas, Casey, 2 datos de recepción, objetos en serie, 68-69, 73 relés de lámina, 53 registros (LDR), 30, 63 lectura, 95-96 símbolo, 111 variable, 41 estructura de control de retorno , 102 LED RGB, 4 conductores, 84 Fuente RSS, control de la lámpara, 75 S Diagramas, símbolos, 110-111 selección de puertos, 25-27 punto y coma, 46, 97 envío de datos, objetos en serie, 68-69, 73 sensores acelerómetros, 70-71 analógico, 64-68 parpadeo LED, 64-67 conmutadores de alfombra, 53 Circuitos infrarrojos, 55, 56, 85 infrarrojos, 70-71 teclado cortar, 13 luz, 62-63 interruptores magnéticos, 53 encendido / apagado, 53-56 resumen, 30 pulsador, 42 caña Relés, 53 termistores, 68 termostatos, 53, 56 interruptores de inclinación, 54, 56, 85 guardabarros ultrasónicos, serie 70-71 Comunicación, 25 - 27, 68 - 69, 73, 90 - 91, 108 109 objetos, 68 - 69, 73 Puertos, 25-27, 90-91 Función Serial.available, 109 Función Serial.begin, 108 Función Serial.flush, 109 Función Serial.print, 108-109 105 función de desplazamiento, 105 función de desplazamiento, 105 cortocircuitos, 89 función sin, 107 comentarios de una sola línea, 98 bocetos función abs, 106 función de lectura analógica, 67, 105 función de analogWrite, 56-58, 65-67, 105 argumentos, 36 LED parpadeante, 30-38, 64-67 parpadear explicación del código del LED, 36-38 operadores booleanos, 103 saltos, 49-51 cálculos, 103 comentarios, 35, 36-37 operadores de comparación, 103 compilación, 33, 46 operadores compuestos, 103-104 constantes, 36, 98 función de restricción, 106 estructuras de control, 100-102 función de cos, 107 corchetes, 34-35, 97 tipos de

datos, 98 -100 #define, 36, 46 función de retardo, 37, 106 delayMicroseconds función, 106 digitalRead función, 42, 64, 104 Función de memoria, Función de memoria, Función de memoria, Función de memoria digital, Función de memoria digital, Función 105 min, 106 sensores infrarrojos pasivos, 56-62 función pinMode, 36, función 104 pow, 107 modulación de anchura de pulso (PWM), 56-62 función pulseln, 105 LED pulsador controlado, 42-51 RAM, 46 Función aleatoria, 108 funciones de números aleatorios, 108 función de función aleatoria, 108 funciones serie, 108-109 objetos serie, 68-69, 73 Función de serie, 109 Función Serial.begin, 108 Función Serial.flush, 109 Función Serial.print, 108-109 Función Serial.println, 109 función Serial.read, 109 función de configuración, 35, 36 función shiftOut, 105 función sin, 107 caracteres especiales, 97-98 esfera lámpara, estado 75-82, estructura 47-48, función 97 tan, 107 Funciones de tiempo, 105-106 carga, 33 val, 46-48 Variables, 45-46, 98-100 tipo de función vacía, 3637 Somlai-Fischer, Adam, 15 sonidos, guardabosques ultrasónicos, 70-71 Pines fuente, transistores MOSFET, 70 caracteres especiales; (Punto y coma), 46, 97 // (delimitador del comentario), 34-35, 36-37, 98 - (operador de decremento), 104 / * (Delimitador de comentarios), 98 && (y operador), 103 {} (Entre corchetes), 34-35, 97 == (igual a), 44-45, 103 > (Mayor que), 103 > = (Mayor o igual que), 103 = (Si declaración), 44-45 ++ (operador de incremento), 104 <(Menor que), 103 % (Módulo), 103 ! = (No igual a), 103 ! (No operador), 103 || (U operador), 103 () (paréntesis), 36 símbolos aritméticos, 103 ASCII, 99 UNICODE, 99 Lámpara de la esfera, estado 74-85, secuencia 4748, estructura 99-100, bosquejo, 97, fuentes 100102, edificio del circuito, excedente 42-44, puente

14 SV1, estructura del control del caso del interruptor 88, 100-101 Conmutadores rebote, 49-51 alfombra, 53 magnéticos, 53 transistores MOSFET, 70 on / off, 53 pulsadores, 43 reed relés, 53 tilt, 54, 56, 85 símbolos programación (Ver caracteres especiales) esquemas 110-111 sintetizadores analógicos , 8 T Interruptor de pulsador táctil, 43 función de bronceado, 107 programa de prueba, Arduino, 88 termistores, 68, 111 termostatos, 53, 56 interruptores de inclinación, 54, 56, 85 funciones de tiempo, 105-106 retoques, 7 juguetes, hacking, 15 transistores MOSFET , 70 funciones trigonométricas, 106-107 solución de problemas, 88-89 circuitos integrados, 89-90 IDE (entorno de desarrollo integrado), 90-91 ayuda en línea, 91-92 vista general, 87-88 problemas de reproducción, 90 Windows, 91 Trucha, grande, 92 VERDADERO, 45 verdadero,98 u Guardabosques ultrasónicos, 70-71 UNICODE, 99 Variable sin signo int, 99 sin signo de función milis largo, 105 Cargando boceto, 33 USB Puertos, Windows, 26-27, 90-91 fuentes de alimentación, 20 objetos en serie, pruebas 68-69, 88 V Controladores de Windows, 24 identificación del puerto, 26-27, 90-91 solución de problemas, 90-91 programación visual, 8 función de vacío tipo, 36-37 Volta, Alessandro, 41 tensión, 41-42 voltios, 41 VVVV, 8 W Agua analogía, electricidad, 39-42 mientras que la estructura de control, 101 mientras que las declaraciones, 103 Wiki, Patio, 16, 91 Ventanas Drivers, instalación, 23-24 identificación de puerto, 25, 26-27 solución de problemas, 90-91 cable, puente, 43-44 x XML, proxy, 75 XP, controladores de Windows, 23-24 identificación de puerto, 26-27, 90-91 solución de problemas, 90-91 Y Luz intermitente amarilla, 88

Introduccion Al Arduino Massimo Banzidocx

Recommend Documents