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 “El conjunto de

¿Desea crear dispositivos que interactúen con el mundo físico? Este recetas de Michael es
libro es perfecto para cualquiera quien desee experimentar con el un buen regalo para
popular microcontrolador Arduino y su entorno de programación. la creciente
Usted encontrará más de 200 consejos y técnicas para construir una
variedad de objetos y prototipos como juguetes, detectores, robots y comunidad de
ropa interactiva que puede sentir y responder al tacto, sonido, Arduino. Cualquiera
posición, calor, y luz. que sea su
Usted no necesita experiencia con Arduino o programación para
conocimiento o
iniciar. Actualizado para Arduino 1.0 liberado, las recetas en esta habilidad, el libro
segunda edición incluyen ejemplos prácticos y orientación para provee soluciones
ayudarle a empezar, expandir, y mejorar sus proyectos
para ese proyecto con
inmediatamente ya sea usted un artista, diseñador, aficionado,
estudiante o ingeniero. el que está luchando
hoy en día y estímulo
• Ponerse al día rápidamente sobre la placa Arduino y para imaginar lo que
conceptos esenciales de software construirá mañana.
• Aprender técnicas básicas para lectura digital y señales
analógicas
Dudo que alguna vez
• Usar Arduino con una variedad de populares dispositivos dejaré mi mesa de
de entrada y sensores trabajo”
• Controlar pantallas visuales, generar sonido, y controlar -Mikal Hart
varios tipos de motores Arduino Uno Asesor Equipo
• 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 corporate@oreilly.com.

Editores: Shawn Wallace y Brian Jepson Indexador: Lucie Haskins

Cubierta Diseñador: Karen Montgomery
Producción Editor: Teresa Elsey
Interior Diseñador: David Futato
Corrector de pruebas: Kiel Furgoneta Cuerno 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-1-
4493-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 permissions@oreilly.com.

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:
bookquestions@oreilly.com
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 compatibles con Arduino está disponible en
http://www.freeduino.org/.

Vea también
Una visión de conjunto de tarjetas Arduino:
http://www.arduino.cc/en/Main/Hardware.
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 ino-
compatible.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<nn> (Donde <nn> 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 la tarjeta
Arduino
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; // conectar el sensor a la entrada analógica
0

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 Bytes Rango Uso

Numéricos
int
unsigned int int.
long

Unsigned long

float

double float double float

boolean falso verdadero

char

byte char,
Otros tipos Uso
String Representa cadenas de chars (Caracteres) normalmente se utiliza para contener texto
void 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 y b es pequeña

// Cambia el valor de DELTA a la diferencia máxima considerada para ser
igualad booleana almostEqual(float a, float b)
{
float const DELTA = .0001 / / m{axima diferencia para ser casi casi
igual
if (a == 0) return fabs(b) <= DELTA;
if (b == 0) return fabs(a) <= DELTA;
returns fabs((a - b) / max(fabs(a), fabs(b))) <= 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 de este Sketch es de la siguiente
manera:
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 <PIN_COUNT; index++)

pinMode (inputPins[index], INPUT);

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) Retorna el n-ésimo caracter del string

compareTo(S2) Compara el String al String dado S2
concat(S2) Retorna un nuevo String que es la combinación del String y S2
endsWith(S2) Retorna true si el String termina con los caracteres S2
equals(S2) Retorna true si el String es exactamente S2 (mayúsculas y minusculas)
equalsIgnoreCase(S2) Lo mismo que equals pero sin coincidir mayúsculas y minúsculas
getBytes(buffer,len) Copia tamaño de caracteres en el suministrado byte buffer
indexOf(S) Retorna el índice del String (o caracter)suminitrado o 1 si no es encontrado
lastIndexOf(S) Lo mismo que indexOf inicia desde el final del String
length() Retorna el número de caracteres en el String
replace(A,B) Reemplaza todas las instancia del String (o carácter) A con las de B
setCharAt(indice,c) Almacena el carácter c en el String en el índice dado
startsWith(S2) Retorna true si el String inicia con los caracteres S2
substring(indice) Retorna un String con los caracteres a partir del indice hasta el final del string
substring(indice,a) Como el anterior, pero el substring termina en la ubicación del carácter antes de
“a”
toCharArray(buffer,len) Copia hasta len los caracteres al buffer suministrado
toInt() Retorna el valor entero de los dígitos numéricos en el String
toLowerCase() Retorna un String con todos los caracteres convertidos a minúsculas
toUpperCase() Retorna un String con todos los caracteres convertidos a mayúsculas
trim() 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/avr-
libc/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 (13, HIGH); // encender el LED
delay (500); // esperar 500 milisegundos
digitalWrite (13, LOW); // apagar el LED
delay (500); // 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 las funciones Arduino:
http://www.arduino.cc/en/Reference/FunctionDe claration

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 <j)
Serial.println("i es menor que j");
if (i <= j)
Serial.println("i es menor o igual a j");

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 = 1 y j = 2
i es menor que j
i es menor o igual a j
i no es igual a j

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

i = 3 y J = 2
i no es igual a j
i es mayor o igual a j
i 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 Ejemplo
& lógico 3 & 1 equals 1
booleano
(11 & 01 equals 01)
3 | 1 equals 3
| lógico
booleano (11 | 01 equals 11)
3 ^ 1 equals 2
^ lógico
booleano 11 ^ 01 10
~1 equals 254
~ lógica
booleana (~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 Operaciones y
Asignación
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 el Valor

Absoluto
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 (Véase el Capítulo 5 para más sobre
analogRead()):

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 la Raíz

Cuadrada
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 (1)); // esto imprime 1.00
Serial.println(ceil (1.1)); // esto imprime 2.00
Serial.println(ceil (0)); // esto imprime 0,00
Serial.println(ceil (0.1)); // esto imprime 1.00
Serial.println(ceil (-1)); // esto imprime -1:00
Serial.println(ceil (-1,1)); // esto 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