1.

FUENTE DE 5V O 12V CON REGULADOR LM

 DIAGRAMA DE CIRCUITO ELECTRONICO DE FUENTE DE TENSION

2. SENSOR DTH 11

Presentar los sensores DHT11.

Mostrar como leerlos utilizando la librera de control.
Escribir un programa bsico de uso.

En la sesion Sensor de temperatura TMP36, vimos cmo medir la temperatura con un sensor
TMP36. Es bastante sencillo y no presenta especiales problemas, ms all de tener cuidado con
las operacin con nmeros float.
Pero en muchas ocasiones, y especialmente en la industria alimentaria, no basta con medir la
temperatura, sino que la humedad relativa es tambin un factor importante a tener en cuenta.
Por eso se desarrollaron los sensores de la familia DHT. Nos proporcionan de forma digital
la temperatura y la humedad, con diferente precisin segn el modelo.
Bsicamente hay dos variantes DHT11 y DHT22
Las caractersticas del DHT11 son:

Funciona con 3,3 y 5V de alimentacin

Rango de temperatura: de 0 a 50 con 5% de precisin (pero
solo mide por grados, no fracciones)
Rango de humedad: de 20% al 80% con 5% de precisin
1 Muestra por segundo (No es el ms rpido del oeste)
Bajo consumo
Devuelva la medida en C

En cuanto al DHT22:

Barato, entre 4 y 5
Funciona con 3,3 y %V de alimentacin
Rango de temperatura: de -40 a 125 0.5C
Rango de humedad: de 0% al 100% con 5% de precisin.
Lee 2 veces por segundo.
Bajo consumo.
Devuelva la medida en C

En cuanto a la forma de conectarlos y programarlos es la misma para

ambos modelos y veremos que hay desarrolladas libreras para Arduino que
soportan los dos de una forma sencilla.
Destacar que el chip incorpora electrnica para hacer internamente la
conversin de temperatura y humedad y nos da un valor de medida de
forma digital, es decir, que no necesitamos un pin analgico como en el
caso del TMP36, sino que lo leeremos con un pin digital.
AMAS DEL CIRCUITO
La conexin es trivial, pero cabe destacar que se vende en dos encapsulados, uno de tres pines
que son GND, Data y Vcc, y otro 4 pines y uno de ellos, sencillamente sobra y no se conecta.
Normalmente viene rotulado en el sensor el nombre de cada pin, y si no ya sabeis, a buscar el
manual en Google

Vamos con el esquema por cortesa de Fritzing:

Y aqu tenemos el esquema de protoboard.

EL PROGRAMA DE LECTURA DEL DHT11

En primer lugar, tenemos que descargar una librera para manejarlos cmodamente, DX11.zip e
importarla. Aqu tenes la librera DHT11.zip

Hacemos el importar la librera DHT11 que nos pondr:

#include <DHT11.h>

Y definimos una instancia del sensor donde declaramos el pin al que esta conectado.

int pin=2;
DHT11 dht11(pin);

Leerlo ahora es muy sencillo:

int error ;
float temp, humi;
error = dht11.read(humi, temp)

Basta con hacer dht11.read pasandole las variables donde queremos el resultado, y comprobamos
que no haya errors (Siempre es buena idea comprobar que no hay error cuando hacemos una
llamda). El programa completo seria ms o menos algo as

#include <DHT11.h>

int pin=2;
DHT11 dht11(pin);

void setup()
{
Serial.begin(9600);
}

void loop()
{
int err;
float temp, hum;
if((err = dht11.read(hum, temp)) == 0) // Si devuelve 0 es que ha leido bien
{
Serial.print("Temperatura: ");
Serial.print(temp);
Serial.print(" Humedad: ");
Serial.print(hum);
Serial.println();
}
else
{
Serial.println();
Serial.print("Error Num :");
Serial.print(err);
Serial.println();
}
delay(1000); //Recordad que solo lee una vez por segundo
}

El resultado se enva a la consola y aqu podis ver una muestra.

 Para hacer variar os valores, de humedad y temperatura y comprobar que todo funciona
correctamente, podeis, sencillamente, enviar vuestro aliento al sensor, y salvo que estis en el
trpico haris subir tanto la temperatura como la humedad relativa.
Como vereris, son de lo mas sencillos de utilizar y un componente habitual de vuestro arsenal de
sensores

3. Servomotor con Arduino tutorial de programacin paso a paso

En este artculo te voy a ensear cmo utilizar un servomotor con Arduino. Antes de continuar es
importante saber qu es un servomotor o servo. Es un motor elctrico pero con
dos caractersticas especiales.

Por un lado, nos permite mantener una posicin que indiquemos, siempre que est dentro del
rango de operacin del propio dispositivo. Por otro lado nos permite controlar la velocidad de
giro, podemos hacer que antes de que se mueva a la siguiente posicin espere un tiempo.

Indice de contenidos

1 Caractersticas tcnicas de un servomotor con Arduino

2 Conexionado con Arduino
3 Cmo programar un servo desde el entorno de Arduino?
4 Conclusin

El ejemplo ms tpico es un coche teledirigido, esos que utilizan los nios y no tan nios. Estos
juguetes suelen tener un mando a distancia donde podemos controlar la velocidad y el giro del
coche. Precisamente el giro se suele hacer con un servomotor donde indicamos, en cada
momento, la posicin o el ngulo de giro que queremos que tenga en un preciso momento.
Caractersticas tcnicas de un servomotor con Arduino
Hay varios modelos de servomotor con Arduino. En este caso vamos a utilizar un Micro Servo 9g
SG90 de Tower Pro. Como siempre digo, hay que mirar la ficha tcnica del producto. Todos
tienen un funcionamiento muy parecido y la programacin puede variar muy poco.
Cosas a tener en cuenta con este dispositivo. Lo primero, el ngulo de giro, en este caso nos
permite hacer un barrido entre -90 y 90. Lo que viene a ser un ngulo de giro de 180. Tiene
una precisin de un grado es decir, podemos mover de grado en grado.
Estos motores funcionan con una seal PWM, con un pulso de trabajo entre 1 ms y 2 ms y con un
periodo de 20 ms (50 Hz). Qu quiere decir todo esto? Este dato nos indica la velocidad
mxima a la que podemos mover el servomotor con Arduino. Solo podremos cambiar de posicin
cada 20 ms. Esto depender del tipo y marca de nuestro servo.
El elegir una salida PWM u otra da lo mismo, todas las salidas de este tipo funcionan igual.
Conexionado con Arduino
Las conexiones dependern del tipo de servomotor con Arduino que estemos utilizando.
Todos deben tener 3 cables. Uno ir a tierra, otro a la alimentacin de 5 Voltios y el tercero a un
pin PWM. Tambin puedes utilizar un shield para controlar servomotores, como el de Adafruit.

Cmo programar un servo desde el entorno de Arduino?

Ahora vamos a ir a lo interesante, la programacin. Para ello tenemos que hacer uso de una
librera externa para poder controlar el servo desde Arduino. Para incorporar la librera tenemos
que ir a Programa/Include Library/Servo.

El cdigo para girar el motor de 0 a 180

Esta accin ya nos ha hecho un include en nuestro cdigo que nos permite controlar el servo. Os
dejo a continuacin un cdigo bsico para posicionar el servo en los ngulos 0, 90 y 180.

1 // Inclumos la librera para poder controlar el servo

2 #include <Servo.h>
3
4 // Declaramos la variable para controlar el servo
5 Servo servoMotor;
6
7 void setup() {
8 // Iniciamos el monitor serie para mostrar el resultado
9 Serial.begin(9600);
10
11 // Iniciamos el servo para que empiece a trabajar con el pin 9
12 servoMotor.attach(9);
13 }
14
15 void loop() {
16
17 // Desplazamos a la posicin 0
18 servoMotor.write(0);
19 // Esperamos 1 segundo
20 delay(1000);
21
22 // Desplazamos a la posicin 90
23 servoMotor.write(90);
24 // Esperamos 1 segundo
25 delay(1000);
26
27 // Desplazamos a la posicin 180
28 servoMotor.write(180);
29 // Esperamos 1 segundo
30 delay(1000);
31 }

De la librera Servo.h hemos declarado un objeto o variable servoMotor y hacemos uso de dos
mtodos. Por un lado el attach, que nos permite indicar en que pin tenemos conectado nuestro
servo, y por otro lado el write, donde indicamos en qu ngulo queremos posicionar nuestro
servomotor.
Girando grado a grado el servomotor
Vamos a realizar otro ejemplo un poco ms complicado, en este caso queremos que el servo haga
un barrido desde el 0 al 180 y luego en sentido contrario. Vamos a utilizar los mismos mtodos
pero incorporamos dos bucles for, uno para cada sentido.

1 // Inclumos la librera para poder controlar el servo

2 #include <Servo.h>
3
4 // Declaramos la variable para controlar el servo
5 Servo servoMotor;
6
7 void setup() {
8 // Iniciamos el monitor serie para mostrar el resultado
9 Serial.begin(9600);
10
11 // Iniciamos el servo para que empiece a trabajar con el pin 9
12 servoMotor.attach(9);
13
14 // Inicializamos al ngulo 0 el servomotor
15 servoMotor.write(0);
16 }
17
18 void loop() {
19
20 // Vamos a tener dos bucles uno para mover en sentido positivo y otro en sentido negativo
21 // Para el sentido positivo
22 for (int i = 0; i <= 180; i++)
23 {
24 // Desplazamos al ngulo correspondiente
25 servoMotor.write(i);
26 // Hacemos una pausa de 25ms
27 delay(25);
28 }
29
30 // Para el sentido negativo
31 for (int i = 179; i > 0; i--)
32 {
33 // Desplazamos al ngulo correspondiente
34 servoMotor.write(i);
35 // Hacemos una pausa de 25ms
36 delay(25);

4. LOS DISPLAYS LCD

Los displays LEDs de 7 segmentos, que vimos en las sesiones anteriores, estn muy bien, son
baratos y prcticos, pero tienen el inconveniente de que no pueden mostrar mensajes de texto,
sino solo nmeros.
Se echa de menos algn sistema para mostrar mensajes de texto sencillos, y por eso se
comercializan los displays LCD. Son faciles de encontrar en diversos formatos : 162 (16
caracteres x 2 lneas) o LCD 164 (16 caracteres x4 lunes).

LCD viene del ingls Liquid Crystal Display, o sea Pantalla de cristal liquido.

Son una opcin muy sencilla de usar, y adems, dan un toque muy pro a vuestros proyectos, y por
eso, en los ltimos aos los displays LCD han ganado mucha aceptacin en productos comerciales
de todo tipo.
Bsicamente porque:

Son baratos.
Estn disponibles en varios tamaos y configuraciones.
Son de bajo consumo.
Muy prcticos si te basta con mostrar solo texto (y algunos caracteres especiales).

En esta sesin veremos cmo conectarlos a vuestros Duinos y cmo usarlos para sacar mensajes
al exterior.

ANTES DE EMPEZAR

Aunque, ltimamente, estos displays suelen venir con los pines soldados, todava hay muchos
sitios que cuando compras uno de estos, te lo envan en kit, con los pines aparte para que los
sueldes

En algn momento tendremos que hablar de cmo soldar componentes, pero ese da, an no ha
llegado.
Lo primero que tienes que saber, es que tienes que soldarlos, y que no vale sujetar los pines de
algn modo ms o menos extravagante. Los sueldas y punto. Hazte a la idea. Cualquier otra
solucin acabara funcionando mal, o directoramente con el display quemado.
Cuando lo tengas listo, pincha el display en la protoboard, dejando sitio para el resto de
componentes y cables, recuerda que habr muchos, as que se generoso con el espacio que
dejas.

DIAGRAMA DE CONEXIN

Aqu teneis el esquema de conexin:

Y este es el esquema para potoboard:

La conexin no es complicada, pero requiere ser cuidadoso. Asi que vamos a ir paso a paso con
los diferentes cables. Empieza conectando tensin y GND a la protoboard.

Vamos ahora a a conectar la alimentacin el panel LCD. Conecta el pin16 del LCD a Ground y el
15 a 5V

Si conectas ahora el cable USB a tu Duino, el LCD debera iluminarse, si no, revisa tus cables
antes de seguir.
Vamos a conectar ahora, el potencimetro de ajuste. Para ello conecta uno de los extremos del pot
a GND y el otro a 5V. El centro al pin 3 del LCD.
Aprovechemos tambin para dar tensin al panel LCD, El pin 1 va a GND y el 2 a tensin:
Si todo ha ido bien, ya podemos encender el dispay y probarlo. Conecta el USB a tu Arduino y
veamos. Si vas girando el potencimetro, en algn momento tienes que ver unos cuadraditos en la
pantalla, en caso contrario revisa las conexiones. No sigas, si no ves esto.

Si ya veis las matrices de puntos en la pantalla, podemos seguir.

Vamos a conectar ya los pines de datos y control. Sin entrar en muchos detallas, no vamos a usar
todos los pines disponibles, porque no los necesitamos. Solo usaremos dos pines de control, RS y
EN y los 4 pines de datos D7, D6, D5, y D4 . No necesitamos mas por ahora.
Vamos con las conexiones de control del display:

RW, LCD pin 5 GND

RS, LCD pin 4 Arduino pin 7
EN, LCD pin 6 Arduino pin 8
Y ya solo nos quedan los 4 cables de datos.
DB7, LCD pin 14 Arduino pin 12
DB6, LCD pin 13 Arduino pin 11
DB5, LCD pin 12 Arduino pin 10
DB4, LCD pin 11 Arduino pin 9
 EL PROGRAMA DE CONTROL

Vamos a usar una librera de control del panel LCD, que viene incluida en nuestro Arduino.
Pinchad en:
\\Programa\Importar Libreria\LiquidCrystal
Y ahora podemos importar uno de los ejemplos o escribir el nuestro, comentando el cdigo.Lo
primero es que al importar la librera nos ha escrito esto:

#include <LiquidCrystal.h>

Despues, hay que inicializar la librera. Creamos una instancia llamada lcd, de la clase

LiquidCrystal y le pasamos como parmetros los pines que hemos usado:

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // ( RS, EN, d4, d5, d6, d7)

Tened cuidado porque los pines que hemos usado, no corresponden a los ejemplos de Arduino,
as que podis cargarlos, peroaseguraros de cambiar la lnea de definicin de los pines, o no
corrern.

El resto es sencillo

void setup()
{
lcd.begin(16, 2); // Fijar el numero de caracteres y de filas
lcd.print("Prometec.net"); // Enviar el mensaje
}

void loop()
{
lcd.setCursor(0, 8); // set the cursor to column 0, line 1
lcd.print(millis() / 1000); // print the number of seconds since reset:
}

Cuidado: Como siempre la primera linea, la superior, es la linea 0 y la segunda la linea 1.

Estos display son muy pesados de cablear, pero muy sencillos de utilizar.
Vamos a probar sacando un reloj (muy sencillo de momento). Si recordis las funciones que
usamos en las ultimas sesiones, podemos recuperar alguna para presentar el valor de millis() como
un reloj

#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup()
{
lcd.begin(16, 2); // Fijamos el numero de caracteres y filas
lcd.print("Prometec.net"); // Aqi va el mensaje
}

void loop()
{
lcd.setCursor(6, 1); // Ponte en la line 1, posicion 6
String s = reloj() ;
lcd.print(s) ;
}
String reloj()
{
int n = millis() / 1000 ; // Lo pasamos a segundos
int segundos = n % 60 ;
int minutos = n / 60 ;

String S = String(minutos) + ":" + String(segundos);

return (S);
}

Merece la pena, comentar algunas cosas de este cdigo. En primer lugar en la funcin reloj,
calculamos los minutos y segundos a partir del reloj interno de Arduino en milisegundos, no hay
nada nuevo en esto. Pero fijaros que hemos definido reloj como String:
String reloj()
Eso significa que vamos a devolver un parmetro tipo String a quien nos haya llamado. En algn
punto de la funcin habr que hacer un return( String).
Fijaros que definimos dentro de la funcin un string llamado s:
String S = String(minutos) + ":" + String(segundos);
En esta lnea no hay que confundir (aunque se escriben exactamente igual), el tipo String para
definir S, con la funcin String(n) que convierte un numero n en un string de texto para que pueda
mezclar el nmero de los minutos y los segundos separados por un smbolo de :.
Al final le aadimos un par de espacios en blanco, para evitar arrastrar fantasmas en la pantalla

Quita los espacios y miro lo que pasa en el cambio de minuto. Cmo lo arreglaras, sin el truco de
poner esos espacios al final? Piensalo.

En la funcin loop, hemos usado

lcd.print(s) ;

Para sacar el mensaje de texto. Todo lo que ya sabis de Serial.print() se usa exactamente igual
con esta instruccin. Y por ltimo, tenemos una lnea como esta:
lcd.setCursor(6, 1); // Ponte en la line 1, posicion 6
Que lo que hace es posicionar el cursor del panel, en la posicin 6 de la segunda lnea, para
escribir la hora centrada. Aqu os dejo un mini video con el resultado.
La librera LCD, viene con varios ejemplos muy interesantes, que os conviene probar. Recordad,
simplemente, que tenis que cambiar las definiciones de los pines para que corran.
Un ejemplo particularmente interesante, es el de CustomCharacter, en el que define una serie de
smbolos especiales y los mueve por la pantalla en funcin de los valores que lee de un
potencimetro.
Sin llegar a tanta sofisticacin, es muy interesante que veamos cmo definir algunos caracteres
especiales, porque en la tabla base del LCD, no estn incluidas , acentos, grados, o . As que
dependiendo del uso que le deis pude seros de inters saber cmo definir tus propios smbolos.

DEFINIENDO TUS PROPIOS CARACTERES

Vamos a definir un carcter propio, para digamos, el smbolo de grados centgrados, por ejemplo.
Lo primero que tenis que saber, es que los caracteres se definen con un array ( si, de nuevo) de
88, como si los dibujarais en una cuadricula de ese tamao, y rellenando el cuadradito completo.
As por ejemplo para el smbolo del grado seria:

byte grado[8] =
{
0b00001100, // Los definimos como binarios 0bxxxxxxx
0b00010010,
0b00010010,
0b00001100,
0b00000000,
0b00000000,
0b00000000,
0b00000000
};

Para montar los caracteres definidos usamos:

lcd.createChar(0, euro);
lcd.createChar(1, grado);

Y ahora ya estan disponibles. Tened en cuenta que solo podemos definir 8 caracteres especiales
en un momento dado ( Aunque podemos definir 30 arrays, de caracteres y crearlos y matarlos
sobre la marcha).
Aqui tenemos un ejemplo del programa:

#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

byte grado[8] =
{
0b00001100,
0b00010010,
0b00010010,
0b00001100,
0b00000000,
0b00000000,
0b00000000,
0b00000000
};

void setup()
{
lcd.begin(16, 2); // Hay que inicializar el LCD
lcd.createChar(1, grado);
lcd.setCursor(0, 0);
lcd.print("Estamos a 25");
lcd.write(1);
}
void loop()
{
}

Y aqui teneis una foto del resultado

Por ltimo, y para cerrar ya la sesin (Todo llega en la vida), Deciros que de nuevo, hemos
montado este display a la brava, conectando un buen nmero de cables.
Esto solo se puede justificar, porque en su da piqu y me compre un display de estos ( en
realidad, dos. Tengo otro de 164), pero si vais a compraros un LCD, por Dios, compraros uno que
sea I2C o algo as, vuestra salud mental mejorar mucho y solo usa 4 cables.
En la prxima sesin montaremos uno para que veis la diferencia.

5. COMO FUNCIONA UN SENSOR ULTRASNICODE DISTANCIA

Hemos visto, en los documentales, que los murcilagos son capaces de volar en completa
oscuridad y sin embargo, sortear obstculos o atrapar insectos en vuelo. Sabemos que lo hacen,
pero rara vez pensamos como.
Tenemos una vaga idea de que se llama ecolocalizacin y que ms o menos tiene que ver con
unos sonidos agudos que emiten y que despus recogen con esas enormes orejas que Dios les ha
dado, pero rara vez nos planteamos cmo es esto posible.
Delfines y ballenas utilizan un sistema similar para atrapar a sus presas, y hasta hemos visto que,
en cualquier pelcula de submarinos, en el momento lgido el capitn ordena emitir un pulso nico
de sonar para localizar al enemigo.
El concepto bsico, es siempre el mismo, sabiendo a qu velocidad viaja el sonido, si emitimos un
pulso snico corto y escuchamos cuanto tiempo tarda en regresar el eco podemos calcular la
distancia a la que se encuentra el objeto en el que ha rebotado la seal.

El radar funciona de modo similar aunque usando ondas de radio frecuencia muy cortasy con una
problemtica propia descomunal. Un pulso de radiofrecuencia se emite desde la antena y se
recoge el eco que vuelve a la velocidad de la luz.

Lo que haremos en esta sesin es utilizar un sensor de distancia sencillo HC-SR04 (y muy
parecido a los sensores de aparcamiento de los coches modernos), que nos permite enviar
estos pulsos ultrasnicos y escuchar el eco de retorno. Midiendo este tiempo, podemos calcular
la distancia hasta el obstculo.

El odo humano no percibe sonidos por encima de 20kHz. Por eso, a las ondas de mayor
frecuencia las llamamos ultrasonidos ( mas all del sonido). Los sensores de ultrasonidos
funcionan sobre los 40 kHz.
No son perfectos, les influye la temperatura ambiente, la humedad y los materiales en los que
reflejan, lo que genera una cierta incertidumbre. Pero a cambio son baratos y efectivos hasta un
poco ms de 3 metros en condiciones normales si la precisin no es un problema determinante

DIAGRAMA DE CONEXIN

Veamos como conectar uno de esto detectores a nuestros Duinos. Aqu est el esquema elctrico
y de protoboard por cortesa de Fritzing:
Y de nuevo, el diagrama de conexin de la protoboard

EL PROGRAMA DE CONTROL

Vamos con el programa, empezamos definiendo algunos valores:

#define trigPin 13
#define echoPin 12
#define led 2

Hasta ahora habamos visto que podamos definir una variable como int, por ejemplo, y tambin
como una constante (const int pin). Aqu utilizamos otro mtodo, el #define que es una directiva
para el compilador.
Esto solo significa que el compilador (en rigor el pre procesador) cambiar todas las ocurrencias de
estos #define en nuestro programa por su valor antes de compilar. Esta es la forma clsica de C de
hacer esto y tiene la virtud de que no ocupa memoria definiendo una variable (y con un Arduino
UNO, que va muy corto de memoria, esto puede ser crtico en ocasiones).

void setup()
{
Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(led, OUTPUT);
}
Ya estamos ms que habituados a la funcin delay(milis), pero el reloj interno de Arduino mide en
microsegundos y tenemos otra funcin parecida delayMicroseconds(s) que simplemente congela
Arduino el nmero especificado de microsegundos.
Para dar un pulso ultrasnico lo que hacemos es activar el pin Trigger durante unos
microsegundos y para ello lo ponemos en HIGH, antes de escuchar el eco:

digitalWrite(trigPin, LOW); // Nos aseguramos de que el trigger est desactivado

delayMicroseconds(2); // Para estar seguros de que el trigger ya est LOW
digitalWrite(trigPin, HIGH); // Activamos el pulso de salida
delayMicroseconds(10); // Esperamos 10s. El pulso sigue active este tiempo
digitalWrite(trigPin, LOW); // Cortamos el pulso y a esperar el echo

Para escuchar el pulso vamos a usar otra funcin, pulseIn() ( Oh s, hay muchas,
muchsimas). Para leer el manual de pulseIn() buscad en google Arduino pulseIn y vereis que
pronto lo encontrais.
Bsicamente lo que hace es escuchar el pin que le pasamos, buscando una seal que pase de
LOW a HIGH ( si le pasamos HIGH como parmetro) y cuenta el tiempo que tarda en volver a bajar
desde que sube.

long duracion, distancia ;

duracion = pulseIn(echoPin, HIGH) ;

Ahora ya sabemos el tiempo que tarda en volver el eco en s. Como la velocidad del sonido es de
343 metros / segundo, Necesitamos 1/343 = 0,00291 segundos para recorrer un metro.
Para usar una medida ms cmoda podemos pasar esto a microsegundos por centmetro:

Como nuestro eco mide el tiempo que tarda el pulso en ir y venir la distancia recorrida ser la
mitad:

As que el programa queda parecido a esto :

#define trigPin 13
#define echoPin 12
#define led 2

void setup()
{ Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(led, OUTPUT);
}

void loop()
{ long duracion, distancia ;
digitalWrite(trigPin, LOW); // Nos aseguramos de que el trigger est desactivado
delayMicroseconds(2); // Para asegurarnos de que el trigger esta LOW
digitalWrite(trigPin, HIGH); // Activamos el pulso de salida
 delayMicroseconds(10); // Esperamos 10s. El pulso sigue active este tiempo
digitalWrite(trigPin, LOW); // Cortamos el pulso y a esperar el echo
duracion = pulseIn(echoPin, HIGH) ;
distancia = duracion / 2 / 29.1 ;
Serial.println(String(distancia) + " cm.") ;
int Limite = 200 ; // Medida en vaco del sensor
if ( distancia < Limite)
digitalWrite ( led , HIGH) ;
else
digitalWrite( led , LOW) ;
delay (500) ; // Para limitar el nmero de mediciones
}

Para convertir esto en un detector de movimiento hemos creado una variable un poco menor de la
medida que el sensor recibe en vacio (en mi caso unos 200 cm). Si la distancia medida cae por
debajo este valor es que algo se ha interpuesto y por tanto encendemos una alarma, en nuestro
caso un humilde LED.
Despus de este ejercicio de fsica y matemticas, que sin duda causar furor entre los estudiantes
aplicados, vamos a hacer el mismo programa pero usando una librera externa, que alguien se ha
molestado en escribir, paras esas pocas personas que no disfrutan de los problemas de ciencias y
que as, podamos ver la diferencia.
Podes descargar la librera de aqu, Descargar, o bien de la web del autor
en code.google.com/p/arduino-new-ping.
Para instalar una librera externa no incluida en el IDE de Arduino tenemos que importarla con el
men Programa \ Importar librera\Aadir librera:

En la ventana que sale, buscad el fichero NewPing_v1.5.zip que habis descargado y

seleccionadlo.
Ya est. Arduino ha importado la librera y los ejemplos que incluye. Si ahora volvis a
Programa\ImportarLibrera, veris que al final de la lista ya est disponible como NewPing, y
adems el zip incluye varios ejemplos de uso. Vamos a cargar el equivalente del programa
anterior. Haced :
Archivo \ Ejemplos \ NewPing \ NewPingExample
Arduino cargara un programa de ejemplo. Las instrucciones claves son primero inicializar la
librera con:
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE) ;
Y despus medir la distancia:

unsigned int uS = sonar.ping() ;

Aqui os copio el ejemplo para vuestra referencia:

#include <NewPing.h>

#define TRIGGER_PIN 12 // Arduino pin tied to trigger pin on the ultrasonic sensor.
 #define ECHO_PIN 11 // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 200

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and

maximum distance

void setup()
{
Serial.begin(115200); // Open serial monitor at 115200 baud to see ping results.
}

void loop()
{
delay(50);
unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS)
Serial.print("Ping: ");
Serial.print(uS / US_ROUNDTRIP_CM);
Serial.println("cm");
}

Como veis la librera se encarga de inicializar los pines necesarios, enviar los pulsos, escuchar el
eco de retorno y de hacer los clculos. No est mal.

Fijaros, que el ejemplo, utiliza diferentes pines a los que nosotros hemos usado,as que tendres
que modificarlos. Igualmente, el ejemplo inicializa la puerta serie a 115.200. Es imprescindible
igualar esta velocidad con la que recibe la consola o veris muchas cosas raras en pantalla.
Los alumnos avispados se habrn dado cuenta de que Arduino viene forrado de ejemplos que
pueden cargar y usar. Os invito a que investiguis y juguis con estos ejemplos cuanto queris.

6. MEDIR DISTANCIAS CON ARDUINO Y SENSOR SHARP GP2Y0A02YK0F

QU ES UN SENSOR SHARP GP2Y0A02YK0F?

El Sharp GP2Y0A02YK0F es un sensor de distancia ptico. Est compuesto por un LED

infrarrojo junto con dispositivo detector de posicin (PSD) y un procesador integrado encargado de
realizar el clculo de la distancia.
El sensor escanea de forma continua los objetos ubicados en frente suyo y proporciona la salida
mediante una referencia de tensin analgica, por lo que podemos emplear las entradas
analgicas de Arduino para leer el valor de la distancia.
El rango de medicin es de 20 a 150 cm, manteniendo un grado de precisin elevado en todo el
intervalo. La tensin de alimentacin es de 4.5 a 5.5V y el consumo de corriente de 33mA. El
intervalo de refresco entre mediciones es de unos 80ms.
El GP2Y0A02YK0F es un dispositivo sencillo de conectar y usar. Sin embargo hay que tener
en cuenta que incorpora un conector JST (Japanese Solderless Terminal) para su conexin, por lo
que tendremos que emplear un conector de este tipo o soldar directamente los terminales en la
placa.
El sensor es poco sensible al color y reflectividad del objeto detectado, ni a la temperatura
ambiente. Sin embargo, s puede ser afectado por luz ambiente si recibe un alto grado de
luminosidad de forma directamente, en especial al usarlo en exterior. Tambin pueden
proporcionar mediciones incorrectas al detectar objetos transparentes o muy brillantes,
especialmente vidrios y espejos.
El sensor Sharp es ms preciso que los sensores de ultrasonidos como el HC-SR04,
especialmente en distancias medias y largas, donde los sensores de ultrasonidos ven afectadas
sus mediciones por los rebotes y ecos que producen las geometras del entorno.
Sin embargo no puede operar en distancias cortas (<20cm) donde el HC-SR04, aunque con baja
precisin, al menos puede realizar mediciones.
Cuando montis estos sensores en un vehculo o robot intentarlos montarlos en la parte trasera
del mismo, aunque la primera tendencia sea montarlos en la delantera. As ganis el ancho del
vehculo como distancia, y podris medir distancias inferiores.
Por otro lado, el sensor Sharp tiene una zona de medicin ms estrecho que el HC-SR04, lo cual
permite obtener mayores para mediciones en frente del objeto. Por contra, ignorar objetos que
el HC-SR04 si detectara por su mayor ngulo de medicin (por ejemplo, las patas de una mesa).
Finalmente, al emplear ms de un sensor pueden producirse interferencias entre las
mediciones si ambos haces interfieren. Sin embargo, el problema es mucho menor que al combinar
sensores HC-SR04, donde podemos tener interferencias incluso sin que los haces interfieran, por
los rebotes y ecos secundarios originados por el propio HC-SR04.
Podemos usar el GP2Y0A02YK0F en nuestros robots para medicin de distancias en rangos
medios y largos en un haz estrecho. Dadas sus diferentes caractersticas, podemos combinarlos
con sensores ultrasonido tipo HC-SR04 para rangos cortos o amplios, o sensores de deteccin de
obstculos para distancias muy cortas.
El sensor Sharp tambin tiene puede ser empleado en otro tipo de aplicaciones como, por ejemplo,
sistemas Touch-Less, control de iluminacin, sensores de posicin, fines de carrera o deteccin de
objetos en un determinada zona.

PRECIO

El sensor Sharp GP2Y0A02YK0F es ms caro que un sensor de ultrasonidos HC-SR04. Podemos

encontrar sensores Sharp GP2Y0A02YK0F por 3.70 en vendedores internacionales de eBay o
AliExpress.
 CMO FUNCIONA EL SHARP GP2Y0A02YK0F?

El emisor LED infrarrojo emite un haz de luz pulsada infrarroja con una longitud de onda de 850nm
+/-70nm. Se enva una luz pulsada para minimizar la influencia de la luz ambiente y del color del
objeto en la medicin.
El detector de posicin PSD (position sensitive detection) es en realidad es un pequeo sensor
CCD lineal que recibe la luz reflejada en cualquier objeto en la trayectoria del rayo. El sensor
emplea triangulacin para determinar la distancia del sensor a los objetos ubicados frente al rayo.

La salida analgica tienen un valor de 2.5V a 20 cm, y de 0.4 a 150cm. Sin embargo, como hemos
mencionado, la respuesta es no lineal por lo que es necesario interpolar el valor para obtener un
nivel de precisin adecuado.
 ESQUEMA DE MONTAJE

El esquema de montaje es sencillo. Por un lado, alimentamos el sensor mediante Vcc y GND
conectndolos, respectivamente, a 5V y GND de Arduino.

Finalmente, conectamos el pin de seal a una de las entradas analgicas de Arduino.

EJEMPLOS DE CDIGO

El siguiente cdigo realiza la medicin de la salida del sensor empleando las entradas
analgicas de Arduino. A continuacin, realiza la interpolacin para obtener la distancia en
centmetros.
Finalmente, muestra los valores por pantalla empleando el puerto serie. En un montaje real,
usaramos esta zona para hacer las acciones necesarias, como detener un robot o activar un
mecanismo.

1 const int sensorPin = A0;

2 const long referenceMv = 5000;
3
4 void setup() {
5 Serial.begin(9600);
6 pinMode(ledPin, OUTPUT);
7 }
8
9 void loop() {
10 //lectura de la tensin
11 int val = analogRead(sensorPin);
12 int mV = (val * referenceMv) / 1023;
13 int cm = getDistance(mV);
14
15
16 //mostrar valores por pantalla
17 Serial.print(mV);
18 Serial.print(",");
19 Serial.println(cm);
20
21 delay(1000);
22 }
23
24 //interpolacin de la distancia a intervalos de 250mV
25 const int TABLE_ENTRIES = 12;
26 const int INTERVAL = 250;
27 static int distance[TABLE_ENTRIES] = {150,140,130,100,60,50,40,35,30,25,20,15};
28
29 int getDistance(int mV) {
30 if (mV > INTERVAL * TABLE_ENTRIES - 1) return distance[TABLE_ENTRIES - 1];
31 else {
32 int index = mV / INTERVAL;
33 float frac = (mV % 250) / (float)INTERVAL;
34 return distance[index] - ((distance[index] - distance[index + 1]) * frac);
35 }
36 }

7. CONTROLANDO VARIOS MOTORES DE CC

En las sesiones previas hemos visto cmo manejar los motores de corriente continua tpicos.
Hemos visto cmo hacerlos girar y como modificar esta velocidad de giro, as como la forma de
invertir el sentido de rotacin mediante un H bridge integrado como el L293D.
Y qu hace un hombre normal, cuando consigue controlar un motor (y ms uno que est leyendo
esto)? Pues naturalmente, probar a manejar varios motores a la vez, digamos 4, y empezar a
pensar en hacer un pequeo cochecito con traccin a las 4 ruedas y control remoto inalmbrico
y. Quieto parado!
Vayamos por partes. De momento solo hemos gobernado un motor, aunque sabemos que
el L293D dispone de capacidad para manejar un segundo motor. Podramos disear un circuito
con dos L293D para mover 4 motores y quizs hacer un Shield para montar todo en la chepa de
nuestro Arduino.
Pero como siempre os digo, si existe una necesidad en este mundo electrnico, siempre hay
alguien presto a vendernos la solucin de forma conveniente. Y como podris imaginar, ni somos
los primeros que hemos tenido esta idea (Ni seremos los ltimos) ni es precisamente una novedad
la solucin, el mercado nos ofrece toda una variedad de Shields para controlar motores muy
interesantes, dependiendo del tamao de los motores, su consumo, la tensin y cualquier otra cosa
que podis imaginaros.
Como en esta humilde casa pensamos que para aprender hay que trastear y preferiblemente por
poca pasta, vamos a presentar un sencillo Motor Shield que fue diseado por nuestros amigos de
Adafruit y luego abandonado en favor de un controlador de motores ms avanzado (y caro) y cuyo
relevo ha sido tomado por la nube de fabricantes chinos, proporcionndonos un Arduino motor
shield V1.0, por muy poco dinero, que nos permite iniciarnos gastando lo justo.
Veamos sus caractersticas.

ADAFRUIT MOTOR SHIELD V1.0

Aqu tenis una foto del Motor Shield V1.0, que podis encontrar fcilmente en cualquier
proveedor:

Las caractersticas principales son:

4 H Bridges incluidos con dos L293D chips.

Hasta 4 motores CC con control bidireccional y seleccin de velocidad de 8 bits.
Mxima corriente de 0,6 Amperios (Aunque acepta picos de hasta 1,2) con una proteccin de
sobre temperatura.
Acepta motores cuya alimentacin va desde 4,5 a 25V.
Podemos aadir otros dos motores Servos o paso a paso.
Dispone de alimentacin de motores, separada de la del Shield para evitar ruido e interferencias.
Bajo precio (En serio).
Compatible con UNOs y Megas por lo menos.
Dispone de una librera cmoda para manejar los motores.

En resumen, es un Shield barato y prctico para manejar pequeos motores de 5V, pero que se
quedar corto si necesitas una cierta potencia en los motores, ya que la intensidad que estos
demandaran superar con facilidad los 0,6A que tiene como lmite este Shield.
Es ideal para construir robots autnomos con pequeos motores y sin peso y sobre todo como
elemento de aprendizaje antes de invertir una pasta gansa en otras opciones mas sofisticadas.

CONECTANDO EL MOTOR SHIELD

El shield conecta directamente los H Bridges L293D a los pines PWM de Arduino y adems
incorpora un viejo conocido nuestro el 74HC595, un Shift Register, para ahorrar pines en la
conexin.
El Shield se reserva los pines 3,4,5,6,7,8,9,10,11,12, los pines 9 y 10 se usan para los servos en
caso de que los incluyamos y quedan libres los pines 2 y 13, as como el 0 y 1 que se usan para la
comunicacin USB con nuestro PC.
Los pines A0 a A5 estn disponibles para nuestro uso y recordar que a una mala, podeos usarlos
como pines digitales tambin.

Hay conexiones para los bornes de 4 motores, marcados como M1, M2, M3 y M4 y conviene que al
conectar sigas el mismo criterio en los bornes y en el Shield porque de lo contrario conseguirs
que alguno de los motores gire al revs de lo que pretendes. Lo que no es muy grave porque se
arregla con facilidad.
Una cosa interesante de este shield es que nos permite separar la alimentacin de los motores de
la alimentacin de Arduino y es de agradecer porque los motores generan mucha interferencia
electromagntica que puede hacer que nuestro Arduino se comporte de forma errtica.
Por eso siempre que sea posible conviene que separis la alimentacin de uno y otro (Aunque en
un robot autnomo va a ser difcil). Para ello basta con que quites el power jumper y la
alimentacin estar separada. Esto ser imprescindible si tus motores son de digamos 9 0 12V
porque tu Arduino solo funciona con 5V (So pena de hacer barbacoa de Arduino).
Vamos a conectar un primer motor al Shield para probar. Lo primero montad el Shield a
vuestro Arduino. Yo os recomiendo un MEGA para que podamos seguir haciendo cosas en el
futuro, pero tambin vale cualquier otro.
Conectad los bornes del motor a los tornillos A y B del Motor Shield, dejando libre el pin central
marcado como GND.

No es importante que borne a que pin, porque lo nico que ocurrir si lo inverts es que el motor
girar al revs. Lo que s es recomendable es que mantengis el mismo criterio para todos los
motores, porque os ahorrar dolores de cabeza.
Como en este primer ejemplo vamos a alimentar el motor desde Arduino y el USB, no olvidis
conectar el power jumper, para que alimentemos los motores directamente desde Arduino.

Seria sencillo manejar el motor a travs del Shield directamente, recurriendo a los pines de control,
y os lo propongo como ejercicio si os parece, pero aqu vamos a descargar ahora una librera de
Adafruit para manejar el Shield directamente, que nos permitir abstraernos del detalle de pines.
La librera que necesitamos es esta adafruit-Adafruit-Motor-Shield-library-8119eec, y para instalarla
seguimos el procedimiento habitual.
Para usarla, lo primero que tenemos que hacer es este par de instrucciones:

#include <AFMotor.h>
AF_DCMotor Motor1(1);

La primera lnea, incluye la librera de AdaFruit en nuestro programa, y la segunda crea una
instancia de un motor conectado a la puerta M1, y le iniciamos con el parmetro que le pasamos
que puede ir del 1, M1 al 4, M4.
Para establecer la velocidad del motor hacemos:

Motor1.setSpeed(200); // Definimos la velocidad de Motor1

Motor1.run(RELEASE);

La primera lnea pone el motor a 200 / 255 del tope de revoluciones, y la segunda lnea indica que
queremos dejar el motor en punto muerto.
Si queremos que el motor avance usamos:

Motor1.run(FORDWARD);

Y para que retroceda hacemos

Motor1.run(BACKWARD);
Y eso es todo lo necesario para controlar un motor. Si queremos hacer un primer programa sencillo
que haga avanzar el motor unos segundos y despus retroceda, podemos escribir un programa
similar a este

#include <AFMotor1.h>
AF_DCMotor1 Motor1(1);

void setup()
{ Motor1.run(RELEASE); }

void loop()
{ Motor1.run(FORWARD);
delay (2000);

Motor1.setSpeed(180);
Motor1.run(BACKWARD);
delay (2000);
}

Aqu os pongo un mini video con el resultado:

MOVIENDO VARIOS MOTORES SIMULTNEAMENTE

Vamos a conectar ahora, 4 motores a nuestro Motor Shield. Yo tengo por aqu rodando un
bastidor con 4 ruedas y motores que voy a usar como base para hace un robot con traccin a las 4
ruedas.
Pero lo mismo da cualquier otro robot que tengis, o hasta un bastidor con las ruedas, a condicin
de que podamos subirle nuestro Arduino mas el motor Shield. Una caja de cartn duro a la que
sujetis los motores y ruedas, sirve de maravilla.
En mi caso lo he puesto en un pedestal, para poder probar los diferentes motores sin que se me
escape corriendo. Vamos con el programa de prueba. Lo primero es incluir la librera y definir las
instancias de los motores que esta ocasin son 4 en vez de 1:

#include <AFMotor.h>

AF_DCMotor Motor1(1);
AF_DCMotor Motor2(2);
AF_DCMotor Motor3(3);
AF_DCMotor Motor4(4);
Definimos la velociodad de los 4 motores en el setup:
void setup()
{ Serial.begin(9600); // set up Serial library at 9600 bps
Motor1.setSpeed(255);
Motor2.setSpeed(255);
Motor3.setSpeed(255);
Motor4.setSpeed(255);
}
Y por ultimo vamos a mandar moverse adelante y atrs y para los 4 motores simultneamente:
Motor1.run(RELEASE);
Motor2.run(RELEASE);
Motor3.run(RELEASE);
Motor4.run(RELEASE);
delay (1000) ;

Motor1.run(FORWARD) ;
Motor2.run(FORWARD);
Motor3.run(FORWARD);
Motor4.run(FORWARD);
delay (2000);

Motor1.run(BACKWARD);
Motor2.run(BACKWARD);
Motor3.run(BACKWARD);
Motor4.run(BACKWARD);
delay (2000);

Como veis no es diferente de mover un solo motor, solo mas pesado. Aqu tenis el programa

Es conveniente que comprobis en vuestro montaje que todas las ruedas giran en la misma
direccin y que no hay ninguna rotando al revs, porque cuando queramos avanzar seria un
problema.
Aqu os dejo un pequeo video con el trest de giro

Con esto, confo en que con esto hayamos dejado listo el hardware de nuestro robot para empezar
a programarlo en serio. Pero parece mas conveniente cortar aqui esta sesin y dejar algo para la
prxima sesin, en la que veremos como mover el robot y hacerlo girar adems de variar la
velocidad de crucero.

Detalle del uso de pines

Una consulta de un lector suscit la cuestin de que pines se usaban para que en este Motor
Shield V1 y como era una cuestin de lo mas razonable que no estaba cubierta
previamente,hemos optado por aadir este pequeo anexo especificando los pines que usa cada
motor y cuales estn disponibles en caso contrario.

ARDUIN
FUNCIN
O

Pin 1 Disponible

Pin 2 Disponible

Pin D3 DC Motor #2 / Stepper #1

Pin D4 Reservado para gobernar el Shift Register 74HC595

Pin D5 DC Motor #3 / Stepper #2

Pin D6 DC Motor #4 / Stepper #2

Pin D7 Reservado para gobernar el Shift Register 74HC595

Pin D8 Reservado para gobernar el Shift Register 74HC595

Pin D9 Servo #1, Disponible si no se usa el servo

Pin D10 Servo #2, Disponible si no se usa el servo

Pin D11 DC Motor #1 / Stepper #1

Pin D12 Reservado para gobernar el Shift Register 74HC595

Pin D13 Disponible

A0,A1,A
Disponibles. Recuerda que pueden usarse como
2,A3,A4,
digitales
A5

Tened presente que no hay ningun pin de Arduino conectado a los motores directamente. La
gestin de los motores se realiza a traves del shift register para ahorra pines y por eso tenis
necesariamente que usar la libreria para manejarlos.