CURSO DE ARDUINO

Primera Parte

P á g i n a 1 | 70
¿Qué es 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.

Se Puede decirle a la placa qué hacer enviando un conjunto de

instrucciones al microcontrolador de la placa. Para hacerlo, se
utiliza el lenguaje de programación Arduino (basado en el cableado )
y el software Arduino (IDE) , basado en el procesamiento .

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

P á g i n a 2 | 70
 El uso del Arduino

Gracias a su experiencia de usuario simple 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 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. Los 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,

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:

• Barato: 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-montados cuestan menos
de $ 50
• Multiplataforma: Las carreras de Arduino Software (IDE) en
Windows, Macintosh OS X, 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
P á g i n a 3 | 70
 programación de procesamiento, por lo que los estudiantes que
aprenden a programar 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 por programadores experimentados. El lenguaje se puede
ampliar a través de las bibliotecas de C ++, y las personas que
desean 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
programas Arduino si lo desea.
• Hardware de código abierto y extensible: los planes 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 construir la versión del
módulo de prueba para comprender cómo funciona y ahorrar dinero.

Usando Arduino

Antes de comenzar a controlar una plataforma Arduino,

necesitaremos configurar el software para programar el tablero

El software Arduino (IDE) nos permite escribir programas y

cargarlos en el tablero.

En la página del software Arduino encontraremos dos opciones de

uso:

1. Si tenemos una conexión a Internet confiable, debemos usar el

IDE en línea (Arduino Web Editor). Nos permitirá guardar
nuestros bocetos en la nube, tenerlos disponibles desde
cualquier dispositivo y hacer una copia de seguridad. Siempre
tendremos la versión más actualizada del IDE sin la necesidad
de instalar actualizaciones o bibliotecas generadas por la
comunidad.
2. Si preferimos trabajar sin conexión, debemos usar la última
versión del IDE de escritorio.

Código en línea en el editor web de Arduino

P á g i n a 4 | 70
Para usar el IDE en línea, simplemente seguimos estas
instrucciones. Recordemos que los tableros funcionan desde el
primer momento en el Editor web, no es necesario instalar nada.

Instalando el IDE de escritorio Arduino

Para obtener instrucciones paso a paso, seleccionamos uno de los

siguientes S.O enlaces según el sistema operativo.

• Windows
• Mac OS X
• Linux
• IDE portátil (Windows y Linux)

Biblioteca, Software Arduino (IDE)

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 programas y
comunicarse con ellos.

Escribir sketches

Los programas escritos con el software Arduino (IDE) se denominan

sketch. Estos bocetos 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 programas, crear, abrir y guardar
bocetos, y abrir el monitor en serie.

Nota: las versiones del software Arduino (IDE) anteriores a 1.0 con
sketches guardados con la extensión (.pde). Es posible abrirlos con

P á g i n a 5 | 70
la versión 1.0, nos pedirá que guardemos el sketch con la extensión
(.ino) al guardar.

• Verificar, Comprueba el código en busca de errores al

compilarlo.
• Cargar, Compila el código y lo carga en la placa configurada.
(Debemos Consultar la carga antes de cargarla).

Nota: Si estamos utilizando un programador externo con la placa,

podemos mantener presionada la tecla "shift" de nuestra
computadora cuando usemos ese icono. El texto cambiará a "Cargar
usando el programador"

Nuevo: Crea un nuevo boceto.

Abrir: Presenta un menú de todos los sketches en nuestro cuaderno

de sketches. 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

necesitamos abrir un sketch tarde en la lista, usemos el Archivo |
Menú de sketches en su lugar.

Guardar: Guarda nuestro sketch.

Monitor serie: Abre el monitor serie. 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 pantalla, ingresamos el texto y hacemos
clic en el botón "enviar" o presione Entrar. Elegimos la velocidad en
baudios del menú desplegable que coincida con la velocidad pasada
a Serial.begin en nuestro sketch. Tengamos en cuenta que en
Windows, Mac o Linux la placa se reiniciará (volverá a ejecutar
nuestro sketch) cuando se conecte con el monitor en serie.

Tengamos en cuenta que el Monitor de serie no procesa caracteres

de control; Si nuestro sketch necesita una gestión completa de la
comunicación en serie con caracteres de control, podemos usar un
programa de terminal externo y conectarlo al puerto COM asignado
a nuestra placa Arduino.

P á g i n a 6 | 70
Para el manejo de las pestañas 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.

Archivo

• Nuevo: Crea una nueva instancia del editor, con la estructura

mínima básica de un sketch ya en su lugar.
• Abrir: Permite cargar un archivo de sketch navegando por las
unidades y carpetas de la computadora.
• Abrir reciente: Proporciona una breve lista de los bocetos más
recientes, listos para abrir.
• Sketchbook (Proyecto): Muestra los bocetos actuales dentro
de la estructura de carpetas del cuaderno de sketch; 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 biblioteca aparece en este elemento del
menú. Todos los ejemplos están estructurados en un árbol que
permite un fácil acceso por tema o biblioteca.
• Cerrar: Cierra la instancia del software Arduino desde el que
se hace clic.
• Guardar: 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.
• Configuración de página: Muestra la ventana Configuración de
página para imprimir.

• Imprimir: 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 se
pueden personalizar algunas configuraciones del IDE, como el
idioma de la interfaz IDE.

P á g i n a 7 | 70
 • Salir: Cierra todas las ventanas IDE. Los mismos bocetos
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 foro: Copia el código del sketch 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 del sketch 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.
• Comentario / descomentar: Pone o elimina el marcador de //
comentario al comienzo de cada línea seleccionada.
• Aumentar / Disminuir sangría: Suma 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.
• Buscar: Abre la ventana Buscar y reemplazar donde puede
especificar texto para buscar dentro del boceto actual de
acuerdo con varias opciones.
• Buscar siguiente: Resalta 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: Resalta la aparición anterior, 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.

P á g i n a 8 | 70
Sketch

• Verificar / compilar: Comprueba el sketch en busca de errores

al compilarlo; informará el uso de memoria para el código y las
variables en el área de la consola.
• Carga (subir): compilaciones y carga el archivo binario en la
placa configurada a través del puerto configurado.
• Cargar (subir) usando el programador: Esto sobrescribirá el
gestor de arranque en la placa; necesitaremos usar
Herramientas> Grabar cargador de arranque para restaurarlo
y poder cargar nuevamente al puerto serie USB. Sin embargo,
nos permite utilizar toda la capacidad de la memoria Flash
para nuestro sketch. Tengamos en cuenta que este comando
no quemará los fusibles.
Para hacerlo, se debe ejecutar un comando Herramientas ->
Grabar cargador de arranque.
• Exportar binario compilado: Guarda un archivo (.hex) que
puede guardarse como archivo o enviarse a la placa utilizando
otras herramientas.
• Mostrar carpeta de sketch (programa): Abre la carpeta de
bocetos actual.
• Incluir biblioteca (librería): Agregamos una biblioteca (librería)
a nuestro sketch insertando #include declaraciones al
comienzo de nuestro código.
Además, desde este elemento del menú podemos acceder al
Administrador de bibliotecas e importar nuevas bibliotecas
desde archivos .zip.
Las bibliotecas (librerías) proporcionan una funcionalidad
adicional para nuestro uso en sketches, por ejemplo, si
trabajamos con hardware o manipulamos datos. Para usar una
biblioteca (librería) en un sketch, seleccionemos en el menú
sketch (Programa)> Incluir biblioteca (librería).
Esto insertará una o más declaraciones #include en la parte
superior del programa y compilará la biblioteca (librería) con
nuestro sketch.
Debido a que las bibliotecas se cargan en el tablero con
nuestro sketch, aumentan la cantidad de espacio que ocupa. Si
un sketch ya no necesita una biblioteca, simplemente debemos
eliminar esas declaraciones #include de la parte superior de
nuestro código.

P á g i n a 9 | 70
 Hay una lista de bibliotecas (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 Biblioteca (librerías). A partir
de la versión 1.0.5 del IDE, podemos importar una biblioteca
desde un archivo zip y usarla en un sketch abierto.
• Instalando una biblioteca, usando el administrador de la
biblioteca
Para instalar una nueva biblioteca en nuestro Arduino IDE,
podemos usar el Administrador de bibliotecas (disponible en
la versión 1.6.2 de IDE). Abramos el IDE y hagamos clic en el
menú "Programa" y luego Incluir biblioteca> Administrar

bibliotecas. Luego, se abrirá el Administrador de bibliotecas y

encontraremos una lista de bibliotecas que ya están instaladas
o listas para la instalación. En este ejemplo instalaremos la
biblioteca Bridge. Desplacémonos por la lista para encontrarla,
hagamos clic en ella y luego seleccionemos la versión de la
biblioteca que deseemos instalar. A veces solo hay disponible
una versión de la biblioteca. Si el menú de selección de versión
no aparece, no nos preocupemos: es normal.

P á g i n a 10 | 70
 Finalmente hagamos clic en instalar y espere a que el IDE
instale la nueva biblioteca. La descarga puede demorar
dependiendo de la velocidad de nuestra conexión. Una vez que
haya terminado, debería aparecer una etiqueta Instalada junto
a la biblioteca de Bridge. Podemos cerrar el administrador de
la biblioteca.
• Agregar archivo (añadir fichero) ... Agrega un archivo fuente al
sketch (se copiará de su ubicación actual). El nuevo archivo
aparece en una nueva pestaña en la ventana de programa. Los
archivos se pueden eliminar del sketch 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

• Formato automático (Auto formato): Esto formatea bien

nuestro código: es decir, lo repara para que la apertura y cierre
de llaves se alineen, y que las declaraciones dentro de llaves
se reparen más.
• Archivar sketch (archivo de programa): Archiva una copia del
programa actual en formato .zip. El archivo se coloca en el
mismo directorio que el sketch.
• Reparar Codificación y recargar: Corrige posibles
discrepancias entre la codificación del mapa de caracteres del
editor y otros mapas de caracteres de los sistemas operativos.
• Monitor serie: Abre la ventana del monitor 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.
P á g i n a 11 | 70
• Placa: Seleccionamos la placa que estamos utilizando.
La selección de la placa tiene dos efectos: establece los
parámetros (por ejemplo, velocidad de CPU y velocidad de
transmisión) utilizados al compilar y cargar sketches; 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, debemos verificarla antes de grabar el
gestor de arranque.
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 que funciona 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.
• Arduino Leonardo: Un ATmega32u4 funcionando a 16 MHz con
reinicio automático, 12 entradas analógicas, 20 E/S digitales y
7 PWM.

P á g i n a 12 | 70
• 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 que funciona
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.
• Motor Arduino Robot: Un ATmega328P funcionando a 16 MHz
con reinicio automático.

P á g i n a 13 | 70
 • Arduino Gemma: Un ATtiny85 que funciona a 8 MHz con reinicio
automático, 1 entrada analógica, 3 E / S digitales y 2 PWM.
• Puerto: Este menú contiene todos los dispositivos seriales
(reales o virtuales) en su máquina. Debería actualizarse
automáticamente cada vez que abramos el menú de
herramientas de nivel superior.
• Programador: Para seleccionar un programador de hardware
cuando se programa una placa o chip y no se utiliza la conexión
USB serie incorporada. Normalmente no necesitaremos esto,
pero si está grabando un cargador de arranque en un nuevo
microcontrolador, lo necesitaremos.
• Grabar cargador de arranque: Los elementos de este menú le
permiten grabar un cargador 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 la placa de destino. Este
comando también establece los fusibles correctos.

Ayuda

Aquí encontraremos un fácil acceso a una serie de documentos que

vienen con el software Arduino (IDE). Tenemos 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.

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.

Bloc de dibujo: El software Arduino (IDE) utiliza el concepto de un

cuaderno de sketches: un lugar estándar para almacenar sus
programas (o sketch). Los sketches en nuestros proyectos se
pueden abrir desde el menú Archivo> Proyectos o desde el botón
Abrir en la barra de herramientas. La primera vez que ejecutemos
el software Arduino, creará automáticamente un directorio para
nuestros proyectos. Puede ver o cambiar la ubicación de la ubicación
de proyectos desde el cuadro de diálogo Preferencias.
P á g i n a 14 | 70
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

Nos permite administrar bocetos 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

Antes de cargar nuestro sketch, debemos seleccionar los elementos

correctos en los menús Herramientas> Programa y Herramientas>
Puerto. Las placas se describen a continuación.

• En la Mac, el puerto serie es probablemente algo así como

/dev/tty.usbmodem 241 (para Uno o Mega2560 o Leonardo) o
/dev/tty.usbserial-1B1 (para 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 , COM7o 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 tableros más
antiguos (pre-Diecimila) que carecen de reinicio automático,
deberá presionar el botón de reinicio en el tablero justo antes
de comenzar la carga. En la mayoría de las placas, verá los
LED RX y TXparpadea mientras se carga el sketch. El software
P á g i n a 15 | 70
 Arduino (IDE) mostrará un mensaje cuando se complete la
carga o mostrará un error.

Cuando cargamos un sketch, está utilizando el gestor de arranque

Arduino, un pequeño programa que se ha cargado en el
microcontrolador de su placa. Nos 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 sketch que se cargó más recientemente en el microcontrolador.
El gestor de arranque parpadeará el LED de la placa (pin 13) cuando
se inicie (es decir, cuando la placa se reinicie).

Bibliotecas

Las bibliotecas proporcionan una funcionalidad adicional para su

uso en sketches, por ejemplo, trabajar con hardware o manipular
datos. Para usar una biblioteca en un sketch, selecciónela en el
menú Programa> Importar biblioteca. Esto insertará una o más
declaraciones #include en la parte superior del sketch y compilará
la biblioteca con su programa. Debido a que las librerías se cargan
en la placa con su sketch, aumentan la cantidad de espacio que
ocupa. Si un sketch ya no necesita una librería, simplemente
eliminemos las declaraciones #include de la parte superior de
nuestro código.

Hay una lista de bibliotecas en la referencia. Algunas bibliotecas

están incluidas con el software Arduino. Otros se pueden descargar
desde una variedad de fuentes o mediante el Administrador de
librería. A partir de la versión 1.0.5 del IDE, puede importar una
biblioteca desde un archivo zip y usarla en un sketch abierto.

Hardware de terceros

Se puede agregar soporte para hardware de terceros al directorio

de hardware del directorio de su sketch. 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, creemos el directorio de hardware, luego

descomprimamos la plataforma de terceros en nuestro propio
subdirectorio. (No usemos "arduino" como el nombre del
P á g i n a 16 | 70
subdirectorio o anulará la plataforma Arduino incorporada). Para
desinstalar, simplemente elimine su directorio.

Monitor en serie

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 pantalla,
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 nuestro sketch. Tengamos en
cuenta que en Windows, Mac o Linux la placa se reiniciará (volverá
a ejecutar nuestro sketch) cuando se conecte con el monitor en serie.
Tengamos 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 nuestra placa Arduino.

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

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

P á g i n a 17 | 70
Si deseamos cambiar el idioma manualmente, iniciemos 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. Seleccionemos nuestro idioma preferido en el menú y
reinicie el software para usar el idioma seleccionado. Si el idioma de
nuestro sistema operativo no es compatible, el software Arduino
(IDE) estará predeterminado en inglés.

Comenzando con Arduino UNO

Este documento explica cómo conectar nuestra placa Uno a la

computadora y cargar nuestro primer sketch. El Arduino Uno se
programa utilizando el Software Arduino (IDE), nuestro entorno de
desarrollo integrado común a todas nuestras placas y que se ejecuta
tanto en línea como fuera de línea.

Use su Arduino Uno en el IDE web de Arduino

Todas las placas Arduino, incluida esta, funcionan de forma

inmediata en el editor web de Arduino, sin necesidad de instalar nada.

El editor web de Arduino está alojado en línea, por lo tanto, siempre

estará actualizado con las últimas funciones y soporte para todas
las placas.

Use su Arduino Uno en el IDE de escritorio Arduino

Si deseamos programar nuestro Arduino Uno mientras está

desconectado, debemos instalar el Arduino Desktop IDE. El Uno, se
programa utilizando el Software Arduino (IDE), nuestro entorno de
desarrollo integrado común a todas nuestras placas. Antes de
continuar, debe haber instalado el software Arduino (IDE) en nuestra
PC.

Conectemos nuestra placa Uno con un cable USB AB; a veces este
cable se llama cable de impresora USB

P á g i n a 18 | 70
La conexión USB con la PC es necesaria para programar la placa y
no solo para encenderla. El Uno, automáticamente extrae energía del
USB o de una fuente de alimentación externa. Conectemos la placa
a nuestra computadora con el cable USB. El LED de alimentación
verde (etiquetado PWR) debería encenderse.

Instalar los controladores de la placa: Si usamos el instalador,

Windows, desde XP hasta 10, instalará los controladores
automáticamente tan pronto como conectemos nuestra placa.

Si descargamos y descomprimimos el paquete Zip o, por alguna

razón, la placa no se reconoció correctamente, sigamos el
procedimiento a continuación.

Hagamos clic en el menú Inicio y abramos el Panel de control.

Mientras estemos en el Panel de control, naveguemos hasta Sistema

y seguridad. Luego, hagamos clic en Sistema. Una vez que la ventana
del sistema esté abierta, abramos el Administrador de dispositivos.

Miremos debajo de Puertos (COM y LPT). Debería ver un puerto

abierto llamado "Arduino UNO (COMxx)". Si no hay una sección COM
y LPT, busque en "Otros dispositivos" para "Dispositivo desconocido".

Hagamos clic derecho en el puerto "Arduino UNO (COmxx)" y

elijamos la opción "Actualizar software de controlador".

A continuación, elijamos la opción "Buscar en mi computadora el

software del controlador".

Finalmente, naveguemos y seleccionemos el archivo del controlador

llamado "arduino.inf", ubicado en la carpeta "Controladores" de la
descarga del software Arduino (no el subdirectorio "Controladores
P á g i n a 19 | 70
USB FTDI"). Si estamos utilizando una versión anterior del IDE (1.0.3
o anterior), elijamos el archivo del controlador Uno llamado "Arduino
UNO.inf"

Windows finalizará la instalación del controlador desde allí.

Primer sketch

Abramos el programa de ejemplo de parpadeo de LED: Archivo>

Ejemplos> 01. Básicos> Blink (Parpadeo).

Seleccionemos nuestro tipo de placa y puerto, deberemos

seleccionar la entrada en el menú Herramientas> Placa que
corresponde a nuestra placa Arduino.

P á g i n a 20 | 70
Seleccionemos el dispositivo serie de la placa desde Herramientas |
Menú de puerto serie. Es probable que sea COM3 o superior ( COM1
y COM2 generalmente están reservados para puertos seriales de
hardware). Para averiguarlo, podemos desconectar nuestra placa y
volver a abrir el menú; la entrada que desaparece debería ser la
placa Arduino. Volvamos a conectar la placa y seleccionemos ese
puerto serie.

Subir programa

Ahora, simplemente haga clic en el botón "Cargar" en el entorno.

Esperemos unos segundos: debería ver parpadear los leds RX y TX
en la placa. Si la carga se realiza correctamente, aparecerá el
mensaje "Carga finalizada". Que aparecerá en la barra de estado.

Unos segundos después de que finalice la carga, deberíamos ver que

el LED del pin 13 (L) en la placa comienza a parpadear (en naranja).
Si es así, hemos puesto a Arduino en funcionamiento.

Estructura básica de los códigos

Un código Arduino es una serie de comandos de programación que

le dirán a nuestro microcontrolador como configurarse al iniciarse y
qué acciones tiene que realizar mientras esté en funcionamiento.
Estos comandos utilizados en Arduino son sentencias muy fáciles e
intuitivas.

El bloque de código debe tener 2 partes, o funciones principales, que

siempre debemos incluir

Primero, void setup(): Dentro de esta función principal escribiremos

las sentencias de configuración que necesitaremos para que
Arduino trabaje correctamente. Éstas se ejecutarán al iniciar
Arduino y una única vez. Con ellas, por ejemplo, asignaremos la
característica de entrada/salida a los pines, el modo de
comunicación serial, activaremos los sensores que vayamos a
necesitar, escribiremos órdenes de inicio del programa…etc.
Algunas de estas sentencias pueden ser: pinMode( , ), Serial.begin(,),
sensors.begin(,)…

P á g i n a 21 | 70
Segunda, void loop(): Ésta debe ir siempre después de void setup().
En ella escribiremos todas las sentencias, bucles y llamadas a
funciones que necesitemos que nuestro Arduino repita
constantemente. Se escribirán en orden de ejecución. Ejemplo de
éstas pueden ser digitalWrite( , ), Serial.print(“ “), if( )…

Existen otras partes del código que no son obligatorias pero que
podemos necesitar, según el código lo requiera, para organizarlo
todo.

Estas zonas pueden ser un espacio para el título, el autor, librerías,

definiciones (variables que vayamos a usar en el programa), una
zona para funciones a las que el programa irá llamando…Cada uno
es libre de organizarlo como quiera, pero cuanto más ordenado esté
todo, más difícil será perdernos cuando los códigos se compliquen.

Abajo podemos ver un ejemplo simple de cómo debe estructurarse

un código.

Sentencias básicas, funciones y librerías

Para poder realizar un código Arduino debemos tener las

herramientas con las que decirle a nuestro microcontrolador que es

P á g i n a 22 | 70
lo que debe hacer en cada momento. Estas herramientas son las
sentencias y funciones.

Arduino usa una serie de sentencias y comandos básicos muy

sencillos, pero a la vez muy potentes. Combinándolos crearemos
programas para decirle a nuestra placa que haga prácticamente
cualquier cosa que queramos.

Las sentencias se dividen por su manera de funcionar dentro del

programa, pudiendo dividirlas en 3 grandes grupos:

Estructurales: Nos dan la forma computacional del código y las

operaciones lógicas a ejecutar. Con éstos son con los que le
marcamos al programa qué camino debe seguir el código al
ejecutarse y qué operaciones debe hacer. Algún ejemplo de las más
usadas son if, for, while, +, -, =, *, /, ==, >, < …

Variables: Con éstas definiremos qué tipo y qué características

tendrán los valores que vamos a usar en el código. Pueden ser
números, caracteres o estados. Podemos encontrarnos aquí las
sentencias int, float, HIGH, LOW, char, string, true, false…

Funciones: Nos permiten realizar una serie de operaciones

concretas y volver a la zona del código en la que se ejecutó. Existen
funciones que están propiamente definidas ya por Arduino como
tales y también podemos crearnos nuestras propias funciones para
que sean llamadas en las zonas de setup o loop cuando lo
necesitemos. Son muy útiles cuando necesitamos realizar un grupo
de acciones varias veces en distintas zonas del código. También es
una buena forma de ahorrar líneas y de organizarse. Ejemplo de
funciones tenemos pinMode, digitalWrite, delay, max, sin, cos,
analogWrite…

Otra cosa importante son las librerías. Son una serie de sentencias
y funciones específicas de cada elemento o shield que conectemos
a Arduino, que no están dentro de las propias IDE, y que realizarán
acciones específicas de cada uno facilitándonos mucho la
programación.

Por último, nombraremos un par de pequeños detalles necesarios

para poder programar nuestro código. Para que cada sentencia o
función se ejecute debe llevar al final de cada orden el signo de
P á g i n a 23 | 70
puntuación punto y coma “; “y al utilizar la doble barra “//” le decimos
al código que lo que se escriba a la derecha es un comentario y que
no debe ejecutarlo (Arduino lo coloreará en gris). Esto veréis que es
muy útil para explicar que estamos haciendo en cada momento.

Compilación y carga.

Una vez que hayamos escrito nuestro código en la IDE Arduino

procederemos a verificar que está correctamente escrito. Para ello
hacemos clic en verificar. Arduino leerá el texto y nos dirá si es
correcto o no. Para ello lo que hará será compilarlo, que significa
traducir el código del lenguaje de programación a un lenguaje que
entienda el microcontrolador directamente.

En el caso de contener un error nos aparecerá en la consola una

explicación orientativa del error.

Si la compilación ha sido correcta, ya podremos cargar nuestro

programa al Arduino. Para ello, con la placa conectada por USB,
pulsamos el botón de carga

P á g i n a 24 | 70
 EJEMPLOS
Ejemplo: Semáforo

Como primer proyecto, realizaremos un semáforo con unos Leds.

Es ideal para iniciarnos en la programación y el montaje de
circuitos porque, como veréis, es muy fácil.

Empezaremos nuestro primer proyecto describiendo los elementos

que vamos a necesitar.

1 x Arduino UNO R3

1 x Protoboard

1 x Led rojo 3mm

1 x Led amarillo 3mm

1 x Led verde 3mm

3 x resistencias de 220Ω.

Cables para conectar todo.

Una vez que tenemos todo, hacemos nuestro montaje siguiendo el

siguiente esquema.

Utilizaremos los pines digitales 2 (rojo), 4 (amarillo) y 7 (verde). Al

conectar los Leds debéis tener en cuenta que tienen polaridad, por
P á g i n a 25 | 70
 lo que tenéis que colocarlos bien para que funcionen. En los Leds
la patilla corta, o el lado que está achatado, es el negativo e irá
conectado a tierra (GND en la placa) a través de una resistencia. La
patilla larga, o lado redondeado, es el positivo y se conectará al pin
del Arduino correspondiente.

Una vez montado, abriremos nuestro IDE Arduino y escribiremos el

programa (sketch).

/* SEMAFORO */
//** Definiciones **//
int rojo=2; //definimos el valor del pin para el led rojo
int amarillo=4; //definimos el valor del pin para el led amarillo
int verde=7; //definimos el valor del pin para el led verde

//** Programa **//

void setup() {
pinMode(verde,OUTPUT); //declaramos el pin verde como salida
pinMode(amarillo,OUTPUT);//declaramos el pin amarillo como salida
pinMode(rojo,OUTPUT); //declaramos el pin rojo como salida
}

void loop() {
digitalWrite(verde,HIGH); //encendemos el led rojo
delay(2000); //esperamos 2 segundos
digitalWrite(verde,LOW); //apagamos el led rojo
delay(500); //esperamos medio segundo

digitalWrite(amarillo,HIGH); //encendemos el led amarillo

delay(2000); //esperamos 2 segundos
digitalWrite(amarillo,LOW); //apagamos el led amarillo
delay(500); //esperamos medio segundo

digitalWrite(rojo,HIGH); //encendemos el led verde

delay(2000); //esperamos 2 segundos
digitalWrite(rojo,LOW); //apagamos el led verde
delay(500); //esperamos medio segundo
}

P á g i n a 26 | 70
Con la sentencia int estamos declarando una variable numérica
entera, para poderla usar después en nuestro código.

El comando delay hace que el programa pare un tiempo determinado.

Éste lo definiremos, en milisegundos, dentro de los paréntesis.

Las funciones pinMode y digitalWrite se explicarán en el siguiente

post, salidas, con detalle.

Espero que os hayáis divertido con este post y que comencéis a

cogerle el gusanillo al mundo del Arduino.

Pines de salida

Arduino utiliza sus pines de salida para enviar señales eléctricas.

Éstas señales pueden utilizarse para alimentar otros dispositivos
(led's, zumbadores...) o para comunicarse enviando una serie de
pulsos que el receptor debe entender.

Las salidas se dividen en dos niveles o estados: HIGH a 5 V y LOW a

0 V. Por defecto, y sin ningún programa cargado en nuestra tarjeta
controladora, las salidas están a nivel LOW. Para valores
intermedios veremos los pines con función PWM despues.

Para valores constantes de 5V, 3.3V y 0V (GND) podemos utilizar los

pines correspondientes del apartado “POWER” de nuestro Arduino.

Configuración y uso de las salidas digitales

P á g i n a 27 | 70
Los pines que podemos configurar para que cambien el nivel de
salida según nuestro programa son los digitales, es decir, los 1 a 13.

Por defecto estos pines están configurados como entradas así que
lo primero que tenemos que hacer para utilizar un pin como salida
es configurarlo como tal. Para ello escribimos esta sentencia dentro
del apartado setup del programa.

pinMode(pin,OUTPUT);

Donde sustituiremos "pin" por el número del pin que queremos

configurar como salida. También podemos almacenar el número de
ese pin en una variable, por ejemplo el pin 10 en la variable llamada
"pinsalida" y escribirla dentro de la función pinMode

int pinsalida = 10; // almacena el número 10 en la variable "pinsalida"

pinMode(pinsalida,OUTPUT); // configura el pin número "pinsalida" (10) como salida

Ahora ya lo tenemos configurado como salida, pero aún sigue a 0 V,

es decir, a nivel LOW. Cuando en un determinado momento del
programa queramos que ese pin se ponga a nivel HIGH escribiremos
esta sentencia
digitalWrite(pinsalida,HIGH);

P á g i n a 28 | 70
Ahora tendremos 5 V permanentemente en ese pin a no ser que en
el programa insertemos
digitalWrite(pinsalida,LOW);

en cuyo caso se volverá al valor de 0 V. Podemos poner los pines a

HIGH o LOW tantas veces como queramos.

IMPORTANTE: hay que tener en cuenta que estos pines tienen una
intensidad limitada a 40 mA , por tanto no será suficiente para
alimentar a algunos relés, motores, bombillas y todo aquello que
necesite mayor corriente.

PWM

La función PWD nos permite obtener valores intermedios de salidas

entre 0 y 5V escalados en en 255 niveles, siendo 0 el más bajo (0 V)
y 255 el más alto (5 V).

Lo que en realidad sucede es que el microcontrolador alterna

rapidísimamente estados HIGH y LOW un tiempo proporcional al
valor requerido. Así, con 127 estaría el 50% del tiempo a HIGH y el
otro 50% restante a LOW. Nosotros no lo notamos porque todo ello
sucede a una frecuencia superior a la que captan nuestros ojos.

Los pines que permiten esta función están señalados con el símbolo
~ . En la placa Uno son los pines 3, 5, 6, 9, 10 y 11.

Si como vimos en anterior apartado ya tenemos nuestro pin

configurado como salida, para obtener un nivel de salida de 75%
escribiremos en nuestro programa

analogWrite(pinsalida,191);

Ya que 191 es el 75% de 255.

Ejemplo función PWM con LED

Este ejemplo consta de dos partes. Primero un led se encenderá

durante dos segundos. Luego variará su intensidad entre los valores
máximo y mínimo gradualmente. Para conseguirlo utilizaremos uno
de los pines PWM. El montaje es de lo más sencillo. Insertamos el
led en la protoboard. Para no dañar el led ponemos en serie una
P á g i n a 29 | 70
 resistencia de unos 220-470 Ohmios. Con valores menores se corre
el riesgo de dañarlo y valores mayores atenúan demasiado el brillo.

Seguidamente unimos mediante cables el pin 10 con la fila del ánodo

(pata larga) y el GND con la fila del extremo libre de la resistencia.
Si el led tiene las patas iguales, una forma de distinguir el cátodo del
ánodo es fijándose en el borde del led que no es completamente
circular. Pues la parte biselada corresponde al cátodo.

Ahora vamos con el programa. En la primera parte declaramos las

variables.
int pinsalida = 10; // variable para guardar el número del pin
int velocidad = 100; // variable para cambiar la velocidad de encendido/apagado
int pwm; // variable que almacenará el valor entre 0 y 255

Cambiando el valor de la variable velocidad haremos que el led tarde

más o menos tiempo en completar los ciclos de cambio de intensidad.

En la función setup hacemos que el led se encienda 2 segundos y

luego se apague.

void setup()
{
pinMode(pinsalida,OUTPUT); // configura "pinsalida" como salida
digitalWrite(pinsalida,HIGH); // pone el "pinsalida" a nivel alto
delay(2000); // espera 2000 milisegundos (2 segundos)
pinMode(pinsalida,LOW); // pon "pinsalida a nivel bajo
delay(1000); // espera 1 segundo
}

P á g i n a 30 | 70
 En la función loop hacemos uso del PWM. Escribimos un bucle “for”
que dará a la variable pwm un valor inicial de 0 y lo irá
incrementando en una unidad hasta que alcance el valor máximo de
255. A continuación, ponemos otro bucle “for” que irá decrementando
el valor desde el máximo hasta el mínimo.

void loop()
{
for(pwm=0;pwm<256;pwm++) // desde pwm valiendo 0; hasta que valga 255; incrementa pwm
{
analogWrite(pinsalida,pwm); // pone el "pinsalida" a el valor que almacena la variable "pwm"
delay(1000/velocidad); // espera (1000/velocidad) milisegundos
}
for(pwm=255;pwm>-1;pwm--) // este bucle hace lo mismo pero decrementando pwm
{
analogWrite(pinsalida,pwm);
delay(1000/velocidad);
}
}

El programa entero quedaría así.

/* ejemplo led pwm /

/***********************/

int pinsalida = 10; // variable para guardar el número del pin

int velocidad = 100; // variable para cambiar la velocidad de encendido/apagado
int pwm; // variable que almacenará el valor entre 0 y 255

void setup()
{
pinMode(pinsalida,OUTPUT); // configura "pinsalida" como salida
digitalWrite(pinsalida,HIGH); // pone el "pinsalida" a nivel alto
delay(2000); // espera 2000 milisegundos (2 segundos)
pinMode(pinsalida,LOW); // pon "pinsalida a nivel bajo
delay(1000); // espera 1 segundo
}

void loop()
{
for(pwm=0;pwm<256;pwm++) // desde pwm valiendo 0; hasta que valga 255; incrementa pwm
{
analogWrite(pinsalida,pwm); // pone el "pinsalida" a el valor que almacena la variable "pwm"
delay(1000/velocidad); // espera (1000/velocidad) milisegundos
}
for(pwm=255;pwm>-1;pwm--) // este bucle hace lo mismo pero decrementando pwm
{
analogWrite(pinsalida,pwm);
delay(1000/velocidad);
}
}

P á g i n a 31 | 70
Descripción de las entradas

Nuestro Arduino no sólo puede enviar señales, sino que también

puede recibirlas con dos propósitos principales como son leer datos
de sensores y recibir mensajes de otros dispositivos (shield, otro
Arduino, PC, etc.). Las entradas las clasificaremos en analógicas y
digitales.

Entradas analógicas

Las entradas analógicas del modelo Uno son las correspondientes a

los pines de A0 a A5. Se caracterizan por leer valores de tensión de
0 a 5 Voltios con una resolución de 1024 (10 bits). Si dividimos 5 entre
1024 tenemos que ser capaz de detectar variaciones en el nivel de la
señal de entrada de casi 5 mV.

Para hacer la lectura de uno de estos pines escribiremos en

nuestro código

lectura = analogRead(pinentrada);

“lectura” lo sustituimos por el nombre de la variable donde

queramos almacenar el valor leído y en “pinentrada” tendremos que
poner el número del pin analógico que hemos elegido (0,1,...5) o el
nombre de la variable que almacena dicho número.

Esta función nos devolverá un valor que va de 0 a 1023 en proporción

al nivel de la señal de entrada. Para una entrada nula obtendremos
el valor 0, para una entrada de 2.5 Voltios 511 (la mitad de 1023) y
para 5 Voltios 1023.

P á g i n a 32 | 70
Entradas digitales

Las entradas digitales son las mismas que las salidas digitales, es
decir, los pines que van del 1 al 13. Se diferencian de las analógicas
porque éstas son capaces de “entender” sólo dos niveles de señal,
LOW o valores cercanos a 0 V y HIGH o valores cercanos a 5 V.

Puede parecer una desventaja, pero en realidad puede ser todo lo

contrario. Y no sólo porque a veces únicamente necesitemos saber
dos estados (interruptor, pulsador, sensor de presencia, final de
carrera....) sino porque así es capaz de leer señales de pulsos
digitales. Esto significa que puede comunicarse.

Por poner un ejemplo, un sensor analógico de temperatura como es

el LM35 incrementaría el nivel de la tensión que llega a la placa de
forma proporcional a la temperatura. Sin embargo, uno digital como
el ds18b20 lo que haría es cambiar la sucesión de pulsos y por tanto
el mensaje que contiene el valor de la temperatura.

Aunque los pines digitales por defecto vienen configurados como

entradas, si queremos hacerlo manualmente escribimos en nuestro
código
pinMode(pinentrada,INPUT);

Para almacenar los dos valores posibles LOW o HIGH en una

variable llamada “lectura” escribimos
lectura = digitalRead(pinentrada);

Medición de temperatura. Sensor M35

Este sensor de temperatura lo podéis encontrar a un barato precio.

Es un sensor lineal, tiene una precisión de 0.5 ºC y una sensibilidad
de 10 mV/ºC.

P á g i n a 33 | 70
Vamos a hacer un pequeño proyecto para medir la temperatura
ambiente y visualizarla en nuestro PC. Su montaje no lleva más de
un par de minutos y podemos verlo claramente en el esquema. La
pata +Vs va al pin 5V, la pata Vout al pin que utilicemos para la
lectura, en este caso el 0, y la restante GND al pin GND. Tened en
cuenta que el dibujo del LM35 está hecho con vista desde las patas.
CUIDADO con colocarlo al revés porque si lo hacéis mal el sensor se
calentará rápidamente y aparte de estropearlo se quemará al
tocarlo.

El programa para este ejemplo es también muy simple y corto. Como

siempre empezamos con la declaración de las variables. Esta vez,
para almacenar la temperatura no utilizaremos una variable del tipo
int sino float para poder almacenar decimales.

float temperatura; // aquí almacenaremos el valor leído

int pinentrada = 0; // utilizaremos el pin A

P á g i n a 34 | 70
 Lo siguiente es abrir el puerto serial en la función setup. Esto se
hace para poder comunicarnos desde nuestro ordenador con el
controlador y así poder mostrar los datos por pantalla.
void setup()
{
Serial.begin(9600); // abrimos el puerto reial a 9600 bps
}

En el código quedaría así

void loop()
{
temperatura = analogRead(pinentrada); // lectura del pin A0
temperatura = (temperatura / 1023 * 5 / 0.01); // "traduce" el valor leído a grados
Serial.print(temperatura); // escribe el valor de la temperatura por el puerto
serial
Serial.print(" grados centigrados \n"); // escribe las unidades
delay(1000); // espera 1 segundo
}

Cargamos el código en la placa y sólo tenemos que pinchar en el

icono del monitor serial

P á g i n a 35 | 70
Si nos muestras caracteres extraños es que la configuración del
monitor serial está comunicándose con una tasa bps distinta a los
9600 con los que hemos configurado nuestro puerto serial. Para
corregirlo sólo tenemos que seleccionar el valor adecuado de la
pestaña desplegable como se puede ver en la siguiente imagen.

/*****************************/
/* Medicion de Temperatura */
/* con el sensor LM35 */
/*****************************/

/****** declaración de variables ******/

float temperatura; // almacenara el valor leido
int pinentrada = 0; // utilizaremos el pin A0

void setup()
{
Serial.begin(9600); // abrimos el puerto serial a 9600 bps
}

void loop()
{
temperatura = analogRead(pinentrada); // lectura del pin A0
temperatura = (temperatura / 1023 * 5 / 0.01); // traduce el valor a ºC
Serial.print(temperatura); // escribe el valor por el puerto serial
Serial.print(" grados centigrados \n"); // escribe las unidades de ºC
delay(1000); // espera un segundo
}

Ejemplo Botones

En este ejemplo, haremos una extensión del anterior. Nos

detendremos en uno de los elementos más básicos en el control de
Arduino, pero de los más usados y prácticos, los botones. Éstos son
un tipo de elemento externo que nos permite controlar físicamente
P á g i n a 36 | 70
acciones a realizar por nuestro sistema a través de dar continuidad
o no a la señal de entrada en la que están instalados. Como podréis
imaginar son parte fundamental de casi cualquier proyecto y son
muy fáciles de usar y programar, aunque hay que tener en cuenta un
par de detalles a la hora de usarlos.

Para comprender bien cómo funcionan en los distintos casos y cómo

solucionar algunos problemillas propios de los botones,
realizaremos 3 ejemplos para verlos detalladamente y en los que
usaremos el mismo circuito/esquema y solo iremos variando su
programación.

Esquema común

Para realizar todos los ejemplos necesitaremos los siguientes

elementos:

• 1 x Arduino UNO R3

• 1 X Protoboard

• 1 x led (usaremos rojo pero vale cualquier color)

• 1 x Botón

• 1x Resistencia de 220Ω (puede valer de 330Ω)

• 1 x Resistencia de 10kΩ (puede valer de 1 ó 5 kΩ)

• Cables para conectar todo

Con todo comenzaremos a montar nuestro circuito como se describe

en el siguiente esquema.

P á g i n a 37 | 70
Usaremos el pin 2 para encender el led y el 4 para saber el estado
del botón. Al montarlo debemos tener en cuenta un par de detalles.
Primero, que conectemos correctamente la polaridad del led,
siguiendo las indicaciones que os dimos en el ejemplo del semáforo.
Segundo, que usemos la resistencia de 10kΩ para conectar el botón
a tierra. Esto es muy importante, ya que con eso protegemos a
nuestra placa de crear un cortocircuito a tierra que podría
deteriorarla. La resistencia de 220Ω, como en ejemplos anteriores,
la usaremos para conectar el led a tierra.

Pulsador

Empezaremos con el botón más sencillo de programar y usar que

tenemos, el pulsador. Éste nos permite realizar una acción mientras
mantengamos pulsado nuestro botón, por ejemplo, que un led se
quede encendido mientras estemos pulsando.

Para nuestro programa declararemos una variable llamada

“pulsador” que usaremos para saber si nuestro botón está pulsado
o no.
int pulsador=0;

Dentro del setup, configuraremos el pin digital 2 como salida para

poder dar la orden de encender o apagar.

pinMode(2, OUTPUT);

Para que podamos saber en qué estado se encuentra nuestro botón

configuraremos el pin digital 4 como entrada.

pinMode(4, INPUT);
P á g i n a 38 | 70
Finalmente, nuestro código loop lo que hará será, primero leer del
pin 4 en qué estado está el botón mediante la sentencia digitalRead.
Este valor lo almacenaremos en la variable “pulsador” que
declaramos anteriormente.

pulsador = digitalRead(4);

Una vez que sepa cómo se encuentra el botón, mediante una función
“if”, si el pulsador está HIGH (pulsado) encenderá el led y si el
pulsador está en LOW (sin pulsar) lo apagará.

if(pulsador==HIGH) {
digitalWrite(2, HIGH);
}
else{
digitalWrite(2, LOW);

El código completo quedaría así:

/**************************/
/* Encender LED con Botón */
/* Pulsador */
/**************************/

//** Definiciones **//

int pulsador=0; //almacena el estado del botón

//** Programa **//

void setup() {
pinMode(2, OUTPUT); //declaramos el pin 2 como salida
pinMode(4, INPUT); //declaramos el pin 4 como entrada
}

void loop() {
pulsador = digitalRead(4); //lee el estado del botón
if(pulsador==HIGH) { //si el estado es pulsado
digitalWrite(2, HIGH); //se enciende el led
}
else{ //si el estado es no pulsado
digitalWrite(2, LOW); //se apaga el led
}
}

Interruptor

Con este tipo, podremos usar un botón de la misma manera que si

usáramos un interruptor de los que conocemos comúnmente.
Cuando pulsemos, se realizará la acción programada (encender el
P á g i n a 39 | 70
led) y se mantendrá en este estado hasta que volvamos a pulsar
nuevamente (se apagará el led).

Para obtener este tipo de botón solo haremos una pequeña

modificación del código anterior. Introduciremos una nueva variable
llamada “estado” que almacene el estado en el que se dejó el led tras
la última pulsación. De esta forma cuando pulsemos, Arduino se
acordará si el led estaba encendido o apagado.

int estado=0;

Usaremos esta “memoria” de Arduino para alternar entre encendido

y apagado cada vez que pulsemos. Esto lo haremos modificando el
código en la zona de void loop(). Primero introducimos un “if” que
hará que cuando pulsemos el botón alterne el valor de la variable
estado entre 0 y 1.

if(pulsador==HIGH){
estado=1-estado;
}

La expresión “estado=1-estado” lo que hace es que, si el estado era

apagado, igual a 0, al pulsar almacenará en la variable el valor 1-0
=1 y si el estado era encendido, igual a 1, al pulsar almacenará 1-1=0.

Después, en vez de comprobar cómo está la variable “pulsador”,

como hacíamos antes, lo que comprobamos es el valor que tiene la
variable “estado”. Si es 1 encenderá el led y si es 0 lo apagará.

if(estado==1) {
digitalWrite(2, HIGH);
}
else{
digitalWrite(2, LOW);

P á g i n a 40 | 70
El código completo quedaría así:

/**************************/
/* Encender LED con Botón */
/* Interruptor 1 */
/**************************/

//** Definiciones **//

int pulsador=0; //almacena el estado del botón

int estado=0; //0=led apagado, 1=led encendido

//** Programa **//

void setup() {
pinMode(2, OUTPUT); //declaramos el pin 2 como salida
pinMode(4, INPUT); //declaramos el pin 4 como entrada
}

void loop() {
pulsador = digitalRead(4); //lee si el botón está pulsado

if(pulsador==HIGH){ //si el boton es pulsado

estado=1-estado;
}

if(estado==1) { //si el estado es 1

digitalWrite(2, HIGH); //se enciende el led
}
else{ //si el estado es 0
digitalWrite(2, LOW); //se apaga el led
}
}

Interruptor con corrección de rebote

Al realizar el anterior ejemplo de interruptor, podréis daros cuenta

que hay algunas veces que nuestro botón falla y no hace
correctamente su función. Es imposible predecir su comportamiento.
A este efecto se le denomina rebote y es debido a varios motivos.
Aquí vamos a dar un par de soluciones rápidas y efectivas que nos
pueden ayudar en la mayoría de casos, pero en el módulo de nivel
intermedio explicaremos una solución al problema del “debounce”
más elaborada y fiable.

Uno de los motivos de este efecto, es que Arduino repite nuestro

loop de instrucciones miles de veces cada segundo. Esto provoca
que cuando pulsamos el botón una sola vez, Arduino leerá cientos
de veces seguidas que hemos pulsado e interpretará que hemos
pulsado todas esas veces. Por eso, la acción de encender y apagar
P á g i n a 41 | 70
se repetirá muy rápidamente, sin que lo apreciemos, hasta dejar el
led en la última posición leída.

Solucionar esto es sencillo. Solo tenemos que introducir una nueva

variable “pulsadorAnt” donde almacenemos en qué estado anterior
se encontraba el botón, pulsado o no, antes de nuestra pulsación.

int pulsadorAnt=0;

seguidamente, en nuestro loop, modificaremos el primer “if” que

teníamos introduciendo una segunda condición. Diremos que para
que Arduino cambie la posición del interruptor, no solo debe leer que
el botón está pulsado, “pulsador==HIGH”, sino que también debe
cumplirse que justo en el instante antes no estuviese pulsado,
“pulsadorAnt==LOW”. De esta forma Arduino solo leerá nuestra
pulsación una sola vez cada vez que pulsemos.

if((pulsador==HIGH)&&(pulsadorAnt==LOW)){
estado=1-estado;
}

Para finalizar, justo después de este “if”, actualizaremos el valor de

la variable “pulsadorAnt” con el nuevo valor de “pulsador” mediante
la siguiente línea.
pulsadorAnt=pulsador;

Si cargásemos ya este nuevo código a la placa, veríamos que nuestro

problema se ha solucionado casi del todo, pero que aún, algunas
veces, falla su funcionamiento. Esto es debido a la propia
construcción del botón.

Un botón, internamente, no es más que dos láminas metálicas que

se unen o separan por la acción de un resorte. En el momento de la
unión, o separación, de las láminas, el resorte provoca una serie de
rebotes entre las láminas que Arduino es capaz de detectar.

P á g i n a 42 | 70
 Para evitar este problema, una solución sencilla es meter una
pequeñísima pausa al programa justo después de que Arduino
detecte nuestra pulsación. De esta forma, cuando el código retome
su funcionamiento, los rebotes habrán terminado y no serán
detectados. En nuestro caso introduciremos una pausa de 40
milisegundos, aunque podéis probar a variar este valor a vuestro
gusto para afinar el resultado.
delay(40);

Podréis observar que aún falla alguna vez pero que su

funcionamiento es bastante más preciso que antes.

Esto es todo. Esperamos que se haya entendido bien y que no quede

muy lioso. Al seguir los pasos veréis que es muy fácil y divertido. Os
dejamos el código completo.

/* Encender LED con Botón */

/* Interruptor sin rebote */
//* Definiciones **//

int pulsador=0; //almacena el estado del botón

int estado=0; //0=led apagado, 1=led encendido
int pulsadorAnt=0; //almacena el estado anterior del boton

//** Programa **//

void setup() {
pinMode(2, OUTPUT); //declaramos el pin 2 como salida
pinMode(4, INPUT); //declaramos el pin 4 como entrada
}

void loop() {
pulsador = digitalRead(4); //lee si el botón está pulsado

if((pulsador==HIGH)&&(pulsadorAnt==LOW)){ //si el boton es pulsado y antes no lo estaba

estado=1-estado;
delay(40); //pausa de 40 ms
}
pulsadorAnt=pulsador; //actualiza el nuevo estado del boton

if(estado==1) { //si el estado es 1

digitalWrite(2, HIGH); //se enciende el led
}
else{ //si el estado es 0
digitalWrite(2, LOW); //se apaga el led
}
}

P á g i n a 43 | 70
Comunicación Serie

1.- ¿Qué es la comunicación serie?

Antes de comenzar, aclararemos que no nos adentraremos mucho

en la definición teórica de la comunicación serie ni en sus
especificaciones técnicas. Existe en Internet una gran cantidad de
información muy detallada al respecto y para nuestro cometido, que
es aprender a manejar Arduino y poder usarlo para nuestros propios
proyectos, no nos interesa complicarnos. Nuestra intención es hacer
accesible, fácil y divertido el mundo Arduino.

Una vez comentado esto, definiremos la comunicación serie como

una “interfaz de comunicación de datos digitales que nos permite
establecer transferencia de información entre varios dispositivos”.
Esto nos va a permitir interactuar con nuestro Arduino, recibiendo
información y enviándosela nosotros cuando lo necesitemos. Otra
cosa que nos será muy útil de esta comunicación, es que podremos
darle las órdenes, previamente programadas, que queramos.

2.- ¿Dónde tenemos que dirigirnos para comunicarnos en serie con

Arduino?

Para poder establecer esta comunicación usaremos el monitor

serial que tenemos en el IDE. Lo encontraremos pulsando el botón

con el mismo nombre, que tenemos arriba a la derecha.

P á g i n a 44 | 70
Una vez que lo pulsemos, se abrirá el monitor en el que podremos
recibir información de Arduino y escribirle nosotros, tanto
información que nos solicite como órdenes.

3.- Conexiones serie en Arduino

En la mayoría de Arduinos podemos encontrar 2 tipos de conexión

serie para las comunicaciones. Primero, tendremos los pines de
transmisión serie, que en Arduino UNO son los pines 0 (RX) para
recibir datos y 1 (TX) para transmitirlos. Con ellos podremos, por
ejemplo, conectar 2 Arduinos entre sí, conectándolos de manera
cruzada, para que trabajen en paralelo o conectar un Arduino con
otro dispositivo que también se comunique con este protocolo. Por
razones obvias no podremos usar estos pines como salidas digitales
mientras los usemos como conexión serial. En segundo lugar,
tenemos los puertos USB (Universal Serial Bus) propios de las
placas Arduino. Estos puertos, al trabajar con protocolo serial, los
podemos usar para conectarnos al PC directamente y facilitarnos así
el conexionado de Arduino con éste.

4.- Ejemplo: Ordenar a Arduino que encienda un Led,

Para entender mejor todo lo explicado, vamos a realizar un
ejemplo muy sencillo pero que nos sirve para darnos cuenta de lo
P á g i n a 45 | 70
 útil y potente que es esta característica de Arduino. Comenzaremos
realizando un esquema de montaje que utilizamos en el semáforo,
utilizando los mismos elementos, pero para un solo Led.

Una vez hemos montado el circuito, vamos al IDE y escribimos el

siguiente código, lo enviamos a nuestro Arduino y una vez terminado
el proceso haremos click en el botón del monitor serial.
/********************************/
/* Ordenar Parpadeos de un Led */
/********************************/
//** Definiciones **//
int parpadeos;
int led = 2;
//** Programa **//

void setup(){
Serial.begin(9600); // Inicia la comunicación serial
pinMode(led, OUTPUT);
}

void loop(){
if (Serial.available()>0){ // Comprueba si el serial está disponible
parpadeos = Serial.read()-48; // leemos el número de parpadeos
if (parpadeos >= 1 && parpadeos <= 9) // Si el valor introducido está entre 1 y 9
{
Serial.print("Se van a dar ");
Serial.print(parpadeos);
Serial.println(" parpadeos");
delay(1500);
for(int i=0;i<parpadeos;i++){ // Realiza los parpadeos
digitalWrite(led, HIGH);
delay(100);
digitalWrite(led, LOW);
delay(200);
}
}
else { // Si introducimos un valor erroneo
Serial.println("El dato introducido es incorrecto");
}
}
}
P á g i n a 46 | 70
Este programa lo que hace es que nuestro Led parpadee el número
de veces que le digamos. Para ello introduciremos valores, entre 1 y
9, por el monitor serial y pulsamos enter.

Para realizar el código, en primer lugar, hemos declarado las

variables que vamos a usar, como en anteriores ejemplos. En la zona
de setup hemos iniciado la comunicación serial con el comando
“ Serial.begin(9600) ” para que Arduino sepa que nos comunicaremos
con él a la velocidad de 9600 bits/seg (la velocidad es variable
siempre que se establezca la misma en el código y en el receptor de
la señal). Esto es necesario ponerlo siempre que vayamos a usar el
monitor serial, ya que sin esta línea Arduino no se comunicará por
serial. También hemos configurado nuestro pin del Led como salida.
Usaremos el pin 2 .

En el cuerpo de la función loop, comenzamos con la función “ if

(Serial.available()>0) ” que comprueba si hemos enviado datos por
serial para que, en nuestro caso, solo nos devuelva datos cuando los
pedimos. Una vez enviado el número, con la expresión “parpadeos =
Serial.read()-48 ” almacenaremos el valor que hemos enviado en la
variable “ parpadeos ”. Como habréis observado, al valor que lee del
serial le restamos 48. Esto es debido a que Arduino lee los
caracteres en código ASCII, el cual podéis ver aquí , y en este código
el número cero equivale al valor 48. De esta forma transformamos
los números de ASCII a decimales.

Continuaremos con “ if (parpadeos >= 1 && parpadeos <= 9) ”

imponiendo que el programa solo funcione si introducimos un
número mayor o igual 1 y menor o igual 9, en caso contrario nos
devolverá el mensaje “ El dato introducido es incorrecto ”.

Mediante la función “ Serial.print() ” Arduino nos imprimirá en el

monitor serial lo que pongamos dentro del paréntesis. Ya sea una
frase, que habremos de introducir entre comillas
Serial.print(“frase”) , o una variable, para lo que pondremos
directamente su nombre sin comillas Serial.print(variable) . Escrito
así nos irá imprimiendo todo en la misma línea, pero si escribimos
“ Serial.print ln () ” lo que haremos será que, tras esa impresión, la
siguiente se empezará a escribir en la línea de abajo. Usaremos esta
función para que Arduino se comunique con nosotros.

P á g i n a 47 | 70
Finalmente definiremos un bucle for. En nuestro caso “ for (int
i=0;i<parpadeos;i++) ”, para que iniciando el valor de “ i ” en 0, si “ i ”
es menor que el valor de parpadeos introducido, encenderá y
apagará el Led una vez e incrementará el valor de “ i ” en 1 cada vez
que pase por el bucle. De esta forma conseguimos que el Led
parpadee las veces que le hemos ordenado.

5.- Ejemplo: Reconocimiento de valores RGB por puerto serie

En el siguiente ejemplo, utilizaremos la comunicación serial para

que Arduino nos dé información, que necesitamos, de nuestro
circuito. Le pediremos que nos dé el valor que tienen 3
potenciómetros conectados a un Led RGB para saber el color exacto
que está dando. Éste es un ejemplo bastante usado en distintos
cursos para enseñar cómo funciona la comunicación serial en
Arduino, pero nos parece útil y divertido realizarlo con vosotros.

Con este circuito, controlaremos qué cantidad de rojo, verde y azul

dará nuestro Led y además, gracias a la comunicación serial,
Arduino nos dirá que color exacto está dando y podremos usar estos
datos con otros programas o decirle nosotros al sistema que dé un
color exacto que queremos.

Antes de comenzar, explicaremos que es un Led RGB. Es un Led que

dentro lleva 3 colores independientes que mezclan su intensidad
para proporcionar casi toda la gama de colores. Existen de dos tipos,
de cátodo común y de ánodo común. Esto solo quiere decir que los 3
Leds internos que lleva el RGB comparten una de las conexiones, ya
sea el cátodo que se conecta a tierra o el ánodo que se conecta a la
alimentación. Es fácil identificar cual es la conexión compartida, ya
que estos Leds tienen 4 filamentos y el más largo es el común. Los
otros 3 filamentos son los que controlan cada color. Da igual el tipo
que usemos, siempre que los conectemos correctamente.

P á g i n a 48 | 70
Para realizar este ejemplo necesitaremos los siguientes elementos:

• 1 x Arduino UNO R3

• 1 X Protoboard

• 1 x led RGB (de cátodo común)

• 3 x Resistencia de 220Ω (puede valer de 330Ω)

• 3 x Potenciómetros lineales de 10kΩ

• Cables para conectar todo

El circuito que debemos montar es el siguiente:

Hay que resaltar, que conectaremos cada ánodo a pines digitales

PWM del Arduino para controlar la intensidad que enviamos a cada
uno. Nosotros usaremos los pines digitales 3, 5 y 6 , y los analógicos
0, 1, y 2 .

Finalmente nos dirigiremos al IDE, escribiremos el siguiente código

y lo cargaremos a nuestro Arduino. Una vez cargado pulsaremos en
el botón de monitor serial.

P á g i n a 49 | 70
/**********************************/
/* Control de Led RGB con Serial */
/**********************************/
//** Definiciones **//

const int ledRojo=3; // definimos los pines digitales para el Led RGB
const int ledVerde=5;
const int ledAzul=6;
const int potRojo=0; // definimos los pines analógicos para los
potenciometros
const int potVerde=1;
const int potAzul=2;
int rojo; // definimos variables para los valores de cada
potenciometro
int verde;
int azul;

//** Programa **//

void setup(){
Serial.begin(9600); // inicia la comunicación serial
pinMode(ledRojo, OUTPUT); // configuramos los pines digitales como salida
pinMode(ledVerde, OUTPUT);
pinMode(ledAzul, OUTPUT);
}

void loop(){
rojo=analogRead(potRojo) / 4; // leemos el valor de cada potenciómetro
verde=analogRead(potVerde) / 4; // y lo almacenamos
azul=analogRead(potAzul) / 4;

analogWrite(ledRojo,rojo);
analogWrite(ledVerde,verde);
analogWrite(ledAzul,azul);

Serial.print("ROJO: ");
Serial.print(rojo); // si fuese ánodo común sería 255-rojo
Serial.print(" / ");
Serial.print("VERDE: ");
Serial.print(verde); // si fuese ánodo común sería 255-verde
Serial.print(" / ");
Serial.print("AZUL: ");
Serial.println(azul); // si fuese ánodo común sería 255-azul

delay(300);
}

Si prestamos atención al código, vemos que no tenemos funciones

que no conozcamos. Solo destacar que, como la función analogRead
lee valores entre 0-1023 y analogWrite los escribe entre 0-255, para
transformar los valores de uno a otro dividiremos el valor leído por
analogRead entre 4 para obtener una relación aproximada y

P á g i n a 50 | 70
suficientemente buena. El resto del programa, con lo aprendido en
los post anteriores, se entiende perfectamente.

Una vez que tenemos todo listo, podemos ver cómo, mientras
movemos los potenciómetros, el Led RGB va creando distintos
colores y en el monitor serial nos aparecen los valores de intensidad
que se están utilizando para conseguirlos. Con estos valores
podemos dirigirnos a cualquier programa de edición gráfica y utilizar
ese color exacto, o viceversa.

Probaremos a conseguir el color del logo de OpenWebinars.net .

Primero, abrimos el logo con Paint y haremos clic en la herramienta
“Selector de color”. Picaremos en el color del logo y después
pulsaremos en “Editar colores”. En la ventana emergente ya
podremos ver los valores RGB de nuestro color.

Ahora, si metemos esos valores en Arduino utilizando los

potenciómetros, nuestro Led RGB brillará con el color que
buscábamos. Podemos jugar con los colores y usarlos como más
nos diviertan.

P á g i n a 51 | 70
Sonidos con Arduino

Función tone

Con Arduino también podemos crear sonidos gracias a la función

tone cuya sintaxis es la siguiente:

tone(pinsalida,frecuencia);

Esta función lo que hace es intercambiar valores HIGH/LOW a la

frecuencia deseada en el pin seleccionado hasta que la volvemos a
llamar con otra frecuencia o le ordenamos que pare con esta función

noTone(pinsalida);

Tenemos que tener en cuenta que sólo es capaz de generar un único

tono a la vez. Si llamamos a la función tone para que genere sonidos
en otro pin sin haber detenido el que está sonando no ocurrirá nada.

Zumbador

Un zumbador es un elemento parecido a un altavoz, pero sólo emite

zumbidos (típico sonido que emiten los electrodomésticos).

Para hacerlo sonar utilizaremos los pines 13 y GND. El montaje no

merece más explicación que la de la imagen.

P á g i n a 52 | 70
Ya sólo falta crear el código y cargarlo. En la función loop hacemos
la llamada a tone para que suene y noTone para detener el sonido.
Cambiando los valores de la función delay haremos que suene
durante más o menos tiempo.

int pinzumbador = 13; // pin del zumbador

int frecuencia = 220; // frecuencia correspondiente a la nota La

void setup()
{
}

void loop()
{
tone(pinzumbador,frecuencia); // inicia el zumbido
delay(2000);
noTone(pinzumbador); // lo detiene a los dos segundos
delay(1000);
}
Podemos observar dos cosas:

Al cargar el programa suena brevemente el zumbador. Esto se debe

a que utilizamos el pin 13 y éste se pone a HIGH brevemente unas
veces cuando se inicia la placa.

Si variamos la frecuencia apenas varía el tono o no suena. La causa

de ésto es que un zumbador tiene poca capacidad para reproducir
sonidos fielmente. La frecuencia influye tan poco que incluso sonaría
conectándolo entre los pines 5V y GND. Para frecuencias demasiado
altas el zumbador no responde.

P á g i n a 53 | 70
Música

En este punto utilizaremos un pequeño altavoz. Podéis aprovechar

uno que tengáis en algún aparato que no utilicéis.

El mismo montaje servirá para los dos ejemplos siguientes. El

primero consistirá en reproducir una escala de 220 a 440 HZ con
todos sus semitonos. En el segundo reproduciremos música.

Si os fijáis en el esquema he puesto un condensador (~0.20€) en

serie con el altavoz. Ésto es para eliminar cualquier componente de
continua. Tened en cuenta que si elegís valores muy pequeños puede
recortar las frecuencias más bajas. Con valores de 47 uF o mayores
va bien. IMPORTANTE: Si usáis condensadores electrolíticos (los
cilíndricos) tenéis que tener en cuenta que tienen polaridad y si lo
colocáis al revés pueden explotar . Fijaros que tienen una franja con
signos “-” en la pata negativa.

P á g i n a 54 | 70
 Vamos con el primer ejemplo. Para no almacenar todas las
frecuencias y tener que escribir la función tone en nuestro código
cada vez que queramos una nueva nota, haremos un pequeño truco.
Almacenaremos sólo el valor de la frecuencia inicial, y las sucesivas
notas tendrán la frecuencia de la anterior multiplicada por 1,059. De
este modo escribiremos una sola vez la función para hacerlo sonar
y un bucle for será el encargado de ir incrementando el valor de la
frecuencia.
/***********************/
/* recorrido de octava */
/***********************/

int pinaltavoz = 13;

int frecuencia=220; // frecuencia correspondiente a la nota La
int contador; // variable para el contador
float m=1.059; // constante para multiplicar frecuencias

void setup()
{
}

void loop()
{
for(contador=0,frecuencia=220;contador<12;contador++)
{
frecuencia=frecuencia*m; // actualiza la frecuencia
tone(pinaltavoz,frecuencia); // emite el tono
delay(1500); // lo mantiene 1.5 segundos
noTone(pinaltavoz); // para el tono
delay(500); // espera medio segundo
}
}
P á g i n a 55 | 70
Ahora pasamos a lo bueno: reproducir música, pero de la que
recuerda a los videojuegos con música de 8 bits.

En este código utilizaremos una función auxiliar que llamaremos

nota con la siguiente estructura

nota(frecuencia,duración);

La ventaja es que nos ahorrará escribir decenas de veces la función

delay para indicar el tiempo que debe durar la nota. Cada vez que
llamemos a esa función se ejecutará esta parte del código

void nota(int frec, int t)

{
tone(spk,frec); // suena la nota frec recibida
delay(t); // para despues de un tiempo t
}

Os dejo varios fragmentos de canciones. Podéis buscar partituras

de canciones y pasar las notas a frecuencia y tiempo.

/**************************/
/* popurri para Arduino */
/**************************/

/**************** Antonio Guillermo Pérez Coronilla ***************/

/* declaración de variables */
int spk=13; // altavoz a GND y pin 13
int c[5]={131,262,523,1046,2093}; // frecuencias 4 octavas de Do
int cs[5]={139,277,554,1108,2217}; // Do#
int d[5]={147,294,587,1175,2349}; // Re
int ds[5]={156,311,622,1244,2489}; // Re#
int e[5]={165,330,659,1319,2637}; // Mi
int f[5]={175,349,698,1397,2794}; // Fa
int fs[5]={185,370,740,1480,2960}; // Fa#
int g[5]={196,392,784,1568,3136}; // Sol
int gs[5]={208,415,831,1661,3322}; // Sol#
int a[5]={220,440,880,1760,3520}; // La
int as[5]={233,466,932,1866,3729}; // La#
int b[5]={247,494,988,1976,3951}; // Si

void nota(int a, int b); // declaración de la función auxiliar. Recibe dos números
enteros.

void setup()
{

P á g i n a 56 | 70
/**************************************/
/* HARRY POTTER */
/**************************************/
nota(b[2], 500);
nota(e[3],1000);
nota(g[3], 250);
nota(fs[3],250);
nota(e[3],1000);
nota(b[3],500);
nota(a[3],1250);
nota(fs[3],1000);
nota(b[2], 500);
nota(e[3],1000);
nota(g[3],250);
nota(fs[3],250);
nota(d[3],1000);
nota(e[3],500 );
nota(b[2],1000 );
noTone(spk); delay(1000);
nota(b[2], 500);
nota(e[3],1000);
nota(g[3], 250);
nota(fs[3],250);
nota(e[3],1000);
nota(b[3],500);
nota(d[4],1000);
nota(cs[4],500);
nota(c[4],1000);
nota(a[3],500);
nota(c[4],1000);
nota(b[3],250);
nota(as[3],250);
nota(b[2],1000);
nota(g[3],500);
nota(e[3],1000);
noTone(spk);
delay(2000);

/*******************/
/* STAR WARS */
/*******************/
/**** tema principal ****/
nota(d[1],150);noTone(spk);delay(50);
nota(d[1],150);noTone(spk);delay(50);
nota(d[1],150);noTone(spk);delay(50);
nota(g[1],900);noTone(spk);delay(150);
nota(d[2],900);noTone(spk);delay(50);
nota(c[2],150);noTone(spk);delay(50);
nota(b[1],150);noTone(spk);delay(50);
nota(a[1],150);noTone(spk);delay(50);
nota(g[2],900);noTone(spk);delay(150);
nota(d[2],900);noTone(spk);delay(100);
nota(c[2],150);noTone(spk);delay(50);
nota(b[1],150);noTone(spk);delay(50);
nota(a[1],150);noTone(spk);delay(50);
nota(g[2],900);noTone(spk);delay(150);
nota(d[2],900);noTone(spk);delay(100);
nota(c[2],150);noTone(spk);delay(50);
nota(b[1],150);noTone(spk);delay(50);
nota(c[2],150);noTone(spk);delay(50);
nota(a[1],1200);noTone(spk);delay(2000); P á g i n a 57 | 70
 /**** marcha del imperio ****/
nota(g[2],500);noTone(spk);delay(100);
nota(g[2],500);noTone(spk);delay(100);
nota(g[2],500);noTone(spk);delay(100);
nota(ds[2],500);noTone(spk);delay(1);
nota(as[2],125);noTone(spk);delay(25);
nota(g[2],500);noTone(spk);delay(100);
nota(ds[2],500);noTone(spk);delay(1);
nota(as[2],125);noTone(spk);delay(25);
nota(g[2],500);
noTone(spk);delay(2000);

/**********************/
/* entre dos aguas */
/**********************/
nota(a[1],400);noTone(spk);delay(400);
nota(e[1],400);noTone(spk);delay(400);
nota(a[1],400);noTone(spk);delay(200);
nota(e[1],200);noTone(spk);delay(200);
nota(a[1],200);noTone(spk);delay(200);
nota(as[1],100);noTone(spk);delay(100);
nota(b[1],400);noTone(spk);delay(400);
nota(fs[1],400);noTone(spk);delay(400);
nota(b[1],400);noTone(spk);delay(200);
nota(fs[1],200);noTone(spk);delay(200);
nota(b[1],200);noTone(spk);delay(200);
nota(as[1],100);noTone(spk);delay(100);
nota(a[1],400);noTone(spk);delay(400);
nota(e[1],400);noTone(spk);delay(400);
nota(a[1],400);noTone(spk);delay(400);
}

void nota(int frec, int t)

{
tone(spk,frec); // suena la nota frec recibida
delay(t); // para despues de un tiempo t
}

void loop()
{
}

Ejemplo de so de sistema OneWire

En este ejemplo realizaremos un ejemplo de medición de

temperatura con el sensor ds18b20. Este sensor, aparte de tener
una buena precisión y una versión sumergible, funciona utilizando
un sistema de conexionado muy particular. Este sistema se
denomina OneWire. Con él conseguimos enviar y recibir datos por
un único cable. Esto tiene sus ventajas e inconvenientes, pero no
deja de ser una opción muy a tener en cuenta cuando vamos justos
de conexiones de control para nuestro proyecto, ya que nos
ahorramos un cable en cada sensor.

P á g i n a 58 | 70
En otro ejemplo, ya realizamos mediciones de temperatura con un
sensor. Lo interesante de este ejemplo no es el medir la temperatura,
si no aprender el funcionamiento del sistema OneWire, para poder
usarlo en cualquier sensor que lo utilice, y la instalación e importado
de librerías de terceros.

Existen muchos detractores de este sistema, que ponen de

manifiesto que el usarlo exige unos códigos algo complicados…y que
el conexionado no es demasiado intuitivo… La verdad es que ni son
tan complicados los códigos, ya que las librerías propias y los
ejemplos que traen estos sensores son una buena herramienta, ni
es tan complicada su conexión, solo hay que seguir el esquema que
os daremos posteriormente. Como veréis en Internet, la mayoría de
errores y problemas de las personas que los usan radican en un mal
conexionado.

¿Cómo usar las librerías y los ejemplos?

Esta vez, usaremos unas librerías en nuestro proyecto para

controlar el sensor térmico con el sistema OneWire que os hemos
comentado. En nuestro post 3, os definimos qué eran las librerías y
ahora os explicaremos como usarlas. Arduino tiene una serie de
librerías genéricas que podemos usar simplemente escribiendo al
principio de nuestro código la sentencia #include < librería .h>
repitiendo con todas las librerías que necesitemos.

P á g i n a 59 | 70
En este ejemplo vamos a usar las librerías propias del sensor en
cuestión, en nuestro caso usaremos las librerías DallasTemperature
y OneWire . Para instalar las librerías propias, o de terceros, una vez
descargadas existen 2 métodos:

1. Método normal: Dentro del IDE, nos dirigimos a Sketch->Importar

librería->Ad library …. Se nos abrirá una ventana de exploración en
la que debemos buscar el archivo rar/zip que hemos descargado. Lo
seleccionamos y ya la tendremos instalada.

2. Método manual: Si el método anterior no funciona, utilizaremos

la instalación manual. Para proceder, descomprimiremos el rar/zip
descargado y copiamos la carpeta de la librería en la ruta
Documentos\Arduino\libraries . Quedando, por ejemplo, de la
siguiente manera.

P á g i n a 60 | 70
Una vez instaladas las librerías que vayamos a usar, podremos usar
los ejemplos que traen cada una para probar sus accesorios. Es
interesante echarles un ojo antes de ponernos a programar como
locos, porque de estos ejemplos podemos aprovechar partes de
código o ver cómo usa las funciones… y así ahorrarnos mucho
trabajo. Para abrir estos ejemplos solo tendremos que dirigirnos
dentro del IDE a Archivo->Ejemplos y ahí veremos todas las librerías
disponibles y dentro de cada una, sus ejemplos correspondientes.

P á g i n a 61 | 70
Ejemplo: Medición de temperatura con sensor ds18b20

Para empezar con este ejemplo detallaremos el material necesario.

• 1 x Arduino UNO R3

• 1 x Protoboard

• 1 x Sensor de Temperatura ds18b20 (versión sumergible)

• 1 x Resistencia de 4,7kΩ

• Cables para conectar todo

En esta ocasión, es muy importante que prestéis atención al montaje

del circuito. No es para nada difícil, pero si no está correcto el sensor
dará medidas erróneas o incluso puede estropearse. El esquema es
el siguiente:

Como observamos en el circuito, alimentaremos a través del pin

DATA, por medio de la resistencia de 4,7kΩ, y los pines VCC y GND
van conectados entre sí y a tierra. En el datasheet del sensor podéis
ver cómo va el patillaje, o bien si usáis la versión sumergible, como
nosotros, la correspondencia de los 3 cables sería: [Rojo]=VCC, [Azul
o Negro] = GND y [Amarillo o Blanco] = DATA.

Una vez conectado todo correctamente, nos dirigiremos al IDE y

escribiremos el siguiente código.
P á g i n a 62 | 70
/******************************/
/* Medir Temperatura ds18b20 */
/******************************/

/*** Librerías ***/

#include <OneWire.h> //Se importan las librerías

#include <DallasTemperature.h>

//** Definiciones **//

#define Pin 2 //Se declara el pin donde se conectará la DATA

OneWire ourWire(Pin); //Se establece el pin declarado como bus para la

comunicación OneWire

DallasTemperature sensors(&ourWire); //Se llama a la librería DallasTemperature

//** Programa **//

void setup() {
delay(1000);
Serial.begin(9600);
sensors.begin(); //Se inician los sensores
}

void loop() {
sensors.requestTemperatures(); //Prepara el sensor para la lectura

Serial.print(sensors.getTempCByIndex(0)); //Se lee e imprime la temperatura en Cª

Serial.println(" Grados Centigrados");

delay(1000); //Se provoca una parada de 1 segundo antes de la

próxima lectura

En el programa, simplemente comenzaremos importando las

librerías, OneWire y DallasTemperature, de la forma que
comentábamos más arriba. Continuaremos definiendo el pin que
utilizaremos como bus de datos. Para ello usaremos la sentencia
#define, la cual nos permite crear un valor constante, pero con la
ventaja de no consumir la RAM que usaría, al compilar, la creación
de una variable. Hay que tener la precaución de escribir
correctamente las definiciones por que pueden provocar el lastrado
de errores a lo largo de todo el código si no se hace bien. En nuestro
caso asignaremos el pin 2 para el bus.

P á g i n a 63 | 70
Con la línea OneWire ourWire(Pin) , le decimos al sensor a través de
que pin se debe comunicar con Arduino y con DallasTemperature
sensors(&ourWire) llamaremos a la librería de Dallas para que
interprete los datos enviados y recibidos por nuestro bus.

Seguidamente, en nuestra función de setup, iniciaremos la

comunicación serial a 9600 bits/seg y con la sentencia
sensors.begin() activaremos los sensores que estemos usando.

Nuestro código en bucle, lo que hará será primero preparar al

sensor ds18b20 para medir, usando la función
sensors.requestTemperatures() y con la línea
Serial.print(sensors.getTempCByIndex(0)) tomará la medida y la
imprimirá, por el monitor serial y en grados centígrados, en una
única sentencia. Finalmente añadiremos la impresión del texto
“ Grados Centígrados ” y haremos una pausa de 1 segundo para que
el sensor no esté realizando miles de medidas constantemente.

Como habéis podido comprobar, es muy sencillo y práctico utilizar

este sistema. Solo hay que familiarizarse con las funciones
específicas de la librería de cada sensor para sacarles el máximo
provecho. Os recomendamos que leáis que funciones específicas
trae cada librería y juguéis un poco con ellas antes de poneros a
P á g i n a 64 | 70
programar vuestro proyecto, seguro que encontraréis algunas
funciones o ejemplos propios que os simplifican el código bastante.

Ejemplo: Pantalla LCD

En ejemplo veremos cómo mostrar a través de una pantalla LCD la

temperatura medida con el sensor LM35 que ya aprendimos a
utilizar en el post 5. ¿una pantalla LCD? Sí, pero no la confundamos
con la pantalla de nuestra televisión o la de nuestro smartphone,
esas son pantallas LCD-TFT,LCD-SPI... nosotros usaremos una LCD
simple y a un sólo color del tipo de las que podemos encontrar en
calculadoras y algunos electrodomésticos.

Material necesario

Suponiendo que ya tenemos nuestra placa Arduino Uno, nuestra

protoboard y un juego de cables, tendremos que hacernos con el
siguiente material:

Pantalla LCD. En este caso he elegido una de 16 columnas y 2

líneas (16x2) por ser probablemente la más común. En tiendas
online las he visto por unos 4 € envío incluido.

Sensor LM35. Si seguiste el post 5 probablemente ya lo tendrás.

Potenciómetro 10k. Lo necesitamos para ajustar el contraste de a

pantalla. Sin él sería ilegible. Cuesta pocos céntimos.

P á g i n a 65 | 70
Montaje

Viendo la foto puede parecer complicado por la cantidad de cables

que tiene, pero en realidad tener más conexiones no lo hace más
difícil. Si hacemos las conexiones paso a paso nos funcionará a la
primera. La que vamos a ver no es la única forma de conectar la
pantalla, pero así podemos utilizar los códigos de ejemplo de la IDE
para LCD sin cambiar ninguna línea. También tenéis que tener en
cuenta que las pantallas las suelen vender con el agujero para
soldarle un pin macho o un cable. Yo le he soldado una tira de pines
macho para poder insertarla en la protoboard pero si no queréis
soldar podéis meter los cables en los agujero con cuidado de que las
puntas no se toquen entre sí. Ahora vamos a ver de izquierda a
derecha como se conecta cada pin de la pantalla. Como los pines 5V
y GND los vamos a utilizar en más de una conexión, los conectamos
a las filas largas de nuestra protoboard y cuando un pin de la
pantalla se corresponda con 5V o GND lo conectaremos con su fila
correspondiente.

• SS a la fila GND
• VDD a la fila 5 V
• V0 a la pata central del potenciómetro
• RS al pin 12
• RW a la fila GND
• E al pin 11
• D0 a D3 sin conexión

P á g i n a 66 | 70
 • D4 al pin 5
• D5 al pin 4
• D6 al pin 3
• D7 al pin 2
• A a la fila 5 V
• K a la fila GND
• Del potenciómetro conectamos una de las patas libres a GND
y otra a 5 V
• Pata VS del sensor a la fila 5 V
• Pata central del sensor al pin A0
• Pata GND del sensor a la fila GND
• Si la pantalla no tiene iluminación prescindiremos de los pines
A y K.

No debemos olvidar que la primera vez que se conecta, tras

alimentarla debemos ajustar el potenciómetro hasta encontrar el
contraste óptimo. Antes de seguir podemos verificar que funciona
perfectamente cargando uno de los códigos de ejemplo de la IDE
como el que encontramos en Archivo → Ejemplos → LiquidCrystal
→ HelloWorld.

Código

Sólo vamos a tratar en profundidad la parte del código que tiene que
ver con el LCD y no con el sensor ya que está visto anteriormente.
Al final del post está el código completo. En primer lugar, tenemos

P á g i n a 67 | 70
que añadir la librería para LCD en Esketch → Importar librería →
LiquidCrystal o escribiendo

#include <LiquidCrystal.h>

Como la configuración de algunos pines puede variar tenemos que

indicarle a la librería cuáles hemos utilizado.

LiquidCrysta lcd(12,11,5,4,3,2);

Ya podemos pasar a la función setup . Ahora iniciamos el LCD.

lcd.begin(6,2);

El 16 y el 2 se refiere al número de columnas y filas de nuestra

pantalla. Lo siguiente es pasar a la función loop e indicar en qué
posición de la pantalla queremos el cursor. De manera genérica, el
comando es:
lcd.setCursor(columna, fila);

Pero ojo, empieza a contar desde cero, es decir, si queremos el

cursor en la primera columna de la primera fila tendremos que
escribir:
let.setCursor(0,0)

Una vez situado el cursor escribimos por pantalla la cadena de

caracteres “Temperatura:”. Las cadenas de caracteres van entre
comillas.
lcd.print(“Temperatura:”);

Suponiendo que ya hemos leído la temperatura y la tenemos

almacenada en una variable llamada temp falta mostrarla por
pantalla. Para que quepa la escribimos en la primera columna de la
segunda fila:

lcd.setCursor(0, 1);
lcd.print(temp);

P á g i n a 68 | 70
Y con esto escribirá el número que amacena la variable temp . Para
que nuestro proyecto quede más estético escribiremos la cadena de
caracteres “C” en la octava columna de la segunda fila (el símbolo “º”
no se muestra correctamente).

lcd.setCursor(7, 1);
lcd.print(“C”);

Aunque es este código no vamos a tener problemas al sobrescribir,

tenemos que tener en cuenta que sólo se borran las posiciones en
las que se escriben, el resto sigue manteniendo los caracteres que
mostraban anteriormente. Para limpiar la pantalla utilizaremos la
opción clear que borrará toda la pantalla.

lcd.clear();

Por último, introducimos un delay al gusto para evitar que refresque

tan rápido que no nos dé tiempo a leer los datos antes de que
cambien.

EJEMPLO HC-SR04 Sensor Ultrasónico y Monitor Serial

Aprenderemos a utilizar el sensor ultrasónico HC-SR04 para medir

distancia y encender un LED cuando se encuentre el objeto dentro
de un determinado rango. Usaremos el Monitor Serial para ver en
tiempo real el valor de distancia medido.

P á g i n a 69 | 70
/ *
programa que envía mediante el Monitor Serie el valor de distancia
leído por el sensor ultrasónico HC - SR04.

* /

int TRIG = 10; // trigger en pin 10

int ECO = 9; // echo en pin 9
int LED = 3; // LED en pin 3
int DURACION;
int DISTANCIA;

configuración nula ()
{
pinMode (TRIG, OUTPUT); // disparador como salida
pinMode (ECO, INPUT); // echo como entrada
pinMode (LED, SALIDA); // LED como salida
Serial.begin (9600); // inicializacion de comunicacion serial a 9600 bps

bucle vacío ()
{

digitalWrite (TRIG, HIGH); // generación del pulso a enviar

retraso (1); // al pin conectado al disparador
digitalWrite (TRIG, LOW); // del sensor

DURACION = pulseIn (ECO, HIGH); // con funcion pulseIn se espera un pulso

// alto en Echo
DISTANCIA = DURACION / 58.2; // distancia medida en centimetros
Serial.println (DISTANCIA); // envio de valor de distancia por monitor serial
retraso (200); // demora entre datos
}

P á g i n a 70 | 70