MANUAL ARDUINO

Facultad de Estudios Superiores

Cuautitlán

Licenciatura en Informática
Manual realizado por:

Carranza Solano Esaú

Carrizosa Hernández Karina

Ibáñez Tapia Manlio Fabio

Vargas Jerónimo Alicia

Arquitectura de Computadoras

Profa. Rosalba Nancy Rosas Fonseca

Grupo 2252

Licenciatura en Informática
 Contenido
Contenido .................................................................................................................................. 1
Introducción ............................................................................................................................. 4
Hardware Arduino.................................................................................................................... 5
¿Qué es un microcontrolador? ............................................................................................ 5
¿Qué es Arduino? .................................................................................................................. 7
Proyecto Arduino ................................................................................................................. 8
Características de la placa Arduino UNO ............................................................................ 9
Placa Arduino y sus partes.............................................................................................. 10
Software Arduino.................................................................................................................... 17
¿Qué es un IDE? ................................................................................................................... 17
Descarga e instalación ........................................................................................................ 17
Entorno de programación y configuración ....................................................................... 21
Prácticas ................................................................................................................................. 24
Práctica 1 ............................................................................................................................. 24
Objetivo .......................................................................................................................... 24
Materiales ....................................................................................................................... 24
Procedimiento ................................................................................................................ 24
Práctica 2 ............................................................................................................................. 27
Objetivo ........................................................................................................................... 27
Materiales ........................................................................................................................ 27
Procedimiento ................................................................................................................. 27
Práctica 3 ............................................................................................................................ 29
Objetivo .......................................................................................................................... 29
Materiales ....................................................................................................................... 29
Procedimiento ................................................................................................................ 29
Práctica 4 ............................................................................................................................. 31
1|Página
 Objetivo ........................................................................................................................... 31
Materiales ........................................................................................................................32
Procedimiento .................................................................................................................32
Práctica 5 .............................................................................................................................33
Objetivo ...........................................................................................................................33
Materiales ....................................................................................................................... 34
Procedimiento ................................................................................................................ 34
Práctica 6 ............................................................................................................................ 36
Objetivo .......................................................................................................................... 36
Materiales ....................................................................................................................... 36
Procedimiento .................................................................................................................37
Práctica 7 ............................................................................................................................ 40
Objetivo .......................................................................................................................... 40
Materiales ........................................................................................................................ 41
Procedimiento ................................................................................................................. 41
Práctica 8 ............................................................................................................................ 46
Objetivo .......................................................................................................................... 46
Materiales ....................................................................................................................... 47
Procedimiento ................................................................................................................ 47
Práctica 9 .............................................................................................................................52
Objetivo ...........................................................................................................................52
Materiales ........................................................................................................................52
Procedimiento .................................................................................................................52
Práctica 10........................................................................................................................... 55
Objetivo .......................................................................................................................... 55
Materiales ....................................................................................................................... 55
Procedimiento ................................................................................................................ 55

2|Página
 Práctica 11 ........................................................................................................................... 58
Objetivo .......................................................................................................................... 58
Materiales ....................................................................................................................... 59
Procedimiento ................................................................................................................ 59
Práctica 12 ............................................................................................................................ 61
Objetivo ........................................................................................................................... 61
Materiales ........................................................................................................................ 61
Procedimiento ................................................................................................................ 62
Conclusión .............................................................................................................................. 66
Referencias ............................................................................................................................. 67

3|Página
 Introducción
Construir coches y helicópteros teledirigidos, fabricar diferentes tipos de robots
inteligentes, crear sintetizadores de sonidos, montar una completa estación
meteorológica (con sensores de temperatura, humedad, presión, etc.), ensamblar una
impresora 3D, monitorizar la eficacia de nuestro refrigerador de cervezas desde el jardín,
controlar a través de internet la puesta en marcha de la calefacción y de las luces en
nuestra casa cuando estemos lejos de ella, enviar periódicamente los datos de consumo
doméstico de agua a nuestra cuenta de Twitter, diseñar ropa que se ilumine ante la
presencia de as, estableces un sistema de secuencia de golpes a modo de contraseña para
abrir puertas automáticamente, apagar todos los televisores cercanos de una sola vez,
implementar un sistema de riego automático y autorregulado según el estado de
humedad detectada en la tierra, fabricar un reloj despertador musical, utilizar una cámara
de vídeo como radar para recibir alamar de intrusos en nuestro teléfono móvil, etc. Todo
lo anterior y muchísimo más se puede conseguir con Arduino.

Todo el mundo, cada día, utiliza la tecnología. La mayoría de nosotros deja la

programación a ingenieros porque pensamos que programar y la electrónica son
complicados y difíciles de entender. En la actualidad estas actividades pueden ser
divertidas y excitantes. Gracias a Arduino, diseñadores, artistas, personas con hobbies y
estudiantes de todas las edades están aprendiendo a crear cosas que se iluminan, mueven
y responden ante personas, animales, plantas y el resto del mundo.

Durante años, Arduino ha sido usado como “cerebro” en miles de proyectos, cada uno
más creativo que el anterior. Una comunidad de colaboradores a nivel mundial a
participado en esta plataforma de código abierto desde personas dedicadas a la
programación, fabricantes, los cuales han contribuido a crear un nuevo mundo de
participación, cooperación y colaboración.

Arduino es abierto y simple. Este manual te guiará a través de lo básico de una forma
sencilla, con proyectos creativos para que los construyas y aprendas. Una vez que domines
lo básico, tendrá en sus manos programas y circuitos que puedes utilizar para crear algo
hermoso y hacer que alguien sonría con su invento.

4|Página
 Hardware Arduino
Un sistema electrónico es un conjunto de: sensores, circuitería de procesamiento y
control, actuadores y fuente de alimentación

Los sensores obtienen información del mundo físico externo y la transforman en una señal
eléctrica que puede ser manipulada por la circuitería interna de control. Existen sensores
de todo tipo: de temperatura, de humedad, de movimiento, de sonido (micrófonos), etc.

Los circuitos internos de un sistema electrónico procesan la señal eléctrica

convenientemente. La manipulación de dicha señal dependerá tanto del diseño de los
diferentes componentes hardware del sistema, como del conjunto lógico de instrucciones
(es decir, del “programa”) que dicho hardware tenga pregrabado y que sea capaz de
ejecutar de forma autónoma.

Los actuadores transforman la señal eléctrica acabada de procesar por la circuitería

interna en energía que actúa directamente sobre el mundo físico externo. Ejemplos de
actuadores son: un motor (energía mecánica), una bombilla (energía lumínica), un altavoz
(energía acústica), etc.

La fuente de alimentación proporciona la energía necesaria para que se pueda realizar

todo el proceso descrito de “obtención de información del medio <-> procesamiento <->
actuación sobre el medio”. Ejemplos de fuentes son las pilas, baterías, adaptadores AC/DC,
etc.

Ilustración 1 Esquema de Sistema Electrónico

¿Qué es un microcontrolador?
Un microcontrolador es un circuito integrado o “chip” (es decir, un dispositivo electrónico
que integra en un solo encapsulado un gran número de componentes) que tiene la
característica de ser programable. Es decir, que es capaz de ejecutar de forma autónoma
5|Página
una serie de instrucciones previamente definidas por nosotros. En el diagrama anterior,
representativo de un sistema electrónico, el microcontrolador sería el componente
principal de la circuitería de procesamiento y control.

Por definición, un microcontrolador (también llamado comúnmente “micro”) ha de incluir

en su interior tres elementos básicos:

CPU (Unidad Central de Proceso): es la parte encargada de ejecutar cada

instrucción y de controlar que dicha ejecución se realice correctamente.
Normalmente, estas instrucciones hacen uso de datos disponibles previamente
(los “datos de entrada”), y generan como resultado otros datos diferentes (los
“datos de salida”), que podrán ser utilizados (o no) por la siguiente instrucción.
Diferentes tipos de memorias: son en general las encargadas de alojar tanto las
instrucciones como los diferentes datos que estas necesitan. De esta manera
posibilitan que toda esta información (instrucciones y datos) esté siempre
disponible para que la CPU pueda acceder y trabajar con ella en cualquier
momento. Generalmente encontraremos dos tipos de memorias: las que su
contenido se almacena de forma permanente incluso tras cortes de alimentación
eléctrica (llamadas “persistentes”), y las que su contenido se pierde al dejar de
recibir alimentación (llamadas “volátiles”). Según las características de la
información a guardar, esta se grabará en un tipo u otro de memoria de forma
automática, habitualmente.
Diferentes patillas de E/S (entrada/salida): son las encargadas de comunicar el
microcontrolador con el exterior. En las patillas de entrada del microcontrolador
podremos conectar sensores para que este pueda recibir datos provenientes de su
entorno, y en sus patillas de salida podremos conectar actuadores para que el
microcontrolador pueda enviarles órdenes e así interactuar con el medio físico. De
todas formas, muchas patillas de la mayoría de los microcontroladores no son
exclusivamente de entrada o de salida, sino que pueden ser utilizados
indistintamente para ambos propósitos (de ahí el nombre de E/S).

Cada vez existen más productos domésticos que incorporan algún tipo de
microcontrolador con el fin de aumentar sustancialmente sus prestaciones, reducir su
tamaño y coste, mejorar su fiabilidad y disminuir el consumo. Así, podemos encontrar
microcontroladores dentro de multitud de dispositivos electrónicos que usamos en
nuestra vida diaria, como pueden ser desde un simple timbre hasta un completo robot

6|Página
pasando por juguetes, frigoríficos, televisores, lavadoras, microondas, impresoras, el
sistema de arranque de nuestro coche, etc.

¿Qué es Arduino?
Arduino es en realidad tres cosas:

Una placa hardware libre que incorpora un microcontrolador reprogramable y una serie
de pines-hembra (los cuales están unidos internamente a las patillas de E/S del
microcontrolador) que permiten conectar allí de forma muy sencilla y cómoda diferentes
sensores y actuadores.

Un software (más en concreto, un “entorno de desarrollo”) gratis, libre y multiplataforma

(ya que funciona en Linux, MacOS y Windows) que debemos instalar en nuestro ordenador
y que nos permite escribir, verificar y guardar (“cargar”) en la memoria del
microcontrolador de la placa Arduino el conjunto de instrucciones que deseamos que este
empiece a ejecutar. Es decir: nos permite programarlo. La manera estándar de conectar
nuestro computador con la placa Arduino para poder enviarle y grabarle dichas
instrucciones es mediante un simple cable USB, gracias a que la mayoría de las placas
Arduino incorporan un conector de este tipo.

Un lenguaje de programación libre. Por “lenguaje de programación” se entiende

cualquier idioma artificial diseñado para expresar instrucciones (siguiendo unas
determinadas reglas sintácticas) que pueden ser llevadas a cabo por máquinas.
Concretamente dentro del lenguaje Arduino, encontramos elementos parecidos a muchos
otros lenguajes de programación existentes (como los bloques condicionales, los bloques
repetitivos, las variables, etc.), así como también diferentes comandos –asimismo
llamados “órdenes” o “funciones” – que nos permiten especificar de una forma coherente
y sin errores las instrucciones exactas que queremos programar en el microcontrolador de
la placa. Estos comandos los escribimos mediante el entorno de desarrollo Arduino.

Con Arduino se pueden realizar multitud de proyectos de rango muy variado: desde
robótica hasta domótica, pasando por monitorización de sensores ambientales, sistemas
de navegación, telemática, etc. Realmente, las posibilidades de esta plataforma para el
desarrollo de productos electrónicos son prácticamente infinitas y tan solo están limitadas
por nuestra imaginación.

7|Página
 Proyecto Arduino
El proyecto Arduino comenzó en Ivrea, Italia (el sitio de la compañía
de computadoras Olivetti), en el año 2005 con el fin de crear un
dispositivo para estudiantes para el control integrado de
proyectos de diseño e interacción, con la finalidad de que fuera
más barato que los sistemas de creación de prototipos
disponibles en ese entonces. A partir de mayo de 2011, más de
300.000 unida- des de Arduino han sido distribuidas. Los fundadores
Massimo

Banzi y David Cuartielles nombraron el proyecto como Arduino de Ivrea, un protagonista

histórico de la ciudad. En primer lugar "Arduino" es un término masculino italiano, que
significa "gran amigo".

El proyecto Arduino es un fork (en la ingeniería de software, un

fork es un proyecto que sucede cuando los desarrolladores tienen
una copia legal del código fuente y empiezan el desarrollo
independiente de ella, creando una obra distinta de software) de
la plataforma Wiring de código abierto. Wiring fue creado por el
artista colombiano y programador Hernando Barragán como una
tesis de maestría en el Instituto de diseño e interacción Ivrea, bajo
la supervisión de Massimo Banzi y Casey Reas. Por otra parte, Wiring se basa en Processing
y su entorno de desarrollo integrado creado por Casey Reas y Ben Fry.

"Arduino fue construido en torno al proyecto Wiring de Hernando

Barragán. Wiring fue el proyecto de tesis de Hernando en el
Instituto de diseño e interacción Ivrea. Fue pensado para ser una
versión electrónica de Processing que utiliza nuestro entorno de
programación y fue modelado para la sintaxis de Processing. Fue
supervisado por mí mismo y Massimo Banzi, un fundador de
Arduino. No creo que Arduino existiría sin Wiring y no creo que
Wiring existiría sin Processing. Y sé que Processing sin duda no existiría sin Design By
Numbers y John Maeda”.

Entrevista con Ben Fry y Casey Reas por Shiffman Daniel (Sep 23, 2009).

8|Página
 Características de la placa Arduino UNO
El microcontrolador es el elemento central de la placa Arduino, que le proporciona su
carácter altamente versátil, de forma similar al que le otorga un microprocesador a una
computadora. Entre las partes más importantes del microcontrolador se tiene:

Un procesador programable que contiene una unidad lógica aritmética (ALU) y los
registros necesarios para la ejecución de las operaciones, que soporta un conjunto
de instrucciones reducido, optimizado y de alto rendimiento.
Memoria flash (no volátil), para almacenar los programas del usuario.
Memoria RAM para los datos del usuario.
Memoria ROM para datos persistentes.
Puertos de entradas/salidas digitales.
Puertos de entrada analógicos.
Salida analógica PWM.
Temporizadores internos.
Comunicación serial, I2C y SPI,
Estado de bajo consumo.

El microcontrolador ejecuta las operaciones en sincronismo con una señal binaria de clock
o reloj, a la velocidad de 8 a 32 MHz, dependiendo del modelo, que le provee un cristal de
cuarzo.

9|Página
 Placa Arduino y sus partes

Vista frontal

2 3

5
4
1 6

10 8

11
9

12

13 14

Vistas auxiliares
1

10 | P á g i n a
 1 Conector USB para el cable tipo AB

2 Pulsador de Reset

3 Pines de E/S digitales y PWM

4 LED verde de placa encendida

5 LED naranja conectado al pin 13

6 ATmega 16U2 encargado de la comunicación con el PC

7 LED TX (Transmisor) y RX (Receptor) de la comunicación serial

8 Puerto ICSP para programación serial

9 Microcontrolador ATmega 328, cerebro del Arduino

10 Cristal de cuarzo de 16Mhz

11 Regulador de voltaje

12 Conector hembra 2.1 mm con centro positivo

13 Pines de voltaje y tierra

14 Entradas análogas

Puerto USB
El puerto USB, cuenta con un conector estándar de tipo B o micro B, según el modelo de
placa, para la transmisión serial de datos de forma bidireccional.

Permite la conexión de la placa a una computadora para la transferencia del programa

compilado, lo que facilita su programación.

11 | P á g i n a
Cuenta con las terminales de energía de 5 V, lo que posibilita la alimentación independiente
de la placa por el puerto USB, por lo que no es necesario otra fuente de alimentación.

Ilustración 2 Conectores USB

Terminales digitales
Arduino dispone de un conjunto de terminales digitales de entrada/salida para la conexión
de cualquier dispositivo externo compatible como: sensores, motores, pantallas, teclados,
tarjetas de expansión como microSD, reloj de tiempo real, tarjetas de red, Bluetooth, GSM,
etc. El número de dispositivos externos digitales, compatibles con Arduino es cada vez
mayor.

Las terminales se numeran a partir de 0 y cada una es configurable mediante software, de

manera individual, como de entrada o de salida de datos, constituyendo el medio más
empleado para la conexión de dispositivos externos.

Las terminales numeradas como 0 y 1 tienen predeterminadas la función de transmisión

serial, sin embargo, también pueden ser reconfiguradas para otros usos, al igual que las
demás terminales digitales.

Si en una terminal digital se dispone un 1 lógico, ello se traduce físicamente en una tensión
o voltaje de aproximadamente 5V; por el contrario, si la terminal se presenta 0 lógico, ello
equivale a una tensión o voltaje de aproximadamente 0V. Esta situación es válida tanto
para la entrada de datos como para la salida.

Existe un límite máximo en la corriente que cada terminal puede suministrar al exterior
cuando se configura como salida, de alrededor de 40mA, la cual no debe excederse;
además se recomienda que la salida de corriente de todas las terminales, en conjunto, no
exceda de 200 mA aproximadamente, aunque ello depende del modelo de placa.

12 | P á g i n a
Modulación por ancho de pulso
Algunas terminales digitales tienen una marca o indicación junto a su numeración, lo que
indica que, cuando son configuradas como de salida, soportan la modulación por ancho
de pulso (PWM).

La modulación por ancho de pulso es una técnica que consiste en controlar el ancho del
pulso de una señal digital de alta frecuencia, para obtener un valor promedio equivalente
proporcional a la relación de los tiempos de duración del pulso alto entre la duración del
pulso bajo, para cada ciclo de la señal digital.

La Ilustración 3, muestra que cuando el ancho de pulso es alto, por ejemplo 90%, el nivel
de tensión promedio es de 4,5 V; cuando es de 50% (denominado duty cycle) valor medio
que se obtiene es 2,5 V y cuando es del 10%, el valor promedio de la tensión es de 0,5 V.

Ilustración 3 Modulación por ancho de pulso

El ancho de pulso puede ser regulado mediante instrucciones de software con muy alta
precisión, para obtener cualquier valor comprendido entre 0 y 5 V, lo cual equivale a un
conversor de señal digital a señal analógica.

Entradas analógicas
Una característica de Arduino es el soporte que brinda para la adquisición de datos
analógicos desde el exterior, para lo que dispone de un conversor analógico digital (CAD)
que convierte las señales analógicas en valores binarios equivalentes, para poder
procesarlos, transmitirlos o almacenarlos en forma digital, de forma similar a lo que se
realiza con un archivo digital de audio o video, como MP3 o MP4.

El CAD incorporado en la placa Arduino tiene una resolución de 10 bits, lo que determina
la subdivisión del rango de voltajes de 0 a 5 V en un conjunto de 2^10 = 1024 valores

13 | P á g i n a
pudiendo discriminarse niveles de voltaje que se diferencian en 5/1024=0,0049 V, que lo
hace conveniente y propicio para una variedad de aplicaciones.

El rango de voltajes que se digitaliza es configurable por software, tanto en su valor

máximo (no superior a 5 V) y en su valor mínimo.

Arduino dispone también la entrada denominada Aref (referencia analógica), que permite
establecer un nivel de referencia externa, la cual servirá de base para la conversión.

Los valores digitales que se obtienen del proceso de conversión se almacenan en variables
estándar o arreglos dentro de la placa.

Reset
La placa Arduino dispone de un botón, tipo pulsador, para el reinicio de la misma, lo que
provoca la ejecución del programa almacenado desde el principio.

LEDs indicadores
La placa contiene cuatro LEDs indicadores incorporados en la misma:

Power ON, indicador de encendido

TX, transmisión serial
RX, recepción serial
LED 13, conectado en la salida digital 13.

Comunicación serial
La comunicación serial entre dispositivos es la más empleada actualmente en los sistemas
de transmisión de datos digitales y es el sistema básico de comunicación de las placas
Arduino. Está soportado por uno o más dispositivos UART o transmisor/receptor
asincrónico serial, mediante los cuales se transmite cada byte de manera independiente
de los demás y en cualquier instante.

El UART da el soporte básico para la comunicación por el puerto USB y para las terminales
digitales denominadas Tx y Rx.

Comunicación SPI
Arduino incluye el sistema de comunicación denominado SPI (Interface serial para
periféricos), para la transferencia de datos, full dúplex (bidireccional simultáneo) de alta
velocidad (hasta 10 MB) y distancias cortas (hasta 30 cm), entre diferentes dispositivos de

14 | P á g i n a
hardware, como memorias, sensores, conversores, otras placas Arduino, etc., bajo el
esquema: maestro/esclavo.

El dispositivo maestro inicia la comunicación, habilitando a un dispositivo esclavo,

pudiendo intercambiar datos de forma sincrónica con el mismo.

Ilustración 4 Comunicación SPI

El estándar utiliza cuatro cables, denominados:

1. MOSI, master out, slave in, transmisión del maestro al esclavo.

2. MISO, master in, slave out, transmisión del esclavo al maestro.
3. SCK, señal de clock de sincronización enviado por el maestro
4. SS, slave select, permite que el dispositivo maestro habilite a un esclavo, uno a la
vez.

Comunicación I2C
Arduino incorpora otro sistema de comunicación para el intercambio de datos, basado en
el protocolo I2C que se caracteriza por emplear solo dos líneas denominadas SDA (serial
data) y SCL (serial clock), y al igual que el protocolo SPI, usa un esquema maestro/esclavo,
una velocidad de hasta 5 MB y un alcance de hasta 30 cm.

A diferencia del protocolo SPI, el I2C permite que cualquier dispositivo conectado sea
maestro, lo que se define mediante un sistema de arbitraje, otorgando ese privilegio a un
dispositivo a la vez. La transferencia de datos siempre lo inicia el dispositivo maestro,
habilitando al esclavo específico mediante una dirección de 7 bits, lo que permite
administrar hasta 128 dispositivos esclavos.

Ilustración 5 Comunicación I2C

15 | P á g i n a
Fuente de alimentación
Los componentes electrónicos de la placa Arduino operan con 5 V y/o 3.3 V, dependiendo
del modelo; estas tensiones se consiguen mediante uno o dos reguladores de tensión
incorporados en la placa, en consecuencia, la alimentación de energía externa debe tener
un voltaje mayor.

Arduino puede ser alimentada a través de tres medios distintos:

Fuente externa de corriente continua, con un valor comprendido entre 7 a 12 V CC,

mediante un conector Jack, con la polaridad indicada.
La fuente de suministro puede ser un adaptador universal de un mínimo de 500
mA, una batería de 9V, un juego de 4 pilas AA conectadas en serie o cualquier
batería recargable que proporciones un voltaje en el rango establecido.
Un conector USB con alimentación de 5 V de cc, proporcionado por una
computadora o un cargador de teléfono móvil. Voltaje entre 7 y 9 V CC,
directamente aplicado a la entrada Vin de la placa y negativo a la terminal GND.

16 | P á g i n a
 Software Arduino
¿Qué es un IDE?
Un programa es un conjunto concreto de instrucciones, ordenadas y agrupadas de forma
adecuada y sin ambigüedades que pretende obtener un resultado determinado. Cuando
decimos que un microcontrolador es “programable”, estamos diciendo que permite
grabar en su memoria de forma permanente (hasta que regrabemos de nuevo si es
necesario) el programa que deseemos que dicho microcontrolador ejecute. Si no
introducimos ningún programa en la memoria del microcontrolador, este no sabrá qué
hacer.

Las siglas IDE vienen de Integrated Development Environment, lo que traducido a nuestro
idioma significa Entorno de Desarrollo Integrado. Esto es simplemente una forma de
llamar al conjunto de herramientas software que permite a los programadores poder
desarrollar (es decir, básicamente escribir y probar) sus propios programas con
comodidad. En el caso de Arduino, necesitamos un IDE que nos permita escribir y editar
nuestro programa (también llamado “sketch” en el mundo de Arduino), que nos permita
comprobar que no hayamos cometido ningún error y que además nos permita, cuando ya
estemos seguros de que el sketch es correcto, grabarlo en la memoria del
microcontrolador de la placa Arduino para que este se convierta a partir de entonces en el
ejecutor autónomo de dicho programa.

Para poder empezar a desarrollar nuestros propios sketches (o probar alguno que
tengamos a mano) deberemos instalar en nuestro computador el IDE que nos proporciona
el proyecto Arduino. Para ello, seguiremos alguno de los pasos mostrados a continuación,
según cada caso particular.

Descarga e instalación
Para instalar este IDE en vuestro sistema operativo solo tienes que seguir unos sencillos
pasos:

1. Descargar el programa gratuito "Arduino IDE" de su propia página web. Ingresa al sitio
www.arduino.cc en la sección Download.

Hacer clic en tu sistema operativo, después en Guardar archivo y lo descargas en alguna

carpeta de acceso fácil en tu computadora.

17 | P á g i n a
 Ilustración 6 Descarga de Arduino IDE

2. Una vez descargado lo ejecutas y podrás ver la siguiente ventana.

Ilustración 7 Aceptación de condiciones

18 | P á g i n a
Aceptamos las condiciones. En este cuadro dejamos todas las opciones marcadas, pero
hay que prestar especial atención a la opción de instalar los USB driver, ya que esto es muy
importante para que la placa Arduino se pueda comunicar con el PC. Pulsamos en
Siguiente e Instalar.

Ilustración 8 Seleccione las opciones de instalación

Ilustración 9 Selección de carpeta de instalación

Y esperaremos que termine de instalar (si pregunta si deseamos instalar el software

Arduino USB le damos a instalar).

19 | P á g i n a
 Ilustración 10 Proceso de instalación

Una vez terminado el proceso, hacemos clic en Cerrar y ya tendremos el IDE instalado en
nuestra PC.

20 | P á g i n a
 Entorno de programación y configuración
Al abrir el programa veremos cómo nos aparece la consola principal del IDE Arduino en la
cual podemos ver las siguientes zonas:

Ilustración 11 Entorno IDE Arduino

En la parte de menú tenemos una zona para acceder a funciones como carga de archivos,
edición del texto del código, carga de librerías y ejemplos, configuración, herramientas,
etc. En los botones de acceso rápido tenemos los siguientes iconos:

Verifica si tu programa está bien escrito y puede funcionar.

Carga el programa a la placa de Arduino tras compilarlo.

Crea un programa nuevo.

Abre un programa.

Guarda el programa en el disco duro del ordenador.

21 | P á g i n a
 (En la parte derecha de la barra de herramientas se encuentra el Monitor Serial) abre
una ventana de comunicación con la placa Arduino en la que podemos ver las respuestas
que nuestro Arduino nos está dando, siempre que tengamos el USB conectado.

En el cuadro del editor de texto escribiremos el código del programa que queramos que
Arduino ejecute.

Finalmente, en el área de mensajes y la consola Arduino nos irá dando información sobre
si la consola está compilando, cargando…y sobre los fallos o errores que se produzcan
tanto en el código como en el propio IDE.

El siguiente paso que realizaremos será configurar nuestro IDE para que se comunique con
nuestra placa Arduino. Para ello conectaremos nuestro Arduino mediante el cable USB al
PC y después de que el sistema operativo haya reconocido e instalado la tarjeta
automáticamente, nos dirigimos a la zona de menú, pulsamos en Herramientas y después
en Tarjeta. Ahí seleccionamos el modelo de tarjeta Arduino que tengamos, en nuestro caso
"Arduino Uno".

Ilustración 12 Selección de Tarjeta

22 | P á g i n a
Después vamos a la opción Puerto Serial y elegimos el COM en el que tenemos conectado
nuestro Arduino.

Ilustración 13 Selección de Puerto COM

Si nos aparecieran varios COM activos, porque estemos usando otros dispositivos serial o
por otro motivo, para saber cuál de ellos es el que se comunica con nuestra placa, solo
tenemos que irnos a Panel de control/Hardware/Administrador de dispositivos. Miramos
la pestaña (Puertos COM y LPT) y ahí nos aparecerá nuestro Arduino y el COM en el que
está conectado. Con esto, ya podemos empezar a programar nuestro Arduino.

23 | P á g i n a
 Prácticas
Estas prácticas son diseñadas con ejercicios prácticos que permiten comprender el
concepto y de manera constante se está verificando lo aprendido mediante preguntas.
Finalmente se plantean ejercicios que involucran casos de la vida real.

Práctica 1
Objetivo
Realizar un ejercicio que consiste en encender y apagar un LED conectado al pin 13 de
Arduino, configurándolo como salida. El tiempo de encendido y apagado es de 100 ms. Al
terminar la práctica número 1 aprenderás lo siguiente:

Activar una salida digital

Encender un LED
Temporizar una señal de salida
Sintaxis de un programa en Arduino

Materiales
1 Arduino UNO
1 LED
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
1 Resistencia 330 Ω

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

C int a = 13; //Nombramos la salida 13 de Arduino.

Ó int N = 0;
D
I void setup() { //Apertura de librería
G pinMode(a, OUTPUT); //Se especifica que la salida trabajará
O digitalWrite(a,LOW);
}
D
E void loop() { //Espacio de trabajo en la librería abierta de
//programación
while(N<=9){ //Veces en las que el LED encenderá
P
N++;
R
//Tiempo de encendido y apagado

24 | P á g i n a
 O digitalWrite(a,HIGH);
G delay(100);
R digitalWrite(a,LOW);
A delay(100);
M }
A
C }
I
Ó
N

2. Conectar el cable USB tipo AB para comunicar el Arduino con el programa escrito en el
software.

3. Después conectamos el LED directamente al PIN 13 del Arduino, con el positivo del LED
(cuidando la polaridad) como se muestra en la imagen.

Ilustración 14 Conexión a Arduino: Práctica 1

En este paso se ha colocado el diodo LED sin resistencia en serie dado que el PIN 13 de
Arduino ya lleva incorporada una resistencia interior, en el caso de colocar el LED en otra
salida deberíamos colocar una resistencia entre 220 y 500 ohmios, dependiendo del
consumo de corriente del diodo. En esta práctica se utilizará una resistencia.

4. Conectaremos el LED en otra salida, para ello vamos a requerir de una protoboard,
cables de conexión y una resistencia de 330 ohms. Retiramos el LED del PIN 13 y

25 | P á g i n a
conectamos un cable de puente con salida al protoboard, en seguida conectamos la
resistencia de 330 ohms en serie, después la terminal positiva del LED.

Ilustración 15 Diagrama eléctrico: Práctica 1

5. Para cerrar el circuito conectamos el otro cable de conexión del PIN GND (Digital
Ground) a la protoboard en otro punto cuidado el sentido de conexión de los puntos,
finalmente cerramos el circuito con la punta negativa del LED.

Ilustración 16 Circuito: Práctica 1

6. Guardamos y compilamos el programa.

26 | P á g i n a
 Práctica 2
Objetivo
Realizar un ejercicio que consiste en encender y apagar un LED en periodos de 50
milisegundos. En la última repetición el LED debe de quedar encendido 5 segundos y
apagarse 5 segundos, el ciclo debe de reiniciarse. Al término de esta práctica aprenderás
lo siguiente:

Activar una salida digital

Encender un LED
Temporizar una señal de salida
Sintaxis de un programa en Arduino
Sintaxis de un ciclo for

Materiales
1 Arduino UNO
1 LED
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
1 Resistencia 330 Ω

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

C int led = 13; //Nombramos la salida 13 de Arduino con el nombre de LED

Ó void setup() { //Apertura de librería
D
I pinMode(led,OUTPUT); //Se especifica que la salida 13 trabajará
G }
O
void loop() { //Espacio de trabajo en la librería abierta de progamación
D for(int i=1;i<=5;i++){ //Ciclo for, 5 veces del LED por 50 ms
E
digitalWrite(led,HIGH);
P delay(50);
R digitalWrite(led,LOW);
O delay(50);
G if (i==5){ //En la quinta repetición el LED durará 5 s
R
A digitalWrite(led,HIGH);
M delay(5000);

27 | P á g i n a
 A digitalWrite(led,LOW);
C delay(5000);
I
Ó
}
N }
}

2. Conectamos el PIN 13 del Arduino al ánodo del LED.

3. Del ánodo del LED conectamos la resistencia de 330 ohms, la otra pata de la resistencia
irá conectada a la línea azul de la protoboard.

4. Conectamos GND de Arduino a la línea azul de la protoboard.

Ilustración 17 Diagrama eléctrico: Práctica 2

28 | P á g i n a
 Ilustración 18 Circuito: Práctica 2

5. Guardamos y compilamos el programa.

Práctica 3
Objetivo
Realizar un ejercicio en el cual se pondrá en práctica las funciones setup, loop y while,
aplicándolos por medio de esta práctica sin mayor dificultad. Al término de esta práctica
aprenderás lo siguiente:

Encender más de un LED

Sintaxis de un programa en Arduino
Aplicación de las funciones setup, loop y while

Materiales
1 Arduino UNO
3 LEDs (cualquier color)
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
3 Resistencias de 330 Ω

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

29 | P á g i n a
 /*Se declaran las variables que se utilizarán, siendo a, b y c las variables donde
indican por medio del número los pines que utilizarán y N es la variable que
servirá en las condiciones*/
int a = 13;
int b = 12;
int c = 11;
int N = 0;
C
Ó
D /*Se declara con digitalWrite que los LEDs comenzarán apagados (LOW), con
I pinMode se indicarán que los pines que se utilizan mandarán datos (OUTPUT)*/
G void setup() {
O pinMode(a, OUTPUT);
D digitalWrite(a,LOW);
E pinMode(b, OUTPUT);
digitalWrite(b,LOW);
P pinMode(c, OUTPUT);
R digitalWrite(c,LOW);
O
G }
R
A void loop() {
M while(N<=4){
A N++;
C
I digitalWrite(a,HIGH);
Ó delay(200);
N digitalWrite(a,LOW);
digitalWrite(b,HIGH);
delay(1000);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
delay(500);
digitalWrite(c,LOW);
}
}

30 | P á g i n a
 Ilustración 19 Diagrama eléctrico: Práctica 3

Ilustración 20 Circuito: Práctica 3

2. Guardamos y compilamos el programa.

Práctica 4
Objetivo
Realizar un ejercicio que consiste en encender 5 LEDs con un encendido secuencial con
periodos de 20 ms entre cada LED. Al terminar la práctica número 4 aprenderás lo
siguiente:

31 | P á g i n a
 Estructura y funcionamiento de un ciclo for
Sintaxis de un programa en Arduino

Materiales
1 Arduino UNO
5 LEDs (cualquier color)
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
5 Resistencias de 330 Ω

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

C int i; //Declaramos una variable de tipo entero i

Ó void setup() {
D
I /*Utilizamos un ciclo for empezando con el número de pines que utilizaremos
G como salida, hasta que el número de pin llegue al intervalo indicando que
O aumentará de uno en uno y se declara la variable i como salida*/
for(i=2;i<11;i++){
D pinMode(i,OUTPUT);
E
}
P }
R
O void loop() {
G for(i=2;i<11;i++){
R
A digitalWrite(i,HIGH);
M delay(20);
A digitalWrite(i,LOW);
C delay(20);
I }
Ó
N }

2. Colocamos una resistencia de 330 ohms entre el ánodo del LED y la salida
correspondiente del Arduino (pines del 10 al 7) y hacer esto en cada LED.

3. Conectar todos lo cátodos de los LEDs a la alimentación de 5V del Arduino.

32 | P á g i n a
 Ilustración 21 Diagrama eléctrico: Práctica 4

Ilustración 22 Circuito: Práctica 4

4. Guardamos y compilamos el programa.

Práctica 5
Objetivo
Realizar un ejercicio que consiste en lograr que 5 LEDs colocados secuencialmente
enciendan alternamente, primero que enciendan los LEDs 1, 3 y 5, al apagarse deberán
encender los LEDs 2 y 4, cabe mencionar que el ciclo debe de repetirse 10 veces. Al terminar
la práctica número 5 aprenderás lo siguiente:

33 | P á g i n a
 Estructura y funcionamiento del comando if
Sintaxis de un programa en Arduino

Materiales
1 Arduino UNO
5 LEDs (cualquier color)
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
5 Resistencias de 330 Ω

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

int led1 = 13; //Se declaran las variables y los pines

int led2 = 12;
int led3 = 11;
int led4 = 10;
int led5 = 9;

bool primeraVez = true; //La primera vez del circuito es verdadera

void setup() {
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
C pinMode(led4,OUTPUT);
Ó
D pinMode(led5,OUTPUT);
I }
G
O void loop() {
if(primeraVez){
D
E primeraVez = false;
for(int i=0; i<10; i=i++){ //Se dice el número de veces que debe de repetirse
P digitalWrite(led1,HIGH); /*Los LEDs 1, 3 y 5 deben de estar encendidos al
R mismo tiempo y el 2 y 4 apagados*/
O digitalWrite(led3,HIGH);
G
R digitalWrite(led5,HIGH);
A digitalWrite(led2,LOW);
M digitalWrite(led4,LOW);

34 | P á g i n a
 A delay(500);
C digitalWrite(led1,LOW); //Se invierte el encendido de los LEDs
I
Ó
digitalWrite(led3,LOW);
N digitalWrite(led5,LOW);
digitalWrite(led2,HIGH);
digitalWrite(led4,HIGH);
delay(500);
}
}
else{ //Cuando han pasado las 10 repeticiones el onceavo encendido es falso
digitalWrite(led1,LOW); //Y por consecuencia se apagan los LEDs
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
digitalWrite(led4,LOW);
digitalWrite(led5,LOW);
}
}

2. Colocar una resistencia de 330 ohms entre el ánodo del LED y la salida correspondiente
del Arduino (pines del 9 al 13) y hacer esto con cada uno de los LEDs.

3. De la resistencia se conectará otro cable al puerto GND del Arduino.

Ilustración 23 Diagrama eléctrico: Práctica 5

35 | P á g i n a
 Ilustración 24 Circuito: Práctica 5

4. Guardamos y compilamos el programa.

Práctica 6
Objetivo
Realizar un ejercicio que consiste en la aplicación de un pulsador en Arduino. Al terminar
la práctica número 6 aprenderás lo siguiente:

Conocer una forma de usar pulsadores en Arduino

Analizar la función antirrebote
Mostrar un ejemplo de contador
Instalar la librería TimerOne
Presentar las interrupciones programadas o Timers

Materiales
1 Arduino UNO
5 LEDs (cualquier color)
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
5 Resistencias de 330 Ω
1 Resistencia de 10k Ω
1 Pulsador

36 | P á g i n a
Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

#define boton 13 //Se define nuestra constante llamada botón 13

int led;
bool valor = 0; /*Se usará para almacenar por un corto período de tiempo la
medición lógica tomada del botón en el PIN 13*/
int contador = 0; //Variable de tipo entero que funciona como contador
int estadoanteriorboton = 0; /*Se almacena el último valor de la posición del
botón por un período más prolongado que la variable valor, se utilizará para
compararse con valor y posteriormente tomar su valor*/
bool leds = false; /*Se utiliza como condición desencadenante de la secuencia de
encendido de los LEDs*/
void setup()
C {
Serial.begin(9600); //Inicia la terminal para depurar el programa
pinMode(boton, INPUT); /*Declara el pin asignado a boton como puerto de
Ó entrada lógica*/
for (led = 8; led <= 12; led++) /*Se genera ciclo que inicie con la variable 8y
termina con su valor en 12*/
D {
pinMode(led, OUTPUT); /*Se declara como salida lógica del pin de igual valor
al valor que tiene en ese instante la variable led*/
digitalWrite(led, LOW); /*Se declara cómo iniciarán los LEDs al inicio del
I programa (apagados)*/
}
}
G void loop()
{
funcionAntirebote(); /*Función encargada de identificar las pulsaciones reales,
O omitiendo las falsas*/
switch (contador) //Se inicia la instrucción de tipo switch con dos casos
{
case 1:
leds = true;
D
break;
case 2:
leds = false;
E contador = 0;
break;
}
//Sale del switch y prosigue con la siguiente instrucción
37 | P á g i n a
 P if (leds == true) //Se comprueba si se debe iniciar la secuencia de encendido
{
contador = 1; /*Se asigna al contador el valor de 1 cada que inicia un ciclo
R entero de la secuencia de los LEDs*/
funcionAntirebote();
for (led = 8; led <= 12; led++) /*Se inicia el ciclo para encender los LEDs en
secuencia*/
O
{
if(contador==2)
{
G break;
}
funcionAntirebote();
R digitalWrite(led, HIGH);
funcionAntirebote();
delay(100);
funcionAntirebote();
A
digitalWrite(led, LOW);
}
funcionAntirebote();
M for (led = 12; led >= 8; led--)
{
if(contador==2)
A {
break;
}
funcionAntirebote();
C
digitalWrite(led, HIGH);
funcionAntirebote();
delay(100);
I funcionAntirebote();
digitalWrite(led, LOW);
}
Ó funcionAntirebote();
}
if (leds == false)
{
N
for (led = 8; led <= 12; led++)
{
digitalWrite(led, LOW);
}
}
}

38 | P á g i n a
 void funcionAntirebote()
{
valor = digitalRead(boton);
if (valor != estadoanteriorboton)
{
if (valor == 1)
{
contador++;
Serial.println(contador);
}
}
estadoanteriorboton = valor;
}

2. Colocar la resistencia de 10 kΩ entre masa y el PIN 13.

3. Colocar una resistencia de 330 Ω entre el ánodo del LED y la salida correspondiente del
Arduino (pines del 8 al 12) y hacer esto con cada LED.

Ilustración 25 Diagrama eléctrico: Práctica 6

39 | P á g i n a
 Ilustración 26 Circuito: Práctica 6

Ilustración 27 Circuito: Práctica 6

4. Guardamos y compilamos el programa.

Práctica 7
Objetivo
Realizar un ejercicio que consiste en elaborar un programa el cual contenga un contador
numérico que vaya desde 0 hasta 9 haciendo uso de un display de 7 segmentos
interactuando con el usuario por medio de un botón, el cual responderá a cada pulsación

40 | P á g i n a
aumentando en uno nuestro contador y para ello se utilizará en el código un do while. Al
terminar la práctica número 7 aprenderás lo siguiente:

Configuración de display de 7 segmentos

Analizar la función de las sentencias do while y Swift case

Materiales
1 Arduino UNO
1 Protoboard
Cables DuPont
1 Display de 7 segmentos
1 Cable USB Tipo AB
7 Resistencias de 220 Ω
1 Resistencia de 10k Ω
1 Push button

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

const int a = 2; /*Se declaran como constantes enteras según la configuración y

los pines a*/
const int b = 3;
const int c = 4;
const int d = 5;
const int e = 6;
const int f = 7;
const int g = 8; /*también se declara como constante el botón y el pin que
utilizará*/
const int botonIncremento = 9;
const int tiempoAntirebote = 10; /*Se declara la constante de la función
C antirebote y el tiempo de antirebote*/
int cuenta = 0; //se declara como entero la cuenta que comenzará en cero
int estadoBotonIncremento; /*Se declaran como enteros el estado de
Ó incremento del botón y el estado anterior al incremento del botón*/
int estadoBotonAnteriorIncremento;
boolean antirebote(int pin)
D { //Se hace uso de la función antirrebote ya antes utilizada
int contador = 0;
boolean estado;
boolean estadoAnterior;
41 | P á g i n a
 I do //El estado del botón será igual al estado anterior
{
estado = digitalRead(pin); //Comenzando con un valor de 0 y aumentara en 1
G cada que
if(estado != estadoAnterior) /*Se oprima el botón y al terminar esta función
comenzará nuevamente*/
{
O
contador = 0;
estadoAnterior = estado;
}
else
D {
contador = contador +1;
}
E delay(1);
}while(contador < tiempoAntirebote);
return estado;
}
P void actualizarNumero() /*Se hace uso de la función actualizar número esto
para ayudar a cambiar de un numero al siguiente cada que se oprima el botón*/
{
switch(cuenta)
R
{
case 0: //Utilizamos la sentencia switch, nos permitirá cambiar de caso
digitalWrite(a, LOW); /*Conforme la cuenta aumente realizando las
O instrucciones que cada caso presente*/
digitalWrite(b, LOW);
digitalWrite(c, LOW);
G digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, HIGH); /*Al final de cada caso se debe poner un break; esto
R
para: */
break; // Aumentar la cuenta pase de un caso a otro ya que si no es así al
case 1: //Uno, aumentar la cuenta seguirá repitiendo el mismo caso
A digitalWrite(a, HIGH);
digitalWrite(b, LOW); /*Se coloca en cada caso la configuración necesaria para
obtener en: */
M digitalWrite(c, LOW); //El display todos los dígitos del 0 al 9
digitalWrite(d, HIGH);
digitalWrite(e, HIGH); //Observación al ser utilizado el display de ánodo común
digitalWrite(f, HIGH); /*las configuraciones en LOW serán las que
A
permanecerán encendidas*/

42 | P á g i n a
 digitalWrite(g, HIGH); /*y las que estén en HIGH permanecerán apagadas.
Funcionará:*/
C
break; //Al revés de la lógica que ya conocemos
case 2:
digitalWrite(a, LOW);
I digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
Ó digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
break;
N
case 3:
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
break;
case 4:
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 5:
digitalWrite(a, LOW);
C
digitalWrite(b, HIGH);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
Ó digitalWrite(e, HIGH);
digitalWrite(f, LOW);
D
digitalWrite(g, LOW);
break;
case 6:
I digitalWrite(a, LOW);
digitalWrite(b, HIGH);
G
digitalWrite(c, LOW);
43 | P á g i n a
 digitalWrite(d, LOW);
digitalWrite(e, LOW);
O
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 7:
digitalWrite(a, LOW);
D
digitalWrite(b, LOW);
digitalWrite(c, LOW);
E digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
P case 8:
digitalWrite(a, LOW);
digitalWrite(b, LOW);
R
digitalWrite(c, LOW);
digitalWrite(d, LOW);
O digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
G
break;
case 9:
R digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
A
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
M digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
A
}
}
C
void setup()
{
I
//En void setup solo declararemos cada pin en el que se encuentra nuestra
pinMode(a, OUTPUT); //configuración como salidas
Ó pinMode(b, OUTPUT);
pinMode(c, OUTPUT); /*y declararemos el PIN que utiliza nuestro botón de
incremento como*/
N
pinMode(d, OUTPUT); //entrada

44 | P á g i n a
 pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
pinMode(botonIncremento, INPUT);
}

void loop()
{
estadoBotonIncremento = digitalRead(botonIncremento);
if(estadoBotonIncremento != estadoBotonAnteriorIncremento)
{
if(antirebote(botonIncremento))
{
cuenta++; //Continuamos con nuestra función antirrebote y le indicamos que
if(cuenta>9)
{
//Cuando la cuenta sea mayor a 9 nos regrese al número 0 y así volverá
cuenta= 0; /*a comenzar aquí, podemos pedirle que la cuenta se quede en 9
o que*/
} //comience en el valor que nosotros le indiquemos
}
}
estadoBotonAnteriorIncremento = estadoBotonIncremento;
actualizarNumero();
}

2. Colocar una resistencia de 220 Ω entre cada letra de acuerdo con la configuración del
display y los pines que utilizaremos como salidas colocándolo en orden desde el PIN 2 al
PIN 8.

3. Conectar un cable de la alimentación del Arduino de 5V a la línea de alimentación de la

protoboard (+), de esta misma línea alimentar el ánodo común del display de 7 segmentos.

4. Alimentar de esta misma línea con un cable una pata del push button y en la otra pata
conectar un cable hacia el PIN 9, en serie con este cable colocar una resistencia de 10 kΩ y
esta a su vez al negativo (-) de la protoboard y del negativo de la protoboard a tierra del
Arduino (GND).

45 | P á g i n a
 Ilustración 28 Diagrama eléctrico: Práctica 7

Ilustración 29 Circuito: Práctica 7

5. Guardamos y compilamos el programa.

Práctica 8
Objetivo
Realizar un ejercicio que consiste en formar la palabra HOLA, carácter por carácter en un
display de 7 segmentos. Al terminar la práctica número 8 aprenderás lo siguiente:

46 | P á g i n a
 Estructura y funcionamiento de un ciclo for
Aprender la conexión de un display de 7 segmentos
Impresión gráfica de caracteres

Materiales
1 Arduino UNO
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
8 Resistencias de 330 Ω
1 Resistencias de 10 kΩ
1 Display de 7 segmentos tipo cátodo DC05
1 Push button

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

//Se declaran los pines que se utilizarán para la activación del display
int e=12;
C
int d=11;
int c=10;
int dp=9;
int g=8;
int f=7;
Ó
int a=6;
int b=5;

int boton=13; //Se declara el botón en el PIN 13 de preferencia

int contador=0;
D
int estadoanterior=0;
bool valor=0;
//Estas tres declaraciones nos sirven para la función antirrebote
int led=5; //Esta variable se usará para la función for
void setup()
I
{
pinMode (a, OUTPUT);
digitalWrite (a, LOW);
pinMode (b,OUTPUT);
digitalWrite (b,LOW);
G
pinMode (c,OUTPUT);
47 | P á g i n a
 digitalWrite (c,LOW);
pinMode (d,OUTPUT);
digitalWrite (d,LOW);
pinMode (e,OUTPUT);
O digitalWrite (e,LOW);
pinMode (f,OUTPUT);
digitalWrite (f,LOW);
pinMode (g,OUTPUT);
digitalWrite (g,LOW);
pinMode (dp,OUTPUT);
digitalWrite (dp,LOW);
/*Con pinMode declaramos que los pines 5 a 12 enviarán datos (OUTPUT), con
digitalWrite declaramos que los pines 5 a 12 su comienzo, en este caso se
D mantendrán suspendidos, lo que tendrá el display totalmente apagado (LOW)*/
pinMode(boton,INPUT); /*El botón, contrario con los demás pines, sin PIN 13
recibirá datos en vez de enviar*/
}

E void funcionAntirebote() /*Función encargada de identificar las pulsaciones

reales, omitiendo las falsas*/
{
valor = digitalRead(boton); /*Se lee el valor en el pin asignado y se almacena en
la variable valor*/
if (valor != estadoanterior)
{
if (valor == 1)
{
P
contador++;
Serial.println(contador);
}
}
estadoanterior = valor;
R
}

void loop()
{
funcionAntirebote();
O
switch (contador)
{
case 1:
for(led = 5; led<=12; led++)
{
G
digitalWrite(led,LOW);

48 | P á g i n a
 }
digitalWrite(e,HIGH);
digitalWrite(c,HIGH);
digitalWrite(g,HIGH);
R digitalWrite(f,HIGH);
digitalWrite(b,HIGH);
break;
//Letra H
case 2:
A for (led = 5; led<=12; led++)
{
digitalWrite(led,LOW);
}
digitalWrite(e,HIGH);
M digitalWrite(d,HIGH);
digitalWrite(c,HIGH);
digitalWrite(f,HIGH);
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
A //Letra O
break;
case 3:
for (led = 5; led<=12; led++)
{
C digitalWrite(led,LOW);
}
digitalWrite(e,HIGH);
digitalWrite(d,HIGH);
digitalWrite(f,HIGH);
I break;
//Letra L
case 4:
for (led = 5; led<=12; led++)
{
Ó digitalWrite(led,LOW);
}
digitalWrite(e,HIGH);
digitalWrite(c,HIGH);
digitalWrite(g,HIGH);
N digitalWrite(f,HIGH);
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
break;
49 | P á g i n a
 //Letra A
default:
for (led = 5; led<=12; led++)
{
digitalWrite(led,LOW);
}
contador=0;
}
}

2. Los pines del 12 al 5 se conectarán a una resistencia de 330 Ω cada uno.

3. Cada resistencia saldrá a una conexión del display, en base al pin que se le conectó y
usando de base el diagrama de la Ilustración 30 se conectarán de la siguiente manera:

PIN CONEXIÓN DEL DISPLAY

12 e
11 d
10 c
9 dp
8 g
7 f
6 a
5 b

Ilustración 30 Tipos de display de 7 segmentos

50 | P á g i n a
4. Los dos puntos que se indican en el diagrama como GND serán conectados a dicho PIN
colocado en la sección DIGITAL.

5. El botón será conectado de un lado por el PIN 5V que se encuentra en la sección POWER.

6. Del otro punto de conexión del botón se conectará el PIN 13 y una resistencia de 10 kΩ,
dicha resistencia estará conectada al punto GND de la sección POWER.

Ilustración 32 Diagrama eléctrico: Práctica 8

Ilustración 31 Circuito: Práctica 8

7. Guardamos y compilamos el programa.

51 | P á g i n a
 Práctica 9
Objetivo
Realizar un ejercicio que consiste en mostrar un ejemplo de programación con un display
de 7 segmentos y un sensor de temperatura. Al terminar la práctica número 9 aprenderás
lo siguiente:

Funcionamiento de display de 7 segmentos

Uso de la librería SevSeg en Arduino

Materiales
1 Arduino UNO
2 Display de 7 segmentos
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
7 Resistencias de 220 Ω
1 Sensor TM35

Procedimiento
1. Descargar la librería “SevSeg.h” de Arduino y agregarla.

2. Escribir el siguiente código en el editor de texto del IDE de Arduino.

#include "SevSeg.h"
SevSeg sevseg;
float celsius=0;
int tempUnidad=0;
int actualizarTiempo=20;
unsigned long tiempo;
float temperaturaPin = 0;
C
Ó
D void setup()
I {
G byte numDigits=2;
O byte digitPints[]={5,4};
D byte segmentPints[]={12,11,10,9,8,7,6};
E bool resistorsOnSegments = false;
byte hardwareConfig = COMMON_CATHODE;
P
R

52 | P á g i n a
 O sevseg.begin(hardwareConfig, numDigits, digitPints, segmentPints,
G resistorsOnSegments);
R
A
sevseg.setBrightness(100);
M }
A
C void loop()
I {
Ó
N
if(millis()-tiempo>=actualizarTiempo)
{
tempUnidad = analogRead(temperaturaPin); // captura temperatura del sensor
tempUnidad = (5.0 * tempUnidad * 100.0)/1024.0; // convierte a grados
centígrados
sevseg.setNumber(tempUnidad,2); // Displays '21.4'
tiempo=millis();
}
sevseg.refreshDisplay();
}

3. Conectamos el TM36.

El sensor de temperatura TMP36 tiene 3 pines. Viendo este componente de frente a su

parte plana:

El pin de 5V del Arduino se conecta al PIN Vs (pin izquierdo) del TMP36.

El pin analógico A0 del Arduino se conecta al PIN Vout (pin central) del TMP36.
Algún PIN GND del Arduino se conecta al PIN GND (pin derecho) del TMP36.

4. Conectamos los displays.

Se puede comprar un display unificado o puentear los displays. Entre cada salida del
display se debe de colocar una resistencia.

53 | P á g i n a
 Ilustración 33 Diagrama eléctrico: Práctica 9

Ilustración 34 Circuito: Práctica 9

5. Guardamos y compilamos el programa.

54 | P á g i n a
 Práctica 10
Objetivo
Realizar un ejercicio que consiste en reproducir una melodía a través de un buzzer. Al
terminar la práctica número 9 aprenderás lo siguiente:

Uso de las señales PWM de Arduino

Simular una alarma haciendo uso de un buzzer en Arduino

Materiales
1 Arduino UNO
1 Buzzer
1 LED
1 Pulsador
Cables DuPont
1 Cable USB Tipo AB
1 Resistencia de 330 Ω
1 Resistencia de 10k Ω

Procedimiento
1. Descargar la librería “SevSeg.h” de Arduino y agregarla.

2. Escribir el siguiente código en el editor de texto del IDE de Arduino.

#include <SoftwareSerial.h> // Incluimos la librería SoftwareSerial

SoftwareSerial BT(6,7); //Tx y Rx
#define led 12
int spkr = 9;
C

int La5 = 880;

int Si = 988;
Ó int Do = 1046;
int Re = 1175;
int Mi = 1318;
int Fa = 1397;
D int Sol = 1568;
int La = 1760;

int a = 400;
55 | P á g i n a
 int b = 200;
I int c = 300;

int i = 0;
int tiempoEntreNotas = 40;
G int tiempoAbierto = 1;
int intervalos = 0;
int intervalo = 1000/tiempoEntreNotas;
int segundos = 0;
O char estado;
bool abierto = false;
int nota[38] = {Mi, Si, Do, Re, Do, Si, La5, La5, Do, Mi, Re, Do, Si, Si, Do, Re, Mi,
Do, La5, La5,
Re, Fa, La, Sol, Fa, Mi, Do, Mi, Re, Do, Si, Si, Do, Re, Mi, Do, La5, La5};
int tiempo[38] = {c, b, b, c, b, b, c, b, b, c, b, b, c, b, b, c, c, c, c, c, a, b, c, b, b, c, b,
c, b, b,
c, b, b, c, b, c, c, c};
D
void setup()
{
Serial.begin(9600);
BT.begin(9600);
pinMode (spkr, OUTPUT);
E
pinMode(led,OUTPUT);
digitalWrite(led,LOW);
}
void loop()
{
estadoBoton();
if(abierto==true)
P {
for(i = 0; i <= 37; i++)
{
tone(spkr, nota[i]);
R delay(tiempo[i]);
noTone(spkr);
estadoBoton();
if(abierto==false)
O
{
break;
}
}
}
G
}

56 | P á g i n a
 bool estadoBoton()
R
{
if(BT.available()>0)
{
estado = BT.read();
}
A

if(estado=='a')
{
digitalWrite(led,HIGH);
M intervalos++;
delay(tiempoEntreNotas);
if(intervalos == intervalo)
{
A if(segundos<tiempoAbierto+1)
{
segundos++;
Serial.println(segundos);
C }
intervalos = 0;
}
}
I if(segundos==tiempoAbierto)
{
abierto = true;
}
Ó
if(estado=='b')
{
digitalWrite(led,LOW);
noTone(spkr);
intervalos = 0;
N
segundos = 0;
abierto = false;
}
}

3. Se realiza la conexión como se muestra en el siguiente diagrama, tan fácil como conectar
negativo a GND y positivo al PIN 9.

57 | P á g i n a
 Ilustración 35 Diagrama eléctrico: Práctica 10

Ilustración 36 Circuito: Práctica 10

4. Guardamos y compilamos el programa.

5. Verificamos que si dejamos el botón en ON (circuito cerrado), el LED permanecerá

encendido y si el botón continúa en esa posición por un minuto la alarma sonora se
activará y no dejará de sonar hasta que el botón cambie de estado.

Práctica 11
Objetivo
Realizar un ejercicio que consiste en elaborar un programa el cual sea capaz de controlar
un sensor de movimiento elaborado con fotodiodos emisor y receptor, con el objetivo de
que al haber presencia de movimiento o alguna barrera física un LED se encienda y al no

58 | P á g i n a
haber durante un minuto se apague. Al terminar la práctica número 11 aprenderás lo
siguiente:

Conexión de un sensor de movimiento o de barrera elaborado con fotodiodos

emisor y receptor

Materiales
1 Arduino UNO
1 Protoboard
Cables DuPont
1 Cable USB Tipo AB
1 Resistencia de 1kΩ
1 Resistencia de 10 kΩ
1 Resistencia de 200 Ω
1 Fotodiodo receptor de infrarrojo
1 Fotodiodo emisor infrarrojo
1 LED

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

C int infrarrojo = 3;
Ó int estado;
D
I void setup() {
G Serial.begin(9600);
O pinMode(12,OUTPUT);
}
D void loop() {
E
estado = digitalRead(infrarrojo);
P if(estado==HIGH)
R {
O digitalWrite(12,HIGH);
G Serial.println("Encender");
R
A }else{
M digitalWrite(12,LOW);
A Serial.println("Apagar");
C delay(5000); //Para usos prácticos se reduce el tiempo de 1 min. a 5 seg.
I }
Ó
N }

59 | P á g i n a
2. Puentear los lados de la protoboard positivo con positivo y negativo con negativo.

3. Colocar una resistencia de 1 kΩ del positivo de la protoboard a la parte positiva del

emisor (patita con doblez) y de la parte negativa del emisor (patita recta) conectar un
cable al negativo de la protoboard.

4. Conectaremos el receptor, pero para este la patita recta se conectará a positivo con una
resistencia de 10 kΩ, dejando un espacio entre el receptor y la resistencia para conectar un
cable de ese punto medio al PIN 3 del Arduino y la patita con un doblez se conectará a
negativo de la protoboard.

5. Conectaremos un LED con su lago negativo al negativo de la protoboard y en su lado

positivo conectaremos una resistencia de 200 Ω a cualquier punto de la protoboard y de
ahí sacaremos un cable al PIN 12 de nuestro Arduino.

6. Por último alimentamos del PIN 5V del Arduino al positivo de la protoboard y del GND
del Arduino al negativo de la protoboard.

Ilustración 37 Diagrama eléctrico: Práctica 11

60 | P á g i n a
 Ilustración 38 Circuito: Práctica 11

7. Guardamos y compilamos el programa.

Práctica 12
Objetivo
Realizar un ejercicio que consiste en simular una puerta de garaje con interruptores
infrarrojos, el primer sensor al bloquear la señal hará que el motor gire en sentido horario
activando un buzzer y un LED, al desbloquear la señal se detendrá, cuando al segundo
sensor se interrumpa, su señal realizará lo mismo que el primero pero el motor girará en
sentido antihorario, utilizando un puente H. Al terminar la práctica número 12 aprenderás
lo siguiente:

Uso de interruptores infrarrojos.

Uso de un motor DC
Aplicación de un Puente H

Materiales
1 Arduino UNO
1 Buzzer
1 LED
2 Emisor y Receptor Infrarrojo
Cables DuPont
1 Cable USB Tipo AB
61 | P á g i n a
 1 Motor de DC
4 Diodos
4 Transistores C2073
1 Buzzer
4 Resistencias de 1 kΩ
3 Resistencias de 330 Ω
2 Resistencias de 33 kΩ

Procedimiento
1. Escribir el siguiente código en el editor de texto del IDE de Arduino.

const int analogInPin = A0; // Pin analogico 1 para la lectura del Fototransistor 1
const int analogInPin1= A1;// Pin analogico 1 para la lectura del Fototransistor 2
const int OutPin = 13; //Pin para el buzzer indicador
const int OutPin1=12;// Pin para el led indicador
int izquierdaPin=9; //Pines de salida del Arduino
int derechaPin=8;
int sensorValue = 0; // Inicializamos el valor del sensor
C int sensorValue1 = 0;

Ó void setup()
{
D Serial.begin(9600);// Inicializamos la comunicación serial a 9600 bps
I pinMode(OutPin, OUTPUT);
pinMode(OutPin1, OUTPUT);
G pinMode(izquierdaPin, OUTPUT);
pinMode(derechaPin, OUTPUT);
O }

void loop()
{
D // leemos el pin para y asignamos el valor a la variable.
sensorValue = analogRead(analogInPin);
E
sensorValue1 = analogRead(analogInPin1);
// Si el valor obtenido es mayor a 900 se activa el LED
if(sensorValue<500)
P {
digitalWrite(OutPin, 1);
R
digitalWrite(OutPin1, 1);
O digitalWrite(izquierdaPin, 0);
digitalWrite(derechaPin, 1);

62 | P á g i n a
 G }
else
R
{
A if(sensorValue1<500)
{
M digitalWrite(OutPin, 1);
digitalWrite(OutPin1, 1);
A
digitalWrite(izquierdaPin, 1);
C digitalWrite(derechaPin, 0);
}
I else
{
Ó
digitalWrite(OutPin, 0);
N digitalWrite(OutPin1, 0);
digitalWrite(izquierdaPin, 0);
digitalWrite(derechaPin, 0);
}
}
// Imprimimos el valor en el monitor.
Serial.print("sensor = ");
Serial.println(sensorValue);
Serial.print("sensor1 = ");
Serial.println(sensorValue1);
}

2. Armar el puente H.

3. Armar el siguiente circuito:

63 | P á g i n a
 Ilustración 39 Diagrama eléctrico: Práctica 12

Ilustración 40 Circuito: Práctica 12

Los pines que controlarán el giro del motor serán el 9 (derecha) y el 8 (izquierda).

Los pines que leerán la señal serán el A0 y el A1.

64 | P á g i n a
El A0 leerá la señal que manden los sensores número 1 para hacer que el motor gire al lado
derecho y el A1 leerá la señal del sensor número 2 y girará de lado izquierdo.

El PIN 13 irá conectado al buzzer y el 12 al LED, servirán como señales de que el motor está
girando.

4. Guardar y compilar el programa.

65 | P á g i n a
 Conclusión
El uso de una placa Arduino requiere un mínimo de conocimientos técnicos básicos, tanto
de electrónica, como de programación; una vez superada esta etapa, su uso es simple,
pudiéndose abordar proyectos de nivel básico e intermedio. Para encarar proyectos
avanzados o más especializados, es necesario considerar otros aspectos técnicos a detalle.

La gran versatilidad de las placas Arduino, permiten aplicarlas en multitud de proyectos en

diferentes áreas, por ejemplo: robótica móvil, robótica industrial, domótica, sistemas de
vigilancia y seguridad, adquisición de datos, sistemas de control automáticos, inteligencia
artificial, publicidad, tableros de control, etc., etc.; estando los campos de aplicación
limitados solo por la creatividad de los usuarios.

Las posibilidades de aplicación de las placas Arduino crecen exponencialmente con la gran
variedad de sensores, actuadores y placas shields existentes y la gran variedad de recursos
de software de programación, plataformas y entornos de desarrollo disponibles.

El realizar las practicas mostradas en este manual nos permite ver el potencial que tiene la
plataforma de desarrollo al utilizar Arduino. Tener conocimientos básicos de electrónica y
conocimientos de programación en lenguaje Java y lenguaje C, para el desarrollo de
la lógica de encendido y apagado de las luces que interpreta la placa Arduino.

En el presente manual se hizo un análisis de cómo se conforman los componentes de

hardware y software en la placa Arduino y los componentes que se utilizaron, se
mostraron los códigos de cada programa y sus correspondientes diagramas eléctricos y
circuitos con el propósito de elaborar los proyectos con facilidad.

Las primeras practicas nos ayudaron a iniciarnos con Arduino UNO, utilizando múltiples
LEDs, integrando pulsadores, buffers y conforme se iba avanzando se empezó a integrar
el uso de IR (Infra Rojo), displays, control de motor, control de salidas digitales, el uso y
control del convertidor analógico digital, etc.

Al terminar las practicas abre la posibilidad de realizar proyectos más grandes y complejos.

66 | P á g i n a
 Referencias
Hughes J. M. (2016) Arduino: A Technical Reference. USA: O’Reilly. 1ra Edición. 613
págs.
Evans M., Noble J., Hochenbaum J. (2013) Arduino in Action, Ed. Manning
Publications Co.
Wheat D., (2011) Arduino Internals, New York, ed. Apress
OxerJ, Blemings H. (2009) Practical Arduino, Cool projects for open source
hardware. New York, ed. Apress.
Página Web oficial de Arduino: https://www.arduino.cc/ [consulta: 20/04/2019].

67 | P á g i n a