22 de agosto de 2016

Contenido
INTRODUCCIÓN .................................................................................................................................. 3
¿QUÉ ES EL ARDUINO? ............................................................................................................... 4
ESTRUCTURA DE UN PROGRAMA ........................................................................................... 5
setup() ............................................................................................................................................. 5
loop() ............................................................................................................................................... 6
DESCRIPCIÓN DE LOS COMPONENTES DEL ARDUINO UNO R3 .................................... 7
DIAGRAMA DE PINES DEL ARDUINO UNO ...................................................................................... 8
Terminales Digitales ........................................................................................................................ 9
Pines Analógicos ............................................................................................................................ 10
Pines de alimentación ................................................................................................................... 11
Otros Pines .................................................................................................................................... 11
PRACTICAS ................................................................................................................................... 12
Práctica 1 – Secuencia básica de 3 leds......................................................................................... 12
Práctica 2 - Lectura de señal analógica con un potenciómetro .................................................... 15
Práctica 3 – Contador .................................................................................................................... 18
Práctica 4 - Control de iluminación de una lámpara ..................................................................... 20
Práctica 5 – Sensor de luz (ldr) ...................................................................................................... 22
Práctica 6 - Control de un motor de dc con un transistor ............................................................. 26
Práctica 7 - Control de un motor a velocidad y sentido de giro variables .................................... 29
Práctica 8 – relevador.................................................................................................................... 31
Práctica 9 - LCD ............................................................................................................................. 34
Práctica 10 – LED RGB ................................................................................................................... 36
Práctica 11 – El zumbador ............................................................................................................. 39
Práctica 12 – Hagamos un juego ................................................................................................... 42
Práctica 13 – LCD + Sensor de temperatura TMP 36 .................................................................... 46
Práctica 14 – El servomotor .......................................................................................................... 48
Práctica 15 - LCD + RGB ................................................................................................................ 51
Práctica 16 - Juego Simon Says ..................................................................................................... 54
Práctica 17 – Temporizador .......................................................................................................... 63
Practica 18 - Control de un Display de 7 segmentos ..................................................................... 70
Práctica 19 – El sensor ultrasonido ............................................................................................... 75
Práctica 20 - Entrada edificio con sensores infrarrojos................................................................. 79
Práctica final – Control por Bluetooth .......................................................................................... 84
 INTRODUCCIÓN

En los últimos años se han desarrollado innumerables aplicaciones en las que es

necesario contar con los conocimientos básicos en el desarrollo y programación de
microcontroladores. La mayoría de los sistemas programables actuales tienen por
lo menos un microcontrolador encargado del control operativo del sistema.

Existen en el mercado muchos fabricantes de microcontroladores, por mencionar

algunos: MICROCHIP, ATMEGA, MOTOROLA entre otras. Estos fabricantes
proveen del software especializado para la programación de sus microcontroladores
y otorgan gran cantidad de información para el usuario.

Actualmente, ARDUINO, una empresa italiana, ha desarrollado placas

microcontroladas educativas con grandes prestaciones. Esta placa posee
microcontroladores ATMEGA encargados del control de la placa. Hay
disponibles gran cantidad de proyectos que se han desarrollado a través de esta
noble interfaz.
 ¿QUÉ ES EL ARDUINO?

Arduino es una plataforma de hardware de código abierto, basada en una sencilla

placa con entradas y salidas, analógicas y digitales, en un entorno de desarrollo que
está basado en el lenguaje de programación Processing. Es un dispositivo que
conecta el mundo físico con el mundo virtual, o el mundo analógico con el digital.

Arduino es una plataforma de hardware en código abierto para gente que quiere
hacer una introducción a la electrónica sin necesidad de tener conocimientos
previos en ciencias. Se puede decir que todo el sistema de desarrollo, el software,
los circuitos y la documentación son abiertos.

Las plataformas Arduino están basadas en los Microcontroladores Atmega168,

Atmega328, Atmega1280, ATmega8 y otros similares, chips sencillos y de bajo
coste que permiten el desarrollo de múltiples diseños. Arduino se puede utilizar
para desarrollar objetos interactivos autónomos o puede ser conectado a software
del ordenador (por ejemplo: Macromedia Flash, Processing, Max/MSP, Pure Data).

La filosofía open source -código abierto- que lo sustenta, tanto el modo en que se
ensambla la placa -hardware- como el código fuente del programa Arduino -
software-, son de acceso público. Esto quiere decir que cualquiera puede usarlo y/o
mejorarlo. Al ser open hardware, tanto su diseño como su distribución es libre. Es
decir, puede utilizarse libremente para el desarrollo de cualquier tipo de proyecto sin
haberse adquirido ninguna licencia.

En la feria Maker Fair del 2011, se presentó la primera placa Arduino de 32 bits para
trabajar tareas más pesadas. Entre ellas se presentó la impresora en 3D de
MakerBot capaz de imprimir en resina cualquier modelo en 3D.
 ESTRUCTURA DE UN PROGRAMA

La estructura básica del lenguaje de programación del Arduino es muy simple, y

corre en al menos 2 partes. Estas 2 partes requeridas, o funciones, encierran
bloques de sentencias.

Código

void setup()

sentencias;

void loop()

sentencias;

Donde setup() es la preparación, loop() es la ejecución. Ambas funciones son

requeridas para que el programa trabaje a la función “setup” debe seguir la
declaración de las variables al principio del programa. Es la primer función para
correr en el programa, se corre solo una vez, y es usada para fijar el modo de los
pins (pinMode), o inicializar la comunicación serial.

La función “loop” es la que le sigue e incluye el código para ser ejecutada

continuamente leyendo las entradas, disparando las salidas, etc. Esta función es el
núcleo de todos los programas arduino, y hace la mayor parte del trabajo.

setup()
La función “setup()” es llamada una vez cuando arranca tu programa. Se usa para
inicializar el modo de los pins (pinMode), o inicializar el modo serial. Se debe incluir
en un programa aun cuando no haya sentencias para correrlas.
 Código

void setup()

pinMode(pin, OUTPUT); // programa un 'pin' como salida

loop()
Después de llamar a la función setup(), la función loop(), hace precisamente lo que
su nombre sugiere, y hace ciclos consecutivamente, permitiendo al programa
cambiar, responder, y controlar a la tarjeta Arduino.

Código
void loop()

digitalWrite(pin, HIGH); //pone el 'pin' en uno lógico

delay(1000); //se espera un segundo

digitalWrite(pin, LOW); //pone el 'pin' en cero lógico

delay(1000); //se espera un segundo

}
 DESCRIPCIÓN DE LOS COMPONENTES DEL ARDUINO UNO R3

Mirando a la placa desde la parte de arriba, este es el esquema de lo que puedes

ver (los componentes de la placa con los que puedes interactuar en su uso normal
están resaltados)

Empezando según las agujas del reloj:

• Terminal de referencia analógica (naranja)
• Tierra digital (verde claro)
• Terminales digitales 2-13 (verde)
• Terminales digitales 0-1/ E/S serie - TX/RX (verde oscuro) - Estos
pines no se pueden utilizar como e/s digitales (digitalRead() y
digitalWrite()) si estás utilizando comunicación serie (por ejemplo
Serial.begin).
• Botón de reinicio - S1 (azul oscuro)
• Programador serie en circuito "In-circuit Serial Programmer" o "ICSP"
(azul celeste)
• Terminales de entrada analógica 0-5 (azul claro)
• Terminales de alimentación y tierra (alimentación: naranja, tierras:
naranja claro)
• Entrada de alimentación externa (9-12VDC) - X1 (rosa)
 • Selector de alimentación externa o por USB (coloca un jumper en los
dos pines más cercanos de la alimentación que quieras) - SV1
(púrpura). En las versiones nuevas de Arduino la selección de
alimentación es automática por lo que puede que no tengas este
selector.
• USB (utilizado para subir programas a la placa y para comunicaciones
serie entre la placa y el ordenador; puede utilizarse como
alimentación de la placa) (amarillo)

DIAGRAMA DE PINES DEL ARDUINO UNO

Terminales Digitales

- En adición a las funciones específicas listadas abajo, las terminales

digitales de una placa Arduino pueden ser utilizados para entradas o
salidas de propósito general a través de los comandos pinMode(),
digitalRead(), y digitalWrite().

- Cada terminal tiene una resistencia pull-up que puede activarse o

desactivarse utilizando DigitalWrite() (con un valor de HIGH o LOW,
respectivamente) cuando el pin está configurado como entrada. La
corriente máxima por salida es 40 mA.
 - Serial: 0 (RX) y 1 (TX). Utilizado para recibir (RX) y transmitir (TX) datos
serie TTL. En el Arduino Diacemila, estas terminales están conectadas
a las correspondientes patas del circuito integrado conversor FTDI USB
a TTL serie. En el Arduino BT, están conectados a las terminales
correspondientes del modulo Bluetooth WT11. En el Arduino Mini y el
Arduino LilyPad, están destinados para el uso de un módulo serie TTL
externo (por ejemplo el adaptador Mini-USB).

- Interrupciones externas: 2 y 3. Estas terminales pueden ser

configuradas para disparar una interrupción con un valor bajo, un pulso
de subida o bajada, o un cambio de valor. Mira la función
attachInterrupt() para más detalles.

- PWM: 3, 5, 6, 9, 10, y 11. Proporcionan salidas PWM de 8 bit con la

función analogWrite(). En placas con ATmega8, las salidas PWM solo
están disponibles en los pines 9, 10, y 11.

- Reset BT: 7. (solo en Arduino BT) Conectado a la línea de reset del

módulo bluetooth.

- SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estas terminales

soportan comunicación SPI. Aunque esta funcionalidad esta
proporcionada por el hardware, no está incluida actualmente el lenguaje
Arduino.

- LED: 13. En el Diacemila y el LilyPad hay un LED en placa conectado al

pin digital 13. cuando el pin tiene valor HIGH, el LED está encendido,
cuando el pin está en LOW, está apagado

Pines Analógicos
En adición a las funciones específicas listadas abajo, los pines de entrada
analógicos soportan conversiones analógico-digital (ADC) de 10 bit utilizando
la función analogRead(). Las entradas analógicas pueden ser también usadas
como pines digitales: entrada analógica 0 como pin digital 14 hasta la entrada
analógica 5 como pin digital 19. Las entradas analógicas 6 y 7 (presentes en el
Mini y el BT) no pueden ser utilizadas como pines digitales.

- I2C: 4 (SDA) y 5 (SCL). Soportan comunicaciones I2C (TWI) utilizando

la librería Wire (documentación en la página web de Wiring).
Pines de alimentación
- VIN: (a veces marcada como "9V"). Es el voltaje de entrada cuando se
está utilizando una fuente de alimentación externa (en comparación con
los 5 voltios de la conexión USB o de otra fuente de alimentación
regulada). Puedes proporcionar voltaje a través de este pin.

- 5V: La alimentación regulada utilizada para alimentar el

Microcontrolador y otros componentes de la placa. Esta puede venir de
VIN a través de un regulador en placa o ser proporcionada por USB u
otra fuente regulada de 5V.

- 3V3: (solo en el Diacemila) Una fuente de 3.3 voltios generada por el

chip FTDI de la placa.

- GND : Pin de tierra.

Otros Pines
- AREF: Referencia de voltaje para las entradas analógicas. Utilizada con
la función analogReference().
- Reset: (Solo en el Diacemila). Pon esta línea a LOW para resetear el
Microcontrolador. Utilizada típicamente para añadir un botón de reset a
shields que bloquean el de la placa principal.
 PRACTICAS

Práctica 1 – Secuencia básica de 3 leds

Se trata de encender y apagar 3 LED colocados en las salidas 6, 7 y 8 (PIN6, PIN7

y PIN8) con una cadencia de 200 ms. Las variables asignadas a cada LED son
LEDPIN1, LEDPIN2 Y LEDPIN3.

Material:
 1 Protoboard
 3 Diodos LED
 3 Resistencias 220 ohm
 Arduino Uno R3
Código
Conexiones
 Práctica 2 - Lectura de señal analógica con un potenciómetro

El potenciómetro es un dispositivo electromecánico que consta de una resistencia

de valor fijo sobre la que se desplaza un contacto deslizante, el cursor, que la divide
eléctricamente.
Un potenciómetro es especificado por su resistencia total, R, entre los terminales
externos 1 y 3; El movimiento del cursor origina un cambio en la resistencia medida
entre el terminal central, 2, y uno cualquiera de los extremos. Este cambio de
resistencia puede utilizarse para medir desplazamientos lineales o angulares de
una pieza acoplada al cursor.
Se conectan en paralelo al circuito y se comporta como un divisor de tensión.

Circuito:
Se conectan tres cables a la tarjeta Arduino. El primero va a tierra desde el terminal
1 del potenciómetro. El terminal 3 va a la salida de 5 voltios. El terminal 2 va desde
la entrada analógica #2 hasta el terminal interno del potenciómetro.
Girando el dial o ajustando el potenciómetro, cambiamos el valor de la resistencia
variable. Esto produce oscilaciones dentro del rango de 5 y 0 voltios, que son
capturados por la entrada analógica.

Material:
• 1 Protoboard
• 1 Diodo LED
• 1 Potenciómetro
• Arduino Uno R3
Código
Conexiónes
 Práctica 3 – Contador

Se trata de contar las veces que se pulsa un botón conectado en la entrada 7 de

Arduino a la vez que cada vez que contamos encendemos el led conectado en la
salida 13. El valor de la variable que almacena el número de impulsos generados
se envía al PC para que se visualice en la pantalla.

Material:

• 1 Protoboard
• 1 Diodo LED
• 1 Resistencia 10 K
• 1 Push Bottom
• Arduino Uno R3

Código
Conexiónes
 Práctica 4 - Control de iluminación de una lámpara

Con esta aplicación se pretende controlar el grado de iluminación de una lámpara

(simulada con un LED) mediante un pulsador. Si no pulsamos el pulsador (entrada
0) la lámpara incrementar y decrementar su brillo o nivel de iluminación. Si
pulsamos (entrada 1) la lámpara se encenderá y apagará con una cadencia de 50
mseg.

Material:
• 1 Protoboard
• 1 Diodo LED
• 1 Resistencia 10 K
• 1 Push Bottom
• Arduino Uno R3

Código
Conexiónes
 Práctica 5 – Sensor de luz (ldr)

Un LDR es una resistencia variable, que varía su valor dependiendo de la cantidad

de luz que incide sobre su superficie. Cuanta más intensidad de luz incide en la
superficie de la LDR menor será su resistencia y cuanta menos luz incide mayor
será la resistencia. Suelen ser utilizados como sensores de luz ambiental o como
una fotocélula que activa un determinado proceso en ausencia o presencia de luz.

Un sensor de luz se compone de una LDR como parte de un divisor de tensión

resistivo. Ejemplo:

Si la LDR es usada como Rtop, como en el primer circuito, da tensión alta (HIGH)
en la salida cuando la LDR está en la luz, y una tensión baja (LOW) en la salida
cuando la LDR está en la sombra.

La acción del divisor de tensión es inversa cuando la LDR es usada como Rbottom
en lugar de Rtop, como en el segundo circuito. El circuito da tensión Baja (LOW)
en la salida cuando la LDR está en la luz, y una tensión alta (HIGH) en la salida
cuando la LDR está en la sombra. El circuito divisor de tensión dará una tensión
de la salida que cambia con la iluminación, de forma inversamente proporcional a
la cantidad de luz que reciba (sensor de oscuridad).

Material:
 1 Protoboard
 1 Diodo LED
 1 Resistencia 5 K
 1 LDR
 Arduino Uno R3
Código
Conexiones
 Práctica 6 - Control de un motor de dc con un transistor

Con este ejemplo vamos a controlar la velocidad de un motor de cc mediante la

utilización de un transistor BD137. Se trata de utilizar la posibilidad de enviar una
señal de PWM a una de las salidas configurables como salidas analógicas.
Téngase en cuenta que el motor debe ser de bajo consumo por dos motivos: primero
porque si alimentamos en las pruebas desde el conector USB no debemos sacar
demasiada corriente del ordenador y segundo porque el transistor es de una
corriente limitada.

El diodo 1N4001 se coloca como protección para evitar que las corrientes inversas
creadas en el bobinado del motor puedan dañar el transistor.

La tensión que sacaremos a la salida 10 (analógica tipo PWM) variara en forma de

rampa ascendente y descendente de manera cíclica tal como vemos en la figura.
Este efecto lo conseguimos con una estructura del tipo for:

for (valor = 0 ; valor <= 255; valor +=5) (ascendente)

for (valor = 255; valor >=0; valor -=5) (descendente)
Obsérvese que los incrementos del valor de la tensión van de 5 en 5 y tenemos que
considerar que 0v equivale a 0 y 5 v. equivale a 255.
Material:

 1 Protoboard
 1 Diodo LED
 1 Resistencia 1 K
 1 Transistor 2N2222
 1 Diodo 1N4001
 1 Motor DC
 Arduino Uno R3

Código
Conexiones
 Práctica 7 - Control de un motor a velocidad y sentido de giro variables

Vamos a demostrar el control simultáneo de la velocidad y del sentido de un motor

de corriente continua.! OJO probar en Arduino con un sólo motor ¡

Material:

 1 Protoboard
 1 Motor DC
 1 L293D
 Arduino Uno R3

Código
Conexiones
 Práctica 8 – relevador

Este sencillo ejemplo enseña como encender una bombilla de 220V de corriente
alterna (AC) mediante un circuito de 5V de corriente continua (DC) gobernado por
Arduino. Se puede utilizar con cualquier otro circuito de 220V con un máximo de
10A (con el relevador del ejemplo).

¿Qué es un relevador?
El relé es un dispositivo electromecánico, que funciona como un interruptor
controlado por un circuito eléctrico en el que, por medio de un electroimán, se
acciona un juego de uno o varios contactos que permiten abrir o cerrar otros
circuitos eléctricos independientes. De aquí extraemos una información muy
importante: Podemos separar dos circuitos de forma que funcionen con voltajes
diferentes. Uno a 5V (Arduino) y otro a 220V (la bombilla).
Como se ve en el esquema inferior hay dos circuitos. El del cableado NEGRO
funciona a 5V de DC y el del cableado ROJO a 220V de AC.

Material:
 1 Protoboard
 1 Motor DC
 1 Relevador 220v
 1 Foco
 Cable para corriente
 1 Transistor BD137
 1 Diodo 1N4001
 1 Resistencia 10k
 Arduino Uno R3
Código
Conexiones
 Práctica 9 - LCD

Se trata del control de un Visualizador de Cristal Líquido (LCD), el cual cuenta con
un controlador en C.I. denominado HD44780.

Material:
 1 Protoboard
 1 LCD 16X2
 1 Potenciómetro 10k

Código
Conexiones
 Práctica 10 – LED RGB

En esta práctica vamos a aprender a usar un led RGB para arduino. Estos leds
tienen 4 patas: una pata es para el color azul, otra para el verde, otra para el rojo y
la cuarta pata (la más larga) es para los 5V.

Montamos el siguiente circuito en la placa protoboard y lo conectamos con el

arduino. La pata más larga del led, es la única que no lleva resitencia (la del color
naranja).
Material:
 1 Protoboard
 1 Led RGB
 3 Resistencias 1 K
 Arduino Uno R3

Código
Con este programa lo que conseguimos es que el led muestre los colores que
deseemos (ya que con el rojo, azul y verde obtenemos la mayoría de los colores).
Podemos variar los colores variando los números en color (0,255,0). Dependiendo
de los números que pongamos tendremos un color u otro.

Conexiones
 Práctica 11 – El zumbador

Bien, hasta ahora lo único que hemos utilizado como salidas de nuestro arduino han
sido luces LED, ahora vamos a conocer un nuevo elemento: el zumbador

El zumbador es un elemento que al recibir corriente

es capaz de emitir una serie de sonidos, incluso
puede llegar a interpretar politonos musicales. Las
notas que toca el zumbador van a estar determinadas
por su período y por el tiempo de espera que tiene de
una nota a otra.

Hoy vamos a realizar una llamada SOS para aprender

el funcionamiento básico. El SOS en código morse se
entiende como 3 pitidos cortos para cada S y un pitido
largo para la O.

Si colocamos un transistor conectado al pin que queramos utilizar, amplificaremos

la corriente haciendo que el sonido producido sea más fuerte. Os dejo una imagen
de cómo es conectado el transistor

Vemos que el zumbador es conectado al colector de nuestro transistor, que la base

es conectada al pin a utilizar (el 2) y que el emisor va directamente a gnd. El cable
positivo de nuestro zumbador es conectado a alimentación positiva.

Una vez realizado el montaje físico, tenemos que programar el circuito. Para nuestro
circuito vamos a emplear dos variables llamadas corto y largo, que cada una
representará a la S y a la O respectivamente. También declararemos un período de
pausa entre letra y letra y declararemos el pin 2 como salida (pinMode).
Material:
 1 Protoboard
 1 Resistencia 10 K
 1 Transistor BD137
 1 Zumbador
 Arduino Uno R3
Código
Conexiones
 Práctica 12 – Hagamos un juego

Este juego va a consistir en que vamos a tener 5 Leds iluminandose de derecha a

izda y cuando el led iluminado sea el del centro, entonces usaremos el pulsador
para "dispararlo". El zumbador que vamos a colocar sonará y los led comenzarán a
ir más deprisa. Tendremos 5 niveles de dificultad, en los que el tiempo de
intermitencia de cada led irá siendo menor.

Esta práctica nos va a servir para repasar lo que ya sabíamos acerca de las salidas
(luces,sonido), repasar los conceptos como vectores y bucles, y para introducir este
nuevo concepto de órdenes.

Material:
 1 Protoboard
 5 Resistencias 10 K
 1 Resistencia 1 k
 1 Zumbador
 1 Push button
 5 leds
 Arduino Uno R3
Código
Conexiones
 Práctica 13 – LCD + Sensor de temperatura TMP 36

En esta práctica vamos a hacer aparecer por nuestra pantalla LCD el valor de la
temperatura que nos indique el sensor de temperatura TMP 36.
Material:
 1 Protoboard
 1 Sensor de temperatura TMP 36
 1 Potenciometro 10k
 1 Display 16*2
 Arduino Uno R3

Código
Conexiónes
 Práctica 14 – El servomotor

Anteriormente, vimos como podíamos hacer con una serie

de actuadores señales de luz, de sonido…Aquí vamos a
generar movimiento.

Este es el último tipo de respuesta que vamos a ver aquí, a

partir de las respuestas que podamos generar a partir de la
lcd, respuestas que serían más gráficas.

Este es el aspecto que puede ofrecer un servomotor. Vemos que tiene distintos tipos
de hélice dependiendo de nuestro interés y que también tiene un motor que es el
que va a proporcionar el giro. La conexión se va a hacer con tres cables: Uno rojo,
que va a ser el que reciba la alimentación, uno negro, que será conectado a tierra y
uno amarillo que va a ser el que reciba la señal.

El montaje es muy sencillo, ahora tenemos que hablar de su código. Lo primero que
vamos a tener que hacer es incluir una nueva librería, la Servo.h. Hay que decir que
el manejo del servomotor puede ser muy extenso y que se puede investigar con el
un sin fin de cosas.
Material:
 1 Protoboard
 1 servomotor
 Arduino Uno R3
Código
Conexiónes
 Práctica 15 - LCD + RGB

En esta práctica vamos a conectar el led rgb con la pantalla ldr. El color que vaya
luciendo en el led, aparecerá escrito en la pantalla ldr.

Material:
 1 Protoboard
 1 led RGB
 1 Potenciometro 10k
 1 Display 16*2
 3 Resistencias 1k
 Arduino Uno R3

Código
conexiones
 Práctica 16 - Juego Simon Says

En esta práctica, vamos a hacer el juego de “Simon Says”, ese famoso juego de
memorizar una secuencia aleatoria de colores.
Material:
 1 Protoboard
 3 led’s
 6 resistencias 1k
 3 push button
 1 zumbador
 Arduino Uno R3

Código
Conexiones
 Práctica 17 – Temporizador

En esta práctica aremos un temporizador o cuenta atrás. Mediante unos pulsadores

podremos poner las horas, minutos y segundos que quieras y mediante otro
pulsador inicias la cuenta atrás.
Material:
 1 Protoboard
 4 push button
 4 Resistencias 1k
 1 zumbador
 1 Display 16*2
 1 potenciometro 10k
 Arduino Uno R3

Código
Conexiones
 Practica 18 - Control de un Display de 7 segmentos

En esta práctica, vamos a volver al uso de la tarjeta micro-controladora Arduino, en

la cual se mostrara el control de un Display de 7 segmentos.

Este es un elemento muy simple que se puede manipular con otro tipo de circuitos
integrados, pero como queremos ir avanzando el uso de matrices, displays y
elementos de control como quizás multiplexores, hemos ido pensando en ir
desarrollando algo introductorio.

Aun así creo que es una práctica perfecta para recordar todo lo que habíamos
aprendido del manejo de leds en Arduino, y para refinar nuestro entendimiento del
código.

Material:
 1 Protoboard
 1 display de 7 segmentos
 1 resistencia 220 ohmios
 1 resistencia 1k
 1 push button
 Arduino Uno R3
Código
Conexiones

El montaje es bastante sencillo, únicamente señalar por si no se entiende bien, que

el cable naranja que conecta el pulsador se conecta al pin digital 2, y que el tercer
pin de la parte de arriba del display lleva una resistencia de 220 ohmios a tierra
directamente, lo único que la arquitectura del programa no me permitía llevarla
directamente.

Con esta práctica estaríamos simulando el funcionamiento de un marcador, ya fuera

de un estadio, de un reloj digital, etc. Como vemos, lo único que necesitamos es
realizar una entrada como orden que haga subir en un dígito la cuenta.

El funcionamiento con dos dígitos sería similar, sólo habría que indicarle al primer
display que cuando la cuenta llegara a una decena, el número nueve se cambiara
a cero, y en el segundo display añadir un uno.
 Práctica 19 – El sensor ultrasonido

En la práctica de hoy enseñaremos las utilidades que puede tener un sensor

ultrasonidos, y como aplicarlo con el uso de un microcontrolador Arduino. En
concreto, vamos a conectar nuestro sensor de ultrasonidos hc-sr04 para que mida
distancia, y vamos a hacer que nos muestre la distancia por una pantalla LCD, como
ya hicimos en otras entradas como la del sensor de temperatura.

Además como elemento añadido, colocaremos un elemento de aviso, un diodo led,

que se encenderá en caso de que nuestro sensor detecte que la distancia que recibe
es demasiado corta(por ejemplo, menor de diez centímetros), y se mantendrá
apagado en caso contrario. Es un sistema muy similar al que usarían los cuadros
de mando de los coches que llevan sensor de aparcamiento incorporado.
Antes de empezar a escribir código, vamos a intentar explicar un poco acerca del
funcionamiento del sensor de ultrasonidos. Su funcionamiento es muy simple.
Vemos que tiene incorporados dos transductores(los cilindros), uno de ellos se
empleará para emitir una señal de ultrasonidos, y el segundo será el encargado de
recibirla.

Si tenemos en cuenta que la velocidad del sonido es 340 m/s y medimos el tiempo
que tarda nuestro sensor en recibir la respuesta, podremos despejar la distancia
con la sencilla fórmula:

distancia = velocidad * tiempo

Una vez dicho esto podemos entrar a ver como el código identifica el tiempo y lo
multiplica por una constante para hallar la distancia

Material:
 1 Protoboard
 1 Sensor ultrasonido hc-sr04
 1 led
 1 potenciometro 10k
 1 Display 16*2
 Arduino Uno R3
Código
Conexiones
 Práctica 20 - Entrada edificio con sensores infrarrojos

En esta práctica vamos a enseñar cómo podemos contar las personas que entran
en un edificio poniendo dos barreras infrarrojas a la entrada.
Antes de empezar vamos a explicar un poco estos sensores. La barrera infrarroja
se compone por un diodo infrarrojo (emisor) y un fototransistor (receptor). Son muy
parecidos a un led común, algunos emisores los encontramos transparentes o con
un ligero color en púrpura y los receptores en trasparentes o negros, estos últimos
por un filtro UV que les permite trabajar mejor incluso expuesto a la luz solar.
El fototransistor (aunque parezca un led corriente) debe conectarse con la patilla
larga a masa y la corta a voltaje.

Para esta práctica hemos usado como emisor el led infrarrojo tranparente y como
receptor el fototransistor de color negro.
 Una vez distinguidos los
diodos vamos a explicar el
planteamiento: lo primero de
todo es que hemos
distinguido entre las
personas que entran y las
que salen. Las personas que
entran, primero pasan la
primera barrera y después la
segunda. Por el contrario,
las personas que salen,
primero pasan la segunda
barrera y después la
primera. Para este caso,
solo vamos a contar las
personas que entran al
edificio.
Además, hemos introducido dos leds (uno verde y otro rojo) para detectar por que
barrera se está pasando. Si pasamos por la primera barrera, se encenderá el led
verde, y si pasamos por la segunda se encenderá el rojo.
Material:
 1 Protoboard
 2 pares de diosdos infrarrojos (dos emisores y dos receptores)
 2 leds (rojo y verde)
 4 Resistencias de 10k
 1 LCD 16*2
 1 Potenciometro de 10k
 Arduino Uno R3
Código
Conexiones
 Práctica final – Control por Bluetooth

Esta práctica consiste en lograr la comunicación del Arduino vía Bluetooth con un
Dispositivo Android y controlar el encendido y apagado de tres LED´s a distancia
a través de una aplicación instalada en el Dispositivo Android (ej. un
celular/tableta).

Material:
• 1 Protoboard
• 1 modulo Bluetooth (HC06)
• 1 celular
• 2 resistencias de 1k
• 2 LED´s
• Arduino uno R3
• Cables

Código
Conexiones

Conexiones
Modulo Bluetooth Arduino
VCC 5V
GND GND
TXD RX (Es la conexión 0 de arduino)
RXD Tx (Es la conexión 1 de arduino)