Arduino Cookbook 2nd Edition

Recetas para iniciar, expandir, y mejorar sus proyectos

EN ESPAÑOL

TRADUCCIÓN: HENRY ALVARADO

Prólogo vii

Electrónica/Software Ingeniería/Robótica

Arduino Cookbook

• Usar Arduino con una variedad de populares dispositivos de entrada y sensores

“El conjunto de recetas de Michael es un buen regalo para la creciente comunidad de Arduino. Cualquiera que sea su conocimiento o habilidad, el libro provee soluciones para ese proyecto con el que está luchando hoy en día y estímulo para imaginar lo que construirá mañana. Dudo que alguna vez dejaré mi mesa de trabajo”

• Controlar pantallas visuales, generar sonido, y controlar varios tipos de motores

-Mikal Hart Arduino Uno Asesor Equipo

¿Desea crear dispositivos que interactúen con el mundo físico? Este libro es perfecto para cualquiera quien desee experimentar con el popular microcontrolador Arduino y su entorno de programación. Usted encontrará más de 200 consejos y técnicas para construir una variedad de objetos y prototipos como juguetes, detectores, robots y ropa interactiva que puede sentir y responder al tacto, sonido, posición, calor, y luz. Usted no necesita experiencia con Arduino o programación para iniciar. Actualizado para Arduino 1.0 liberado, las recetas en esta segunda edición incluyen ejemplos prácticos y orientación para ayudarle a empezar, expandir, y mejorar sus proyectos inmediatamente ya sea usted un artista, diseñador, aficionado, estudiante o ingeniero. • Ponerse al día rápidamente sobre la placa Arduino y conceptos esenciales de software • Aprender técnicas básicas para lectura digital y señales analógicas

• Interactuar con dispositivos que utilizan controles remotos, incluyendo Televisores y electrodomésticos • Aprender técnicas para manejo retrasos de tiempo y medición del tiempo • Aplicar avanzada codificación y manejo de técnicas de memoria

Michael Margolis es un tecnólogo en el campo de la computación en tiempo real, con experiencia en el desarrollo de hardware y software para interactuar con el entorno. Él tiene más de 30 años de experiencia en niveles superiores con Sony, Microsoft, and Lucent/Bell Labs, y ha escrito librerías y núcleo de software incluido en la distribución Arduino 1.0

Prólogo viii

SEGUNDA EDICIÓN

Arduino Cookbook

Michael Margolis

Arduino Cookbook, Segunda Edición Michael Margolis Derechos de autor © 2012 Michael Margolis, Nicholas Weldin. Todo derechos reservados Impreso en los EEUU Publicado por O'Reilly Medios, Inc., 1005 Gravenstein Carretera Norte, Sebastopol, California 95472. O'Reilly libros puede ser comprado para educativa, negocio, o venta promocional utilizar. Online ediciones son también disponible para más títulos ( http://my.safaribooksonline.com). Para más información, póngase en contacto nuestro corporativo/institucional departamento de venta: (800) 998-9938 o [email protected].

Editores: Shawn Wallace y Brian Jepson Producción Editor: Teresa Elsey Corrector de pruebas: Kiel Furgoneta Cuerno

Indexador: Lucie Haskins Cubierta Diseñador: Karen Montgomery Interior Diseñador: David Futato Illustrator: Robert Romano

Marzo 2011: Primero Edition.Diciembre 2011: Segundo Edition.

Revisión Historia para la Segundo Edición: 2011-12-09 Primero liberación Ver http://oreilly.com/catalog/errata.csp?isbn=9781449313876

para más detalles.

Nutshell Handbook, el logotipo de Nutshell Handbook, y el logotipo de O'Reilly son marcas registradas de O'Reilly Media, Inc. Arduino Cookbook, la imagen de un juguete conejo, y conexo comercio vestido son marcas comerciales de O'Reilly Medios, Inc. Muchas de las designaciones usadas por los fabricantes y los vendedores para distinguir su productos son reclamados como marcas. Donde aquellas designaciones aparecen en este libro, y O'Reilly Medios, Inc., era consciente de una marca comercial reclamar, la designaciones tener estado impreso en tapas o inicial gorras. Mientras cada precaución tiene han tomado en la preparación de este libro, la editor y autores asumirá ninguna responsabilidad para errores o omisiones, o para daños y perjuicios resultante desde la utilizar de la información mantenida con- en el presente documento.

ISBN: 978-1-449-31387-6 [LSI] 1323465788

Prólogo

Este libro fue escrito por Michael Margolis con Nick Weldin para ayudarle a usted explorar las increíbles cosas usted puede hacer con Arduino. Arduino es un familia de microcontroladores (Pequeños ordenadores) y un entorno de creación de software que hace fácil para usted crear programas (Llamados sketches) que pueden interactuar con el mundo físico. Las cosas que usted puede hacer con Arduino pueden sentir y responder al tacto, sonido, posición, calor, y luz. Este tipo de tecnología, a menudo referido a como computación física, es usado en todo tipo de cosas desde el iPhone hasta sistemas electrónicos de automóviles. Arduino hace esto posible para cualquier persona con un interés, incluso personas sin experiencia en programación o electrónica para usar esta rica y compleja tecnología.

¿A quién va dirigido este libro? A diferencia de otros libros, la experiencia con software y hardware es no indispensable. Este libro es dirigido a los lectores interesados en el uso de la tecnología de computación para interactuar con el entorno. Es para personas que quieren a rápidamente encontrar la solución a los problemas de hardware y software. Las recetas proporcionan la información que usted necesita para llevar a cabo un amplio alcance de tareas. También tiene detalles para ayudarle a personalizar soluciones para cumplir sus necesidades específicas. Hay insuficiente espacio en un libro limitado a 700 páginas cubrir a fondo la teoría general, así que hay Enlaces a referencias externas son proporcionados a lo largo de la libro. Ver "Qué Fueron dejados en la página xiv” para algunas referencias generales para aquellos sin experiencia en programación o electrónica. Si usted no tiene experiencia en programación experiencia, tal vez usted tiene un gran idea para un proyecto interactivo pero no tiene la habilidades para desarrollarlo, este libro le ayudará a aprender lo que necesita saber para escribir código que funcione, usando ejemplos que cubran más de 200 tareas comunes. Si usted tiene alguna experiencia en programación pero es nuevo en Arduino, el libro le ayudará a ser productivo rápidamente demostrando cómo implementar específicamente las capacidades de Arduino para su proyecto.

Prólogo xi

Personas que ya han usado Arduino deberían encontrar el contenido útil para rápido aprendizaje de nuevas técnicas, que son explicadas usando ejemplos prácticos. Este le ayudará a embarcarse en proyectos más complejos mostrando cómo resolver problemas y utilizando capacidades que pueden ser nuevas para usted. Experimentados programadores en C / C + + pueden encontrar ejemplos de cómo a utilizar recursos de bajo nivel AVR (interruptores, temporizadores, I2C, Ethernet, etc) para construir aplicaciones que utilizan el entorno Arduino.

Estructura del libro El libro contiene información que cubre el amplio alcance de las capacidades de Arduino, desde básicos conceptos y tareas comunes, hasta tecnología avanzada. Cada técnica es explicada en una receta que muestra cómo implementar una capacidad específica. Usted no necesitar a leer el contenido en secuencia. Donde una receta utiliza una técnica cubierta en otra receta, el contenido en la otra receta hace referencia en lugar de repetir detalles en múltiples lugares. Capítulo 1, Empezando, introducción al entorno de Arduino y proporcionar ayuda en conseguir el entorno de desarrollo Arduino y hardware instalado y trabajando. El próximo par de capítulos introduce al desarrollo de software Arduino. Capítulo 2, Haciendo al Sketch realizar su orden, cubre conceptos y tareas esenciales de software, y el Capítulo 3, Usando operadores Matemáticos, muestra cómo a hacer uso de las más comunes funciones matemáticas. Capítulo 4, Comunicaciones Serie, describe cómo a consigue Arduino a conectarse y comunicarse con su ordenador y otro dispositivos. Puerto Serie es el más común método para entrada y salida de Arduino, y esta capacidad es usada en muchas de las recetas de todo el libro. Capítulo 5, Entrada Digital y Analógica simple, introduce un alcance de básico técnicas para la lectura de señales digitales y analógicas. Capítulo 6, Entradas desde Sensores, construye sobre esto con recetas que explican cómo a utilizar dispositivos que permiten a Arduino sentir el tacto, sonido, posición, calor, y luz. Capítulo 7, Salidas Visuales, acerca de controladores de luz. Recetas sobre conmutación en uno o muchos LEDs y control de brillo y de color. Este capítulo explica cómo usted puede controlar barras gráficas y displays LED numéricos, así como crear patrones y animaciones con matrices de LED. Además, el capítulo proporciona una introducción general a salidas digitales y analógicas para aquellos que son nuevos en esto. Capítulo 8, Salida física, explica cómo usted puede hacer mover cosas controlando motores con Arduino. El amplio alcance de tipos de motores es cubierta: solenoides, servo motores, DC motores, y motores paso.

Prólogo xii

Capítulo 9, Salida de Audio, muestra cómo a generar sonido con Arduino a través de un dispositivo de salida como un altavoz. Esto cubre reproducción simple de tonos y melodías y reproducción de archivos WAV y MIDI. Capítulo 10, Controlando Remotamente Dispositivos Externos, describe técnicas que pueden utilizarse para interactuar con casi cualquier dispositivo que usa alguna forma de control remoto, incluyendo TV, equipos de audio, cámaras, puertas de garaje, electrodomésticos, y juguetes. Esto se basa en técnicas usadas en anteriores capítulos para conectar Arduino a dispositivos y módulos. Capítulo 11, El uso de pantallas, acerca de interfaz de LCD de texto y gráficos. El capítulo muestra cómo usted puede conectar estos dispositivos para visualización de texto, desplazar o resaltar palabras, y crear símbolos y caracteres especiales. Capítulo 12, Uso de Tiempo y Fechas, cubre la construcción en Arduino relacionado a funciones de tiempo e introduce muchas técnicas adicionales para la manipulación de tiempo de retrasos, medición de tiempo, y tiempos y fechas en el mundo real. Capítulo 13, Comunicación mediante I2C y SPI, acerca de los estándares, Circuito Inter-Integrado (I2C) e Interfaz Serie Periférica (SPI). Estos estándares proporcionan formas sencillas para información digital a ser transferido entre sensores y Arduino. Este capítulo muestra cómo a utilizar I2C y SPI para conectar a dispositivos comunes. Esto también muestra cómo para conectar dos o más placas Arduino, usando I2C para aplicaciones multi-placas. Capítulo 14, Comunicación Inalámbrica, Acerca de la comunicación inalámbrica con XBee y otros módulos inalámbricos. Este capítulo proporciona ejemplos que van desde simple puerto serie de reemplazo inalámbrico a redes de malla conectando múltiples placas a múltiples sensores. Capítulo 15, Ethernet y Networking, describe las muchas formas que usted puede utilizar Arduino con la Internet. Este tiene ejemplos que demuestran cómo a construir y utilizar clientes y servidores web y muestra cómo a utilizar la más común conexión comunicación a protocolos de internet con Arduino. Las librerías de software Arduino son una forma estándar de añadir funcionalidad al Entorno de Arduino. Capítulo 16, El uso, Modificación, y Creación Librerías, explica cómo utilizar y modificar librerías de software. Este también proporciona dirección en cómo a crear sus propias librerías. Capítulo 17, Codificación Avanzada y Manipulación de Memoria, cubre técnicas avanzadas de programación, y la temas aquí son más técnicos que las otras recetas en este libro porque ellos cubren cosas que son generalmente ocultas por la amigable envoltura de Arduino. Las técnicas en este capítulo pueden ser usadas para hacer un Sketch más eficiente, ello puede ayudar a mejorar rendimiento y reducir el tamaño del código de sus Sketches. Capítulo 18, Uso del Controlador Chip Hardware, muestra cómo acceder y utilizar funciones de hardware que no son completamente expuestos a través de la documentación de lenguaje Arduino. Esto cubre uso de hardware de bajo nivel de entrada / salida de registros, temporizadores, e interruptores.

Prólogo xiii

Apéndice A, Componentes Electrónicos, proporciona una visión de conjunto de los componentes utilizados a lo largo del libro. Apéndice B, Uso Esquemáticos, Diagramas y Hojas de Datos, explica cómo a utilizar diagramas esquemáticos y hojas de datos. Apéndice C, Construcción y Conexión del Circuito, proporciona un breve introducción a utilizando un protoboard, conectando y uso fuentes de poder y baterías, y utilizando condensadores para desacoplamiento. Apéndice D, Consejos en Solución de problemas de Software, proporciona consejos en arreglo de problemas de compilación y ejecución. Apéndice E, Consejos en Solución de problemas de Hardware, incluye problemas con circuitos electrónicos. Apéndice F, Pines Digitales y Analógicos, proporciona tablas indicando funcionalidad proporcionada por los pines en placas estándar de Arduino. Apéndice G, ASCII y Ampliado Juegos de caracteres, proporciona tablas que muestra caracteres ASCII. Apéndice H, Migración a Arduino 1.0, explica cómo a modificar código escrito para anteriores lanzamientos para ejecutar correctamente con Arduino 1.0.

Qué Fue Dejado Fuera No hay lugar en este libro para incluir teoría y práctica electrónica, aunque orientación es proveída para construir circuitos usados en la recetas. Para más detalle, Los lectores pueden querer a remitir a material que es extensamente disponible en la Internet o a libros tal como la siguiente: • • • •

Make: Electronics Charles Platt (O'Reilly, búsquelo en oreilly.com) Getting Started in Electronics por Forrest M. Mims III (Master Publishing) Physical Computing por Dan O'Sullivan y Tom Igoe (Cengage) Práctical Electronics forInventors por Paul Scherz (McGraw-Hill)

Este libro explica cómo escribir código para lograr tareas específicas, pero es no una introducción a la programación. Relevantes conceptos de programación son brevemente explicados, pero hay insuficiente lugar para incluir detalles. Si usted desea aprender más acerca de la programación, usted puede querer a remitir a la Internet o a uno de la siguiente libros: • Práctical C Programaming por Steve Oualline (O'Reilly; búsquelo en oreilly.com) • A book on C por Al Kelley y Ira Pohl (Addison-Wesley)

Prólogo xiv

Mi favorito, aunque no realmente un libro para principiantes, es el libro que yo he usado para aprender Programación C: • The C Programming Languaje por Brian W. Kernighan y Dennis M. Ritchie (Prentice Hall)

Estilo de Código (Acerca del Código) El código usado a lo largo de este libro ha sido adaptado para ilustrar claramente el tema tratado en cada receta. Como una consecuencia, algunos atajos comunes de codificación han sido evitados, particularmente en los primeros capítulos. Programadores experimentados en C a menudo utilizan ricas, pero breve expresiones que son eficientes pero pueden ser un poco difícil comprender para principiantes. Por ejemplo, los primeros capítulos incrementan variables usando expresiones explicitas que son fáciles para no programadores, léase: resultado = resultado + 1 / / incrementa el contador

Más bien que la siguiente, comúnmente usada por experimentados programadores, que hace lo mismo: resultado + +; / / incrementa el uso del operador de incremento posterior

Siéntase libre de sustituir su estilo preferido. Los principiantes deberían estar tranquilos ya que no hay beneficio en rendimiento o en tamaño de código usando la forma breve. Algunas expresiones de programación son tan comunes que ellas son usadas en su forma breve. Por ejemplo, las expresiones de bucle son escritos de la siguiente manera: for (int i = 0; i < 4; i++)

Este es equivalente a la siguiente: int i; for (i = 0; i < 4; i = i+1)

Ver Capítulo 2 para más detalles en estas y otras expresiones usadas a lo largo del libro. Una buena práctica de programación implica asegurar que valores usados son válidos (Basura entra igual a basura sale) por revisión antes de usarlos en cálculos. Sin embargo, para mantener el código centrado en tema de la receta, muy poca comprobación de errores código ha sido incluida.

Plataforma Arduino Notas de la versión Esta edición ha sido actualizada para Arduino 1.0. Todo el código ha sido probado con la última versión Arduino 1.0 (RC2). La descarga del código para esta edición ha sido actualizada en línea si es necesario apoyo a la versión final 1.0, a fin de comprobar el libro del sitio web para conseguir el más reciente código. La descarga contiene un archivo llamado changelog.txt que indicará código que ha sido cambiado desde la edición publicada.

Prólogo xv

Aunque muchos de los Sketches ejecutará en las más recientes versiones de Arduino, usted necesita cambiar la extensión desde .ino a .pde para cargar el Sketch en un pre-1.0 IDE. Si usted no ha migrado a Arduino 1.0 y tiene una buena razón para seguir con una versión anterior, usted puede utilizar el código ejemplo en la primero edición de este libro (Disponibles en http://shop.oreilly .com/product/9780596802486.do), que ha sido probado con versiones desde la 0018 a 0022. Tenga en cuenta que muchos recetas en la segunda edición han sido mejoradas, así nosotros motivamos a usted a actualizarse a Arduino 1.0. Si usted necesita ayuda para migrar código antiguo, véase el Apéndice H. Hay también un enlace a erratas en ese sitio. Las erratas dan lectores una manera de hacernos saber acerca de los errores tipográficos, errores, y otro problemas con el libro. Las erratas serán visibles en la página de inmediato, y vamos a confirmar ellas después de revisarlas. O'Reilly puede también corregir erratas en futuras impresiones del libro y en Safari, haciendo para el lector una mejor experiencia rápidamente. Si usted tener problemas haciendo funcionar ejemplos, comprobar el archivo changelog.txt en la última descarga de código a ver si el Sketch ha sido actualizado. Si eso no corrige el problema, consulte el Apéndice D, el cual incluye la solución de problemas de software. El foro Arduino es un buen lugar para publicar una pregunta si usted necesitar más Ayuda: http://www.arduino.cc. Si le gusta o no le gusta este libro, por todo medios, por favor que la gente lo sepa. Las reseñas de Amazon son una popular manera para compartir su felicidad u otros comentarios. Usted puede También dejar comentarios en el sitio de O'Reilly para este libro libro.

Convenciones Usadas en Este Libro Las siguientes convenciones son usadas en este libro: Cursiva Indica nombres de rutas, nombres de archivo, y nombres de programas; direcciones de internet, tal como Dominios y URL; y nuevo artículos donde ellos son definidos. Constante ancho

Indica líneas de comando y Opciones que deberían ser mecanografiado textualmente; nombres y palabras clave en programas, incluyendo método nombres, nombres de variable, y nombres de clases; y elemento y etiquetas HTML Constante ancho audaz

Indica énfasis en líneas de código en programas Constante ancho cursivo Indica texto que debería ser reemplazado con valores suministrados por el usuario. Este icono significa un consejo, sugerencia, o nota general.

Prólogo xvi

Este icono indica una advertencia o precaución.

Uso de Ejemplos de Código Este libro está aquí para ayudarle a hacer cosas con Arduino. En general, usted puede utilizar el código en este libro en sus programas y documentación. Usted no necesita a contactarnos para pedir permiso a menos que esté reproduciendo una significativa porción del código. Por ejemplo, escribir un programa use varios trozos de código desde este libro no requiere permiso. Vender o distribuir un CD-ROM de ejemplos de este libro requiere permiso. Contestar una pregunta citando este libro y citando ejemplo de código hace no necesita permiso. La incorporación de una significativa cantidad de ejemplo de código de este libro en su del producto documentación necesita permiso. Nosotros apreciamos, pero no requerimos, atribución. Una atribución en general incluye el título, autor, editor, e ISBN. Por ejemplo: "Arduino Cookbook, Segunda Edición, por Michael Margolis con Nick Weldin (O'Reilly). Derechos de autor 2012 Michael Margolis, Nicholas Weldin, 978-14493-1387-6. " Si usted siente su uso de ejemplos de código cae fuera de su uso justo, o el permiso dado aquí, no dude en contactarnos en [email protected].

Safari ® Libros Online Safari Libros Online es una biblioteca digital que le permite usted fácilmente buscar encima de 7500 referencias a libros de tecnología y creatividad y Vídeos para encontrar la respuestas usted necesitar rápidamente. Con una suscripción, usted puede leer cualquier página y ver cualquier vídeo desde nuestra biblioteca en línea. Leer libros en su teléfono celular y dispositivos móviles. Acceder a nuevos títulos antes que ellos estén disponibles para imprimir y conseguir exclusivo acceso a manuscritos en desarrollo y publicar comentarios para los autores. Copiar y pegar muestras de código, organizar sus favoritos, descargar capítulos, marcar secciones de libros, crear notas, imprimir páginas, y beneficio de toneladas de otras características de ahorro de tiempo. O'Reilly Medios de comunicación tiene subido este libro al servicio Safari Libros Online. Para tener completo acceso digital a este libro y otros en similares temas desde O'Reilly y otros publicadores, regístrese gratis en http://my.safaribooksonline.com.

Cómo contactarnos Nosotros hemos probado y verificado la información en este libro a lo mejor de nuestra capacidad, pero puede encontrar que características han cambiado (O incluso que hemos hechos unos pocos errores).

Prólogo xvii

Por favor, háganos saber acerca de cualquier error que usted encuentre, como bien como sus sugerencias para futuras ediciones, por escrito a: O'Reilly Media, Inc. 1005 Gravenstein Carretera Norte Sebastopol, CA 95472 800-998-9938 (En Estados Unidos o Canadá) 707-829-0515 (Internacional / local) 707-829-0104 (Fax) Nosotros tenemos una página web para este libro, donde enumeramos fe de erratas, ejemplos, y cualquier información adicional. Usted puede acceder a esta página en: http://shop.oreilly.com/product/0636920022244.do Para comentarios o preguntas técnicas acerca de este libro, enviar email a: [email protected] Para más información acerca de nuestros libros, cursos, conferencias, y noticias, ver nuestro sitio web en http://www.oreilly.com. Encuéntrenos en Facebook: http://facebook.com/oreilly Síganos en Twitter: http://twitter.com/oreillymedia Véanos en YouTube: http://www.youtube.com/oreillymedia

Agradecimientos La contribución de Mella Weldin fue invaluable para la terminación de este libro. Este fue 90 por ciento escrito cuando Mella vino al consejo y sin su habilidad y entusiasmo, seguiría siendo 90 por ciento escrito. Sus manos en la experiencia Arduino se ejecuta talleres para todos niveles de usuarios habilitados para hacer el asesoramiento en este libro práctico para nuestro amplio alcance de lectores. Gracias, Nick, por su conocimiento y genial, naturaleza colaborativa. Simon St. Laurent fue el editor en O'Reilly quien primero expresó interés en este libro. Y en el final, él es el hombre que sacó esto juntos. Su apoyo y estímulo nos mantuvo inspirados como nosotros tamizamos nuestro camino a través de los volúmenes de material necesario a hacer la materia justa. Brian Jepson me ayudo a comenzar con la escritura de este libro. Su vasto conocimiento de cosas Arduino y su preocupación y experiencia para comunicar acerca de la tecnología claro Inglés establece un alto estándar. Él fue una mano rectora para la conformación del libro y fabricación de tecnología fácilmente accesible para lectores. Nosotros también tenemos a Brian gracias por el contenido de XBee en el Capítulo 14. Brian Jepson y Shawn Wallace fueron editores técnicos para esta segunda edición y proporcionaron excelente asesoramiento para mejorar la precisión y claridad del contenido.

Prólogo xviii

Audrey Doyle trabajó incansablemente para erradicar errores tipográficos y gramáticos en el manuscrito inicial y desenredar algunas de las más complejas expresiones. Philip Lindsay colaboró en contenido para el Capítulo 15 en la primera edición. Adrian McEwen, el principal desarrollador para muchas mejoras de la Ethernet mejoras en la versión 1.0, proporcionó valioso asesoramiento para asegurar este Capítulo reflejó todos los cambios en esa versión. Mikal Hart escribió recetas sobre GPS y software serie. Mikal fue la elección natural para este no sólo porque él escribió las librerías, sino también porque él es un comunicador con fluidez, un Arduino entusiasta, y gran colaborador. Arduino es posible por la creatividad del equipo de desarrollo del núcleo Arduino; Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, y David Mellis. En nombre de todos los usuarios de Arduino, deseo expresar nuestro agradecimiento por sus esfuerzos en fabricar esta fascinante tecnología simple y su generosidad en hacerlo gratis. Agradecimiento especial a Alexandra Deschamps-Sonsino, cuyos Tinker London workshops proporcionan importante comprensión a las necesidades de los usuarios. Gracias también a Peter Knight, que tiene previsto todo tipo de soluciones inteligentes Arduino como bien como la base de un número de recetas en este libro. En favor de todo el mundo que ha descargado las librerías contribuidas por usuarios Arduino, Me gustaría agradecer a los autores quienes generosamente han compartido su conocimiento. La disponibilidad de un amplio alcance de hardware es un grande parte de lo que hace a Arduino emocionante, gracias a los proveedores por disponibilidad y soporte a un vasto alcance de grandes aparatos. Los siguientes fueron útil en proporcionar hardware usado en el libro: SparkFun, Creador Shed, Gravitech, y NKC Electronics. Otros proveedores que han sido útiles incluyen Moderno Dispositivo, Liquidware, Adafruit, MakerBot Industries, Mindkits, Oomlout, y SK Pang. Nick le gustaría agradecer a todo el mundo que estuvo involucrado con Tinker London, sobre todo a Alexandra, Peter, Brock Craft, Daniel Soltis y todas las personas quienes asistieron en talleres en los últimos años. Nick finalmente agradece a su familia, Jeanie, Emily, y Finn, quien estuvo de acuerdo en dejarle hacer esto en sus vacaciones de verano, y por supuesto, mucho después de lo que ellos habían pensado, y a su padres, Franco y Eva, por llevarlo hasta a tomar cosas aparte. Último pero no menos, Yo expresar gracias a las siguientes personas: Joshua Noble por introducirme a O'Reilly. Su libro, Programming Interactivity, es altamente recomendado para aquellos interesados en ampliar su conocimiento en la computación interactiva. Robert Lacy-Thompson por afrecer asesoramiento temprano con la primera edición. Mark Margolis por su apoyo y ayuda como una caja de resonancia en la concepción y desarrollo del libro.

Prólogo xix

Agradezco a mis padres por ayudarme a ver que las artes creativas y tecnología no fueron distintas entidades y que, cuando combinada, ellas pueden conducir a extraordinarios resultados. Y finalmente, este libro no habría sido comenzado o terminado sin el apoyo de mi esposa, Bárbara Faden. Mi agradecido reconocimiento para ella por mantenerme motivado y por su lectura cuidadosa y contribuciones para el manuscrito.

Notas en la Segunda Edición La segunda edición de este libro ha seguido relativamente rápidamente desde la primera, impulsado por la version de Arduino 1.0. El propósito declarado de 1.0 es introducir un cambio significativo va a allanar el camino para futuras mejoras pero cambiando algunos códigos escritos para software anterior. Estos han requerido cambios en código en muchos de los capítulos de este libro. Más cambiado es el Capítulo 15, Ethernet y Networking, y Capítulo 13, Comunicación Usando I2C y SPI, pero todo de las recetas en esta edición ha sido migrado a 1.0, con muchas actualizaciones para utilizar características nuevas en esta versión. Si usted está utilizando una versión anterior a Arduino 1.0, entonces usted puede descargar código de la primera edición de este libro. Ver " Plataforma Arduino Notas de versión" en página xv para descargar detalles. Apéndice H, Migración a Arduino 1. 0, ha sido adicionado para describir los cambios introducidos por Arduino versión 1.0. Este describe cómo actualizar código antiguo para utilizar con Arduino 1.0. Recetas para dispositivos que no son más extensamente disponibles han sido actualizadas para utilizar reemplazos actuales y algunos nuevos sensores y dispositivos inalámbricos han sido añadidos. Erratas publicadas en el sitio de O'Reilly ha sido corregida, gracias a lectores que se han tomado tiempo para notificarnos de éstas. Creemos que le gustarán las mejoras hechas en Arduino 1.0, así como las mejoras hechas para esta edición de Arduino Cookbook. La primera edición fue bien recibida; la crítica constructiva es dividida entre las personas que prefirieron más contenido técnico y aquellos que prefirieron menos. En un libro que nosotros limitado a sólo 700 páginas (para mantener lo asequible y portátil), que parece indicar que el equilibrio adecuado ha sido alcanzado.

Prólogo xx

CAPÍTULO 1

Empezando

1.0 Introducción El entorno de Arduino ha sido diseñado para ser de fácil uso para principiantes que no tienen experiencia en software o electrónica. Con Arduino, usted puede construir objetos que pueden responder a y/o controlar luz, sonido, tocar, y movimiento. Arduino ha sido usado para crear una asombrosa variedad de cosas, incluyendo instrumentos musicales, los robots, esculturas de luz, juegos, muebles interactivos, e incluso prendas de vestir interactivas.

Si usted no es un principiante, por favor siéntase libre de adelantarse a recetas que le interesen.

Arduino es usado en muchos programas educativos en todo el mundo, particularmente por diseñadores y artistas que quieren fácilmente crear prototipos pero hacer sin necesitar una profunda comprensión de los detalles técnicos detrás sus creaciones. Porque este es diseñado para ser utilizado por gente no técnica, el software incluye muchos ejemplos de código para demostrar cómo utilizar las varias facilidades de la tarjeta Arduino. Aunque este es fácil a utilizar, el hardware subyacente de Arduino trabaja al mismo nivel de sofisticación que los ingenieros emplear para construir dispositivos embebidos. Personas que ya han con microcontroladores son también han sido atraído por Arduino por su ágil capacidad de desarrollo y su facilidad para rápida implementación de ideas. Arduino es mejor conocido por su de hardware, pero usted también necesita software para programar dicho hardware. Ambos el hardware y la software se llaman "Arduino". La combinación le permite a usted crear proyectos que sienten y controlan el mundo físico. El software es gratuito, de código abierto, y multiplataforma. Las tarjetas son baratas, o usted puede construir su propia tarjeta (El diseño de hardware también es de código abierto). Además, hay es una activa comunidad Arduino como apoyo, esta accesible mundialmente a través de los foros y wikis de Arduino (Conocido como la Zona de juegos Arduino). Los foros y las

1

wikis ofrecen ejemplos de proyectos en desarrollo y soluciones par problemas que pueden servir de inspiración y asistencia sobre como usted realizar sus propios proyectos. Las recetas en este capítulo comenzarán por explicar cómo instalar el entorno de desarrollo y cómo a compilar y ejecutar un ejemplo de Sketch.

El código fuente en el que contiene las instrucciones para controlar Arduino funcionalmente es generalmente referido como un Sketch en la comunidad Arduino. La palabra Sketch será usado a lo largo de este libro para remitir a un Programa de código Arduino.

El Skecth Blink, que viene con Arduino, es usado como un ejemplo para recetas en este capítulo, aunque la última receta en el capítulo va además por añadir sonido y reúne entradas a través de algunos hardware adicionales, no sólo el parpadeo de la luz integrada en la tarjeta. El Capítulo 2 incluye cómo estructurar un Sketch para Arduino y proporciona una introducción a la programación.

Si usted ya sabe las formas básicas acerca de Arduino, siéntase libre de saltarse hacia próximos capítulos. Si es su primera vez usando Arduino, tenga paciencia en estas primeras recetas, tendrá más suaves resultados más tarde.

Arduino Software Programas, llamados Sketches, son creados en un ordenador usando el entorno integrado de desarrollo (IDE) Arduino. El IDE permite usted a escribir, editar código y convertir este código en instrucciones que el hardware Arduino entiende. El IDE también transfiere aquellas instrucciones a la tarjeta Arduino (Un proceso llamado carga).

Arduino Hardware La tarjeta Arduino es donde el código que usted escribe es ejecutado. La tarjeta puede sólo controlar y responder a la electricidad, así componentes específicos son adjuntados para permitir interactuar con el mundo real. Estos componentes pueden ser sensores, que convierten algún aspecto del mundo físico a electricidad así que la tarjeta puede sientir esto, o actuadores, que consiguen electricidad desde la tarjeta y la convierten que cambia el mundo físico. Los ejemplos de sensores incluyen interruptores, acelerómetros, y sensores ultrasónicos de distancia. Los actuadores son cosas como luces y LEDs, altavoces, motores, y pantallas. Hay una variedad de tarjetas oficiales que usted puede utilizar con el software Arduino y una amplia gama de tarjetas compatibles con Arduino producidas por miembros de la comunidad. Las tarjetas más populares tienen conector USB que se utiliza para proporcionar potencia y conectividad para cargar su software en la tarjeta. La Figura 1-1 muestra una tarjeta básica con la que inicia la mayoría de personas, la Arduino Uno.

2

Figura 1-1. Tarjeta Básica: Arduino Uno. Fotografía cortesía de todo.to.it.

Arduino Uno tiene un segundo microcontrolador a bordo para manejar toda la comunicación USB; el pequeño chip montado en superficie (El ATmega8U2) es situado cerca del zócalo USB en la tarjeta. Este puede ser programado por separado para permitir a la tablero para aparecer como diferentes dispositivos USB (Véase Receta 18.14 para un ejemplo). La tarjeta Arduino Leonardo reemplaza los controladores ATmega8U2 y la ATmega328 con un solo chip ATMEGA32U4 que implementa el protocolo USB en software. Las tarjetas compatibles con Arduino Teensy y Teensy de PJRC ( http://www.pjrc.com/teensy/) también capaces de emular dispositivos USB. Tarjetas más antiguas, y más de las tarjetas compatibles con Arduino, utilizan un chip de la empresa FTDI que proporciona una solución de hardware USB para conexión al puerto serial de su ordenador. Usted puede conseguir tarjetas tan pequeñas como una estampilla, tal como la Arduino Mini y Pro Mini; las tarjetas más grandes tienen más opciones de conexión más potentes procesadores, tal como la Arduino Mega; y tarjetas adaptadas para aplicaciones específicas, tal como la LilyPad para aplicaciones utilizables, la Fio proyectos inalámbricos, y la Arduino Pro para aplicaciones embebidas (Proyectos independientes que a menudo funcionan con baterías). Reciente adiciones al alcance incluiyen la Arduino ADK, que tiene un zócalo USB anfitrión sobre este y que es compatible con la Android Open Accessory Development Kit, el oficialmente aprobado método de adjunción de hardware para dispositivos Android. La tarjeta Leonardo usa un chip controlador (El ATMEGA32U4) que es capaz de presentarse a sí mismo como varios dispositivos HID.

3

La tarjeta Ethernet incluye conectividad Ethernet, y tiene una opción Power Over Ethernet, así es posible utilizar un solo cable para conectar y energizar la tarjeta. Otras tarjetas compatibles con Arduino también están disponibles, incluyendo las siguientes:

    

Arduino Nano, una tarjeta diminuta con capacidad USB, de Gravitech ( http://store.grav itech.us/arna30wiatn.html) Bare Bones Board, una tarjeta de bajo costo disponible con o sin capacidad USB, de Modern Device ( http://www.moderndevice.com/products/bbb-kit) Boarduino, un tarjeta protoboard compatible de bajo costo b, de Adafruit Industrias ( http://www.adafruit.com/) Seeeduino, un flexible variación de la tarjeta USB estándar, de Seeed Estudio Bazar ( http://www.seeedstudio.com/) Teensy y Teensy + +, tarjetas diminutas pero extremadamente versátiles, de PJRC (http://www.pjrc.com / teensy /)

Una lista de tarjetas http://www.freeduino.org/.

compatibles

con

Arduino

está

disponible

en

Vea también Una visión de conjunto http://www.arduino.cc/en/Main/Hardware.

de

tarjetas

Arduino:

Guías online para comenzar con Arduino están disponible en http://arduino.cc/en/Guíde/Windows para Windows, http://arduino.cc/en/Guide/MacOSX para Mac OS X, y http://www.arduino.cc/playground /Learning/Linux para Linux. Una lista de más de cien tarjetas que pueden ser usadas con el Entorno de Desarrollo Arduino puede encontrarse en: http://jmsarduino.blogspot.com/2009/03/comprehensive-ardu inocompatible.html

1.1 Instalando el Entorno de Desarrollo Integrado (IDE) Problema Usted quiere instalar el Entorno de Desarrollo Arduino desarrollo en su ordenador.

Solución El software Arduino para Windows, Mac, y Linux puede ser descargado desde http:// arduino.cc /en/Main/Software. La descarga de Windows es un archivo ZIP. Descomprimir el archivo para cualquier conveniente el directorio Archivos de programa/Arduino es un lugar sensato.

4

El software gratuito para descomprimir archivos, llamado 7-Zip, puede ser descargado desde http://www.7-zip.org/.

Descomprimir el archivo creara una carpeta llamada Arduino-00 (Donde es el número de versión de Arduino que usted descargó). El directorio contiene el archivo ejecutable (Llamado Arduino.exe), a lado de varios otros archivos y carpetas. Haga doble clic en el archivo Arduino.exe y la pantalla de inicio debería aparecer (Véase Figura 1-2), seguido por la ventana principal del programa (Véase la figura 1-3). Sea paciente, esto puede tomar algún tiempo para cargar el software.

Figura 1-2. pantalla de inicio de Arduino (Versión 1.0 en Windows 7)

La descarga de Arduino para Mac es una imagen de disco (. DMG); haga doble clic en el archivo cuando la descarga esté completa. La imagen será montada (esta aparecerá como una tarjeta de memoria en el escritorio).

5

Figura 1-3. Ventana principal de Arduino (Arduino 1.0 en una Mac)

Dentro de la imagen de disco está la aplicación Arduino. Copia este a alguna parte conveniente la carpeta Aplicaciones es un lugar sensato. Haga doble clic en la aplicación una vez que usted lo haya copiado (No es una buena idea ejecutarlo desde la imagen de disco). La pantalla de inicio aparecerá, seguido por la ventana principal del programa. La instalación en Linux varía dependientemente de la Linux distribución que usted esté utilizando. Ver la wiki de Arduino para información (http://www.arduino.cc/playground /Learning/Linux). Para permitir al Entorno de Desarrollo Arduino comunicarse con la tarjeta, usted necesita instalar controladores (drivers). En Windows, utilizar el cable USB para conectar su PC y la tarjeta Arduino y esperar a que aparezca el asistente de Nuevo Hardware encontrado. Si usted está usando una tarjeta Uno, dejar al asistente intentar encontrar e instalar los drivers. Puede fallar hacer esto (No se preocupe, este es el comportamiento esperado). Para arreglar esto ahora necesita ir a Menú Inicio →Panel de control →Administrador de dispositivos

6

En la lista que se visualiza encontrar la entrada Puertos (COM y LPT) llamado Arduino UNO (COM nn). nn será el número que Windows ha asignado al puerto creado para la tarjeta. Usted verá un junto a este un logo de advertencia porque los drivers apropiados no han sido aún asignados. Haga clic en la entrada y seleccione Actualizar Software de controlador. Elegir la opcion "Buscar software de controlador en el equipo", y navegar a la carpeta Drivers dentro la carpeta Arduino ha sido descomprimida. Seleccionar el archivo ArduinoUNO.inf y Windows debería entonces completar la instalación proceso. Si usted está usando una tarjeta anterior (Cualquier tarjeta que use drivers FTDI) con Vista o Windows 7 y está en línea, usted puede dejar al asistente buscar los drivers y estos se instalarán automáticamente. En Windows XP (O si usted no tiene acceso a Internet), que debe especificar la ubicación de los drivers. Usar el selector de archivos para navegar al directorio FTDI Controladores USB, situado en la directorio donde usted descomprimido los archivos de Arduino. Cuando este controlador esté instalado, el asistente de Nuevo Hardware Encontrado aparecerá de nuevo, diciendo un nuevo serial puerto ha sido encontrado. Seguir el mismo proceso como antes.

Es importante que usted siga a la secuencia de pasos para instalar los controladores dos veces, o el software no será capaz de comunicarse con la tarjeta.

En Mac, las más recientes tarjetas Arduino, tal como la Uno, pueden ser usadas sin controladores adicionales. Cuándo usted conecte la tarjeta una notificación se abrirá hasta decir un nuevo puerto de red ha sido encontrado, usted puede rechazar esto. Si usted está usando tarjetas anteriores (Las tarjetas que necesitan drivers FTDI), usted necesitará instalar controladores (Drivers). Hay un paquete llamado FTDIUSBSerialDriver, con un rango de números después, dentro de la imagen de disco. Haga doble clic en este y el instalador empezará el proceso. Usted necesitará saber la contraseña del Administrador para completar el proceso. En Linux, muchas distribuciones tienen el controlador ya instalado, pero sega el Enlace de Linux dado en este capítulo de introducción para información específico de su distribución.

Discusión Si el software falla para empezar, comprobar la sección de solución de problemas en el sitio web Arduino, http://arduino.cc/en/Guide/Troubleshooting, para ayudar la resolución problemas de instalación.

Vea también Guías online para empezar con Arduino disponibles en http://arduino.cc/en/Guide/Windows para Windows, http://arduino.cc/en/Guide/MacOSX para Mac OS X, y http://www.arduino.cc/playground /Learning/Linux para Linux.

7

1.2 Inicializando Arduino

la

tarjeta

Problema Usted quiere encender una nueva tarjeta y verificar que esté trabajando.

Solución Conecte la tarjeta en un puerto USB en su ordenador y compruebe que el LED verde indicador de alimentación en la tarjeta se enciende. Tarjetas Arduino estándar (Uno, Duemilanove, y Mega) tienen un LED verde de indicador de alimentación situado cerca del botón de reseteo. Un LED naranja cerca del centro de la tarjeta (Con la etiqueta "Pin 13 LED " en Figura 1-4) debe parpadear cuando la tarjeta es encendida (Las tarjetas vienen precargadas de fábrica con software para parpadear el LED como una simple revisión de funcionamiento de la tarjeta).

Figura 1-4. Básico Arduino bordo (Duemilanove y Uno)

Nuevas tarjetas tal como Leonardo tienen los LEDs situados cerca del conector USB; véase la figura 1-5. Recientes tarjetas tienen pines duplicados para utilizar con I2C (Marcada SCL y SDA). Estas tarjetas también tienen un pin marcado IOREF que puede utilizarse para determinar el voltaje de funcionamiento del chip.

8

Figura 1-5. Tarjeta Leonardo Las más recientes tarjetas tienen tres conexiones adicionales en el nuevo estándar para disposición de conectores en la tarjeta. Este no afecta la utilización de antiguos shields (todos continuarán trabajando con las nuevas tarjetas, sólo como lo hicieron en tarjetas anteriores). Las nuevas conexiones proporcionan un pin (IOREF) para shields que detectan la referencia analógica de voltaje (por lo que valores analógicos de entrada pueden ser calibrados a la fuente de voltaje), pines SCL y SDA para permitir una conexión consistente para dispositivos I2C (La ubicación de los Pines I2C han diferido en anteriores tarjetas debido a diferentes configuraciones de chip). Los Shields diseñados para las nuevas disposiciones deberían trabajar en cualquier tarjeta que use las nuevas localizaciones de pines. Un pin adicional (Al lado del Pin IOREF) es no es usado al momento, pero permite nueva funcionalidad para ser implementado en el futuro sin necesidad de cambiar la disposición de pin de nuevo.

Discusión Si el LED de encendido no ilumina cuando la tarjeta es conectada a su ordenador, la tarjeta probablemente no esté recibiendo energía. El LED intermitente (Conectado a la salida digital pin 13) es controlada por código de ejecutado en la tarjeta (Nuevas tarjetas tienen precargado el Sketch de ejemplo “Blink”). Si el LED pin 13 parpadea, el Sketch se está ejecutando correctamente, lo que significa que la tarjeta está funcionando. Si el LED verde de encendido está funcionando pero el LED pin 13 no está parpadeando, puede ser que el codigo de fabrica no esté en el chip; siga las instrucciones en la Receta 1.3 para cargar el Sketch Blink sobre en la tarjeta para verificar que la tarjeta está funcionando. Si no está usando una tarjeta estándar, esta puede no tener un incorporado LED pin 13, revise la documentación para detalles de su tarjeta. La tarjeta Leonardo desvanece el LED de arriba a abajo (Esto se ve como si el LED estuviera "Respirando") para mostrar que la tarjeta esta funcionando.

9

Vea también Guías online para empezar con Arduino disponibles en http://arduino.cc/en/Guide/Windows para Windows, http://arduino.cc/en/Guide/MacOSX para Mac OS X, y http://www.arduino.cc /playground/Learning/Linux para Linux. La guía de solución de problemas puede encontrarse en http://arduino.cc/en/Guide /Troubleshooting.

1.3 Uso del Entorno de Desarrollo Integrado (IDE) para Preparar un Sketch Arduino Problema Usted quiere a conseguir un Sketch y prepararlo para cargarlo a la tarjeta.

Solución Use el IDE Arduino para crear, abrir, y modificar Sketches que definen que hará la tarjeta. Usted puede utilizar los botones en la parte superior del IDE para realizar estas acciones (Se muestra en la Figura 1-6), o usted puede utilizar los menús o atajos de teclado (Mostrado en Figura 1-7). El área de edición de Sketches es usted visualiza y edita un código para un Sketch. Este soporta claves comunes de edición de texto tal como Ctrl-F (⌘ + F en Mac) para buscar, Ctrl-Z (⌘ + Z en Mac) para deshacer, Ctrl-C (⌘ + C en un Mac) para copiar texto seleccionado, y Ctrl-V (⌘ + V en un Mac) para pegar texto seleccionado La Figura 1-7 muestra cómo cargar el Sketch “Blink” (El Sketch que viene precargado en una tarjeta Arduino nueva). Después que haya iniciado el IDE, ir a la Archivo → Ejemplos seleccionar 01. Basics → Blink, como se muestra en la Figura 1 - 7. La código para parpadeo la incorporado LED voluntad ser desplegado en la Dibujo Editor ventana (Consulte a Figura 1-6). Antes que el código puede ser enviado a la tarjeta, este necesita ser convertido en instrucciones que puedan ser leídas y ejecutadas por el chip controlador de Arduino; esto es llamado compilar. Para hacer esto, clic el botón compilar (El botón en la parte superior izquierda con un visto en su interior), o seleccionar Sketch → Verificar/Compilar (Ctrl-R; ⌘ + R en Mac). Usted debería ver un mensaje que dice "Compilando el Sketch..." y una barra de progreso en el area de mensaje debajo del área de edición de texto. Después de un segundo o dos, aparecerá un mensaje que dice "Compilación terminada". El área negra de consola contendrá el siguiente mensaje: Tamaño binario del Sketch: 1026 bytes (de un máximo de 32.256 bytes)

10

El mensaje exacto puede ser distinto dependiente en su tarjeta y versión de Arduino; este que le dice el tamaño del Sketch y el máximo tamaño que su tarjeta puede aceptar.

Figura 1-6. IDE Arduino

Discusión El código fuente para Arduino es llamado un Sketch. El proceso que toma un Sketch y lo convierte en una forma que puede trabajar en la tarjeta es llamado compilación. El IDE usos un número de herramientas de líneas de comandos detrás de escenas para compilar un Sketch. Para más información sobre esto, ver la Receta 17.1. El mensaje final diciéndole el tamaño del Sketch indica cuanto espacio es necesario para almacenar las instrucciones del programa en la tarjeta. Si el tamaño del Sketch compilado es mayor que el disponible en la memoria de la tarjeta, el siguiente mensaje de error se visualiza:

11

Figura 1-7. Menú del IDE (Seleccionando el Sketch de ejemplo “Blink”) Sketch demasiado grande; ver http://www.arduino.cc/en/Guide/Troubleshooting#size para obtener consejos sobre su reducción.

Si esto sucede, usted necesita a hacer su Sketch más pequeño poderlo cargar en la tarjeta, o conseguir una tarjeta con mayor capacidad. Si hay errores en el código, el compilador imprimirá uno o más mensajes de error en la ventana de consola. Estos mensajes pueden ayudar a identificar el error ver Apéndice D sobre consejos para la solución de problemas de software.

Para evitar sobrescribir accidentalmente los ejemplos, el IDE Arduino no permitir guardar los cambios a los ejemplos de Sketches proporcionados. Usted necesita renombrarlos usando la opción Guardar Como en el menú. Usted puede guardar Sketches que haya escrito usted mismo con el botón Guardar (Véase Receta 1,5).

Como usted desarrolla y modifica un Sketch, usted debería también considerar usar la opción en el menú Archivo → Guardar Como y usar un nombre diferente o número de versión regularmente así que como implementa cada poco, usted puede ir regresando a una versión anterior si usted lo necesita.

12

Código subido sobre la bordo no puede descargarse espalda sobre su ordenador. Hacer seguro usted guardar el boceto código en su ordenador. No se puede guardar cambios espalda a la ejemplo archivos; usted necesitar a utilizar Guardar Como y dar la cambiado expediente otro nombrar.

Vea también Receta 1.5 espectáculos un ejemplo dibujar. Apéndice D tiene consejos en la solución de problemas de software.

1.4 Cargar y Ejecutar el Sketch Blink Problema Usted quiere a transferir su Sketch compilado a la tarjeta Arduino y verlo funcionar.

Solución Conectar su tarjeta Arduino a su ordenador usando el cable USB. Cargar el Sketch Blink en el IDE como está descrito en la Receta 1.3. Siguiente, seleccionar Herramientas → Tarjeta desde el menú desplegable y seleccionar la nombre de la tarjeta que usted ha conectado (Si esta es la tarjeta estándar Uno, es probablemente que sea la primera tarjeta en la lista). Ahora seleccionar Herramientas → puerto Serial. Usted conseguirá una lista desplegable lista de puertos serial disponible en su ordenador. Cada máquina tendrá una diferente combinación de puertos serial, dependiente de los otros dispositivos usted haya usado con su ordenador. En Windows, ellos serán enumerados como entradas COM. Si hay una sola entrada, seleccione esa. Si hay múltiples entradas, su tarjeta probablemente sea la última entrada. En Mac, su

tarjeta será enumerado dos veces si esta es una tarjeta Uno:

/dev/tty.usbmodem-XXXXXXX /dev/cu.usbmodem-XXXXXXX

Si usted tener un más viejo bordo, lo será enumerado como de la siguiente manera: /dev/tty.usbserial-XXXXXXX /dev/cu.usbserial-XXXXXXX

Cada placa tendrá diferentes valores para XXXXXXX. Seleccione cualquiera de las dos entradas. Clic en el botón cargar (En Figura 1-6, es el segundo botón desde la izquierda), o elegir Archivo → Cargar usando Programador (Ctrl-U, ⌘ + U en Mac). El software compilará el código, como en la Receta 1. 3. Después el software es compilado, y este es subido a la tarjeta. Si usted mira su tarjeta, usted verá el LED dejar de parpadear y dos luces (Etiquetados como LEDs Seriales en la Figura 1 - 4) justo debajo previamente el LED

13

de parpadeo debería parpadear por un par de segundos mientras se carga el código. La luz original debería entonces comenzar a parpadear intermitentemente nuevamente como el código se ejecute.

Discusión Para el IDE a enviar el código compilado a la tarjeta, la tarjeta necesita ser conectada al ordenador, y usted necesita decirle al IDE que tarjeta y puerto serial está utilizando. Cuando una carga inicia, cualquier Sketch ejecutado en la tarjeta es detenido (Si usted ejecutaba el Sketch Blink, el LED dejará de parpadear). El nuevo Sketch es subido a la tarjeta, sustituyendo al Sketch anterior. El nuevo Sketch comenzará a funcionar cuando la carga haya sido completada exitosamente.

Antiguas tarjetas Arduino y algunas compatibles hacer no interrumpen automáticamente el Sketch en funcionamiento al iniciar la carga. En este caso, necesitar presionar el botón Reset en la tarjeta sólo después de esto el software informa que se ha compilado (Cuando usted ve el mensaje acerca del tamaño del Sketch). Esto puede tomar unos pocos intentos para conseguir la sincronización correcta entre el fin de la compilación y el presionado del botón Reset.

El IDE visualizará un mensaje de error si la carga no es exitosa. Los problemas son generalmente debido a la equivocada selección de tarjetas o puerto serial, o la tarjeta no está conectada. La tarjeta y puerto serie seleccionados actualmente son desplegados en la barra de estado en la parte inferior de la ventana de Arduino. Si usted tiene problemas identificando el correcto puerto en Windows, intente desconectando la tarjeta y entonces seleccione Herramientas → Puerto Serial para ver que puerto puerto no se visualización en la lista. Otro enfoque es a seleccionar los puertos, uno por uno, hasta que usted vea parpadear las luces en la tarjeta parpadeo para indicar que el código está cargando.

Vea también La página de solución de problemas Arduino: http://www.arduino.cc/en/Guide/Troubleshooting.

1.5 Creando y Guardando un Sketch Problema Usted quiere a crear un Sketch y guardarlo en su ordenador.

Solución Para abrir un editor para un nuevo Sketch, ejecutar el IDE (Véase la Receta 1.3), ir al menú Archivo, y seleccionar Nuevo. Pegue el siguiente código en el editor de Sketch (Es similar al Sketch Blink, pero los parpadeos son dos veces más largos):

14

const int ledPin = 13 // LED conectado al pin digital 13 void setup () { pinMode (ledPin, OUTPUT); // habilitar salida en ledPin } void loop () { digitalWrite (ledPin, HIGH); // cambia el LED a encendido delay (2000); // esperar durante dos segundos digitalWrite (ledPin, LOW); / / cambia el LED a apagado delay (2000); // esperar durante dos segundos }

Compilar el código haciendo clic al botón compilar (el botón en la parte superior izquierda botón con un visto en el interior), o seleccionar Sketch → Verificar / Compilar (Véase Receta 1.3). Cargar el código haciendo clic en el botón cargar, o elegir Archivo → Cargar usando programador (véase Receta 1.4). Después de cargar, el LED deberá parpadear cada dos segundos. Usted puede guardar este dibujo a su ordenador haciendo clic en el botón Guardar, o seleccionar Archivo → Guardar. Usted puede guardar el Sketch usando un nuevo seleccionando la opción Guardar Como. Un cuadro de dialogo se abrirá donde usted podrá ingresar el nombre del archivo.

Discusión Cuando usted guarda un archivo en el IDE, un cuadro de diálogo estándar del operativo sistema se abrirá. Este sugiere guardar el Sketch en una carpeta llamada Arduino en su carpeta Mis Documentos (O su carpeta Documentos en Mac). Usted puede reemplazar el nombre por defecto del Sketch con un nombre que refleja el propósito de su Sketch. Hacer clic en Guardar para guardar el archivo.

El nombre por defecto es la palabra Sketch seguido por la fecha actual. Secuenciales letras comenzando desde la a son usadas para distinguir Sketches creados el mismo día. Sustituir el nombre por defecto por algo significativo le ayuda a usted a identificar el propósito de un Sketch cuando usted vuelva a usarlo nuevamente.

Si usted utiliza caracteres que el IDE no permite (Por ejemplo, la carácter espacio), el IDE automáticamente reemplaza estos con caracteres válidos. Los Sketches de Arduino son guardados como archivos de texto con la extensión .ino. Versiones de los IDE usaban la extensión .pde extensión, también usada por Processing. Estas son automáticamente guardadas en una carpeta con el mismo nombre del Sketch.

15

Usted puede guardar sus Sketches en cualquier carpeta en su ordenador, pero si usted utiliza la carpeta predeterminada (La carpeta Arduino en su carpeta Documentos) sus Sketches aparecerán automáticamente en el menú del software Arduino y será fácil de localizar.

Si usted tiene editado uno de los ejemplos de la descarga de Arduino, no podrá guardar los cambios expediente usando el mismo nombre del archivo. Esto preserva los ejemplos estándar intactos. Si usted quiere guardar un ejemplo modificado, usted necesitará seleccionar otra ubicación para el Sketch.

Después que usted haya hecho cambios, verá un cuadro de diálogo preguntando si usted quiere guardar el Sketch cuando un Sketch es cerrado.

El símbolo § siguiendo el nombre del Sketch en la barra superior de la Ventana del IDE indica que el código del Sketch tiene cambios que todavía no han sido guardados en el ordenador. Este símbolo es eliminado cuando usted guarda el Sketch.

El software Arduino no proporciona cualquier tipo de versión de control, de modo que si usted quiere ser capaz de revertir a versiones anteriores de un Sketch, usted puede utilizar Guardar Como regularmente y dar a cada revisión del Sketch un nombre ligeramente diferente. Frecuentemente compilar cuando usted modifica o añade código es un buen camino para comprobar para errores cuando usted escribe su código. Este hará fácil encontrar y corregir cualquier error porque estos generalmente estarán asociados con lo que usted haya escrito.

Una vez que un Sketch ha sido subido a la tarjeta no hay forma de descargarlo de regreso a su ordenador. Asegúrese de guardar cualquier cambio que desee mantener en sus Sketches.

Si usted prueba y guarda un Sketch en una carpeta que no está con el mismo nombre del Sketch, el IDE le informará que este no puede ser abierto como está y sugerirá hacer clic para crear una carpeta para el Sketch con el mismo nombre.

Los Sketches pueden ser encontrados en una carpeta con el mismo nombre del Sketch. El IDE creará la carpeta automáticamente cuando guarde un nuevo Sketch. Los Sketches hechos con versiones anteriores del software Arduino tienen una extensión de archivo diferente (.pde). El IDE los abrirá, cuando usted guarde el Sketch creará un archivo con la nueva extensión (.ino). El Código escrito para las primeras versiones del IDE puede no ser capaz de compilarse en la versión 1.0. Más de los cambios para conseguir el funcionamiento del código antiguo es fácil de hacer. Ver Apéndice H para más detalles.

16

Vea también El código en esta receta y a lo largo de este libro utiliza la expresión const int para proporcionar nombres significativos (LedPin) para constantes en lugar de números (13). Ver Receta 17.5 para más sobre el uso de constantes.

1.6 Usando Arduino Problema Usted quiere a empezar con un proyecto que es fácil de construir y divertido para usar.

Solución Esta receta proporciona una muestra de algunas de las técnicas que son detalladas en capítulos posteriores. La dibujo esta basado en el código de parpadeo de LED de la receta anterior, pero en lugar de utilizar un retraso fijado, la velocidad es determinado por un sensor sensible a la luz llamado Resistor Dependiente de Luz o LDR (ver Receta 6.2). Conectar el LDR como se muestra en la Figura 1-8.

Figura 1-8. Arduino con Resistor Dependiente de Luz (LDR)

Si no está familiarizado con la construcción de un circuito a partir un esquemático, véase el Apéndice B para ilustraciones paso a paso sobre cómo a hacer este circuito en una protoboard.

17

El siguiente Sketch lee el nivel de luz de un LDR conectado al pin analógico 0. El nivel de luz nivel captado por el LDR cambiará la velocidad de parpadeo del LED conectado al pin 13: const int ledPin = 13 // LED conectado al pin digital 13 const int sensorPin = 0; 0

// conectar el sensor a la entrada analógica

void setup () { pinMode (ledPin, OUTPUT); }

// habilitar la salida en ledPin

void loop () { int velocidad = analogRead(sensorPin); // leer la entrada analógica digitalWrite (ledPin, HIGH); // cambiar el LED a encendido delay (velocidad); // esperar con una duracion dependiente del nivel de luz digitalWrite (ledPin, LOW); // cambiar el LED a apagado delay (velocidad); }

Discusión El valor del resistor de 4.7K no es crítico. Cualquiera desde 1K a 10K puede ser utilizado. La nivel de luz en el LDR cambiará el nivel de voltaje en el pin analógico 0. La comando analogRead (Véase Capítulo 6) proporciona un valor que va desde alrededor de 200 cuando la LDR está oscurecido a 800 cuando lo esta muy iluminado. Este valor determina los tiempos de duración del encendido y apagado del LED, así el tiempo de parpadeo aumenta la intensidad de la luz. Usted puede escalar la velocidad de parpadeo velocidad usando la función map de Arduino de la siguiente manera:

const int ledPin = 13 // LED conectado al pin digital 13 const int sensorPin = 0; // conectar el sensor a la entrada analógica 0 // Las siguientes dos líneas marcan el mínimo y máximo retardo entre parpadeos const int minDuration = 100 // espera minima entre parpadeos const int maxDuration = 1000 // espera máxima entre parpadeos

void setup () { pinMode (ledPin, OUTPUT); // habilitar la salida en ledPin } void loop () { int velocidad = analogRead (sensorPin); // leer la entrada analógica // La línea siguiente escala la frecuencia de parpadeo entre los valores mínimos y máximos velocidad = map (velocidad, 200,800, minDuration, maxDuration) // convertir a velocidad de parpadeo velocidad = constrain (velocidad, minDuration, maxDuration) // restringir el valor

18

digitalWrite (ledPin, HIGH); // cambia el LED a encendido delay (velocidad); // espera cuya duración depende del nivel de luz digitalWrite (ledPin, LOW); // cambia el LED a apagado retardo (tasa); }

La Receta 5.7 proporciona más detalles sobre el uso la función map para escalar valores. La Receta 3.5 tiene detalles sobre uso de la función constrain para asegurar que valores no excedan un rango dado. Si usted quiere a ver el valor de la variable velocidad en su ordenador, usted puede imprimir esto en el Monitor Serial Arduino como se muestra en el revisado código de bucle código a continuación. El Sketch visualizará la velocidad de parpadeo el Monitor Serial. Abra abra la Ventana del Monitor Serial en el IDE Arduino haciendo clic en el icono en la parte superior derecha de la barra (Véase el capítulo 4 para más sobre el uso del Monitor Serial):

const int ledPin = 13 // LED conectado al pin digital 13 const int sensorPin = 0; // conectar el sensor a la entrada analógica 0 // Las siguientes dos líneas marcan el retardo minimo y máximo entre parpadeos const int minDuration = 100 // espera minima entre parpadeos const int maxDuration = 1000 // espera máxima entre parpadeos

void setup () { pinMode (ledPin, OUTPUT); // habilitar la salida en ledPin Serial.begin (9600); // inicializa el serial } void loop () { int velocidad= analogRead (sensorPin); // leer la entrada analógica // La siguiente línea escala la frecuencia de parpadeo entre los valores mínimos y máximos velocidad = map (velocidad, 200800, minDuration, maxDuration) // convertir a velocidad de parpadeo velocidad = constrain (velocidad, minDuration, maxDuration); // restringir el valor Serial.println (velocidad); // imprimir velocidad al monitor serie digitalWrite (ledPin, HIGH); // cambia el LED a encendido delay (velocidad); // espera cuya de duración depende del nivel de luz digitalWrite (ledPin, LOW); // cambia el LED a apagado delay (velocidad); }

Usted puede utilizar el LDR para control el tono de un sonido conectando un pequeño altavoz al pin, como muestra en Figura 1-9.

19

Figura 1-9. Conexiones para un altavoz con el circuito del LDR

Usted necesitará para aumentar la velocidad de encendido / apagado en el pin una frecuencia en el espectro de audio. Este es conseguido, como se muestra en la siguiente código, por las decrecientes duraciones mínima y máxima: const int OutputPin = 9;

// altavoz conectado al pin digital 9

const int sensorPin = 0; // conectar el sensor a la entrada analógica 0 const int minDuration = 1 // 1 ms encendido, 1 ms apagado (500 Hz) const int maxDuration = 10 // 10 ms encendido, 10 ms apagado (50 Hz) void setup () { pinMode (OutputPin, OUTPUT); }

// habilitar la salida en OutputPin

void loop () { int sensorReading = analogRead (sensorPin) // leer el analógico de la tasa de entrada int velocidad = map (sensorReading, 200800, minDuration, maxDuration); velocidad = constrain (tasa, minDuration, maxDuration) // restringir el valor digitalWrite (OutputPin, HIGH); // cambia el LED a encendido delay (velocidad); // espera cuya duración depende del nivel de luz digitalWrite (OutputPin, LOW); // cambia el LED a apagado delay (velocidad); }

20

Ver También Ver Receta 3.5 para detalles sobre el uso de la función constrain. Ver Receta 5.7 para una discusión sobre la función map. Si usted está interesado en la creación de sonidos, ver el Capítulo 9 para una completa discusión sobre salida de audio con Arduino.

21

CAPÍTULO 2

Haciendo al Sketch realizar su orden

2.0 Introducción Aunque mucho de un proyecto Arduino proyecto involucrará la integración de la tarjeta Arduino con el soporte de hardware, usted necesitara ser capaz de decirle a la tarjeta qué a hará con el resto de su proyecto. Este capítulo introduce esenciales elementos de programación Arduino, muestra a los no programadores cómo utilizar comunes construcciones del lenguaje, y proporciona una visión general de la sintaxis para lectores que no están familiarizados con C o C + +, el lenguaje que utiliza Arduino. Ya que hacer ejemplos interesantes requiere hacer que Arduino realice algo, las recetas utilizan capacidades físicas de la tarjeta que son detallados en próximos capítulos. Si cualquier código en este capítulo no está claro, siéntase libre adelantarse, particularmente al Capítulo 4 para más sobre salida serial y el Capítulo 5 para más sobre uso de pines digitales y analógicos. Usted no necesita entender todo el código en los ejemplos, sin embargo, ve cómo funcionan capacidades específicas que son enfocadas en las recetas. Aquí hay algunas de las funciones más comunes, usadas en los ejemplos que son incluidos en los próximos capítulos: Serial.println(valor);

Imprime el valor al Monitor Serial del IDE Arduino así usted podrá ver la Salida de Arduino en su computador; ver la Receta 4.1. pinMode(pin, mode);

Configura un pin digital para leer (INPUT) o escribir (OUTPUT) un valor digital; ver la introducción en el Capítulo 5. digitalRead(pin);

Lee un valor digital (HIGH o LOW) en un pin para establecerlo como entrada; ver la Receta 5.1. digitalWrite(pin, valor);

Escribe un valor digital (HIGH o LOW) en un pin para establecerlo como salida; ver la Receta 5.1.

22

2.1 Estructurando un Programa Arduino Problema Usted es nuevo en programación y quiere entender la construcción de un Programa de Arduino.

Solución Programas para Arduino son en generalmente llamados Sketches; los primeros usuarios eran artistas y diseñadores y los Sketches reflejan la forma rápida y fácil para realizar una idea. Los términos Sketches y programa son intercambiables. Los Sketches contienen el código que tiene las instrucciones que la tarjeta llevará a cabo. El Código que necesita ejecutar sólo una vez (como configurar la placa para su aplicación) necesita ser colocado en la función setup. El código a ser ejecutar continuamente después de la configuración irá en la función loop. Aquí un típico Sketch: const int ledPin = 13;

// LED conectado al pin digital 13

// El método setup () se ejecuta una vez, cuando el Sketch se inicia void setup () { pinMode (ledPin, OUTPUT); // inicializa el pin digital como salida } // El método loop () se ejecuta una y otra vez, void loop () { digitalWrite (ledPin, HIGH); // encender el LED delay (1000); // esperar un segundo digitalWrite (ledPin, LOW); // apagar el LED delay (1000); // esperar un segundo }

Cuando el IDE de Arduino IDE termina de cargar el código, y cada vez que usted potencie la tarjeta después de haber subido este código, este iniciará y llevara a cabo las instrucciones secuencialmente. Ete ejecuta el código una vez en setup y entonces va a través del código en loop. Cuando llega al final del loop (Marcada por la llave cerrada, }) este regresa al comienzo del loop.

Discusión Este ejemplo continuamente parpadea un LED por escritura de salidas HIGH y LOW en un pin. Ver el Capítulo 5 para aprender más acerca del uso de los pines de Arduino. Cuando el Sketch comienza, el código en setup configura el modo del pin (lo que permite iluminar un LED). Después que el código en setup es completado, el código en loop es repetidamente llamado (para parpadear el LED) siempre y cuando la tarjeta Arduino este potenciada.

23

Usted no necesita saber esto para escribir Sketches Arduino, pero programadores con experiencia en C y C+ + pueden preguntarse a donde se ha ido la esperada función main(). Está ahí, pero está oculta bajo la cubierta del Entorno de Arduino. El proceso de construcción de crea un archivo intermedio que incluye el código del Sketch y las siguientes declaraciones adicionales: int main (void) { init (); setup (); for (; ;) loop (); return 0; }

La primera cosa que sucede es una llamada a una función init() que inicializa el Hardware Arduino. Siguiente, la función setup() de su Sketch es llamada. Finalmente, la función loop() es llamado una y una vez. Porque el ciclo for nunca termina, la sentencia return es ejecutada.

Ver También La Receta 1.4 explica cómo Cargar un Sketch a la tarjeta Arduino. El Capítulo 17 y http://www.arduino.cc/en/Hacking/BuildProcess más información sobre el proceso de construcción.

2.2 Uso de Tipos Primitivos Simples (Variables) Problema Arduino tiene diferente tipos de variables para representar valores eficientemente. Usted quiere saber cómo seleccionar y utilizar estos tipos de datos de Arduino.

Solución Aunque el tipo de dato int (Abreviatura de número entero, un valor de 16 bits en Arduino) es la más común elección para los valores numéricos que se encuentran en las aplicaciones de Arduino, usted puede utilizar la Tabla 2-1 para determinar los tipos de datos que espera que encajen en su aplicación.

24

Tabla 2-1. Tipos de datos Arduino Tipos Numéricos

Bytes Rango

Uso

int unsigned int

int.

long Unsigned long float double

float

boolean

falso

double

float

verdadero

char byte

char,

Otros tipos

Uso

String void

Representa cadenas de chars (Caracteres) normalmente se utiliza para contener texto Sólo se utiliza en las declaraciones de funciones donde no se devuelve ningún valor.

Discusión Excepto en situaciones donde máximo rendimiento o eficiente memoria son requeridos, variables declaradas usando int serán adecuadas para valores numérico si los valores hacer no exceden su alcance (Mostrado en la primera fila en Tabla 2-1) y si usted no necesita a trabajar con valores fraccionarios. Muchos de los ejemplos oficiales de Arduino declaran variables numéricas como int. Pero a veces usted necesitara elegir un tipo que específicamente se ajuste a su aplicación. A veces usted necesita números negativos y a veces no, por lo que los tipos numéricos vienen en dos versiones: signed y unsigned. Valores unsigned son siempre positivos. Variables sin la palabra clave unsigned son signed así que ellos pueden representar valores negativos y positivos. Uno razón para utilizar valores unsigned es cuando la gama de valores signed no encajarán en el rango de la variable (Una variable unsigned tiene dos veces la capacidad que una variable signed). Otra razón por la que los programadores eligen utilizar tipos unsigned es a claramente indicar a las personas que el código esperado nunca será un número negativo. Los tipos boolean tienen dos posibles valores: true o false. Estos son comúnmente usados en revisión del estado de un interruptor (Si es pulsado o no). Usted puede también utilizar HIGH y LOW como equivalentes a true y false donde este tiene más sentido; digitalWritte(pin, HIGH)forma es una más expresiva de encender un LED que digitalWrite(pin, true) o digitalWrite(pin, 1), aunque todo de estos son tratados idénticamente cuando el Sketch es ejecutado, dibujo en realidad carreras, y probablemente vienen todas estas formas de código publicados en la web.

25

Vea también La referencia de Arduino en http://www.arduino.cc/en/Reference/HomePage proporciona detalles sobre tipos de datos.

2.3 Usando Números de Punto Flotante Problema Los números de punto flotante son usados para valores expresados con punto decimal (Esta es la forma para representar valores fraccionarios). Usted quiere calcular y comparar estos valores en su Sketch.

Solución El siguiente código muestra cómo a declarar variables de punto flotante, ilustrando problemas que puedan encontrarse comparaciones de valores de punto flotante, y demuestra cómo superarlos:

/* * Ejemplo de punto flotante * Este Sketch inicializa un valor flotante a 1,1 * Se reduce varias veces el valor de 0,1 hasta que el valor sea 0 * /

float valor = 1,1; void setup () { Serial.begin (9600); } void loop () { valor = valor - 0.1 / / reducir el valor de 0,1 en cada iteración del loop if (valor == 0) Serial.println ("El valor es exactamente cero"); else if (almostEqual(valor, 0)) { Serial.print ("El valor"); Serial.print (valor, 7); // para imprimir 7 lugares decimales Serial.println ("es casi igual a cero"); } else Serial.println(valor); delay (100);

26

} // Devuelve un valor true si la diferencia entre a // Cambia el valor de DELTA a la diferencia máxima igualad booleana almostEqual(float a, float b) { float const DELTA = .0001 / / m{axima diferencia igual if (a == 0) return fabs(b) <= DELTA; if (b == 0) return fabs(a) <= DELTA; returns fabs((a - b) / max(fabs(a), fabs(b))) <= }

y b es pequeña considerada para ser

para ser casi casi

DELTA;

Discusión Las matemáticas de punto flotante no son exactas, y los valores devueltos pueden tener un pequeño error de aproximación. El error ocurre porque el valor de punto flotante incluye un amplio rango, así la representación interna de la valor puede sólo mantener una aproximación. Por esto, usted necesita probar si los valores están dentro de un rango de tolerancia e lugar de una igualdad exacta. La salida del Monitor Serial manera:

de este Sketch es de la siguiente

1.00 0.90 0,80 0,70 0,60 0,50 0.40 0,30 0.20 0.10 El valor -0.0000001 es casi igual a cero -0.10 -0.20

La salida continúa produce números negativos. Usted puede imprimir el código "La valor es exactamente cero " después valor es 0.1 y luego 0.1 es restado desde esto. Pero valor nunca es exactamente igual cero; es muy cercano, pero no es suficientemente bueno para pasar la prueba: if (valor == 0). Esto es porque la memoria eficiente de solo puede almacenar una aproximación de los números de punto flotante que puede contener el enorme rango de valores que puede representar. La solución para este es comprobar si una variable es cercana al valor deseado, como se muestra en este receta. La función almostEqual prueba si la variable valor está dentro del objetivo deseado 0.00001 y retorna true si es así. El rango aceptable es configurado con la constante DELTA, usted puede cambiar ésta a menores o mayores valores como lo requiera. La función llamada fabs (Abreviatura de floating-point absolute value) retorna el valor absoluto de una variable de punto flotante y esta es usado para probar la diferencia entre los parámetros dados.

27

El punto flotante aproxima números porque este sólo usa 32 bits para sostener todos los valores dentro de un enorme rango. Ocho bits son usados para el multiplicador decimal (El exponente), y que deja 24 bits para el signo y el valor solo suficiente para siete dígitos decimales significativos. Aunque las funciones float y double son exactamente lo mismo en Arduino, doubles sí tienen un mayor precisión en muchos otras plataformas. Si usted está importando código que usa float y doble desde otra plataforma, comprobar que hay suficiente precisión para su aplicación.

Vea también La referencia de Arduino para float: http://www.arduino.cc/en/Reference/Float.

2.4 Trabajando con Grupos de Valores Problema Usted quiere a crear y utilizar un grupo de valores (Llamados Arrays). Los arrays pueden ser una simple lista o estos pueden tener dos o más dimensiones. Usted quiere saber cómo determinar el tamaño del array y cómo a acceder a los elementos en el array.

Solución Este Sketch crea dos arrays: un array de enteros para pines conectado a interruptores y un array de pines conectados a LEDs, como se muestra en la Figura 2-1: / * Sketch array un array de interruptores controla un array de LEDs véase el Capítulo 5 para más información sobre el uso de los interruptores véase el Capítulo 7 para obtener información sobre los LED * / int inputPins [] = {2,3,4,5}

// crear un array de pines para entradas de

interruptor int ledPins [] = {10,11,12,13}; // crea un array de pines de salida para LED void setup () { for(int index = 0; index <4; index + +) { pinMode(ledPins [index], OUTPUT); // declara LED como salida pinMode (inputPins [index], INPUT); // declara los interruptores como entrada digitalWrite (inputPins [index], HIGH); // permite levantar las resistencias // (Ver la receta de 5.2) } }

28

void loop () { for(int index = 0; index <4; index + +) { int val = digitalRead (inputPins [indice]); // lee el valor de entrada if (val == LOW) // Comprobar si se pulsa el interruptor { digitalWrite(ledPins [index], HIGH); // enciende el LED si se pulsa el interruptor } else { digitalWrite(ledPins [index], LOW); // apaga el LED } } }

Figura 2-1. Conexiones para LEDs e interruptores

29

Discusión Los Arrays son colecciones de variables consecutivas del mismo tipo. Cada variable en la colección es llamada un elemento. El número de elementos es llamado la tamaño del array. La Solución demuestra un uso común de arrays en código Arduino: almacenando una colección de pines. Aquí los pines conectan a interruptores y LEDs (Un tema cubierto en más detalle en el Capítulo 5). La parte importante de este ejemplo es la declaración del array y el acceso a los elementos del array. La siguiente línea de código declara (Crea) un array de enteros con cuatro elementos e inicializa cada elemento. El primero elemento es igual a 2, el segundo a 3, y así en: int inputPins [] = {2,3,4,5};

Si usted no inicializa valores cuando declara un array (Por ejemplo, cuando los valores sólo están disponibles cuando el Sketch se está ejecutando), usted necesita cambiar cada elemento individualmente. Usted puede declarar el array de la siguiente manera: int inputPins [4];

Este declara un array de cuatro elementos con el valor inicial de cada elemento establecido a cero. El número dentro de los corchetes ([]) es el tamaño, y este fija el número de los elementos. Este array tiene un tamaño de cuatro y puede contener, a lo más, cuatro valores enteros. El tamaño puede ser omitido si el array declarado contiene inicializadores (Como se muestra en el primero ejemplo) porque la compilador hace al array tan grande como se cuente el número de inicializadores. El primer elemento de la colección es elemento [0]: int FirstElement = inputPins [0]; / / esta es el primer elemento inputPins[0] = 2; // establece el valor de este elemento igual a 2

El último elemento es uno menor que el tamaño, así en la anterior ejemplo, con un tamaño de cuatro, el último elemento es 3: int lastElement = inputPins [3]; // este es el último elemento

Puede parecer extraño que un array con un tamaño de cuatro tiene el último elemento accedido usando array[3], pero porque el primero elemento es array [0], los cuatro elementos son: inputPins[0], inputPins[1], inputPins[2], inputPins[3]

En la anterior Sketch, los cuatro elementos son accedidos usando un ciclo for: for(int index = 0; index <4; index++) { // Obtener el número de pin accediendo a cada elemento del array de pines pinMode (ledPins [Índice], OUTPUT); // declara LED como salida pinMode (inputPins [Índice], INPUT); // declara pulsador como entrada }

Este bucle pasará a través de la variable index con valores comenzando en 0 y finalizando en 3. Es un error común error acceder a un elemento que está más allá del tamaño actual del array.

30

Este es un error que puede tener muchos síntomas diferentes y debe tener cuidado tomado a evitarlo. Una forma de mantener sus bucles bajo control es establecer el tamaño de una matriz por usando constantes de la siguiente manera: const int PIN_COUNT = 4; // define una constante para el número de elementos int inputPins [PIN_COUNT] = {2,3,4,5}; for (int index = 0; index
La compilador no informará un error si usted accidentalmente intentar almacenar o leer más allá del tamaño del array. Usted necesita ser cuidadoso ya que usted sólo a los elemntos que están dentro los límites que ha establecido. Usar una constante para establecer el tamaño de un array y en código referente a sus elementos ayuda a su código a permanecer dentro los límites del array.

Otro uso de los arrays es mantener una cadena de caracteres de texto. En código Arduino, estos se llaman character Strings (Strings para abreviaturas).Una cadena de carácter consiste de uno o más caracteres, seguido por carácter nulo (El valor 0) a indicar el final de la cadena.

El caracter nulo en el final de una cadena de caracteres no es lo mismo que el caracter 0. El nulo tiene un valor ASCII de 0, mientras 0 tiene un valor ASCII de 48.

Los métodos para utilizar Strings están incluidos en las Recetas 2.5 y 2.6.

Vea también Receta 5,2; Receta 7.1

2.5 Usando la Funcionalidad String de Arduino Problema Usted quiere manipular texto. Usted necesitar copiar este, añadir bits juntos, y determinar la número de caracteres.

Solución La receta anterior menciona sobre cómo los arrays de caracteres pueden ser usados para almacenar texto: estos arrays de caracteres son en generalmente llamados Strings. Arduino tiene una capacidad llamada String que añade una rica funcionalidad para almacenar y manipular texto.

31

La palabra String con una S mayúscula se refiere a la capacidad de texto proporcionada por la librería String de Arduin. La palabra String con un s en minúsculas se refiere al grupo de caracteres en lugar de la Funcionalidad String de Arduino.

Esta receta demuestra cómo utilizar Strings Arduino. La capacidad String fue introducida en la versión 0019 alfa (anterior a 1.0) de Arduino. Si estás utilizando versión más vieja, usted puede utilizar la libreria Text-String; ver el enlace al final de esta receta.

Cargar el siguiente Sketch en su tarjeta, y abra el Monitor Serial para visualizar los resultados: /* Sketch Basic_Strings */ String text1= "Esta cadena"; Cadena texto2 = "tiene más texto"; Text3 String; // que se asignará en el Sketch void setup () { Serial.begin (9600); Serial.print(texto1); Serial.print("es de"); Serial.print(text1.length ()); Serial.println("Caracteres de largo."); Serial.print("texto2 es"); Serial.print(text2.length ()); Serial.println("caracteres de largo"); texto1.concat(texto2); Serial.println("Texto1 contiene ahora:"); Serial.println(texto1); } void loop () { }

Discusión Este Sketch crea tres variables de tipo String, llamado texto1, texto2, y texto3. Variables de tipo String tienen incorporadas capacidades para manipular texto. La declaración texto1.length () retorna (Proporciona el valor de) la longitud (Número de caracteres) en la cadena texto1.

32

texto1.concat (texto2) combina el contenido de los strings; en este caso, anexa el contenido de texto2 al final de texto1 (Concat es abreviatura para concatenar).

El Monitor Serial mostrará lo siguiente: Esta cadena es de 11 caracteres de largo. texto2 es de 14 caracteres de largo. texto1 ahora contiene: Esta cadena tiene más texto

Otro camino para combinar strings es utilizar el string operador de suma. Añadir estas dos líneas al final del código setup: texto3 = texto1 + "y más"; Serial.println(text3);

El nuevo código resultará en el Monitor Serial añadiendo la siguiente línea a la final de la pantalla: Se trata de una cadena con más texto y más

Usted puede utilizar las funciones indexOf y lastIndexOf para encontrar una instancia de un carácter particular en un string. Porque la clase String es una reciente adición a Arduino, que se encontrará una gran cantidad de código que utiliza arrays de caracteres en lugar de tipo string. Ver la Receta 2.6 para más sobre uso de arrays de caracteres sin la ayuda de la funcionalidad String de Arduino.

Si usted ver una línea como la siguiente: char oldString[] = "Este es un array de caracteres";

el código utiliza array de caracteres estilo C (Véase la Receta 2. 6). Si la declaración se ve de esta manera: String newString = "esto es un objeto String";

la código usa Strings Arduino. Para convertir array de caracteres estilo C colección a un String Arduino, sólo asignar el contenido del array al objeto String: char oldString[] = "Quiero este array de caracteres en un objeto String"; String newString = oldString;

Para utilizar cualquiera de las funciones listadas en la Tabla 2-2, usted necesita invocarlas en un objeto string existente, como en este ejemplo: int len = myString.Length();

33

Tabla 2-2. Breve visión de conjunto de funciones String de Arduino charAt(n) compareTo(S2) concat(S2) endsWith(S2) equals(S2) equalsIgnoreCase(S2) getBytes(buffer,len) indexOf(S) lastIndexOf(S) length() replace(A,B) setCharAt(indice,c) startsWith(S2) substring(indice) substring(indice,a) toCharArray(buffer,len) toInt() toLowerCase() toUpperCase() trim()

Retorna el n-ésimo caracter del string Compara el String al String dado S2 Retorna un nuevo String que es la combinación del String y S2 Retorna true si el String termina con los caracteres S2 Retorna true si el String es exactamente S2 (mayúsculas y minusculas) Lo mismo que equals pero sin coincidir mayúsculas y minúsculas Copia tamaño de caracteres en el suministrado byte buffer Retorna el índice del String (o caracter)suminitrado o 1 si no es encontrado Lo mismo que indexOf inicia desde el final del String Retorna el número de caracteres en el String Reemplaza todas las instancia del String (o carácter) A con las de B Almacena el carácter c en el String en el índice dado Retorna true si el String inicia con los caracteres S2 Retorna un String con los caracteres a partir del indice hasta el final del string Como el anterior, pero el substring termina en la ubicación del carácter antes de “a” Copia hasta len los caracteres al buffer suministrado Retorna el valor entero de los dígitos numéricos en el String Retorna un String con todos los caracteres convertidos a minúsculas Retorna un String con todos los caracteres convertidos a mayúsculas Retorna un String con todos los espacios en blanco removidos

Ver las páginas de referencia Arduino para más acerca del uso y variantes para estas funciones.

Eligiendo entre Strings Arduino y array de caracteres C Los tipos de datos String incorporados en Arduino son más fáciles de utilizar que los array de caracteres C, pero este se consigue a través del código complejo en la librería String, que exige mas en su Arduino, y es, por la naturaleza, más propenso a problemas. Los tipos de datos String son tan flexibles porque hacen uso de la asignación de memoria dinámica. Que es, cuando usted crear o modificar un Cadena, Arduino requiere una nuevo región de memoria de la librería C, y cuando ya está uso un String, Arduino necesidades a liberación esa memoria. Esta generalmente trabaja sin problemas, pero en la práctica hay muchas grietas a través de las cuales puede fugarse memoria. Los errores en la librería String pueden resultar en que alguna o toda la memoria no sea devuelta adecuadamente. Cuando este sucede, la memoria disponible en Arduino disminuirá lentamente (Hasta que reinicie el Arduino). E incluso si no hubo fugas de memoria, es complicado a escribir código para comprobar si una solicitud de String ha fracasado debido a la insuficiente memoria (Las funciones String imitan aquello en Processing, pero a diferencia de esa plataforma, Arduino no tiene excepción de ejecución de errores).

34

Quedarse sin memoria dinámica es un error que puede ser muy difícil de localizar porque el Sketch puede ejecutar sin problemas por días o semanas antes que inicie el mal comportamiento a través de la memoria insuficiente. Si usted utiliza el array de caracteres C, usted está en el control del uso memoria: está asignando una cantidad fija (Estática) de memoria al momento de compilar así usted no conseguirá fugas de memoria. Su Sketch Arduino tendrá la mismo cantidad de memoria disponible en todo tiempo que se esté ejecutando. Y si usted hacer intenta asignar más memoria que la disponible, encontrar la causa es fácil porque hay herramientas que le dirán cuanta memoria estático a usted tiene asignada (Véase la referencia para avr-objdump en la Receta 17.1). Sin embargo, con array de caracteres C, es fácil para usted tener otro problema: C No le impide la modificación de memoria más allá de los límites del array. Así si asigna un array como myString[4], y asigna myString[4] = 'A' (Recuerde, myString[3] es el final del array), nada le impedirá hacer esto. Pero quién sabe qué pieza de memoria se refiere a myString[4]? ¿Y quién sabe si la asignación de 'A' a la posición de memoria le causará un problema? Más probable, hará que el Sketch se porte mal. Así, la librería String incorporada en Arduino, por virtud del uso de memoria dinámica, corre el riesgo de consumir su memoria disponible. El array de caracteres C exige cuidado epara asegurar que usted no exceda los límites de los arrays que utilice. Utilizar la librería String incorporada en Arduino si usted necesita capacidad de manejo de texto enriquecido y usted no podrá crear y modificar Strings una y otra vez. Si usted necesita crear y modificar estas en un bucle que es constantemente repetido, es mejor asignar asignación un grande array de caracteres C y la escribir su código cuidadosamente así usted no escribira sobrepasando los límites de ese array. Otro instancia donde usted puede preferir array de caracteres C sobre Strings Arduino es en grandes Sketches necesitará más de la RAM o flash disponible. El código ejemplo String Toint usa casi 2 KB más flash que su equivalente código usando un array de caracteres C y atoi a convertir a un int. La versión String Arduino también requiere un poco más de RAM para contener información asignada en adición al String actual. Si usted hacer sospecha que la librería String, o cualquier otra libreria que hace uso de la memoria dinámica asignada, está fugando memoria, usted puede determinar cuanta memoria esta libre en cualquier tiempo dado; ver la Receta 17.2. Comprobar la cantidad de RAM cuando su Sketch inicie, y monitoree esto para ver si está decreciendo a lo largo del tiempo. Si usted sospecha de un problema con la librería String, busque la lista de errores abiertos (http://code.google.com/p/arduino/issues/lista) para "String".

Vea también La distribución Arduino proporciona ejemplos String de Sketches (Archivo → Ejemplos →Strings). La página de referencia para String puede ser encontrada en http://arduino.cc/en/Reference /StringObject.

35

Tutoriales para la nueva librería String están disponibles en http://arduino.cc/en/Tutorial/HomePage y un tutorial para la librería original (Sólo necesaria si usted está utilizando una versión de Arduino más antigua que 0019 alfa) está disponible en http://www.arduino.cc/en/Tutorial/ TextString.

2.6 Usando Caracter String C Problema Usted quiere a entender el uso de caracteres String: usted quiere saber cómo crear un String, encontrar su longitud, comparar, y copiar, o anexar strings. La núcleo de lenguaje C lenguaje hace no es compatible con la capacidad String de Arduino, por lo que usted querrá entender el código de otras plataformas, escrito para funcionar con primitivos arrays de caracteres.

Solución Los arrays de caracteres son a veces llamados character strings (O simplemente strings para abreviar). La Receta 2.4 describe los Arrays de Arduino en en general. Esta receta describe funciones que operan sobre cadenas de caracteres. Usted declara strings como este: Char stringA[8]; // declarar una cadena de hasta 7 caracteres más la terminación nula Char stringB[8] = "Arduino" // como el anterior e inicializa el string a "Arduino" char stringC[16] = "Arduino" // como el anterior, pero la cadena tiene espacio para crecer Char stringD[] = "Arduino" // el compilador inicializa y calcula el tamaño del string

Use strlen (abreviatura para string length) para determinar el número de caracteres antes de la terminación nula: int length = strlen(string); // retorna el número de caracteres en el string

length será 0 para stringA y 7 para los otros strings mostrados en el código anterior. El nulo

que indica el final del cadena no es contado por strlen. Use strcpy (abreviatura para string copy) para copiar una cadena a otra: strcpy (destino, origen); // copiar cadena de origen a la de destino

Use strncpy para limitar el número de caractaress a copiar (Útil para evitar escribir más caracteres que el string destino puede contener). Usted puede ver este uso en la Receta 2.7: // Copiar hasta 6 caracteres del origen al destino strncpy(destino, origen, 6);

Use strcat (Abreviatura para string concatenate) a anexar un string al final de otro: // Anexar el string de origen al final del string de destino strcat (destino, origen);

36

Asegurese siempre que haya suficiente espacio en el destino cuando copia o concatena strings. No olvide permitir espacio para la terminación nula.

Use strcmp (abreviatura para string compare) para comparar dos cadenas. Usted puede ver este uso en la Receta 2.7: if(strcmp(str, "Arduino") == 0) // Hacer algo si la variable str es igual a "Arduino"

Discusión El texto representado en el Entorno de Arduino usando un array de caracteres son llamados strings. Un string se compone de un número de caracteres seguido por un nulo (el valor 0). El nula no es visible, pero es necesario para indicar el final del string al software.

Vea también Vea una de las muchas referencia en línea sobre C/C + + en páginas, tal como http://www.cplusplus.com/ Referencia / clibrary / cstring / y http://www.cppreference.com/wiki/string/c/start.

2.7 Dividiendo Grupos de Texto Separados por comas Problema Usted tiene un string que contiene dos o más piezas de datos separadas por comas (O cualquier otro separador). Usted quiere a división el string de manera usted pueda utilizar cada parte individual.

Solución Este Sketch impresiones el texto encontrado entre cada coma: / * * *

* Sketch SplitSplit Divide una string separado por comas /

String texto = "Peter, Paul, Mary" // una string de ejemplo String mensaje = texto; // mantiene el texto aún no dividido int commaPosition; // la posición de la siguiente coma en la cadena void setup () { Serial.begin (9600); Serial.println (mensaje); // mostrar el string de origen {

37

commaPosition = mensaje.indexOf (','); si (commaPosition!= -1) { Serial.println (mensaje.substring (0, commaPosition)); mensaje = mensaje.substring (commaPosition 1, mensaje.length ()); } else { //Aquí después de encontrar la última coma if(mensaje.length ()> 0) Serial.println (mensaje); // si hay un texto después de la última coma, // Imprimir este } } while(commaPosition> = 0); } void loop () { }

El Monitor Serial mostrará lo siguiente: Peter, Paul, Mary Peter Paul Mary

Discusión Este Sketch usa funciones String para extraer texto de entre las comas. La siguiente código: commaPosition = message.indexOf (',');

establece la variable commaPosition a la posición de la primero coma en el String llamado mensaje (este será establecido a -1 si no encuentra comas). Si hay una coma, la función substring es usada para imprimir el texto desde el comienzo del cadena hasta a, pero excluyendo la coma. El texto que fue impreso, y su seguida coma, son eliminado del mensaje en esta linea: mensaje = mensaje.substring (commaPosition 1, mensaje.length ());

substring retorna una cadena comenzando desde commaPosition+1 (La posición justo después de

la primera coma) hasta a la longitud de la mensaje. Este resultados en que el mensaje que contiene sólo el texto después de la primera coma. Esto se repite hasta que no encuentre más comas (commaPosition será igual a -1). Si usted es un programador experimentado, usted también podrá utilizar funciones de bajo nivel que son parte de la librería estándar C. La siguiente Sketch tiene similar funcionalidad a el anterior uno usando strings Arduino: / * * *

* Sketch SplitSplit Divide una cadena separada por comas /

38

const int MAX_STRING_LEN = 20

// establesca esto al string más grande // que procesará

char StringList [] = "Peter, Paul, Mary" // un string de ejemplo char StringBuffer [MAX_STRING_LEN 1]; // un buffer estático para el cálculo y la salida void setup () { Serial.begin (9600); } void loop () { char * str; char * p; strncpy(StringBuffer, StringList, MAX_STRING_LEN) //copiar cadena de origen Serial.println(StringBuffer) //mostrar la cadena de origen for(str = strtok_r (StringBuffer, ",", &p); // dividir usando comas str; //Bucle while str no es nulo str = strtok_r (NULL,",", &p) //obtener los siguientes símbolos ) { Serial.println (str); } delay (5000); }

La funcionalidad esencial viene de la función llamada strtok_r (La nombre de la versión de strtok que viene con el compilador Arduino). La primera vez que usted llama a strtok_r, usted pasar el string que desee a simbolizar (Separar en valores individuales).Pero strtok_r sobrescribe los caracteres en este string cada vez que éste encuentre una nueva muestra, por lo que es mejor pasar una copia del string como se muestra en este ejemplo. Cada llamada que sigue utiliza un NULL para decir a la función que debería moverse al próximo símbolo. En este ejemplo, cada uno simbólo es impreso al puerto serial. Si su símbolos constan sólo de números, ver la Receta 4.5. Este muestras cómo extraer valores numéricos separados por comas en una corriente serie de caracteres.

Vea también Ver http://www.nongnu.org/avr-libc/user-manual/group avr string.html para más sobre funciones string C tales como strtok_r y strcmp. La Receta 2,5; en línea se referencias a las funciones strtok_r y strcmp en C / C + +.

39

2.8 Convirtiendo un Número a un String Problema Usted necesita convertir un número a un string, quizás para mostrar el número en un LCD u otra pantalla.

Solución La variable String convertirá números a cadenas de caracteres automáticamente. Usted puede utilizar valores literales, o el contenido de una variable. Por ejemplo, la siguiente código funcionará: String myNumber = 1234;

Al igual que este: int valor = 127; Cadena myReadout = "La lectura fue"; myReadout.concat(valor);

O este: int valor = 127; String myReadout = "La lectura fue"; myReadout + = valor;

Discusión Si usted está convirtiendo un número a texto para visualizarlo en un LCD o dispositivo serial, la solución más simple es a utilizar la capacidad de conversión incluida en las bibliotecas LCD y Serial (Ver la receta 4,2). Pero quizás usted esté usando un dispositivo que no tiene este soporte incorporado (véase el Capítulo 13) o usted quiere manipular el número como un string en su Sketch. La clase String de Arduino automáticamente convierte valores numéricos cuando estos han sido firmados como una variable string. Usted puede combinar(Concatenar) valores numéricos al final de un string usando la función concat o el string y el operador +. La operador + es usado con tipos numéricos así como strings, pero este se comportará diferentemente con cada uno.

La siguiente código resultada en un numero teniendo un valor de 13: int numero = 12; numero + = 1;

Con un String, como muestra aquí: String textNumber = "12"; textNumber + = 1;

40

textNumber es la cadena de texto "121".

Anterior a la introducción de la clase String, era común encontrar código Arduino usando la función itoa o ltoa. La nombres vienen de "Entero para ASCII " (Itoa) y "largo para ASCII " (l). La versión String descrita anteriormente es fácil de utilizar, pero la siguiente puede ser usada si usted prefiere trabajar con array de caracteres C como se describe en la Receta 2.6. itoa o ltoa toman tres Parámetros: el valor a convertir, el buffer que mantendrá el string de

salida, y la base numérica (10 para números decimales, 16 para hexadecimales, y 2 para binarios). La siguiente Sketch ilustra cómo a convertir valores numéricos usando ltoa: / * * NumberToString * Crea una string de un número dado * / void setup () { Serial.begin (9600); } char buffer[12]; // tipo de datos long tienen 11 caracteres (incluyendo el // el signo menos) y un terminador nulo void loop () { Long valor = 12345; ltoa (valor, buffer, 10); Serial.print (valor); Serial.print ("tiene"); Serial.print (strlen (buffer)); Serial.println ("dígitos"), valor = 123456789; ltoa (valor, buffer, 10); Serial.print(valor); Serial.print("tiene"); Serial.print(strlen (buffer)); Serial.println("dígitos"); delay (1000); }

Su buffer necesita ser suficientemente grande para mantener el máximo número de caracteres en el string. 16 bits para números enteros de base 10 (Decimal), esos son siete caracteres (Cinco dígitos, un posible signo menos, y un terminación 0 que siempre significa el final de un string); Enteros largos necesitan 32 bits para 12 caracteres (10 dígitos, el signo menos, y la terminación0). No se da ninguna advertencia si usted excede el tamaño del buffer; este es un error que puede causar todo tipo de extraños síntomas, porque el desbordamiento corromperá algunas otras partes de la memoria que puede ser usada por su programa. La manera fácil para manejar esto es a siempre utilizar un buffer de 12 caracteres y siempre utilizar ltoa porque este funcionará en valores de 16 bits y 32 bits.

41

2.9 Convirtiendo un String a un Número Problema Usted necesita convertir un string a un número. Quizás usted ha recibido un valor como un string sobre un enlace de comunicación y usted necesita a utilizar este como un entero o valor de punto flotante.

Solución Hay un número de formas para resolver esto. Si el string es recibido como datos seriales, puede ser convertido tan pronto como cada carácter es recibido. Ver la Receta 4.3 para un ejemplo de cómo a hacer este usando el puerto serial. Otro enfoque para convertir strings de texto que representan números es a utilizar la function de conversion del lenguaje C llamadas atoi (Para variables int) o atol (Para variables long). Este fragmento de código termina los dígitos entrantes en cualquier carácter que es no un dígitos (o si la buffer está completo). Para que este funcione, sin embargo, necesitara permitir la opción de salto de línea en el Monitor Serial o tipo algunos otro terminación carácter: / * * StringToNumber * Crea un número desde una string * / const int ledPin = 13 // pin al que el LED está conectado int blinkDelay // velocidad de parpadeo determinada por esta variable Char strValue [6]; //debe ser lo suficientemente grande para contener todos los dígitos y el // 0 que termina la cadena int index = 0; // El índice en el array que almacena los dígitos recibidos void setup () { Serial.begin (9600); pinMode (ledPin, OUTPUT); // activar pin LED como salida } void loop () { if (Serial.available ()) { char ch = Serial.read (); if (index <5 && isdigit (ch)) { strValue [index + +] = ch // agregar el carácter ASCII a la cadena; } else { // Aquí cuando búfer este o al principio no hay digito strValue [index] = 0; // terminar la serie con un 0 blinkDelay = atoi (strValue); // use atoi para convertir la cadena en un entero int index = 0; }

42

} blink (); } void blink () { digitalWrite (ledPin, HIGH); delay (blinkDelay/2) // esperar la mitad del periodo de parpadeo digitalWrite (ledPin, LOW); delay (blinkDelay / 2) // esperar a la otra mitad }

Discusión Las funciones oscuramente llamadas atoi (Por ASCII a int) y atol (Por ASCII a de largo) convierten un string en enteros o números enteros largos. Para utilizarlas, usted tener que recibir y almacenar todo el string en un array de carácter antes usted puede llamar a la función conversión. El código crea un array de caracteres llamado strValue que puede almacenar hasta a cinco dígitos (Se declaró como char strValue[6] porque debe tener espacio para la terminación nula). Este llena este array con dígitos desde Serial.read hasta que obtiene el primero carácter que no es un dígito válido. El array es finalizado con un nulo y la función atoi es llamada para convertir el array de caracteres en la variable blinkRate. La función llamada blink se llama para usar el valor almacenado en blinkDelay. Como se menciona en la advertencia en la Receta 2.4, usted necesita ser cuidadoso para no exceder el límite del array. Si usted no está seguro de cómo a hacer eso, vea la sección Discusión de esa receta. El lanzamiento 22 de Arduino adiciona el método toInt para convertir un String a un entero: String aNumber = "1234"; int value = aNumber.toInt ();

Arduino 1.0 adiciona el método parseInt que puede ser usado para conseguir valores enteros del Serial y Ethernet (O cualquier objeto que deriva desde la clase Stream). La siguiente fragmento convertirá secuencias de dígitos numéricos en números. Esto es similar al fragmento solución pero no necesita un buffer (Y no limita el número de los dígitos a 5): int blinkDelay / / velocidad de parpadeo determinada por este bucle variablevoid () { if (Serial.available ()) { blinkRate = Serial.parseInt (); } parpadear (); }

43

Métodos Stream-Parsing como parseInt utilizan un tiempo de espera para retornar el control a su Sketch si los datos no llegan dentro del intervalo deseado. El tiempo de espera por defecto es un segundo pero este puede ser cambiado por llamando el método setTimeout: Serial.setTimeout (1000 * 60); // esperar hasta un minuto parseInt (Y todos los otros métodos Strean) retornará cualquier valor que

se obtuvo antes del tiempo de espera si no se recibido delimitador. El valor de retorno consistirá de cualquier valor que se haya recogido; si no hay dígitos que se hayan recibido, el retorno será cero. Arduino 1.0 no tiene una forma para determinar si un método de análisis tiene tiempo de espera, pero este capacidad es prevista para una futura versión.

Vea también Documentación para atoi puede ser encontrada en: http://www.nongnu.org/avrlibc/user-manual/ grupo avr stdlib.html. Hay muchas paginas de referencia sobre C/ C++ incluyendo estas funciones de bajo nivel, como http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/ o http://www.cppreference .com / wiki / cadena / c / atoi. Ver la Receta 4.3 y Receta 4.5 para más acerca del uso parseInt con Serial.

2.10 Estructurando Su Código en Bloques Funcionales Problema Usted quiere saber cómo añadir funciones a un Sketch, y la cantidad correcto de funcionalidad a ir en sus funciones. Usted también quiere entender cómo planificar la estructura global del Sketch.

Solución Las funciones son usadas para organizar las acciones realizadas por su Sketch en bloques funcionales. Las Funciones empaquetan funcionalmente en bien definidas entradas (Información dado a una función) y salidas (Información prevista por una función) que hacen fácil estructurar, almacenar, y reutilizar su código. Usted ya está familiarizado con las dos funciones que están en cada Sketch Arduino: void y loop. Usted crea una función declarando su tipo de retorno (La información que proporciona), su nombre, y cualquier parámetro opcional (Los valores) que la función recibirá cuando es llamada.

44

Los términos funciones y métodos son usados para referirse a bloques bien definidos de código que puede ser llamado como una sola entidad por otras regiones de un programa. El lenguaje C se refiere a estos como funciones. Lenguajes orientados a objetos como C + + que exponen funcionalidad a través de clases tienden a utilizar el término método. Arduino usa una mezcla de estilos (La Sketches ejemplo tienden a utilizar estilo C-like, las librerias tienden a ser escritas a exponiendo métodos de clase C++). En este libro, el término función es usado usualmente a menos que el código sea expuesto a través de una clase. No se preocupe; si esos terminos no son claros para usted, trate ambos terminos como el misma.

Aquí hay una simple función que sólo parpadea un LED. Esta no tiene parámetros y no devuelve nada (La anterior funcion void indica que nada será devuelto): // parpadear un led una vez LED blink1 () { digitalWrite delay (500); digitalWrite delay (500); }

(13, HIGH); // encender el LED // esperar 500 milisegundos (13, LOW); // apagar el LED // esperar 500 milisegundos

La siguiente versión tiene un parámetro (El entero llamado count) que determina cuántos veces el LED parpadea: // Parpadear un LED el número de veces determinado en el parámetro count void blink2(int count) { while (count > 0) // repetición hasta que la cuenta ya no sea mayor que cero { digitalWrite (13, HIGH); delay (500); digitalWrite (13, LOW); delay (500); count = count -1; // decrementa el count } }

Programadores experimentados notarán que ambas funciones podría ser parpadear porque la compilador diferenciará estos por el tipo de valores utilizados para la parámetro. Este comportamiento es llamada función sobrecargada. La Arduino print discutida en la Receta 4.2 es un común ejemplo. Otro ejemplo de sobrecarga es en la discusión de la Receta 4.6.

Esa versión revisa para ver si el valor de count es 0. Si no, esta parpadea el LED y luego reduce el valor de count de a uno. Este será repetido hasta que count no sea mayor que 0.

45

Un parámetro es a veces referido como un argumento en algunas documentaciones. Por prácticos propósitos, usted puede tratar estos términos como si significaran lo mismo.

Aquí hay un Sketch ejemplo que toma un parámetro y retorna un valor. El parámetro determina la longitud del tiempo del LED encendido y apagado (En milisegundos). La función continúa parpadeando el LED hasta que un botón es presionado, y la número de veces que el LED parpadeo es devuelto desde la función: /* blink3 sketch Demuestra llamando a una función con un parámetro y devolviendo un valor. Utiliza el mismo cableado que el sketch de pull-up de la Receta 5.2 El LED parpadea cuando el programa se inicia y se detiene cuando se pulsa un interruptor conectado al pin digital 2. El programa imprime el número de veces que el LED parpadea. * / const int ledPin = 13; // pin de salida para el LED const int InputPin = 2 // pin de entrada para el interruptor; void setup () { pinMode (ledPin, OUTPUT); pinMode (InputPin, INPUT); digitalWrite (InputPin, HIGH); // Uso resistencia interna pull-up (Receta 5.2) Serial.begin (9600); } void loop () { Serial.println ("Pulse y mantenga pulsado el interruptor para detener el parpadeo"); int cuenta = blink3 (250) // parpadear el 250 ms LED encendido y 250 ms apagado Serial.print ("El número de veces que el conmutador parpadeó fue"); Serial.println (cuenta); } // Parpadear un LED utilizando el período de retardo dado // Devuelve el número de veces que el LED destellaba int blink3 (int período) { int resultado = 0; int switchVal = ALTO // con pull-ups, esta será alta cuando el interruptor está hacia arriba while(switchVal == HIGH) // repetir este bucle hasta que se pulse el interruptor // (esta será baja cuando se pulsa) { digitalWrite (13, HIGH); delay(período); digitalWrite (13, LOW); delay(período); resultado = resultado + 1 // incrementar el contador

46

switchVal = digitalRead (InputPin); // lee el valor de entrada } // Aquí switchVal ya no es alto porque el interruptor se presiona return resultado; // se devolverá este valor }

Discusión El código en esta receta de Solución ilustra las tres formas de función llamar que usted se encontrará. blink1 tiene no tiene parámetro y no retorna valor. Su forma es: void blink1 () { / / Código de aplicación va aquí ... }

blink2 toma un solo parámetro pero no retorna un Valor: void blink2 (int count) { / / Código de aplicación va aquí ... }

blink3 tiene un solo parámetro y retorna un Valor: int blink3 (int período) { // Código de aplicación va aquí ... }

El tipo de dato que precede el nombre de la función indica el tipo de retorno (no retorna si es void). Cuando declara la función (Escribirndo el código que define la función y su acción), usted no pone un punto y coma siguido al paréntesis al final. Cuando utiliza la función (Call), usted no necesita un punto y coma al final de la línea que llama la función. La mayor parte de la funciones que se encontrará serán algunas variantes de estas formas. Por ejemplo, aquí hay una función que toma un parámetro y retorna un Valor: int sensorPercent(int pin) { int percent; int val = analogRead(pin) // leer el sensor (rangos de 0 a 1023) percent= map(val, 0,1023,0,100); // percent irá desde 0 a 100. return percent; }

La el nombre de la función es sensorPercent. Esta da un número de pin analógico para leer y devuelve el valor como un porcentaje (Véase la Receta 5.7 para más sobre analogRead y map). El int en frente de la declaración dice al compilador (Y recuerda al programador) que la función retornará un número entero. Al crear funciones, elegir el tipo de retorno apropiado a la acción que la función realiza. Esta función retorna un valor entero de 0 a 100, así un tipo de retorno int es apropiado.

47

Es recomendado que de sus funciones nombres significativos, y es una práctica común combinar palabras escribiendo con mayúscula la primera letra de cada palabra, excepto para la primera palabra. Use cualquier estilo que prefiera, pero esto ayuda a otros que lean su código si usted conserva su estilo de nombramiento consistente. sensorPercent tiene un parámetro llamado pin (Cuando la función es llamada, pin es da el valor

que es pasado a la función). cuerpo de la función (La código dentro de los paréntesis) realiza la acción quiere que lea un valor desde un pin de entrada analógica y lo convierta a un porcentaje. En el anterior ejemplo, el porcentaje es temporalmente almacenado en una variable llamada percent. La siguiente declaración causa que el valor almacenado en la variable temporal percent sea regresado a la aplicación llamada: return percent;

La misma funcionalidad puede ser alcanzada sin uso la variable temporal percent: int sensorPercent(int pin) { int val = analogRead (pin) // leer el sensor (rangos de 0 a 1023) return map(val, 0,1023,0,100); // percent irá desde 0 a 100. }

Aquí es cómo la función puede ser llamada: // Imprimir el valor del porcentaje de 6 pines analógicos for int sensorPin = 0; sensorPin <6; sensorPin + +) { Serial.print("Porcentaje de sensor en el pin"); Serial.print(sensorPin); Serial.print("es"); int val = sensorPercent (sensorPin); Serial.print(val); }

Vea También La página de referencia a http://www.arduino.cc/en/Reference/FunctionDe claration

las

funciones

Arduino:

2.11 Retornando Más Que Uno Valor desde una Función Problema Usted quiere retornar dos o más valores desde un función. La Receta 2.10 proporciona ejemplos para la más común forma de una función, una que retorna sólo un valor o ninguno en todo. Pero a veces usted necesita modificar o retornar más que un valor.

48

Solución Hay varias formas de resolver esto. La fácil a entender es tener la función cambiando algunas variables globales y en realidad no retorna cualquier cosa desde la función: /* Swap sketch demuestra cambiando dos valores usando variables globales * / int x; // x e y son variables globales int y; void setup () {Serial.begin (9600); } void loop () { x = random (10) // recoger algunos números aleatorios y = random (10); Serial.print ("El valor de x e y antes de intercambiar son:"); Serial.print (x); Serial.print (","); Serial.println (y); swap (); Serial.print ("El valor de x e y después del intercambio son:"); Serial.print (x); Serial.print (","); Serial.println (y); Serial.println (); delay (1000); } // Cambiar los dos valores globales void swap () { int temp; ‘ temp = x; x = y; y = temp; }

La función swap cambia dos valores usando variables globales. Las variables globales son fáciles de entender (Global las variables son valores que son accesible en todas partes y cualquier cosa puede cambiarlas), pero estan son evitadas por programadores experimentados porque esta no advierte la modificacion del valor de una variable o tiene una function detenida función porque usted ha cambiado el nombre o tipo de una variable global en otra parte en el Sketch. Una más segura y más elegante solución es pasar referencias a los valores que usted quiere cambiar y permitir a la función utilizar las referencias para modificar los valores. Este se hace de la siguiente manera: / * functionReferences sketch demuestra devolviendo más de un valor al pasar referencias * /

49

void setup () { Serial.begin (9600); } void loop () { int x = random (10) / / recoger algunos números aleatorios int y = random (10); Serial.print ("El valor de x e y antes de intercambiar son:"); Serial.print (x); Serial.print (","); Serial.println (y); swap (x, y); Serial.print ("El valor de x e y después del intercambio son:"); Serial.print (x); Serial.print (","); Serial.println (y); Serial.println (); delay (1000); } // Cambiar los dos valores dados void swap (int &valor1, int &valor2) { int temp; temp = valor1; valor1 = valor2; valor2 = temp; }

Discusión La función swap es similar a las funciones con parámetros descritas en la Receta 2.10, pero el signo (&) símbolo indica que los parámetros son referencias. Esto significa cambios en valores dentro de la función, también cambiara el valor de la variable que se da cuando la función se llama. Usted puede ver cómo este funciona al ejecutar el código en esta Receta de Solución y verificando que los parámetros son intercambiados. Entonces modificar el código al eliminar la dos signos & en la función definición. La línea cambiada debería lucir como esta: void swap(int valor1, valor2 int)

Ejecutando el código muestra que los valores no son intercambiados, los cambios realizados dentro de la función son locales a la función y son perdidos cuando la función retorna.

Si usted está usando la liberación 21 de Arduino o anterior, usted necesitará crear una función declaración para informar al compilador que su función está utilizando referencias. El Sketch para esta receta en la descarga para la primero edición de este libro muestra cómo a crear la función declaración: // funciones con referencias deben ser declaradas antes de su uso // La declaración va en la parte superior, antes de que su código setup y void

50

// Note el punto y coma al final de la declaración void swap(int &valor1, int &valor2);

La función declaración es un prototipo, una especificación de los nombres, los tipos de los valores que pueden ser pasados a la función, y el tipo de retorno de la función. El proceso de contruccion Arduino por lo general crea las declaraciones para usted bajo la cubierta. Pero cuando usted utilizar sintaxis no estándar (para Arduino 21 y anterior, de todos modos), el proceso de construcción no crea la declaración y usted necesita añadirla a su código, como está hecho con la linea antes de setup. La función definición es la función encabezamiento y la función cuerpo. La función encabezamiento es similar a la declaración excepto que no tiene un punto y coma al final. La función cuerpo es la código dentro de los parentesis que es ejecutada para realizar alguna acción cuando la función es llamada.

2.12 Tomando Acciones Basadas en Condiciones Problema Usted quiere ejecutar un bloque de código sólo si una condición particular es verdadera. Por ejemplo, puede querer a iluminar un LED si un interruptor es presionado o si un valor analógico es mayor que algun umbral.

Solución La siguiente código usa la conexion muestrada en la Receta 5.1: /* Sketch pulsador un interruptor conectado al pin digital 2 enciende el LED en el pin 13 * / int const ledPin = 13 // seleccionar el pin para el LED const int inputPin = 2 // seleccionar el pin de entrada (por un pulsador) void setup () { pinMode(ledPin, OUTPUT); // declara pin LED como salida pinMode(InputPin, INPUT); // declara pin pulsador como entrada } void loop () { int val = digitalRead(InputPin); // lee el valor de entrada if (val == HIGH) // comprueba si la entrada es ALTA { digitalWrite(ledPin, HIGH); // LED enciende si se pulsa el interruptor } }

51

Discusión La declaración if es usada para probar la valor de digitalRead. Una declaración if necesita tener una prueba dentro de los paréntesis que sólo pueden ser verdadero(true) o falso(falso). En el ejemplo en esta receta de Soluciones, es val == HIGH, y el bloque de código seguido a la declaración if sólo es ejecutado si la expresión es verdadera. El bloque de código consiste en todo el código dentro las llaves (O si usted no utiliza llaves, el bloque es sólo la próxima declaración ejecutable finalizado por un punto y coma). Si usted quiere hacer una cosa si un declaración es verdadera y otra si es falsa, utilizar la declaración if ... else: / * Sketch pulsador un interruptor conectado al pin 2 ilumina el LED en el pin 13 * / int const ledPin = 13 // seleccionar el pin para el LED const int inputPin = 2 // seleccionar el pin de entrada (por un pulsador) void setup () { pinMode(ledPin, OUTPUT); // declara pin LED como salida pinMode (inputPin, INPUT); // declara pin pulsador como entrada } void loop () { int val = digitalRead(InputPin); // lee el valor de entrada if(val == HIGH) // comprueba si la entrada es ALTA { // Hacer esto si val es ALTO digitalWrite (ledPin, HIGH); // LED encendido si se pulsa el interruptor } else { // Else hace esto si val no es ALTO digitalWrite(ledPin, LOW); // apaga el LED } }

Véase También Ver la discusión sobre tipos Boolean en la Receta 2.2.

2.13 Repitiendo una Secuencia de Declaraciones Problema Usted quiere repetir un bloque de declaraciones mientras un expresión es verdadera.

52

Solución El bucle while repite uno o más instrucciones mientras una expresión es verdadera: / * * Repetir * Parpadea mientras una condición es verdadera * / const int ledPin = 13 // el LED es conectado al pin digital a const int sensorPin = 0; // entrada analógica 0 void setup () { Serial.begin (9600); pinMode(ledPin, OUTPUT); // activar pin LED como salida } void loop () { while(analogRead (sensorPin)> 100) { blink(); // llamar a una función para encender y apagar un LED Serial.print ("."); } Serial.println(analogRead (sensorPin)) // esto no se ejecuta hasta que // El bucle while termina! } void blink () { digitalWrite(ledPin, HIGH); delay (100); digitalWrite(ledPin, LOW); delay (100); }

Este código ejecutará las declaraciones en el bloque dentro las llaves, {}, mientras el valor desde analogRead sea mayor que 100. Este podría ser usado para parpadear un LED como una alarma mientras algunos valores excedan un umbral. El LED es apagado cuando el valor del sensor valor es 100 o menos; este parpadea continuamente cuando el valor es mayor que 100. La {} símbolos que definir un bloque de código son dado vario nombres, incluyendo soportes, rizado aparatos ortopédicos, y apoyos. Este libro se refiere a como corchetes.

Discusión Las llaves definen la extension del bloque de código a ser ejecutado en un bucle. Si las llaves no son utilizado, sólo la primero línea de código será repetido en el bucle:

53

while(analogRead (sensorPin)> 100) blink (); // línea inmediatamente después de la expresión bucle se ejecuta Serial.print ("."); // Esto no se ejecuta hasta que después de que finalice un bucle while!

Loops sin soportes lata comportarse inesperadamente si usted tener más de un línea de código.

El bucle do... while es similar al bucle while, pero las instrucciones en el bloque de código son ejecutadas antes que condición sea revisada. Use este forma cuando usted necesite tener el código ejecutado al menos una vez, incluso si la expresión es falsa: do { blink(); // llamar a una función para encender y apagar un LED } while (analogRead (sensorPin)> 100);

El código anterior parpadeará el LED al menos una vez y mantendrá intermitente tanto como el valor leido desde un sensor sea mayor que 100. Si el valor no es mayor que 100, el LED sólo parpadeará una vez. Este código podría ser usado en un circuito cargador de baterias, si fuera llamado una vez cada 10 segundo o por lo que: un solo parpadeo muestra que el circuito está activo, mientras que continuos parpadeos indicant que la batería está cargada. Sólo la código dentro un mientras o hacer bucle voluntad ejecutar hasta la las condiciones lo permiten salida. Si su dibujo necesidades a rotura fuera de un bucle en respuesta hasta cierto otro condición tal como un tiempo de espera, sensor estado, o otro de entrada, lata utilizar romper: while(analogRead (sensorPin)> 100) { blink(); if (Serial.available ()) break; // cualquier entrada serial sale del bucle while }

Véase También Los capítulos 4 y 5

2.14 Repitiendo Declaraciones con un Contador Problema Usted quiere repetir una o más declaraciones un cierto número de veces. El bucle for es similar al bucle while, pero usted tendrá más control sobre las condiciones inicial y final.

54

Solución Este Sketch rcuenta desde cero a tres imprimiendo el valor de la variable i en un bucle for: / * Sketch BucleFor demuestra el bucle for * / void setup () { Serial.begin (9600);} void loop () { Serial.println("for (int i=0; i <4; i++)"); for(int i=0; i <4; i++) { Serial.println (i); } }

La salida del Monitor Serial desde este es como sigue (esto será visualizado una y otra vez): for(int i=0; i <4; i++) 0 1 2 3

Discusión El bucle for consiste de tres partes: inicialización, prueba condicional, e iteración (Una declaración que es ejecutado en la final de cada pasada a través del bucle). Cada parte es separada por un punto y coma. En el código de este La receta de Soluciones, int i=0; inicializa la variable i a 0; i < 4; pruebas la variable para ver si es menor que 4; y i++ incrementa i. El bucle for puede utilizar una variable existente, o lo puede crear una variable para uso exclusivo dentro del bucle. Esta versión usa el valor de la variable j creado anteriormente en el Sketch: int j; Serial.println("for(j = 0; j <4; j + +)"); for(j = 0; j <4; j + +) { Serial.println (j); }

Esto es casi lo mismo como el anterior ejemplo, pero no tiene palabra clave int en la parte de inicialización porque la variable j ya fue definida. La salida de esta versión es similar a la salida de la versión anteroir: for (j = 0; i <4; i + +) 0 1 2 3

55

Usted puede dejar completamente fuera la parte de inicialización si usted quiere el bucle utiliza el valor de un variable definida anteriormente. Este código inicia el bucle con j igual a 1: int j = 1; Serial.println("for (; j <4; j + +)"); for(; j <4; j + +) { Serial.println (j); }

La anterior código imprime lo siguiente: for (; j <4; j + +) 1 2 3

Usted controla cuando detener el bucle en la prueba condicional. El anterior ejemplo prueba si la variable del bucle es menor que 4 y terminará cuando la condición ya no sea verdadera.

Si su variable del bucle inicia en 0 y usted quiere repetir cuatro veces, su declaración condicional debería probar para un valor menor que 4. La bucle se repite mientras la condición sea verdadero y hay cuatro valores que son menores que 4 con un bucle iniciado en 0.

El siguiente código prueba si el valor de la variable del bucle es menor o igual que 4. Se imprimirá los dígitos desde 0 a 4: Serial.println("for (int i = 0; i <= 4; i + +)"); for(int i = 0; i <= 4; i + +) { Serial.println (i); }

La tercera parte de un bucle for bucle es la declaración iterador que es ejecutada al final de cada pasadaa través del bucle. Este puede ser cualquier declaración C / C + + válida. La siguiente aumenta el valor de i de a dos en cada pasada: Serial.println("for (int i = 0; i <4; i + = 2)"); for(int i = 0; i <4; i + = 2) { Serial.println (i); }

Esa expresión sólo imprime los valores 0 y 2. La expresión iterador puede ser usado para que el bucle cuente de arriba hacia abajo, en este caso desde 3 a 0: Serial.println("for (int i = 3; i> = 0; i -)"); for(int i = 3; i> = 0; i -) {

56

Serial.println(i); }

Como las otras partes del bucle for, la expresión iterator puede ser dejada en blanco (siempre debe tener la dos punto y coma separando la tres partes incluso si estas están en blanco). Esta versión sólo incrementa i cuando una entrada de un pin es alta. El bucle for no cambia el valor de i; lo es sólo cambiado por la declaración if después de Serial.print usted necesitará definir inPin y configurar este como INPUT con pinMode (): Serial.println("for (int i = 0; i <4;)"); for(int i = 0; i <4;) { Serial.println(i); if(digitalRead (inPin) == HIGH) { i++; // sólo incrementar el valor de i si la entrada es alta } }

Véase También La referencia de Arduino para la declaración for: http://www.arduino.cc/en/Reference/For

2.15 Saliendo de un Bucle Problema Usted quiere terminar un bucle antes basado en algunas condición que usted esté probando.

Solución Use el siguiente código: while (analogRead (sensorPin)> 100) { if (digitalRead (switchPin) == HIGH) { break; // salir del bucle, si se pulsa el interruptor } flashLED (); / llamar a una función para encender y apagar el LED }

Discusión Este código es similar a la uno usando el bucle while, pero usa la declaración break para salir del bucle si un pin digital cambia a alto. Por ejemplo, si un interruptor es conectado en la pin como se muestra en la Receta 5.1, el bucle saldrá y la LED dejará de parpadear incluso si la condición en el bucle while es verdadera.

57

Véase también La referencia Arduino para la declaración break: http://www.arduino.cc/en/Reference/Break

2.16 Tomando una Variedad de Acciones Basadas en una Sola Variable Problema Usted necesita hacer diferentes cosas dependiendo de algunos valores. Usted podría utilizar múltiples declaraciones if y else, pero el código pronto se vuelve complejo y difícil de entender o modificar. Además, usted puede querer probar para un rango de valores.

Solución La declaración switch sirve para seleccionar de un número de alternativas. Lo es funcionalmente similar a multiples declaraciones if / else pero es más concisa: / * * Sketch SwitchCase * Ejemplo mostrando la sentencia switch conectando caracteres desde el puerto serial * Enviando el carácter 1 parpadea el LED una sola vez, el enviando el 2 parpadea dos veces * Enviando + enciende el LED, el enviando - lo apaga * Cualquier otro carácter imprime un mensaje en el Monitor Serial * / int const ledPin = 13 // el Led está conectado al pin 13 void setup () { Serial.begin (9600); // Inicializa el puerto serie para enviar y // Recibir a 9600 baudios pinMode (ledPin, OUTPUT); } void loop () { if(Serial.available ()) // Comprueba si al menos un caracter // está disponible { char ch = Serial.read (); switch (ch) { case '1': blink (); break; case '2': blink (); blink (); break; case '+': digitalWrite(ledPin, HIGH); break;

58

case '-': digitalWrite (ledPin, LOW); break; default: Serial.print(ch); Serial.println("fue recibido, pero no esperado"); break; } } } void blink () { digitalWrite(ledPin, HIGH); delay (500); digitalWrite(ledPin, LOW); delay (500); }

Discusión La declaración switch evalúa la variable ch recibida desde el puerto serial y ramifica a la etiqueta que coincide con su valor. La etiquetas necesariamente deben ser constantes numéricas(Se puede utilizar strings en una declaración case) y dos etiquetas no pueden tener el mismo valor. Si no tiene una declaración break seguida a cada expresión, la ejecución fracasará en la declaración: case '1': blink (); // sin declaración break antes de la próxima etiqueta case '2': blink(); // case '1'seguirá aquí blink (); break; // la declaración break saldrá de la expresión switch

Si la declaración break al final de case '1': fue eliminado (Como muestra en el código anterior), cuando ch es igual al caracter 1 la función blink será llamada tres veces. Olidar accidentalmente el break es un error común. Dejar intencionalmente fuera el break es a veces muy útil; esto puede confundir a otros leyendo su código, así es una buena práctica aclarar indicando su intenciones con comentarios en el código. Si su interruptor declaración es mal comportamiento, comprobar a asegurar que usted no tiene olvidados la rotura declaraciones.

La etiqueta default: es usada para capturar valores que no coinciden con cualquiera de las etiquetas case. Si no hay la etiqueta default, la expresións switch no hará ninguna cosa si hay no hay coincidencia.

59

Véase también Referencia Arduino para la declaración switch y case: http://www.arduino.cc/en/Reference /SwitchCase

2.17 Comparando Caracteres y Valores Numéricos Problema Usted quiere determinar la relación entre valores.

Solución Comparar valores enteros usando los operadores relacionales mostrados en la Tabla 2-3. Tabla 2-3. Operadores de relación e igualdad Operador Prueba para

Ejemplo

==

2 == 3 // evalúa a falso

!=

2 != 3 // evalúa a verdadero

>

2 > 3 // evalúa a falso

<

2 < 3 // evalúa a verdadero

> =

2 >= 3 // evalúa a falso

<=

2 <= 3 // evalúa a verdadero

El siguiente Sketch demuestra los resultados del uso de los operadores de comparación: / * * *

* RelationalExpressions Sketch Demuestra la comparación de los valores /

int i=1; // algunos valores para empezar int j = 2; void setup () { Serial.begin (9600); } void loop(){ Serial.print("i ="); Serial.print(i); Serial.print("y j ="); Serial.println(j); if(i
60

if(i!=j) Serial.println ("i no es igual a j"); if (i == j) Serial.println("i es igual a j"); if(i> = j) Serial.println ("i es mayor o igual a j"); if(i> j) Serial.println("i es mayor que j"); Serial.println (); i = i + 1; if(i> j + 1) delay (10000); // largo retraso después de que i ya no está cerca de j }

Esta es la salida:’ i i i i

= 1 y j = 2 es menor que j es menor o igual a j no es igual a j

i i i i

= 2 y j = 2 es menor o igual a j es igual a j es mayor o igual a j

i i i i

= 3 y J = 2 no es igual a j es mayor o igual a j es mayor que j

Discusión Note que el operador igualdad es el doble signo igual , ==. Uno de los más comunes errores de programación es confundir este con la operador de asignación, que usa un solo signo igual. La siguiente expresión comparará el valor de i a 3. El programador intenciona esto: if(i == 3) / / pruena si i es igual a 3

Pero él pone esto en el Sketch: if(i = 3) // un solo signo igual utilizado por error!!

Este siempre retornará verdadero, porque i será cambiado a 3, así estos serán igual cuando se comparen.

Un consejo paraa ayudar a evitar esa trampa cuando compare las variables a constantes (valores fijados) es poner la constante en el lado izquierdo de la expresión:

61

if(3 = i) // un solo signo igual utilizado por error!!

El compilador le dirá acerca de este error porque este sabe que usted no puede asignar un diferente valor a una constante.

El mensaje de error es algo hostil "Valor necesario como operando de la izquierda de asignación ". Si usted ve este mensaje, el compilador es que le dice que usted está tratando de asignar un valor a algo que no puede ser cambiado.

Véase también La referencia Arduino para condicionales y operadores de comparación: http://www.arduino.cc/ es /Reference/If

2.18 Comparando Strings Problema Usted quiere a ver si dos strings son idénticos.

Solución Hay una función para comparar strings, llamado strcmp (abreviatura string compare). Aquí está un fragmento que muestra su uso: Char cadena1[] = "izquierda"; Char cadena2[] = "derecha"; if(strcmp(cadena1, cadena2) == 0) Serial.print ("cadenas son iguales")

Discusión strcmp retorna el valor 0 si los strings son iguales y un valor mayor que cero si el primer carácter

que no coincide tiene un valor mayor en el primer string que en el segundo. Este devuelve un valor menor que cero si el primer carácter que no coincide en el primer string es menor que en el segundo. Generalmente usted sólo quiere saber si ellos son iguales, y aunque la prueba para cero puede parecer no intuitiva al principio, Pronto conseguirá usarla.

62

Tenga en cuenta que strings de desigual longitud no serán evaluados como iguales incluso si el string más corto está contenida en el más largo. Por lo tanto: strcmp("left", "leftcenter") == 0) // esto evaluará como false

Usted puede comparar strings hasta a un número dado de caracteres al usar la función strncmp. Usted da a strncmp el máximo número de caracteres a comparar y dejará de comparar después de muchos caracteres: strncmp("left", "leftcenter", 4) == 0) // esto se evaluará como true

Diferentes strings de caracteres, Arduino Strings pueden ser directamente comparados de la siguiente manera: StringOne String = String ("esto"); if (stringOne == "esto") Serial.println ("esto va a ser verdad"); if (stringOne == "eso") Serial.println ("esto es falso");

Un tutorial sobre comparación Arduino String está en http://arduino.cc/en/Tutorial/StringCom parisonOperators.

Véase también Más información sobre strcmp está disponible en http://www.cplusplus.com/reference/clibrary/ cstring /strcmp /. Ver la Receta 2.5 para una introducción al Arduino String.

2.19 Realizando Comparaciones Lógicas Problema Usted quiere evaluar la relación lógica entre dos o más expresiones. Por ejemplo, usted desea tomar una diferente acción dependiente en la condiciones de una declaración if.

Solución Uso los operadores lógico como se indica en la Tabla 2-4. Tabla 2-4. Operadores Lógicos Símbolo Función && || !

Comentarios verdadero verdadero verdadera

&& || falsa

63

Discusión Los operadores lógicos retornan valores verdaderos o falsos basados en la relación lógica. La ejemplos que siguen asume que usted tiene sensores conectados a los pines digitales 2 y 3 como es discutido en el Capítulo 5. El operador lógico “AND” (&&) retornará true si sus dos operandos son verdaderos, y false de otro modo: if (digitalRead(2) && digitalRead (3)) blink(); / / parpadear si ambos pines están ALTOS

El operador lógico “Or” (||) retornará true si cualquiera de sus dos operandos son verdaderos, y false si ambos operandos son falsos: if (digitalRead (2) | | digitalRead (3)) blink (); // parpadea si cualquiera de los pines están ALTOS

El operador “Not” (!) tiene sólo un operando, cuyo valor es invertido a false si su operando es verdadero y true si su operando es falso: if(!digitalRead (2)) blink (); // parpadea si el pin no es ALTO

2.20 Realizando Operaciones lógicas booleanas Problema Usted quiere cambiar o quitar ciertos bits en un valor.

Solución Uso los operadores lógicos booleanos como se indica en la Tabla 2-5. Tabla 2-5. Operadores bit Símbolo Función &

|

Resultado

lógico booleano lógico booleano lógico

^ booleano

~

lógica booleana

Ejemplo 3 & 1 equals 1 (11 & 01 equals 01) 3 | 1 equals 3 (11 | 01 equals 11) 3 ^ 1 equals 2 11 ^ 01

10

~1 equals 254 (~00000001 equals 11111110)

64

Aquí hay un Sketch que demuestra los valores ejemplo mostrados en la Tabla 2-5: / * * bits Sketch * Demuestra operadores lógicos booleanos * / void setup () { Serial.begin (9600); } void loop () { Serial.print ("3 & 1 iguales"); / / AND lógico booleano 3 y 1 Serial.print (3 & 1); // imprimir el resultado Serial.print ("decimal o en binario:"); Serial.println (3 & 1, BIN); // imprime la representación binaria del resultado Serial.print ("3 | 1 iguales"); // OR lógico booleano 3 o 1 Serial.print (3 | 1); Serial.print ("decimal o en binario:"); Serial.println (3 | 1, BIN); // imprime la representación binaria del resultado Serial.print ("3 ^ 1 iguales"); // OR exclusivo lógico booleano o 3 o 1 Serial.print (3 ^ 1); Serial.print ("decimal o en binario:"); Serial.println (3 ^ 1, BIN); // imprime la representación binaria del resultado byte de byteVal = 1; int intval = 1; byteVal = ~byteVal // negacion lógica booleana intval = ~ intval; Serial.print("~ byteVal (1) es igual a"); //negacion lógica booleana de un valor de 8 bits Serial.println(byteVal, BIN); // imprime la representación binaria del resultado Serial.print("~ intval (1) es igual a "); //negacion lógica booleana un valor de 16 bits Serial.println(intval, BIN); // imprime la representación binaria del resultado delay (10000); }

Este es desplegado en el Monitor Serial: 3 & 1 es igual a 1 decimal o en binario: 1 3 | 1 es igual a 3 decimal o en binario: 11 3 ^ 1 es igual a 2 decimal o en binario: 10 ~byteVal(1) es igual a 11111110 ~intval(1) es igual a 11111111111111111111111111111110

Discusión Operadores lógicos booleano son usados para configurar o probar Bits. Cuando usted usa "AND" o "OR" en dos valores, el operador funciona en individualmente en cada bit. Es fácil ver cómo este funciona buscando la representación binaria de los valores.

65

El decimal 3 es en binario 00000011, y el decimal 1 es 00000001. El AND lógico booleano opera en cada bit. Los bits más a la derecha son ambos 1, así la resultado de AND es 1. Moviendo a la izquierda, los próximos bits son 1 y 0; AND resulta estos en 0. Todos los bits restantes son 0, así el resultado lógico booleano de estos será 0. En otras palabras, para cada posición de bit donde hay un 1 en ambos lugares, la resultado tendrá un 1; de lo contrario, lo tendrá un 0. Así, 11 & 01 es igual a 1. Las Tablas 2-6, 2-7, y 2-8 deberían ayudarle a aclarar los valores lógicos booleano AND, OR y OR exclusivo.

Tabla 2-6. AND lógico booleano Bit1

Bit2

Bit1 and Bit2

Tabla 2-7. OR lógico booleano Bit1

Bit2

Bit1 or Bit2

Tabla 2-8. Or exclusivo lógico booleano Bit1

Bit2

Bit1 ^ Bit2

Todas las expresiones lógicas booleanas funcionan en dos valores, excepto para el operador negación. Este simplemente invierte cada bit, así 0 se convierte en 1 y 1 se convierte en 0. En el ejemplo, el valor byte (8 bits) 00000001 se convierte en 11111110. El valor int tiene 16 bits, así que cuando cada uno es invertido, el resultado es 15 unos seguidos por un solo cero.

Véase también La referencia Arduino para los operadores lógicos booleanos AND, OR, y OR Exclusivo: http://www.arduino.cc /es/Reference /bit a bit

66

2.21 Combinando Asignación

Operaciones

y

Problema Usted quiere a entender y utilizar operadores compuestos. No es raro a ver código publicado que usa expresiones que hacen más de una cosa en una sola declaración. Usted quiere entender a + = b, a >> = b, y a & = b.

Solución La Tabla 2-9 muestra los operadores compuestos de asignación y su equivalente completa expresión. Tabla 2-9.Operadores compuestos Operador Ejemplo

Expresión equivalente

+ =

valor + = 5;

valor = valor + 5; // añade 5 al valor

- =

valor - = 4;

valor = valor - 4; // sustrae 4 desde valor

* =

valor * = 3;

valor = valor * 3; // multiplica el valor por 3

/ =

valor / = 2;

valor = valor / 2; // divide el valor por 2

>> =

valor >> = 2;

valor = valor >> 2; // desplaza el valor dos lugares a la derecha

<< =

valor << = 2;

valor = valor << 2; // desplaza el valor dos lugares a la izquierda

Y =

enmascarar & = 2; enmascarar = enmascarar & 2; // AND binario enmascarar con 2

| =

enmascarar | = 2; enmascarar = enmascarar | 2; // OR binario enmascarar con 2

Discusión Estas declaraciones compuestas no son más eficiente en tiempo de ejecución que la expresión complete equivalente, y si usted es nuevo programando, use la expresión completa ya que es más clara. Codificadores Experimentados a menudo utilizan la forma más corta, por lo que es útil para reconocer las expresiones al ejecutar a través de ellas.

Véase También Ver http://www.arduino.cc/en/Reference/HomePage para un índice a las paginas de referencia para operadores compuestos.

67

CAPÍTULO 3

Usando Operadores Matemáticos

3.0 Introducción Casi cada Sketch usa operadores matemáticos paraa manipular el valor de variables. Este capítulo proporciona una breve visión de conjunto de los más comunes operadores matemáticos. Como el capítulo anterior, este resumen es ante todo para no programadores o programadores que no están familiarizados con C o C++. Para más detalles, ver uno de los libros de referencia sobre C mencionados en el Prólogo.

3.1 Sumando, Restando, Multiplicando, y Dividiendo Problema Usted quiere a realizar matemáticas simples en valores en su Sketch. Usted quiere controlar el orden en que que las operaciones son realizadas y usted puede necesitar manejar diferentes tipos de variables.

Solución Use el siguiente código: int myValue; myValue = 1 + 2 // Suma myValue = 3 - 2; // resta myValue = 3 * 2 // multiplicación myValue = 3/2; // división (el resultado es 1)

Discusión Suma, resta, y multiplicación para enteros funciona mucho como usted espera.

68

Asegúrese que su resultado no excederá el máximo tamaño de la variable de destino. Ver la Receta 2.2.

La división de tipos enteros trunca la fracción resto en la división ejemplo mostrada en esta receta de Solución; myValue será igual a 1 después de la división (Véase la Receta 2.3 si su aplicación requiere resultados fraccionarios): int valor = 1 + 2 * 3 + 4;

Declaraciones compuestas, tal como la declaración anterior, puede aparecer ambigua, pero la prioridad (Orden) de cada operador está bien definida. La multiplicación y división tienen una mayor prioridad que la suma y resta, así el resultado será 11. Es aconsejable utilizar parentesis en su código para hacer clara la prioridad de cálculo deseada. int valor = 1 + (2 * 3) + 4; produce el mismo resultado pero es fácil de leer. Use paréntesis si usted necesita alterar la prioridad, como en este ejemplo: int valor = ((1 + 2) * 3) + 4;

El resultado será 13. La expresión en el interior de los paréntesis es calculada primero, así 1 es sumado a 2, este entonces es multiplicado por 3, y finalmente, se suma 4, resultando 13.

Véase también Receta 2.2; Receta 2.3

3.2 Incrementando y Disminuyendo Valores Problema Usted quiere aumentar o disminuir el valor de una variable.

Solución Use el siguiente código: int myValue = 0; miValor = miValor + 1; // esto suma uno a la variable miValor miValor + = 1; // Esto hace lo mismo que lo anterior miValor = mivalor – 1; // esto resta uno de la miValor miValor - = 1; // Esto hace lo mismo que lo anterior miValor = mivalor + 5; // esto añade cinco a la variable miValor miValor + = 5; // esto hace lo mismo que lo anterior

69

Discusión Incrementar y disminuir los valores de las variables es una de las tareas más comunes de programación, y la tarjeta Arduino tiene operadores para hacer esto fácil. Incrementar un valor por uno es llamado incrementing, y disminuir este por uno es llamado decrementing. La forma larga de hacer esto es de la siguiente manera: miValor = mivalor + 1; // esto suma uno a la variable miValor

Pero usted puede también combinar la incremento y decremento operadores con la asignar operario, como esto: myValue + = 1 / / Esto hace lo mismo que el anterior

Vea también Receta 3.1

3.3 Encontrando el Residuo Después de Dividir Dos Valores Problema Usted quiere encontrar el residuo después de dividir dos valores.

Solución Use el símbolo % (el operador módulo) para obtener el residuo: int miValor0 = 20%10; // obtener el módulo(residuo) de 20 dividido para 10 int miValor1 = 21%10; // obtener el módulo (residuo) de 21 dividido para 10

miValor0 es igual a 0 (20 dividido para 10 tiene un residuo de 0). miValor1 es igual a 1 (21

dividido para 10 tiene un residuo de 1).

Discusión El operador módulo es sorprendentemente útil, particularmente cuando usted quiere ver si un valor es un múltiplo de un número. Por ejemplo, el código en esta receta de Solución puede ser mejorado para detectar cuando un valor es un múltiplo de 10: int miValor; / / ... Código aquí para fijar el valor de miValor if(miValor%10 == 0) { Serial.println ("El valor es un múltiplo de 10"); }

El código anterior toma el módulo de la variable miValor y compara el resultado a cero (Ver receta 2.1 7). Si la resultado es cero, un mensaje es impreso diciendo el valor es un múltiplo de 10.

70

Aquí hay un ejemplo similar, pero usando 2 con el operador módulo, la resultado puede utilizarse para comprobar si un valor es par o impar: int miValor; / / ... Código aquí para fijar el valor de miValor if(miValor%2 == 0) { Serial.println ("El valor es par"); } else { Serial.println ("El valor es impar"); }

Este ejemplo calcula la hora en un reloj de 24 horas para cualquier número dado de hora offset: void printOffsetHour (int hourNow, int offsetHours) { Serial.println ((hourNow + offsetHours)% 24); } void printOffsetHour (int hourNow, int offsetHours) { Serial.println ((hourNow + offsetHours)% 24); }

Ver También La referencia Arduino para % (El operador módulo): http://www.arduino.cc/en/Reference/Modulo

3.4 Determinando Absoluto

el

Valor

Problema Usted quiere conseguir el valor absoluto de un número.

Solución abs(x) calcula el valor absoluto de x. El siguiente ejemplo toma el valor absoluto de la diferencia

entre lecturas en dos puertos de entrada analógicos analogRead()):

(Véase el Capítulo 5 para más sobre

int x = analogRead (0); int y = analogRead (1); if (abs(x)> 10) { Serial.println ("Los valores analógicos difieren en más de 10"); }

71

Discusión abs(x-y); retorna el valor absoluto de la diferencia entre x e y. Esto es usado para valores enteros (y enteroslargos). Para retornar el valor absoluto de valores de punto flotante, consulte la Receta

2.3.

Véase también La referencia Arduino para abs: http://www.arduino.cc/en/Reference/Abs

3.5 Limitando un Número a un Rango de Valores Problema Usted quiere asegurar que un valor esté siempre dentro algún limite inferior y superior.

Solución constrain(x, min, máx) retorna un valor que está dentro los límites de min y max: myConstrainedValue = constrain(myValue, 100, 200);

Discusión myConstrainedValue es cambiado a un valor que siempre será mayor o igual a 100 y menor que o igual a 200. Si myValue es menos]r que 100, el resultado será 100; si este es myor que 200, este

será cambiado a 200. La Tabla 3-1 muestra algunos ejemplos de valores de salida usando un min de 100 y un max de 200. Tabla 3-1. Salida desde constreñir con min = 100 y max = 200 myValue (el valor de entrada)

constrain(myValue, 100, 200)

Véase también Receta 3.6

72

3.6 Encontrando el Mínimo o Máximo de Algunos Valores Problema Usted quiere encontrar el mínimo o máximo de dos o más valores.

Solución min(x, y) retorna el menor de dos números. max(x, y) retorna el mayor de dos números:

myValue = analogRead (0); myMinValue = min (myValue, 200); // myMinValue será el más pequeño de los // MyVal o 200 myMaxValue = máx (myValue, 100); // myMaxValue será el más grande de los // MyVal o 100

Discusión La Tabla 3-2 muestra algunos ejemplo de valores de salida usando un min de 200. La tabla muestra que el salida es la mismo como la entrada (myValue) hasta que el valor se convierte en mayor que 200. Tabla 3-2. Salida desde min(myValue, 200) myValue (el valore de entrada) min (myValue, 200)

La Tabla 3-3 muestra la salida usando un max de 100. La tabla muestra que la salida es la mismo que la entrada (myValue) cuando el valor es mayor o igual a 100. Tabla 3-3. Salida desde max(myValue, 100) myValue (el valor de entrada) max(myValue, 100)

73

Use min cuando usted quiera limitar el límite superior. Esto puede ser contrario a la intuición, pero al retornar el valor menor de la entrada y el valor mínimo, la salida desde min nunca será mayor que el valor mínimo (200 en el ejemplo). Del mismo modo, utilizar max para limitar el límite inferior. La salida desde max voluntad nunca será menor que el máximo valor (100 en el ejemplo). Si quiere encontrar el min o max de más que dos valores, usted puede poner los valores en cascada de la siguiente manera: // myMinValue será el menor de las tres lecturas analógicas: int myMinValue = min(analogRead(0), min(analogRead (1), analogRead (2)));

En este ejemplo, el valor mínimo valor se encuentra en los puertos analógicos 1 y 2, y luego el mínimo de eso y el puerto 0. Esto puede ser ampliado para tantos ítems como usted necesite, pero tenga cuidado al ubicar los paréntesis correctamente. EL siguiente ejemplo obtiene el máximo de cuatro valores: int myMaxValue = máx (analogRead (0), máximo (analogRead (1), max (analogRead (2), analogRead (3))));

Véase también Receta 3.5

3.7 Elevando un Número a una Potencia Problema Usted quiere elevar un número a una potencia.

Solución pow(x, y) retorna el valor de x elevado a la potencia y: miValor = pow(3,2);

Este calcula 3 2, así miValor será igual a 9.

Discusión La función pow puede funcionar en enteros o valores de punto flotante y este retorna el resultado como un valor de punto flotante: Serial.print(pow (3,2)) / / esto imprime 9.00 int z = pow (3,2); Serial.println (z) / / esto imprime 9

La primera salida es 9.00 y la segundo es 9; estos son no exactamente lo mismo porque la primera impresión visualiza la salida como un número de punto flotante número y la segunda trata el valor como un entero antes la impresión, y por lo tanto se visualiza sin el punto decimal.

74

Si usted utiliza la función pow , usted podria querer leer la Receta 2.3 para entender la diferencia entre estos y valores enteros. Aquí hay un ejemplo de potencia elevada a un número a un fraccionario: float s = pow(2, 1,0 / 12) // la duodécima raíz de dos

La duodécima raíz de dos es la misma como 2 a la potencia de 0.083333. El valor resultante, s, es 1.05946 (Este es el radio de la frecuencia de dos notas adyacentes en un piano).

3.8 Sacando Cuadrada

la

Raíz

Problema Usted quiere calcular la raíz cuadrada de un número.

Solución La función sqrt(x) retorna la raíz cuadrada de x: Serial.print (sqrt (9)); // esto imprime 3.00

Discusión La función sqrt retorna un número de punto flotante (Véase la función pow discutida en la Receta 3.7).

3.9 Redondeando Números de Punto Flotante Problema Usted quiere el próximo valor entero mayor o menor, de un número de punto flotante (floor o ceil).

Solución floor(x) retorna el anterior valor entero que no es mayor que x. ceil(x) retorna el valor proximo entero que no es menor que x.

Discusión Estas funciones son usadas para redondear números de punto flotante; utilice floor (x) para conseguir el anterior entero que no sea mayor que x. Utilice ceil para conseguir el proximo entero que sea mayor que x. Aquí hay algunos ejemplos de salidas usando floor: Serial.println(floor (1)) // esto imprime 1.00 Serial.println(floor (1,1)) // esto imprime 1.00

75

Serial.println(floor(0)) // esto imprime 0.00 Serial.println(floor(0,1)) // esto imprime 0.00 Serial.println(floor(-1)) // esto imprime -1.00 Serial.println(floor(-1,1)) // esto imprime -2.00

Aquí hay algunos ejemplos de salidas usando ceil: Serial.println(ceil Serial.println(ceil Serial.println(ceil Serial.println(ceil Serial.println(ceil Serial.println(ceil

(1)); (1.1)); (0)); (0.1)); (-1)); (-1,1));

// // // // // //

esto esto esto esto esto esto

imprime 1.00 imprime 2.00 imprime 0,00 imprime 1.00 imprime -1:00 imprime -1:00

Usted redondear al entero más cercano de la siguiente manera: if(floatValue> 0,0) result = floor(floatValue + 0,5); else result = ceil(num - 0.5);

Usted puede truncar un número de punto flotante número por casting (Conversión) a un int, pero este hace no redondea correctamente. Números negativos tal como -1,9 debe redondearse a -2, pero cuando cambia a un int este es redondeado hasta -1. El mismo problema existe con números positivos: 1.9 debería redondearse a 2 pero se redondea a 1. Use floor y ceil para conseguir resultados correctos.

3.10 Usando Funciones Trigonométricas Problema Usted quiere conseguir el seno, coseno, o tangente de un ángulo dado en radianes o grados.

Solución sin(x) retorna el seno del ángulo x. cos(x) retorna el coseno del ángulo x. tan(x) retorna la tangente del ángulo x.

Discusión Los ángulos son especificados en radianes y el resultado es un número de punto flotante (Véase la Receta 2.3). El siguiente ejemplo ilustra las funciones trigonométricas:

float grados = 30 // ángulo en grados float rad = grados * PI/180 // convertir a radianes Serial.println(rad); // imprimir los radianes Serial.println(sin (rad)); // imprime el seno Serial.println(cos (rad)); // imprime el coseno

76

Este convierte los ángulo en radianes e imprime el seno y coseno. Aquí está la salida con anotaciones añadidas: 0.52 30 grados es 0.5235988 radianes, imprimiendo sólo se muestra dos decimales 0.50 seno de 30 grados es 0.5000000, aparece aquí con dos decimales 0.87 coseno es 0,8660254, que se redondea hasta 0,87

Aunque el Sketch calcula estos valores usando la completa precisión de números de punto flotante, la rutina Serial.print muestra los números de punto flotante con dos lugares decimales. La conversión desde radianes a grados y viceversa es material de trigonometría. PI es la familiar constante para π (3.14159265 ...). PI y 180 son ambas constantes, y Arduino proporciona algunos constantes precalculadas que usted puede utilizar para realizar conversiones grados/radianes: rad = deg*DEG_TO_RAD // una forma de convertir grados a radianes deg = rad*RAD_TO_DEG // una forma de convertir radianes a grados

Usar grados * DEG_TO_RAD luce más eficiente que grados*PI/180, pero no lo es, ya que el compilador Arduino compilador es suficientemente inteligente para reconocer que PI/180 es una constante (el que nunca cambiará), así este sustituye el resultado de dividir PI para 180, que pasará a ser el mismo valor de la constante DEG_TO_RAD (0,017453292519 ...). Use cualquiera enfoque que usted prefiera.

Vea también Las referencias Arduino para sin ( http://www.arduino.cc/en/Reference/Sin), cos ( http://ardui no.cc / es / Referencia / Cos), y tan ( http://arduino.cc/en/Reference/Tan)

3.11 Generando Números Aleatorios Problema Usted quiere conseguir un número aleatorio, cualquiera dentro del rango que va desde cero hasta a un máximo especificado o restringido entre un mínimo y máximo valor que usted proporcione.

Solución Use la función random para retornar un número aleatorio. Llamar random con un solo parámetro configura el límite superior; el valor devuelto estará en el rango de cero a un valor menor que el límite superior: random(max) // devuelve un número aleatorio entre 0 y max -1

Llamando azar con dos parámetros conjuntos la inferior y superior límites; la valores regresado oscilará desde la inferior unida (inclusive) a uno menos que la superior dependiente: aleatorio (min, max); / / devuelve un número aleatorio entre min y max -1

77