Capítulo 3

Proyecto Arduino

Para hablar de este tema, traduciremos y complementaremos la información suministrada en la página

web oficial del proyecto Arduino, www.arduino.cc, sin alterar en ningún momento la información, solo
complementando en los casos que amerite

¿Qué es el Arduino?
Arduino es una plataforma electrónica de código abierto basada en hardware y software fácil de usar. Las
placas Arduino pueden leer entradas (luz en un sensor, un dedo en un botón o un mensaje de Twitter) y
convertirlo en una salida: activar un motor, encender un LED, publicar algo en línea. Puede decirle a su
placa qué hacer enviando un conjunto de instrucciones al microcontrolador de la placa. Para hacerlo,
utiliza el lenguaje de Programación Arduino (basado en el lenguaje Wiring, el cual es un marco de
Programación de código abierto para microcontroladores) y el software Arduino (IDE), basado en
Processing (Processing es un cuaderno de proyectos de software flexible y un lenguaje para aprender a
codificar dentro del contexto de las artes visuales).

Con los años, Arduino ha sido el cerebro de miles de proyectos, desde objetos cotidianos hasta
instrumentos científicos complejos. Una comunidad mundial de creadores (estudiantes, aficionados,
artistas, Programadores y profesionales) se ha reunido en torno a esta plataforma de código abierto, sus
contribuciones se han sumado a una increíble cantidad de conocimiento accesible que puede ser de gran
ayuda para principiantes y expertos por igual.

Arduino nació en el Instituto de Diseño de Interacción Ivrea como una herramienta fácil para la creación
rápida de prototipos, dirigida a estudiantes sin experiencia en electrónica y Programación. Tan pronto
como llegó a una comunidad más amplia, la placa Arduino comenzó a cambiar para adaptarse a las nuevas
necesidades y desafíos, diferenciando su oferta de placas simples de 8 bits a productos para aplicaciones
IoT (Internet of Thing, Internet de las cosas), dispositivos portátiles, impresión 3D y entornos integrados.
Todas las placas Arduino son completamente de código abierto, lo que permite a los usuarios construirlas
de forma independiente y eventualmente adaptarlas a sus necesidades particulares. El software también
es de código abierto y está creciendo a través de las contribuciones de los usuarios de todo el mundo.

¿Por qué Arduino?

Gracias a su experiencia de usuario sencilla y accesible, Arduino se ha utilizado en miles de proyectos y
aplicaciones diferentes. El software Arduino es fácil de usar para principiantes, pero lo suficientemente
 Proyecto Arduino | 10

flexible para usuarios avanzados. Se ejecuta en Mac, Windows y Linux. Los maestros y los estudiantes lo
usan para construir instrumentos científicos de bajo costo, para probar los principios de la química y la
física, o para comenzar con la Programación y la robótica. Diseñadores y arquitectos construyen
prototipos interactivos, músicos y artistas lo utilizan para instalaciones y para experimentar con nuevos
instrumentos musicales. Los creadores, por supuesto, lo usan para construir muchos de los proyectos
exhibidos en la Feria de Maker, por ejemplo. Arduino es una herramienta clave para aprender cosas
nuevas. Cualquiera, niños, aficionados, artistas,Programadores, puede comenzar a jugar siguiendo las
instrucciones paso a paso de un kit o compartiendo ideas en línea con otros miembros de la comunidad
Arduino.

Hay muchos otros microcontroladores y plataformas de microcontroladores disponibles para la

computación física. Parallax Basic Stamp, Netmedia's BX-24, Phidgets, MIT's Handyboard y muchos otros
ofrecen una funcionalidad similar. Todas estas herramientas toman los detalles desordenados de la
Programación del microcontrolador y lo envuelven en un paquete fácil de usar. Arduino también simplifica
el proceso de trabajar con microcontroladores, pero ofrece alguna ventaja para maestros, estudiantes y
aficionados interesados sobre otros sistemas:

• Económico: las placas Arduino son relativamente baratas en comparación con otras plataformas de
microcontroladores. La versión menos costosa del módulo Arduino se puede ensamblar a mano, e
incluso los módulos Arduino pre ensamblados cuestan menos de $ 50
• Multiplataforma: el software Arduino (IDE) se ejecuta en los sistemas operativos Windows,
Macintosh OSX y Linux. La mayoría de los sistemas de microcontroladores están limitados a Windows.
• Entorno de Programación simple y claro: el software Arduino (IDE) es fácil de usar para principiantes,
pero lo suficientemente flexible como para que los usuarios avanzados también lo aprovechen. Para
los maestros, está convenientemente basado en el entorno de Programación de procesamiento, por
lo que los estudiantes que aprenden a proyector en ese entorno estarán familiarizados con el
funcionamiento del IDE de Arduino.
• Software de código abierto y extensible: el software Arduino se publica como herramientas de código
abierto, disponibles para su extensión porProgramadores experimentados. El lenguaje se puede
ampliar a través de las Librerías de C ++, y las personas que deseen comprender los detalles técnicos
pueden dar el salto de Arduino al lenguaje de Programación AVR C en el que se basa. Del mismo
modo, puede agregar el código AVR-C directamente en sus proyectos Arduino si lo desea.
• Hardware de código abierto y extensible: los planos de las placas Arduino se publican bajo una
licencia Creative Commons, por lo que los diseñadores de circuitos experimentados pueden hacer su
propia versión del módulo, extenderlo y mejorarlo. Incluso los usuarios relativamente inexpertos
pueden crear la versión del módulo de prueba para comprender cómo funciona y ahorrar dinero.

Comenzando con los productos Arduino

¡BIENVENIDO A ARDUINO! ANTES DE COMENZAR A CONTROLAR EL MUNDO ALREDEDOR DE USTED,
NECESITARÁ CONFIGURAR EL SOFTWARE PARA PROYECTOR SU PLACA

El software Arduino (IDE) le permite escribir proyectos y subirlos a su pizarra. En la página del software
Arduino encontrarás dos opciones:
 Proyecto Arduino | 11

1. Si tiene una conexión a Internet confiable, debe usar el IDE en línea (Arduino Web Editor). Le
permitirá guardar sus proyectos en la nube, tenerlos disponibles desde cualquier dispositivo y hacer
una copia de seguridad. Siempre tendrá la versión más actualizada del IDE sin la necesidad de instalar
actualizaciones o Librerías generadas por la comunidad.
2. Si prefiere trabajar sin conexión, debe usar la última versión del IDE de escritorio.

Instale el IDE de escritorio Arduino

Para obtener instrucciones paso a paso, seleccione uno de los siguientes enlaces según su sistema
operativo.

• Windows (https://www.arduino.cc/en/Guide/Windows)
• Mac OS X (https://www.arduino.cc/en/Guide/MacOSX)
• Linux (https://www.arduino.cc/en/Guide/Linux)
• IDE portátil (Windows y Linux) (https://www.arduino.cc/en/Guide/PortableIDE)

Instale el software Arduino (IDE) en PC con Windows

Descargue el software Arduino (IDE)

Obtenga la última versión de la página de descarga. Puede elegir entre el instalador (.exe) y los paquetes
Zip. Sugerimos que use el primero que instale directamente todo lo que necesita para usar el Software
Arduino (IDE), incluidos los controladores. Con el paquete Zip necesitas instalar los controladores
manualmente. El archivo Zip también es útil si desea crear una instalación portátil.

Cuando finalice la descarga, continúe con la instalación y permita el proceso de instalación del controlador
cuando reciba una advertencia del sistema operativo.

Elija los componentes para instalar

 Proyecto Arduino | 12

Elija el directorio de instalación (le sugerimos que mantenga el predeterminado)

El proceso extraerá e instalará todos los archivos necesarios para ejecutar correctamente el software
Arduino (IDE)

Proceda con las instrucciones específicas de la Placa

Cuando el software Arduino (IDE) está instalado correctamente, puede volver a la página de inicio y elegir
su placa de la lista a la derecha de la página.

Instale el software Arduino (IDE) en OS X

Descargue el software Arduino (IDE)
 Proyecto Arduino | 13

Obtenga la última versión de la página de descarga. El archivo está en formato Zip; Si usa Safari, se
expandirá automáticamente. Si usa un navegador diferente, es posible que deba extraerlo manualmente.

Copie la aplicación Arduino en la carpeta Aplicaciones (o en otra parte de su computadora).

Proceda con las instrucciones específicas de la placa

Cuando el software Arduino (IDE) está instalado correctamente, puede volver a la página de inicio y elegir
su placa de la lista a la derecha de la página.
 Proyecto Arduino | 14

Instale el software Arduino (IDE) en Linux

Inicio rápido

La compilación de Linux del software Arduino (IDE) ahora es un paquete que no requiere ningún
procedimiento específico para las diversas distribuciones disponibles de Linux. La única información
relevante es la versión de 32 o 64 bits del sistema operativo.

Descargue el software Arduino (IDE)

Obtenga la última versión de la página de descarga. Puede elegir entre las versiones 32, 64 y ARM. Es muy
importante que elija la versión correcta para su distribución de Linux. Al hacer clic en la versión elegida,
accederá a la página de donación y luego podrá abrir o guardar el archivo. Por favor guárdelo en su
computadora.

Extrae el paquete

El archivo está comprimido y debe extraerlo en una carpeta adecuada, recordando que se ejecutará desde
allí.
 Proyecto Arduino | 15

Ejecute el script de instalación

Abra la carpeta arduino-1.6.x que acaba de crear el proceso de extracción y detecte el archivo install.sh.
Haga clic derecho sobre él y elija Ejecutar en terminal en el menú contextual. El proceso de instalación
finalizará rápidamente y debería encontrar un nuevo icono en su escritorio.

Si no encuentra la opción de ejecutar el script desde el menú contextual, debe abrir una ventana de
Terminal y pasar a la carpeta arduino-1.6.x. Escriba el comando ./install.sh y espere a que finalice el
proceso. Debería encontrar un nuevo icono en su escritorio.
 Proyecto Arduino | 16

Continúe con las instrucciones específicas de la placa

Cuando el software Arduino (IDE) está instalado correctamente, puede volver a la página de inicio y elegir
su placa de la lista a la derecha de la página.

Por favor lee...

Puede suceder que cuando cargue un proyecto, después de haber seleccionado su placa y el puerto serie,
obtenga un error Error al abrir el puerto serie ... Si obtiene este error, debe configurar el permiso del
puerto serie.

Abra la Terminal y escriba:

ls -l / dev / ttyACM *

obtendrás algo como:

crw-rw ---- 1 marcación raíz 188, 0 5 abr 23.01 ttyACM0

El "0" al final de ACM puede ser un número diferente o se pueden devolver varias entradas. Los datos que
necesitamos son "marcado" (es el propietario del grupo del archivo).

Ahora solo necesitamos agregar a nuestro usuario al grupo:

sudo usermod -a -G dialout <nombre de usuario>

donde <nombre de usuario> es su nombre de usuario de Linux. Deberá cerrar sesión e iniciar sesión
nuevamente para que este cambio surta efecto.
 Proyecto Arduino | 17

Este es el procedimiento para acceder al puerto serie desde el software Arduino (IDE) si obtiene un error

Después de este procedimiento, debería poder continuar normalmente y cargar el proyecto en su placa o
usar el Monitor de serie.

Cómo crear y usar una versión portátil del software Arduino

(IDE)
¿Por qué portátil?
Casi en todas las escuelas, los estudiantes no tienen privilegios de administrador, por lo que no tienen
acceso de escritura en algunas carpetas. Esto lleva a algún problema al usar el software Arduino (IDE) ya
que sus preferencias y su cuaderno de proyectos se guardan en una de esas carpetas. Usando una versión
portátil del IDE puede superar este problema.

Otro escenario puede ser el siguiente: desea organizar un taller y necesita alguna Librería adicional o un
núcleo específico. Dado que la versión portátil almacena el cuaderno de proyectos, las Librerías y la
carpeta de hardware localmente, puede tener un punto de partida igual para todas las personas que se
unen al taller simplemente replicando la misma carpeta en todas las máquinas. Esto también es bastante
útil si por alguna razón no tiene una conexión a Internet y desea preparar todo para su proyecto sin
descargas ni demoras.

Además, una instalación portátil podría estar en un pendrive, permitiéndole llevar consigo su conjunto
personal de proyectos, núcleos y Librerías, para usar en cualquier computadora sin afectarlo con sus
archivos.

Cómo hacerlo portátil en Windows y Linux

El procedimiento consta de unos simples pasos. Puede usar un pendrive o una carpeta local en su
máquina. Una vez hecho esto, con Librerías y núcleos adicionales donde sea necesario, esa carpeta se
puede copiar en otras máquinas.

• Descargue una versión comprimida del Arduino IDE de acuerdo con su sistema operativo;
• Una vez completada la descarga, extraiga el contenido del archivo en la unidad elegida (local o pendrive);
• Abra la carpeta extraída y en su raíz cree un nuevo directorio llamado portable, junto con los demás;
 Proyecto Arduino | 18

La estructura de árbol debe ser como esta; la carpeta portátil será poblada por el Software Arduino (IDE)
según lo necesiten las Librerías, proyectos y núcleos.

Para usar esta instalación, inicie el ejecutable Arduino;

A partir de ahora, todos los proyectos, Librerías y núcleos adicionales se instalarán en la carpeta portátil.
Puede copiar toda la carpeta principal y llevarla a donde quiera: conservará todas sus preferencias,
Librerías, núcleos y proyectos.

Nota de MacOS / OS X
La instalación portátil no es oficialmente compatible con los sistemas operativos Mac de Apple por varias
razones. Uno de ellos está relacionado con la firma del paquete (firmamos el paquete Arduino IDE):
agregar cualquier contenido, como núcleos adicionales, libs y proyectos, al paquete romperá la firma. Una
consecuencia de eso es la reacción del Gatekeeper que incluso podría detener el inicio de la aplicación.
Esto está relacionado con el sistema operativo y no con nuestro IDE. De todos modos, si quieres
experimentar, puedes consultar este hilo del foro y probar por ti mismo las soluciones desarrolladas por
la comunidad.

Actualización de la instalación portátil

Si desea actualizar una instalación portátil a una versión más nueva, descargue la nueva versión en
formato comprimido y luego extraiga el contenido en una carpeta temporal. Ahora puede mover la
 Proyecto Arduino | 19

carpeta "portátil" que tiene de la instalación anterior a la nueva, o copiar todos los archivos de la nueva
versión a la anterior, sobrescribiendo todos los archivos. De cualquier manera, debe terminar con la
instalación actualizada del software Arduino portátil (IDE) con sus núcleos, Librerías y proyectos
preservados. Recuerde cambiar el nombre de la carpeta raíz con la versión de lanzamiento adecuada, si
es necesario. Siempre debe iniciar el archivo ejecutable "Arduino" desde el interior de la carpeta de su
instalación portátil para usar los proyectos, núcleos y Librerías que contiene. Si tiene otra instalación del
software Arduino (IDE) en la máquina que está utilizando, esa versión no se verá afectada. Las Librerías y
núcleos ya instalados en la máquina no serán vistos ni utilizados por la instalación portátil.

Anatomía de la placa Arduino / Genuino Uno

Las placas Arduino / Genuino detectan el entorno al recibir entradas de muchos sensores y afectan su
entorno al controlar luces, motores y otros actuadores. Las placas Arduino / Genuino son la plataforma
de desarrollo de microcontroladores que estará en el centro de sus proyectos. Al hacer algo, construirá
los circuitos e interfaces para la interacción y le dirá al microcontrolador cómo interactuar con otros
componentes. Aquí la anatomía de Arduino / Genuino Uno.

Ilustración 1.Placa Arduino UNO

1. Pines digitales Use estos pines con digitalRead(), digitalWrite() y analogWrite(). analogWrite() funciona solo en
los pines con el símbolo PWM.
2. Pin 13 LED El único actuador integrado en su placa. Además de ser un objetivo útil para su primer proyecto
de parpadeo, este LED es muy útil para la depuración.
3. LED de encendido Indica que su Genuino está recibiendo energía. Útil para la depuración.
4. Microcontrolador ATmega El corazón de su placa.
5. Entrada analógica Use estos pines con analogRead().
6. Pines GND y 5V Use estos pines para proporcionar alimentación + 5V y tierra a sus circuitos.
7. Conector de alimentación Así es como enciende su Genuino cuando no está enchufado a un puerto USB
para alimentación. Puede aceptar voltajes entre 7-12V.
8. LED TX y RX Estos LED indican la comunicación entre su Genuino y su computadora. Espere que parpadeen
rápidamente durante la carga de proyectos, así como durante la comunicación en serie. Útil para la
depuración.
9. Puerto USB Se utiliza para alimentar su Genuino Uno, cargar sus proyectos en su Genuino y para
comunicarse con su proyecto Genuino (a través de Serial. Println() etc.).
10. Botón de reinicio Reinicia el microcontrolador ATmega.

Microcontroladores
 Proyecto Arduino | 20

• Pines digitales: cómo funcionan los pines y qué significa que se configuren como entradas o salidas.
• Pines de entrada analógica: Detalles sobre la conversión de analógico a digital y otros usos de los pines.
• PWM: Cómo la función analogWrite() simula una salida analógica mediante modulación de ancho de pulso.
• Memoria: Los diversos tipos de memoria disponibles en la placa Arduino.

Pines digitales
Los pines del Arduino se pueden configurar como entradas o salidas. Este documento explica el
funcionamiento de los pines en esos modos. Mientras que el título de este documento se refiere a los
pines digitales, es importante tener en cuenta que la gran mayoría de los pines analógicos Arduino
(Atmega), pueden ser configurados, y utilizados, exactamente de la misma manera que los pines digitales.

Propiedades de los pines configurados como INPUT

Los pines Arduino (Atmega) tienen como valor predeterminado las entradas, por lo que no es necesario
que se declaren explícitamente como entradas con pinMode() cuando se utilizan como entradas. Se dice
que los pines configurados de esta manera están en un estado de alta impedancia. Los pines de entrada
hacen exigencias extremadamente pequeñas en el circuito que están tomando muestras, equivalentes a
una resistencia en serie de 100 M delante del pasador. Esto significa que se necesita muy poca corriente
para mover el pin de entrada de un estado a otro, y puede hacer que los pines sean útiles para tareas tales
como implementar un sensor táctil capacitivo, leer un LED como un fotodiodo o leer un sensor analógico
con un esquema como RCTime.

Esto también significa, sin embargo, que los pines configurados como pinMode(pin, INPUT) sin nada
conectado a ellos, o con cables conectados a ellos que no están conectados a otros circuitos, informarán
de cambios aparentemente aleatorios en el estado del pin, captarán ruido eléctrico del entorno o
acoplarán capacitivamente el estado de un pin cercano.

Resistencias pull-up con pines configurados como INPUT

A menudo es útil dirigir un pin de entrada a un estado conocido si no hay ninguna entrada presente. Esto
se puede hacer agregando una resistencia pull-up (a +5V), o una resistencia de retroceso (resistencia a
tierra) en la entrada. Una resistencia de 10K es un buen valor para una resistencia pull-up o pull-down.

Propiedades de pines configurados como INPUT_PULLUP

Hay resistencias pull-up 20K integradas en el chip Atmega a las que se puede acceder desde el software.
Se accede a estas resistencias pull-up integradas estableciendo pinMode() como INPUT_PULLUP. Esto invierte
eficazmente el comportamiento del modo INPUT, donde HIGH significa que el sensor está apagado, y LOW
significa que el sensor está encendido.

El valor de esta extracción depende del microcontrolador utilizado. En la mayoría de las placas basadas en
AVR, se garantiza que el valor esté entre 20k y 50k. En el Arduino Due, está entre 50k y 150k. Para
obtener el valor exacto, consulte la hoja de datos del microcontrolador en su placa.
 Proyecto Arduino | 21

Al conectar un sensor a un pin configurado con INPUT_PULL-UP, el otro extremo debe estar conectado a
tierra. En el caso de un simple interruptor, esto hace que el pin lea ALTO cuando el interruptor está abierto,
y BAJO cuando se presiona el interruptor.

Las resistencias pull-up proporcionan suficiente corriente para iluminar un LED conectado a un pin que se
ha configurado como entrada. Si los LED de un proyecto parecen estar funcionando, pero muy
tenuemente, esto es probablemente lo que está pasando.

Las resistencias pull-up son controladas por los mismos registros (ubicaciones internas de memoria de
chip) que controlan si un pin es ALTO o BAJO. Por lo tanto, un pin que está configurado para tener
resistencias pull-up activadas cuando el pin es un INPUT, tendrá el pin configurado como HIGH si el pin se
cambia a una SALIDA con pinMode(). Esto también funciona en la otra dirección, y un pin de salida que se
deja en un estado HIGH tendrá las resistencias pull-up establecidas si se cambia a una entrada con
pinMode().

Antes de Arduino 1.0.1, era posible configurar los pull-ups internos de la siguiente manera:
pinMode(pin, INPUT); ajuste el pin a la entrada
digitalWrite(pin, HIGH); activar las resistencias pull-up

NOTA: El pin digital 13 es más difícil de usar como entrada digital que los otros pines digitales porque tiene
un LED y una resistencia unidos a él que se ha soldado a la placa en la mayoría de las placas. Si habilita su
resistencia pull-up interna de 20k, se colgará alrededor de 1.7V en lugar de los 5V esperados porque el
LED a bordo y la resistencia de serie tiran del nivel de voltaje hacia abajo, lo que significa que siempre
devuelve LOW. Si debe utilizar el pin 13 como entrada digital, establezca su pinMode() en INPUT y utilice
una resistencia pull-down externa.

Propiedades de pines configurados como OUTPUT

Se dice que los pines configurados como OUTPUT con pinMode() están en un estado de baja impedancia.
Esto significa que pueden proporcionar una cantidad sustancial de corriente a otros circuitos. Los pines
Atmega pueden fuente (proporcionar corriente positiva) o hundirse (proporcionar corriente negativa)
hasta 40 mA (miliamperios) de corriente a otros dispositivos/circuitos. Esto es suficiente corriente para
iluminar brillantemente un LED (no olvide la resistencia de la serie), o ejecutar muchos sensores, por
ejemplo, pero no suficiente corriente para ejecutar la mayoría de los relés, solenoides o motores.

Los cortocircuitos en los pines Arduino, o intentar ejecutar dispositivos de alta corriente desde ellos,
pueden dañar o destruir los transistores de salida en el pin, o dañar todo el chip Atmega. A menudo, esto
resultará en un pin "muerto" en el microcontrolador, pero el chip restante seguirá funcionando
adecuadamente. Por esta razón es una buena idea conectar los pines OUTPUT a otros dispositivos con
resistencias de 470 o 1k, a menos que se requiera el máximo consumo de corriente de los pines para
una aplicación en particular.

Pines de entrada analógica

 Proyecto Arduino | 22

Una descripción de los pines de entrada analógica en un chip Arduino (ATmega8, ATmega168,
ATmega328P o ATmega1280).

Convertidor A/D
Los controladores ATmega utilizados para el Arduino contienen un convertidor de 6 canales (8 canales en
el Mini y Nano, 16 en el Mega) analógico a digital (A/D). El convertidor tiene una resolución de 10 bits,
devolviendo enteros de 0 a 1023. Mientras que la función principal de los pines analógicos para la mayoría
de los usuarios de Arduino es leer sensores analógicos, los pines analógicos también tienen toda la
funcionalidad de los pines de entrada/salida de propósito general (GPIO) (lo mismo que los pines digitales
0 - 13).

Por lo tanto, si un usuario necesita pines de salida de entrada de propósito más general, y todos los pines
analógicos no están en uso, los pines analógicos se pueden utilizar para GPIO.

Asignación de pines
Los pines analógicos se pueden utilizar de forma idéntica a los pines digitales, utilizando los alias A0 (para
la entrada analógica 0), A1, etc. Por ejemplo, el código tendría este aspecto para establecer el pin
analógico 0 en una salida y establecerlo EN ALTO:
pinMode(A0, OUTPUT);
digitalWrite(A0, HIGH);

Resistencias removibles
Los pines analógicos también tienen resistencias pull-up, que funcionan de manera idéntica a las
resistencias pull-up en los pines digitales. Se habilitan mediante la emisión de un comando como
pinMode(A0, INPUT_PULLUP); ajuste pull-up en el pin analógico 0
Tenga en cuenta, sin embargo, que activar una extracción afectará a los valores notificados por analogRead().

Detalles y advertencias
El comando analogRead no funcionará correctamente si un pin se ha establecido previamente en una
salida, por lo que, si este es el caso, vuelva a establecerlo en una entrada antes de usar analogRead. Del
mismo modo, si el pasador se ha establecido en HIGH como salida, se establecerá la resistencia pull-up
cuando se vuelva a conmutar a una entrada.

La hoja de datos de ATmega también advierte contra la conmutación de pines analógicos en proximidad
temporal cercana a la realización de lecturas A/D (analogRead) en otros pines analógicos. Esto puede
causar ruido eléctrico e introducir fluctuación en el sistema analógico. Puede ser deseable, después de
manipular los pines analógicos (en modo digital), añadir un breve retardo antes de usar analogRead() para
leer otros pines analógicos.

PWM
 Proyecto Arduino | 23

El ejemplo de desvanecimiento muestra el uso de la salida analógica (PWM) para difuminar un LED. Está
disponible en el menú File->Proyectobook->Examples->Analog del software Arduino.

La modulación de ancho de pulso, o PWM, es una técnica para obtener resultados analógicos con medios
digitales. El control digital se utiliza para crear una onda cuadrada, una señal conmutada entre encendido
y apagado. Este patrón de encendido/apagado puede simular voltajes entre encendido completo (5
Voltios) y apagado (0 Voltios) cambiando la parte del tiempo que la señal pasa en comparación con el
tiempo que la señal pasa a apagado. La duración de "en el tiempo" se llama el ancho del pulso. Para
obtener valores analógicos variables, cambie o modula ese ancho de pulso. Si repite este patrón de
encendido/apagado lo suficientemente rápido con un LED, por ejemplo, el resultado es como si la señal
fuera una tensión constante entre 0 y 5v controlando el brillo del LED.

En el gráfico siguiente, las líneas verdes representan un período de tiempo regular. Esta duración o
período es la inversa de la frecuencia PWM. En otras palabras, con la frecuencia PWM de Arduino a unos
500 Hz, las líneas verdes medirían 2 milisegundos cada una. Una llamada a analogWrite() está en una escala
de 0 a 255, de modo que analogWrite(255) solicita un ciclo de trabajo del 100% (siempre activado), y
analogWrite(127) es un ciclo de trabajo del 50% (en la mitad del tiempo) por ejemplo.

Ilustración 2. Pulso Modulado por ancho de pulso

Una vez que tenga este ejemplo en ejecución, tome su Arduino y sacuda de un lado a otro. Lo que está
haciendo aquí es esencialmente mapear el tiempo a través del espacio. Para nuestros ojos, el movimiento
 Proyecto Arduino | 24

desenfoca cada LED parpadea en una línea. A medida que el LED se desvanece dentro y fuera, esas
pequeñas líneas crecerán y se reducirán en longitud. Ahora estás viendo el ancho del pulso.

Memoria
Las notas de esta página son para todas las placas excepto la Due, que tiene una arquitectura diferente

Hay tres grupos de memoria en el microcontrolador utilizado en placas Arduino basadas en avr:

La memoria flash (espacio del proyecto), es donde se almacena el proyecto de Arduino.

SRAM (memoria estática de acceso aleatorio) es donde el proyecto crea y manipula variables cuando se
ejecuta.

EEPROM es un espacio de memoria que los programadores pueden utilizar para almacenar información a
largo plazo.

La memoria flash y la memoria EEPROM no son volátiles (la información persiste después de apagar la
alimentación). SRAM es volátil y se perderá cuando la potencia se cicla.

El chip ATmega328 que se encuentra en el Uno tiene las siguientes cantidades de memoria:
Flash 32k bytes (de los cuales .5k se utiliza para el gestor de arranque)
SRAM 2k bytes
Byte EEPROM 1k
El ATmega2560 en el Mega2560 tiene un mayor espacio de memoria:
Flash 256k bytes (de los cuales 8k se utiliza para el gestor de arranque)
SRAM 8k bytes
Byte EEPROM 4k
Observe que no hay mucha SRAM disponible en el Uno. Es fácil de usar todo por tener un montón de
cadenas en su proyecto. Por ejemplo, una declaración como:
char message[] á "Apoyo el proyecto de Cape Wind.";
Pone 33 bytes en SRAM (cada carácter toma un byte, más el terminador '-0'). Esto puede no parecer
mucho, pero no tarda mucho en llegar a 2048, especialmente si tiene una gran cantidad de texto para
enviar a una pantalla, o una tabla de búsqueda grande, por ejemplo.

Si se quede sin SRAM, el proyecto puede fallar de maneras inesperadas; parecerá que se carga
correctamente, pero no se ejecuta, o se ejecuta de forma extraña. Para comprobar si esto está
sucediendo, puede intentar comentar o acortar las cadenas u otras estructuras de datos en el proyecto
(sin cambiar el código). Si luego se ejecuta con éxito, es probable que se esté quedando sin SRAM. Hay
algunas cosas que puede hacer para abordar este problema:

Si su proyecto habla con un proyecto que se ejecuta en un ordenador (de escritorio/portátil), puede
intentar cambiar los datos o cálculos al ordenador, reduciendo la carga en el Arduino.

Si tiene tablas de búsqueda u otras matrices grandes, utilice el tipo de datos más pequeño necesario para
almacenar los valores que necesita; por ejemplo, un int ocupa dos bytes, mientras que un byte utiliza solo
uno (pero puede almacenar un rango de valores más pequeño).
 Proyecto Arduino | 25

Si no necesita modificar las cadenas o los datos mientras se ejecuta el proyecto, puede almacenarlos en
memoria flash (proyecto) en lugar de SRAM; para ello, utilice la palabra clave PROGMEM.

Para utilizar el EEPROM, consulte la Librería EEPROM.

 Capítulo 4
Software Arduino (IDE)

Introducción
El Arduino Integrated Development Environment, o Arduino Software (IDE), contiene un editor de texto
para escribir código, un área de mensajes, una consola de texto, una barra de herramientas con botones
para funciones comunes y una serie de menús. Se conecta al hardware Arduino y Genuino para cargar
proyectos y comunicarse con ellos.

El IDE está compuesto de las siguientes áreas:

 Software Arduino (IDE) | 27

Barra de Menú
Contiene todas las funciones disponibles para el IDE, las cuales contiene las siguientes funciones:

Archivo

Nuevo: Crea una nueva instancia del editor, con la estructura mínima de un boceto ya en su lugar.
Abrir: Permite cargar un archivo de boceto navegando por las unidades y carpetas de la computadora.
Abrir Reciente: Proporciona una breve lista de los Proyectos más recientes, listos para abrir.
Proyecto: Muestra los Proyectos actuales dentro de la estructura de carpetas del cuaderno de Proyectos;
Al hacer clic en cualquier nombre, se abre el boceto correspondiente en una nueva instancia del editor.
Ejemplos: Cualquier ejemplo proporcionado por el software Arduino (IDE) o la Librería se muestra en este
elemento del menú. Todos los ejemplos están estructurados en un árbol que permite un fácil acceso por
tema o Librería.
Cerrar: Cierra la instancia del software Arduino desde el que se hace clic.
Salvar: Guarda el boceto con el nombre actual. Si el archivo no ha sido nombrado antes, se proporcionará
un nombre en la ventana "Guardar como ...".
Guardar como... Permite guardar el boceto actual con un nombre diferente.
Configurar página: Muestra la ventana de configuración de página para imprimir.
Impresión: Envía el boceto actual a la impresora de acuerdo con la configuración definida en Configuración
de página.
Preferencias: Abre la ventana de Preferencias donde algunas configuraciones del IDE pueden
personalizarse, como el idioma de la interfaz IDE.
Salir: Cierra todas las ventanas IDE. Los mismos Proyectos abiertos cuando se eligió Salir se volverán a
abrir automáticamente la próxima vez que inicie el IDE.

Editar

Deshacer / Rehacer: Retrocede uno o más pasos que realizó durante la edición; cuando regreses, puedes
seguir adelante con Rehacer.
Cortar: Elimina el texto seleccionado del editor y lo coloca en el portapapeles.
Copiar: Duplica el texto seleccionado en el editor y lo coloca en el portapapeles.
Copiar para el foro: Copia el código de su boceto en el portapapeles en un formulario adecuado para
publicar en el foro, completo con coloración de sintaxis.
Copiar como HTML: Copia el código de su boceto en el portapapeles como HTML, adecuado para incrustar
en páginas web.
Pegar: Pone el contenido del portapapeles en la posición del cursor, en el editor.
Seleccionar todo: Selecciona y resalta todo el contenido del editor.
Ir a la línea… Desplaza el cursor hasta la línea especificada
Comentar / des comentar: Pone o elimina el // marcador de comentario al comienzo de cada línea
seleccionada.
Aumentar / Disminuir sangría: Agrega o resta un espacio al comienzo de cada línea seleccionada,
moviendo el texto un espacio a la derecha o eliminando un espacio al comienzo.
Incrementa Tamaño Fuente / Reduce Tamaño de Fuente: Reduce o incrementa el tamaño de la fuente en
el editor del proyecto.
 Software Arduino (IDE) | 28

Buscar: Abre la ventana Buscar y reemplazar, donde puede especificar el texto para buscar dentro del
boceto actual de acuerdo con varias opciones.
Buscar siguiente: Destaca la siguiente aparición, si la hay, de la cadena especificada como elemento de
búsqueda en la ventana Buscar, en relación con la posición del cursor.
Buscar anterior: Destaca la aparición anterior, si la hubiera, de la cadena especificada como elemento de
búsqueda en la ventana Buscar en relación con la posición del cursor

Proyecto

Verificar / compilar: Comprueba su boceto en busca de errores al compilarlo; informará el uso de memoria
para el código y las variables en el área de la consola.
Subir: Compila y carga el archivo binario en la placa configurada a través del puerto configurado.
Subir usando Programador: Esto sobrescribirá el gestor de arranque en la placa; necesitará usar
Herramientas> Grabar cargador de arranque para restaurarlo y poder cargar nuevamente al puerto serie
USB. Sin embargo, le permite utilizar toda la capacidad de la memoria Flash para su boceto. Tenga en
cuenta que este comando NO quemará los fusibles. Para hacerlo, se debe ejecutar un comando
Herramientas -> Grabar cargador de arranque.
Exportar binarios compilados: Guarda un archivo.hex que puede guardarse como archivo o enviarse a la
pizarra utilizando otras herramientas.
Mostrar carpeta de Programas: Abre la carpeta de Proyectos actual.
Incluir Librería: Agrega una Librería a su boceto insertando #include declaraciones al comienzo de su
código. Para más detalles, vea las Librerías a continuación. Además, desde este elemento del menú puede
acceder al Administrador de Librerías e importar nuevas Librerías desde archivos .zip.
Añadir archivo... Agrega un archivo fuente al boceto (se copiará de su ubicación actual). El nuevo archivo
aparece en una nueva pestaña en la ventana de boceto. Los archivos se pueden eliminar del boceto
utilizando el menú de pestañas accesible haciendo clic en el pequeño icono del triángulo debajo del
monitor en serie, uno en el lado derecho de la barra de herramientas.

Herramientas

Auto formato: Esto formatea bien su código: es decir, lo sangra para que la apertura y cierre de llaves se
alineen, y que las declaraciones dentro de llaves se sangran más.
Archivo de programa: Archiva una copia del boceto actual en formato .zip. El archivo se coloca en el mismo
directorio que el boceto.
Reparar codificación y recargar: Soluciona posibles discrepancias entre la codificación del mapa de
caracteres del editor y otros mapas de caracteres de los sistemas operativos.
Administrar Librerías… Abre el gestor de librerías con el fin de instalar, remover o actualizar librerías
Monitor serie: Abre la ventana del monitor en serie e inicia el intercambio de datos con cualquier placa
conectada en el puerto seleccionado actualmente. Esto generalmente restablece la placa, si la placa
admite Restablecer a través de la apertura del puerto serie.
Plotter Serial: Permite crear gráficas a partir de las variables seleccionadas
WiFi101 / WiFiNINA Actualizador de firmware: Abre la consola para actualización del firmware de las
placas WiFi101 / WiFiNINA
Placa: Seleccione la Placa que está utilizando. Consulte a continuación las descripciones de las distintos
placas.
 Software Arduino (IDE) | 29

Puerto: Este menú contiene todos los dispositivos seriales (reales o virtuales) en su máquina. Debería
actualizarse automáticamente cada vez que abra el menú de herramientas de nivel superior.
Obtén información de la Placa: Conecta con la placa a fin de obtener la siguiente información:
BN: Arduino/Genuino Uno
VID: NxNNNN
PID: NxNNNN
SN: XXXXXXXXXXXXXXXXXXX
Programador: Para seleccionar un Programador de hardware al proyector una placa o chip y no utilizar la
conexión serie USB incorporada. Normalmente no necesitará esto, pero si está grabando un cargador de
arranque en un nuevo microcontrolador, lo usará.
Quemador Bootloader: Los elementos de este menú le permiten grabar un gestor de arranque en el
microcontrolador en una placa Arduino. Esto no es necesario para el uso normal de una placa Arduino o
Genuino, pero es útil si compra un nuevo microcontrolador ATmega (que normalmente viene sin un gestor
de arranque). Asegúrese de haber seleccionado la placa correcta del menú Placas antes de grabar el gestor
de arranque en el placa de destino. Este comando también establece los fusibles correctos.

Ayuda

Inicio Rápido / Entorno / Problemas / Referencia: Aquí encontrará un fácil acceso a una serie de
documentos que vienen con el software Arduino (IDE). Tiene acceso a Introducción, Referencia, esta guía
para el IDE y otros documentos localmente, sin conexión a Internet. Los documentos son una copia local
de los documentos en línea y pueden enlazar a nuestro sitio web en línea.
Ayuda Galileo / Inicio Rápido / Problemas: Abre la página de ayuda para la Placa Intel® Galileo. Galileo es
una placa de microcontrolador basada en el procesador de aplicaciones Intel® Quark SoC X1000, un
sistema Intel Pentium de 32 bits en un chip (https://www.arduino.cc/en/ArduinoCertified/IntelGalileo)
Ayuda de Edison / Inicio Rápido / Problemas: Abre la página de ayuda para la Placa Intel® Edison. El módulo
Intel® Edison es un SoC (Sistema en Chip) que incluye una CPU Intel® Atom ™ 500MHz de doble núcleo y
doble hilo y un microcontrolador Intel® Quark ™ de 100MHz.
(file:///C:/Program%20Files%20(x86)/Arduino/reference/Edison_help_files/ArduinoIDE_guide_edison.ht
ml)
Buscar en referencia: Esta es la única función interactiva del menú Ayuda: selecciona directamente la
página relevante en la copia local de la Referencia para la función o comando debajo del cursor
Preguntas más frecuentes: Abre la página web interna de preguntas más frecuentes (FAQ) del proyecto
Arduino (file:///C:/Program%20Files%20(x86)/Arduino/reference/www.arduino.cc/en/Main/FAQ.html)
Visita Arduino.cc: Abre la página web del proyecto Arduino (http://www.arduino.cc/)
Sobre Arduino : Abre la ventana de bienvenida del IDE, donde se puede visualizar la versión del mismo

Barra de Herramientas

Verificar: Comprueba su código en busca de errores al compilarlo.

 Software Arduino (IDE) | 30

Menú de
Subir: Compila su código y lo carga en la placa configurada. Consulte la carga opciones
a continuación para obtener más detalles. para
Nota: Si está utilizando unProgramador externo con su placa, puede pestañas
mantener presionada la tecla "shift" en su computadora cuando use este
icono. El texto cambiará a "Cargar usando elProgramador" Permite

Nuevo: Crea un nuevo boceto.

Abierto
Presenta un menú de todos los Proyectos en su cuaderno de Proyectos. Al
hacer clic en uno, se abrirá dentro de la ventana actual sobrescribiendo su
contenido.
Nota: debido a un error en Java, este menú no se desplaza; si necesita abrir
un boceto tarde en la lista, use el Archivo | Menú de Proyectos en su lugar.

Salvar: Guarda tu boceto.

Monitor en serie: Abre el monitor en serial.

administrar opciones para las pestañas de proyecto, en el se puede abrir una nueva pestaña
(Ctrl+Mayús+N), Renombrar, Borrar, Pestaña Anterior (Ctrl+Mayús+Izquierda), Pestaña Siguiente
(Ctrl+Mayús+Derecha) y escoger el proyecto abierto

Pestaña de Proyectos
En el IDE se pueden abrir varias pestañas con distintos proyectos, a fin de poderlos manejar en una sola
ventana e interactuar entre ellos. Cada proyecto se convertirá en una pestaña distinta y pueden ser
manejadas con el Menú de opciones para pestañas. Si el proyecto no ha sido guardado, mostrará un § al
lado derecho del nombre del proyecto

Barra de Desplazamiento
Permite navegar en el área de trabajo

Área de Programación
Es el editor de texto que permite escribir los códigos requeridos para establecer el programa que se quiere
descargar a la Placa de Arduino

Área de Notificación
En esta Área el IDE ofrece información acerca de lo que ocurre en la aplicación y los resultados de
funciones ejecutadas tales como Guardar, Compilar, etc.
 Software Arduino (IDE) | 31

Barra de Interfaz
Ofrece información sobre la placa conectada y el puerto seleccionado

Escribir Proyectos
Los proyectos escritos con el software Arduino (IDE) se denominan Proyectos. Estos Proyectos se escriben
en el editor de texto y se guardan con la extensión de archivo.ino. El editor tiene funciones para cortar /
pegar y para buscar / reemplazar texto. El área de mensajes proporciona comentarios al guardar y
exportar y también muestra errores. La consola muestra la salida de texto del software Arduino (IDE),
incluidos los mensajes de error completos y otra información. La esquina inferior derecha de la ventana
muestra la placa configurada y el puerto serie. Los botones de la barra de herramientas le permiten
verificar y cargar proyectos, crear, abrir y guardar Proyectos, y abrir el monitor en serie.

Nota: las versiones del software Arduino (IDE) anteriores a 1.0 guardan Proyectos con la extensión .pde.
Es posible abrir estos archivos con la versión 1.0, pero se le pedirá que guarde el boceto con la extensión
.ino al guardar.

Se encuentran comandos adicionales dentro de los cinco menús: Archivo, Editar, Boceto, Herramientas,
Ayuda. Los menús son contextuales, lo que significa que solo están disponibles los elementos relevantes
para el trabajo que se está realizando actualmente.

Cuaderno de Proyectos
El software Arduino (IDE) utiliza el concepto de un cuaderno de Proyectos: un lugar estándar para
almacenar sus programas (o Proyectos). Los Proyectos en su cuaderno de Proyectos se pueden abrir desde
el menú Archivo> Cuaderno de Proyectos o desde el botón Abrir en la barra de herramientas. La primera
vez que ejecute el software Arduino, creará automáticamente un directorio para su cuaderno de
Proyectos. Puede ver o cambiar la ubicación de la ubicación del cuaderno de Proyectos desde el cuadro
de diálogo Preferencias.

A partir de la versión 1.0, los archivos se guardan con una extensión de archivo .ino. Las versiones
anteriores usan la extensión .pde. Aún puede abrir archivos con nombre .pde en la versión 1.0 y
posteriores, el software cambiará automáticamente el nombre de la extensión a .ino.

Pestañas, múltiples archivos y compilación

Le permite administrar Proyectos con más de un archivo (cada uno de los cuales aparece en su propia
pestaña). Estos pueden ser archivos de código Arduino normales (sin extensión visible), archivos C
(extensión .c), archivos C ++ (.cpp) o archivos de encabezado (.h).

Cargando a la placa
Antes de cargar su boceto, debe seleccionar los elementos correctos en los menús Herramientas> Placa y
Herramientas> Puerto. Las placas se describen a continuación. En Mac, el puerto serie es probablemente
algo así como /dev/tty.usbmodem241 (para Uno o Mega2560 o Leonardo) o /dev/tty.usbserial-1B1 (para
 Software Arduino (IDE) | 32

una placa USB Duemilanove o anterior), o / dev / tty .USA19QW1b1P1.1 (para una placa serie conectada
con un adaptador USB a serie Keyspan). En Windows, probablemente sea COM1 o COM2 (para una placa
serie) o COM4, COM5, COM7 o superior (para una placa USB); para averiguarlo, busque un dispositivo
serie USB en la sección de puertos del Administrador de dispositivos de Windows. En Linux, debería ser /
dev / ttyACMx, / dev / ttyUSBx o similar. Una vez que haya seleccionado el puerto serie y la placa correctos,
presione el botón de carga en la barra de herramientas o seleccione el elemento Cargar del menú Boceto.
Las placas Arduino actuales se reiniciarán automáticamente y comenzarán la carga. Con placas más
antiguos (pre-Diecimila) que carecen de reinicio automático, deberá presionar el botón de reinicio en la
placa justo antes de comenzar la carga. En la mayoría de las placas, verá que los LED RX y TX parpadean a
medida que se carga el boceto. El software Arduino (IDE) mostrará un mensaje cuando se complete la
carga o mostrará un error.

Cuando carga un boceto, está utilizando el gestor de arranque Arduino, un pequeño programa que se ha
cargado en el microcontrolador de su placa. Le permite cargar código sin usar ningún hardware adicional.
El gestor de arranque está activo durante unos segundos cuando la placa se reinicia; luego comienza el
boceto que se cargó más recientemente en el microcontrolador. El gestor de arranque parpadeará el LED
incorporado (pin 13) cuando se inicie (es decir, cuando la placa se reinicie).

Librerías
Las Librerías proporcionan una funcionalidad adicional para su uso en Proyectos, p. trabajando con
hardware o manipulando datos. Para usar una Librería en un boceto, selecciónela en el menú Boceto>
Importar Librería. Esto insertará una o más declaraciones #include en la parte superior del boceto y
compilará la Librería con su boceto. Debido a que las Librerías se cargan en la placa con su boceto,
aumentan la cantidad de espacio que ocupa. Si un boceto ya no necesita una Librería, simplemente
elimine sus declaraciones #include de la parte superior de su código.

Hay una lista de Librerías en la referencia. Algunas Librerías están incluidas con el software Arduino. Otros
se pueden descargar desde una variedad de fuentes o mediante el Administrador de la Librería. A partir
de la versión 1.0.5 del IDE, puede importar una Librería desde un archivo zip y usarla en un boceto abierto.
Consulte estas instrucciones para instalar una Librería de terceros.

Para escribir su propia Librería, vea más adelante

Hardware de terceros
Se puede agregar soporte para hardware de terceros al directorio de hardware del directorio de su
cuaderno de bocetos. Las plataformas instaladas allí pueden incluir definiciones de placa (que aparecen
en el menú de la placa), bibliotecas principales, cargadores de arranque y definiciones de programador.
Para instalar, cree el directorio de hardware, luego descomprima la plataforma de terceros en su propio
subdirectorio. (No use "arduino" como el nombre del subdirectorio o anulará la plataforma Arduino
incorporada). Para desinstalar, simplemente elimine su directorio.

Para obtener detalles sobre la creación de paquetes para hardware de terceros, consulte la especificación
de hardware de terceros Arduino IDE 1.5.
 Software Arduino (IDE) | 33

Monitor serial
Esto muestra la serie enviada desde la placa Arduino o Genuino a través de un conector USB o serie. Para
enviar datos a la pizarra, ingrese el texto y haga clic en el botón "enviar" o presione Entrar. Elija la velocidad
en baudios del menú desplegable que coincida con la velocidad pasada a Serial.begin en su boceto. Tenga
en cuenta que en Windows, Mac o Linux la placa se reiniciará (volverá a ejecutar su boceto) cuando se
conecte con el monitor en serie. Tenga en cuenta que el Monitor de serie no procesa caracteres de control;
Si su boceto necesita una gestión completa de la comunicación en serie con caracteres de control, puede
usar un programa de terminal externo y conectarlo al puerto COM asignado a su placa Arduino.

También puede hablar con la placa desde Processing, Flash, MaxMSP, etc. (consulte la página de interfaz
para más detalles).

Preferencias
Algunas preferencias se pueden establecer en el cuadro de diálogo de preferencias (que se encuentra en
el menú Arduino en Mac, o Archivo en Windows y Linux). El resto se puede encontrar en el archivo de
preferencias, cuya ubicación se muestra en el cuadro de diálogo de preferencias.

Ayuda de idioma

Ilustración 3. Selección de idiomas del IDE en el menú Preferencias

 Software Arduino (IDE) | 34

Desde la versión 1.0.1, el software Arduino (IDE) se ha traducido a más de 30 idiomas diferentes. Por
defecto, el IDE se carga en el idioma seleccionado por su sistema operativo. (Nota: en Windows y
posiblemente en Linux, esto está determinado por la configuración regional que controla los formatos de
moneda y fecha, no por el idioma en que se muestra el sistema operativo).

Si desea cambiar el idioma manualmente, inicie el Software Arduino (IDE) y abra la ventana de
Preferencias. Al lado del Idioma del editor hay un menú desplegable de los idiomas admitidos
actualmente. Seleccione su idioma preferido en el menú y reinicie el software para usar el idioma
seleccionado. Si el idioma de su sistema operativo no es compatible, el software Arduino (IDE) estará
predeterminado en inglés.

Puede devolver el software a su configuración predeterminada de seleccionar su idioma en función de su

sistema operativo seleccionando Predeterminado del sistema en el menú desplegable Idioma del editor.
Esta configuración tendrá efecto cuando reinicie el software Arduino (IDE). Del mismo modo, después de
cambiar la configuración de su sistema operativo, debe reiniciar el software Arduino (IDE) para actualizarlo
al nuevo idioma predeterminado.

Placas
La selección de la placa tiene dos efectos: establece los parámetros (por ejemplo, velocidad de la CPU y
velocidad de transmisión) utilizados al compilar y cargar bocetos; y establece y la configuración de archivos
y fusibles utilizada por el comando del cargador de arranque. Algunas de las definiciones de la placa
difieren solo en la última, por lo que incluso si ha estado cargando correctamente con una selección
particular, querrá verificarla antes de grabar el gestor de arranque. Puede encontrar una tabla de
comparación entre los distintos Placas aquí.

El software Arduino (IDE) incluye el soporte integrado para las placas en la siguiente lista, todo basado en
el AVR Core. El Administrador de placas incluido en la instalación estándar permite agregar soporte para
el creciente número de placas nuevas basadas en diferentes núcleos como Arduino Due, Arduino Zero,
Edison, Galileo, etc.

Arduino Yùn: Un ATmega32u4 funcionando a 16 MHz con reinicio automático, 12 entradas analógicas, 20
E / S digitales y 7 PWM.
Arduino / Genuino Uno: Un ATmega328P funcionando a 16 MHz con reinicio automático, 6 entradas
analógicas, 14 E / S digitales y 6 PWM.
Arduino Diecimila o Duemilanove con ATmega168: Un ATmega168 funcionando a 16 MHz con reinicio
automático.
Arduino Nano con ATmega328P: Un ATmega328P funcionando a 16 MHz con reinicio automático. Tiene
ocho entradas analógicas.
Arduino / Genuino Mega 2560: Un ATmega2560 funcionando a 16 MHz con reinicio automático, 16
entradas analógicas, 54 E / S digitales y 15 PWM.
Arduino Mega: Un ATmega1280 funcionando a 16 MHz con reinicio automático, 16 entradas analógicas,
54 E / S digitales y 15 PWM.
Arduino Mega ADK: Un ATmega2560 funcionando a 16 MHz con reinicio automático, 16 entradas
analógicas, 54 E / S digitales y 15 PWM.
 Software Arduino (IDE) | 35

Arduino Leonardo: Un ATmega32u4 funcionando a 16 MHz con reinicio automático, 12 entradas

analógicas, 20 E / S digitales y 7 PWM.
Arduino / Genuino Micro: Un ATmega32u4 funcionando a 16 MHz con reinicio automático, 12 entradas
analógicas, 20 E / S digitales y 7 PWM.
Arduino Esplora: Un ATmega32u4 funcionando a 16 MHz con reinicio automático.
Arduino Mini con ATmega328P: Un ATmega328P funcionando a 16 MHz con reinicio automático, 8
entradas analógicas, 14 E / S digitales y 6 PWM.
Arduino Ethernet: Equivalente a Arduino UNO con un escudo Ethernet: un ATmega328P que funciona a
16 MHz con reinicio automático, 6 entradas analógicas, 14 E / S digitales y 6 PWM.
Arduino Fio: Un ATmega328P funcionando a 8 MHz con reinicio automático. Equivalente a Arduino Pro o
Pro Mini (3.3V, 8 MHz) con ATmega328P, 6 entradas analógicas, 14 E / S digitales y 6 PWM.
Arduino BT con ATmega328P: ATmega328P funcionando a 16 MHz. El cargador de arranque grabado (4
KB) incluye códigos para inicializar el módulo bluetooth integrado, 6 entradas analógicas, 14 E / S digitales
y 6 PWM.
LilyPad Arduino USB: Un ATmega32u4 funcionando a 8 MHz con reinicio automático, 4 entradas
analógicas, 9 E / S digitales y 4 PWM.
LilyPad Arduino: Un ATmega168 o ATmega132 funcionando a 8 MHz con reinicio automático, 6 entradas
analógicas, 14 E / S digitales y 6 PWM.
Arduino Pro o Pro Mini (5V, 16 MHz) con ATmega328P: Un ATmega328P funcionando a 16 MHz con
reinicio automático. Equivalente a Arduino Duemilanove o Nano con ATmega328P; 6 entradas analógicas,
14 E / S digitales y 6 PWM.
Arduino NG o anterior con ATmega168: Un ATmega168 funcionando a 16 MHz sin reinicio automático. La
compilación y carga es equivalente a Arduino Diecimila o Duemilanove con ATmega168, pero el cargador
de arranque quemado tiene un tiempo de espera más lento (y parpadea el LED del pin 13 tres veces al
reiniciar); 6 entradas analógicas, 14 E / S digitales y 6 PWM.
Arduino Robot Control: Un ATmega328P funcionando a 16 MHz con reinicio automático.
Arduino Robot Motor: Un ATmega328P funcionando a 16 MHz con reinicio automático.
Arduino Gemma: Un ATtiny85 funcionando a 8 MHz con reinicio automático, 1 entrada analógica, 3 E / S
digitales y 2 PWM.

Para obtener instrucciones sobre cómo instalar el soporte para otras placas, consulte el hardware de
terceros arriba
 Capítulo 5
Librerías

Introducción
El entorno Arduino se puede ampliar mediante el uso de Librerías, al igual que la mayoría de las
plataformas de Programación. Las Librerías proporcionan una funcionalidad adicional para su uso en
proyectos, p. trabajando con hardware o manipulando datos. Para usar una Librería en un proyecto,
selecciónela desde Proyecto > Importar Librería.

Para conocer las Librerías oficiales, actualizaciones y contribuciones, puede visitar

https://www.arduino.cc/en/Reference/Libraries o en el foro en
https://forum.arduino.cc/index.php/board,23.0.html

Librerías estándar

• EEPROM - lectura y escritura en almacenamiento "permanente"

• Ethernet - para conectarse a Internet con Arduino Ethernet Shield, Arduino Ethernet Shield 2 y Arduino
Leonardo ETH
• Firmata - para comunicarse con aplicaciones en la computadora mediante un protocolo serie estándar.
• GSM - para conectarse a una red GSM / GRPS con el escudo GSM.
• LiquidCrystal - para controlar pantallas de cristal líquido (LCD)
• SD - para leer y escribir tarjetas SD.
• Servo - para controlar servomotores.
• SPI - para comunicarse con dispositivos que utilizan el bus de interfaz periférica serial (SPI)
• SoftwareSerial - para comunicación en serie en cualquier pin digital. La versión 1.0 y posteriores de
Arduino incorporan la Librería NewSoftSerial de Mikal Hart como SoftwareSerial.
• Stepper - para controlar motores paso a paso
• TFT - para dibujar texto, imágenes y formas en la pantalla Arduino TFT
• WiFi - para conectarse a Internet utilizando el escudo Arduino WiFi
• Wire - interfaz de dos cables (TWI / I2C) para enviar y recibir datos a través de una red de dispositivos o
sensores.

Varias Librerías vienen instaladas con el IDE, pero también puede descargar o crear las suyas propias.

instalación de Librerías.
 Librerías | 37

Una vez que se sienta cómodo con el software Arduino y utilice las funciones integradas, puede ampliar
la capacidad de su Arduino con Librerías adicionales.

¿Qué son Librerías?

Las Librerías son una colección de código que le facilita la conexión a un sensor, pantalla, módulo, etc. Por
ejemplo, la Librería incorporada LiquidCrystal facilita la comunicación con las pantallas LCD de caracteres.
Hay cientos de Librerías adicionales disponibles en Internet para descargar. Las Librerías integradas y
algunas de estas Librerías adicionales se enumeran en la referencia. Para usar las Librerías adicionales,
deberá instalarlas

Cómo instalar una Librería

Usando el administrador de la Librería
Para instalar una nueva Librería en su Arduino IDE, puede usar el Administrador de Librerías (disponible
en la versión 1.6.2 de IDE). Abra el IDE y haga clic en el menú " Proyecto " y luego Incluir Librería>
Administrar Librerías.

Ilustración 4.Sección Administrar Librerías

Luego, se abrirá el Administrador de Librerías y encontrará una lista de Librerías que ya están instaladas o
listas para la instalación. En este ejemplo instalaremos la Librería Bridge. Desplácese por la lista para
encontrarla, haga clic en ella y luego seleccione la versión de la Librería que desea instalar. A veces solo
 Librerías | 38

hay disponible una versión de la Librería. Si el menú de selección de versión no aparece, no se preocupe:
es normal.

Ilustración 5.Gestor de Librerías

Finalmente haga clic en instalar y espere a que el IDE instale la nueva Librería. La descarga puede demorar
dependiendo de la velocidad de su conexión. Una vez que haya terminado, debería aparecer una etiqueta
Instalada junto a la Librería de Bridge. Puedes cerrar el administrador de la Librería.

Ilustración 6.Librería instalada

 Librerías | 39

Ahora puede encontrar la nueva Librería disponible en el menú Proyecto> Incluir Librería. Si desea agregar
su propia Librería al Administrador de Librerías, siga estas instrucciones.

Importar una Librería .zip

Las Librerías a menudo se distribuyen como un archivo o carpeta ZIP. El nombre de la carpeta es el nombre
de la Librería. Dentro de la carpeta habrá un archivo .cpp, un archivo .h y, a menudo, un archivo
keywords.txt, una carpeta de ejemplos y otros archivos requeridos por la Librería. A partir de la versión
1.0.5, puede instalar Librerías de terceros en el IDE. No descomprima la Librería descargada, déjela como
está.

En el IDE de Arduino, navegue hasta Proyecto> Incluir Librería> Agregar Librería .ZIP. En la parte superior
de la lista desplegable, seleccione la opción "Agregar Librería .ZIP".

Ilustración 7.Añadir Librería ZIP

Se le pedirá que seleccione la Librería que desea agregar. Navegue hasta la ubicación del archivo .zip y
ábralo
 Librerías | 40

Ilustración 8. Selección del archivo ZIP

Vuelva al menú Proyecto> Incluir Librería. Ahora debería ver la Librería en la parte inferior del menú
desplegable. Está listo para ser utilizado en su proyecto. El archivo zip se habrá expandido en la carpeta
de Librerías en su directorio de proyectos de Arduino.

Nota: la Librería estará disponible para su uso en proyectos, pero con versiones anteriores de IDE, los
ejemplos de la Librería no se expondrán en Archivo> Ejemplos hasta después de que se reinicie el IDE.

Instalación manual
Cuando desee agregar una Librería manualmente, debe descargarla como un archivo ZIP, expandirla y
colocarla en el directorio adecuado. El archivo ZIP contiene todo lo que necesita, incluidos ejemplos de
uso si el autor los ha proporcionado. El administrador de la Librería está diseñado para instalar este archivo
ZIP automáticamente como se explicó en el capítulo anterior, pero hay casos en los que es posible que
desee realizar el proceso de instalación manualmente y colocar la Librería en la carpeta de Librerías de su
proyecto.

Extraiga el archivo ZIP con toda su estructura de carpetas en la carpeta C:\Program Files
(x86)\Arduino\libraries.
 Librerías | 41

Ilustración 9. Copia y extracción de los archivos de la Librería en la carpeta de Librerías de Arduino

Inicie el software Arduino (IDE), vaya a Proyecto> Incluir Librería. Verifique que la Librería que acaba de
agregar esté disponible en la lista.
 Librerías | 42

Ilustración 10. Verificación de la disponibilidad de la Librería

Tenga en cuenta: las Librerías Arduino se administran en tres lugares diferentes: dentro de la carpeta de
instalación de IDE, dentro de la carpeta principal y en la carpeta de Librerías dentro de su cuaderno de
proyectos. La forma en que se eligen las Librerías durante la compilación está diseñada para permitir la
actualización de las Librerías presentes en la distribución. Esto significa que colocar una Librería en la
carpeta "Librerías" en su cuaderno de proyectos anula las versiones de otras Librerías.

Lo mismo ocurre con las Librerías presentes en instalaciones de núcleos adicionales. También es
importante tener en cuenta que la versión de la Librería que coloque en su cuaderno de dibujo puede ser
inferior a la de las carpetas de distribución o núcleo, sin embargo, será la utilizada durante la compilación.
Cuando selecciona un núcleo específico para su placa, se utilizan las Librerías presentes en la carpeta del
núcleo en lugar de las mismas Librerías presentes en la carpeta de distribución IDE.

Por último, pero no menos importante, es la forma en que el Software Arduino (IDE) se actualiza a sí
mismo: todos los archivos en Proyectos / Arduino (o la carpeta donde instaló el IDE) se eliminan y se crea
una nueva carpeta con contenido nuevo.

Es por eso que recomendamos que solo instale Librerías en la carpeta del proyecto para que no se eliminen
durante el proceso de actualización de Arduino IDE.

Escribir una Librería para Arduino

(https://www.arduino.cc/en/Hacking/LibraryTutorial)
 Librerías | 43

Este documento explica cómo crear una Librería para Arduino. Comienza con un proyecto para flashear el
código Morse y explica cómo convertir sus funciones en una Librería. Esto permite a otras personas usar
fácilmente el código que ha escrito y actualizarlo fácilmente a medida que mejora la Librería.

Para obtener más información, consulte la Guía de estilo de API para obtener información sobre cómo
hacer una buena API de estilo Arduino para su Librería.

Comenzamos con un proyecto que hace un código Morse simple:

int pin = 13;

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

void loop()
{
dot(); dot(); dot();
dash(); dash(); dash();
dot(); dot(); dot();
delay(3000);
}

void dot()
{
digitalWrite(pin, HIGH);
delay(250);
digitalWrite(pin, LOW);
delay(250);
}

void dash()
{
digitalWrite(pin, HIGH);
delay(1000);
digitalWrite(pin, LOW);
delay(250);
}
Si ejecuta este proyecto, mostrará el código para SOS (una llamada de socorro) en el pin 13.

El proyecto tiene algunas partes diferentes que necesitaremos traer a nuestra Librería. Primero, por
supuesto, tenemos las funciones dot () y dash () que hacen el parpadeo real. En segundo lugar, está la
variable ledPin que usan las funciones para determinar qué pin usar. Finalmente, está la llamada a
pinMode () que inicializa el pin como salida.

¡Comencemos a convertir el proyecto en una Librería!

Necesita al menos dos archivos para una Librería: un archivo de encabezado (con la extensión .h) y el
archivo fuente (con la extensión .cpp). El archivo de encabezado tiene definiciones para la Librería:
básicamente una lista de todo lo que está dentro; mientras que el archivo fuente tiene el código real.
 Librerías | 44

Llamaremos a nuestra Librería "Morse", por lo que nuestro archivo de encabezado será Morse.h. Echemos
un vistazo a lo que contiene. Puede parecer un poco extraño al principio, pero tendrá más sentido una vez
que vea el archivo fuente que lo acompaña.

El núcleo del archivo de encabezado consiste en una línea para cada función en la Librería, envuelta en
una clase junto con cualquier variable que necesite:
class Morse
{
public:
Morse(int pin);
void dot();
void dash();
private:
int _pin;
};

Una clase es simplemente una colección de funciones y variables que se mantienen juntas en un solo
lugar. Estas funciones y variables pueden ser públicas, lo que significa que las personas que usan su
Librería pueden acceder a ellas, o privadas, lo que significa que solo se puede acceder desde la propia
clase. Cada clase tiene una función especial conocida como constructor, que se utiliza para crear una
instancia de la clase. El constructor tiene el mismo nombre que la clase y no tiene ningún tipo de retorno.

Necesita un par de otras cosas en el archivo de encabezado. Una es una declaración #include que le da
acceso a los tipos y constantes estándar del lenguaje Arduino (esto se agrega automáticamente a los
proyectos normales, pero no a las Librerías). Se ve así (y va por encima de la definición de clase dada
anteriormente):
#include "Arduino.h"
Finalmente, es común envolver todo el archivo de encabezado en una construcción de aspecto extraño:
#ifndef Morse_h
#define Morse_h

// la declaración #include y el código aquí ...

#endif
Básicamente, esto evita problemas si alguien accidentalmente # incluye su Librería dos veces.

Finalmente, generalmente coloca un comentario en la parte superior de la Librería con su nombre, una
breve descripción de lo que hace, quién lo escribió, la fecha y la licencia.

Echemos un vistazo al archivo de encabezado completo:

/*
Morse.h - Librería para flashear el código Morse.
Creado por David A. Mellis, 2 de noviembre de 2007.
Publicada en el dominio público.*/
#ifndef Morse_h
 Librerías | 45

#define Morse_h

#include "Arduino.h"

class Morse
{
public:
Morse(int pin);
void dot();
void dash();
private:
int _pin;
};

#endif
Ahora veamos las distintas partes del archivo fuente, Morse.cpp.
Primero viene un par de declaraciones #include. Estos le dan al resto del código acceso a las funciones
estándar de Arduino y a las definiciones en su archivo de encabezado:
#include "Arduino.h"
#incluye "Morse.h"
Luego viene el constructor. Nuevamente, esto explica lo que debería suceder cuando alguien crea una
instancia de su clase. En este caso, el usuario especifica qué pin le gustaría usar. Configuramos el pin como
salida y lo guardamos en una variable privada para usar en otras funciones:
Morse::Morse(int pin)
{
pinMode(pin, OUTPUT);
_pin = pin;
}
Hay un par de cosas extrañas en este código. Primero está el Morse:: antes del nombre de la función. Esto
dice que la función es parte de la clase Morse. Verá esto nuevamente en las otras funciones de la clase.
La segunda cosa inusual es el guion bajo en el nombre de nuestra variable privada, _pin. Esta variable
puede tener el nombre que desee, siempre que coincida con la definición en el archivo de encabezado.
Agregar un guion bajo al comienzo del nombre es una convención común para dejar en claro qué variables
son privadas, y también para distinguir el nombre del nombre del argumento de la función (pin en este
caso).

Luego viene el código real del proyecto que está convirtiendo en una Librería (¡finalmente!). Se ve más o
menos igual, excepto con Morse:: delante de los nombres de las funciones, y _pin en lugar de pin:
void Morse::dot()
{
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}
 Librerías | 46

void Morse::dash()
{
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}
Finalmente, también es típico incluir el encabezado del comentario en la parte superior del archivo fuente.
Veamos todo:
/*
Morse.cpp - Librería para flashear el código Morse.
Creado por David A. Mellis, 2 de noviembre de 2007.
Publicada en el dominio público.
*/

#include "Arduino.h"
#include "Morse.h"

Morse::Morse(int pin)
{
pinMode(pin, OUTPUT);
_pin = pin;
}

void Morse::dot()
{
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}

void Morse::dash()
{
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}
Y eso es todo lo que necesita (hay algunas otras cosas opcionales agradables, pero hablaremos de eso más
adelante). Veamos cómo usas la Librería.

Primero, haga un directorio Morse dentro del subdirectorio de Librerías de su directorio de cuaderno de
proyectos. Copie o mueva los archivos Morse.h y Morse.cpp a ese directorio. Ahora inicie el entorno
Arduino. Si abre el menú Proyecto> Importar Librería, debería ver Morse dentro. La Librería se compilará
con proyectos que la usen. Si la Librería no parece compilarse, asegúrese de que los archivos realmente
terminen en .cpp y .h (sin extensión adicional .pde o .txt, por ejemplo).

Veamos cómo podemos replicar nuestro viejo proyecto SOS usando la nueva Librería:
 Librerías | 47

#include <Morse.h>

Morse morse(13);

void setup()
{
}

void loop()
{
morse.dot(); morse.dot(); morse.dot();
morse.dash(); morse.dash(); morse.dash();
morse.dot(); morse.dot(); morse.dot();
delay(3000);
}
Aquí hay algunas diferencias con respecto al proyecto anterior (además del hecho de que parte del código
se ha movido a una Librería).Primero, hemos agregado una declaración #include en la parte superior del
proyecto. Esto hace que la Librería Morse esté disponible para el proyecto y la incluye en el código enviado
a la pizarra. Eso significa que si ya no necesita una Librería en un proyecto, debe eliminar la instrucción
#include para ahorrar espacio.

En segundo lugar, ahora creamos una instancia de la clase Morse llamada morse:
Morse morse(13);
Cuando se ejecuta esta línea (que en realidad sucede incluso antes de la función setup ()), se llamará al
constructor de la clase Morse y se le pasará el argumento que ha dado aquí (en este caso, solo 13).Observe
que nuestra configuración () ahora está vacía; eso se debe a que la llamada a pinMode () ocurre dentro de
la Librería (cuando se construye la instancia).

Finalmente, para llamar a las funciones dot () y dash (), necesitamos prefijarlas con morse. - el nombre de
la instancia que queremos usar. Podríamos tener varias instancias de la clase Morse, cada una en su propio
pin almacenado en la variable privada _pin de esa instancia. Al llamar a una función en una instancia
particular, especificamos las variables de la instancia que se deben usar durante esa llamada a una función.
Es decir, si tuviéramos ambos:
Morse morse(13);
Morse morse2(12);
luego dentro de una llamada a morse2.dot (), _pin sería 12.

Si probó el nuevo proyecto, probablemente notó que nada de nuestra Librería era reconocido por el
entorno y resaltado en color. Desafortunadamente, el software Arduino no puede determinar
automáticamente lo que ha definido en su Librería (aunque sería una buena característica), por lo que
debe brindarle un poco de ayuda. Para hacer esto, cree un archivo llamado keywords.txt en el directorio
Morse. Debe tener un aspecto como este:
Morse KEYWORD1
dash KEYWORD2
dot KEYWORD2
 Librerías | 48

Cada línea tiene el nombre de la palabra clave, seguida de una pestaña (no espacios), seguida del tipo de
palabra clave. Las clases deben ser KEYWORD1 y son de color naranja; las funciones deben ser KEYWORD2
y serán marrones. Tendrá que reiniciar el entorno Arduino para que reconozca las nuevas palabras clave.

También es bueno proporcionar a las personas un proyecto de ejemplo que use su Librería. Para hacer
esto, cree un directorio de ejemplos dentro del directorio Morse. Luego, mueva o copie el directorio que
contiene el proyecto (llamémoslo SOS) que escribimos anteriormente en el directorio de ejemplos. (Puede
encontrar el proyecto usando el comando Proyecto> Mostrar carpeta de proyectos). Si reinicia el entorno
Arduino (es la última vez, lo prometo), verá un elemento Library-Morse dentro del menú Archivo>
Proyecto> Ejemplos que contiene tu ejemplo Es posible que desee agregar algunos comentarios que
expliquen mejor cómo usar su Librería.

Guía de estilo de API para obtener información sobre cómo

crear una buena API de estilo Arduino para su Librería.
Guía de estilo Arduino para escribir Librerías
Esta es una guía de estilo para escribir API de Librería en un estilo Arduino. Algunos de estos van en contra
de la práctica profesional de Programación. Somos conscientes de eso, pero es lo que ha hecho posible
que tantos principiantes comiencen con Arduino fácilmente. Así que codifique con estos principios en
mente. Si tiene sugerencias sobre cómo hacer que las Librerías Arduino sean más claras para ese público
central, pase a la discusión. Este es un trabajo en progreso.

Sé amable con el usuario final. Suponga que está escribiendo una API para una persona inteligente que
no ha programado antes. Desarrolle un modelo mental claro del concepto con el que está trabajando y
los términos y funciones que utilizará.

Haga coincidir su API con las capacidades subyacentes. No desea exponer los detalles de implementación
al usuario, pero tampoco desea una API que sugiera un modelo mental inexacto de las posibilidades. Por
ejemplo, si solo hay unas pocas opciones posibles para una configuración en particular, no use una función
que tome un int, ya que implica que puede usar cualquier valor que desee.

Organice sus funciones públicas en torno a los datos y la funcionalidad que desea el usuario. Muy a
menudo, el conjunto de comandos para un módulo electrónico en particular es demasiado complicado
para los usos más comunes, o puede reorganizarse en torno a la funcionalidad de nivel superior. Piensa
en lo que la persona promedio piensa que hace, y trata de organizar tus funciones API en torno a eso. La
Librería BMP085 de Adafruit es un buen ejemplo. El comando readPressure () realiza todos los pasos
necesarios para obtener la presión final. La Librería envuelve esta serie de funciones comúnmente
ejecutadas en un comando único de alto nivel que devuelve el valor que el usuario busca en el formato
que espera. Abstrae no solo los comandos I2C de bajo nivel, sino también los cálculos de temperatura y
presión de nivel medio, al tiempo que ofrece esas funciones de nivel medio como funciones públicas para
quienes las desean.

Use palabras completas y cotidianas. No sea conciso con los nombres o variables de su función. Use
términos cotidianos en lugar de técnicos. Elija términos que correspondan a la percepción popular del
concepto en cuestión. No asumas conocimientos especializados. Por ejemplo, esta es la razón por la que
 Librerías | 49

utilizamos analogWrite () en lugar de pwm (). Sin embargo, las abreviaturas son aceptables si son de uso
común o son el nombre principal de algo. Por ejemplo, "HTML" es relativamente común y "SPI" es
efectivamente el nombre de ese protocolo ("interfaz serial-periférica" es probablemente demasiado
largo). ("Wire" probablemente fue un error, ya que el protocolo que usa generalmente se llama "TWI" o
"I2C").

Evite palabras que tengan significados diferentes para el público en general. Por ejemplo, para
losProgramadores, un error es una notificación de que algo sucedió. Para el público en general, los errores
son cosas malas.

Cuando tenga que usar un término específico de dominio, escriba una o dos oraciones describiéndolas
PRIMERO al público en general. Es probable que encuentre un término mejor, y si no, habrá comenzado
la documentación en su Librería.

Documente y comente a medida que avanza. Al escribir ejemplos y documentación, siga esta guía de
estilo: http://arduino.cc/en/Reference/StyleGuide

Utilice las Librerías y estilos centrales establecidos.

Use read () para leer entradas y write () para escribir en salidas, p. digitalRead (), analogWrite (), etc.

Utilice las Librerías Stream.h e Print.h cuando trabaje con secuencias de bytes. Si no es apropiado, al
menos intente utilizar su API como modelo. Para más información sobre esto, ver abajo

Para aplicaciones de red, use las Librerías Cliente y Servidor como base.

Use begin () para inicializar una instancia de Librería, generalmente con algunas configuraciones. Use end
() para detenerlo.

Utilice nombres de funciones de casos de camellos, no guiones bajos. Por ejemplo, analogRead, no
analog_read. O myNewFunction, no my_new_function. Hemos adoptado esto de Processing.org por
razones de legibilidad.

LONG_CONSTANT_NAMES_FULL_OF_CAPS son difíciles de leer. Intenta simplificar cuando sea posible, sin
ser conciso.

Intenta evitar los argumentos booleanos. En su lugar, considere proporcionar dos funciones diferentes
con nombres que describan las diferencias entre ellos.

No asumas el conocimiento de los punteros. Los usuarios principiantes de C consideran que este es el
obstáculo más grande y se confunden mucho con & y *, por lo que cada vez que puedan evitar que pasen
el rato en la API, hágalo. Una forma es pasar por referencia usando la notación de matriz en lugar de la
notación *, por ejemplo.
void printArray (char * array);
puede ser reemplazado por
void printArray (matriz char []);
 Librerías | 50

Aunque hay algunas Librerías donde pasamos punteros usando estructuras como caracteres constantes,
evite cualquier cosa que requiera que el usuario los pase. Por ejemplo, en lugar de:
foo.readAccel (& x, & y, & z);
usa algo como esto:
xAxis = adxl.readX ();
yAxis = adxl.readY ();
zAxis = adxl.readZ ();
Cuando utilice la comunicación en serie, permita que el usuario especifique cualquier objeto Stream, en
lugar de codificar "Serial". Esto hará que su Librería sea compatible con todos los puertos seriales en Mega
y Due, y también puede usar interfaces alternativas como SoftwareSerial. El objeto Stream se puede pasar
al constructor de su Librería o a una función begin () (como referencia, no como puntero). Ver Firmata 2.3
o XBee 0.4 para ejemplos de cada enfoque.

Al escribir una Librería que proporcione comunicación byte-stream, herede la clase Stream de Arduino,
de modo que su Librería pueda usarse con todas las demás Librerías que acepten objetos Stream. Si es
posible, guarde los datos entrantes en el búfer, para que read () acceda inmediatamente a los datos del
búfer, pero no espere a que lleguen más datos. Si es posible, su método write () debe almacenar datos en
un búfer de transmisión, pero write () debe esperar si el búfer no tiene suficiente espacio para almacenar
de inmediato todos los datos salientes. La función yield () debe llamarse mientras espera.

Aquí hay algunas Librerías que son ejemplares de Adafruit. Ella divide las funciones de los dispositivos en
sus actividades de alto nivel realmente bien. https://github.com/adafruit/Adafruit-BMP085-Library
https://github.com/adafruit/DHT-sensor-library

Esto es un buen trabajo de abstracción de la Librería Wire (I2C): https://github.com/adafruit/RTClib

Reference Home

Las correcciones, sugerencias y nueva documentación deben publicarse en el Foro.

 Capítulo 6
Programación

Referencia del Lenguaje

El lenguaje de Programación Arduino se puede dividir en tres partes principales: funciones, valores
(variables y constantes) y estructura.

Funciones
Para controlar la placa Arduino y realizar cálculos. Para detalles de cada una de ellas, visitar
https://www.arduino.cc/reference/en/

Entrada/salida Digital Matemáticas Números aleatorios

digitalRead() abs() random()
digitalWrite() constrain() randomSeed()
pinMode() map()
max()
Bits y Bytes
Entrada/salida analógica min() bit()
analogRead() pow() bitClear()
analogReference() sq() bitRead()
analogWrite() sqrt() bitSet()
bitWrite()
Familia Zero, Due y MKR Trigonométricas
highByte()
analogReadResolution() cos() lowByte()
analogWriteResolution() sin()
tan()
Interrupciones
Entrada/salida Externas
advanzadas Caracteres
attachInterrupt()
noTone() isAlpha() detachInterrupt()
pulseIn() isAlphaNumeric()
isAscii() Interrupciones
pulseInLong()
shiftIn() isControl() interrupts()
shiftOut() isDigit() noInterrupts()
tone() isGraph()
isHexadecimalDigit() Comunicaciones
Tiempo isLowerCase() Serial
delay() isPrintable() Stream
delayMicroseconds() isPunct()
isSpace() USB
 Programación | 55

micros() isUpperCase()
Keyboard
millis() isWhitespace()
Mouse

Variables
Tipos de datos y constantes de Arduino. Para detalles de cada una de ellas, visitar
https://www.arduino.cc/reference/en/

Constantes Tipos de datos Alcance variable y

Floating Point Constants String()
calificadores
Integer Constants array const
HIGH | LOW bool scope
INPUT | OUTPUT | boolean static
INPUT_PULL-UP byte volatile
LED_BUILTIN char
double Utilidades
true | false
float PROGMEM
Conversión int sizeof()
(unsigned int) long
(unsigned long) short
byte() size_t
char() string
float() unsigned char
int() unsigned int
long() unsigned long
word() void
word

Estructura
Los elementos del código Arduino (C++). Para detalles de cada una de ellas, visitar
https://www.arduino.cc/reference/en/

Código Operadores Operadores bit a bit

aritméticos
loop() & (y bit a bit)
setup() % (recordatorio) << (desplazamiento a la
* (multiplicación) izquierda)
Estructura de control
+ (suma) >> (desplazamiento a la
break - (resta) derecha)
continue / (division) ^ (xor bit a bit)
do...while = (operador de | (or bit a bit)
else asignación) ~ (nor bit a bit)
for
Operadores de Operadores compuestos
goto
comparación
if %= (resto compuesto)
return != (no igual a) &= (compuesto y bit a
< (menor que) bit)
 Programación | 56

switch...case <= (menor o igual *= (multiplicación

while que) compuesta)
== (igual a) ++ (incremento)
Sintaxis adicional
> (mayor que) += (suma compuesta)
#define (definir) >= (mayor o igual -- (decremento)
#include (incluir) que) -= (resta compuesta)
/= (división compuesta)
/* */ (comentario de Operadores
^= (compuesto xor bit a
bloque) booleanos
bit)
// (comentario de ! (no lógico) |= (compuesto or bit a
una sola línea) && (y lógico) bit)
|| (o lógica)
; (punto y coma)
Operadores de
{} (llaves) acceso de puntero
& (operador de
referencia)
* (operador de
diferencia)