La idea
Vamos a explicar un poco el funcionamiento del sensor de distancia HC-SR04,
de una pantalla LED y pingüino. Para eso vamos a hacer un pequeño
dispositivo que lo que va hacer es detectar objetos que pasen por
delante de él. La detección de objetos se hará mediante el sensor
de distancia(HC-SR04) y la salida se hará en el LCD, el dispositivo
LCD va indicando cuantos objetos han pasado y a qué distancia tiene
el objeto actual. La gestión del problema la hace pingüino. Con
este pequeño proyecto podemos ir viendo el funcionamiento de dichos
dispositivos
Pinguino
Pinguino es una plataforma de hardware y
software "open source" que nos permite el desarrollo de
aplicaciones robóticas. Es similar a Arduino pero basado en un
microcontrolador PIC. El Pinguino que voy a usar lleva el PIC18F4550.
Lo podéis comprar directamente o podéis hacerlo
vosotros mismos que es más divertido. Podéis conseguir información
en su pagina oficial: http://www.pinguino.cc/
HC-SR04
El HC-SR04 es un
sensor de ultrasonidos que nos sirve para medir la distancia que hay
desde el sensor hasta un objeto que se encuentre enfrente del mismo.
Este sensor es capaz de medir distancias desde 2 centímetros hasta 4
metros.
El
sensor envía un pulso de ultrasonido (que no percibe el oído humano
por su alta frecuencia) a través de uno de cilindros (transductor),
este sonido rebota en un objeto y al volver es recibido por el otro
cilindro. El tiempo que tarda esta operación es el que define la
distancia del objeto.
La conexión se debe de hacer de la siguiente
manera:
El primer y el ultimo pin son la alimentación
del dispositivo (5V y tierra). Los pines del medio son los encargados
de hacer de sonar. “Trig” es el encargado de enviar la señal y
“Echo” devolverá el eco de dicha señal.
LCD
El lcd es un dispositivo que nos va a servir
para poder mostrar cualquier tipo de información al usuario. En
nuestro caso lo que vamos a querer es ir mostrando la distancia
actual de un objeto y un contador de objetos que han pasado por
delante del sensor.
Para nuestro ejemplo vamos a usar un LCD de
2x16. Compatible con el driver Hitachi HD44780.
Las patillas de conexión del lcd son las
siguientes:
Nº
Pin
|
Función |
Nombre |
1
|
Tierra
(0V) |
GND |
2
|
Alimentación
5V (4.7V – 5.3V)
|
Vcc |
3
|
Ajuste
de contraste; Mediante una resistencia variable |
VEE |
4
|
Selección
registro de comandos (0) o registro de datos (1)
|
Register
Select |
5
|
Escritura
(0), Lectura (1)
|
Read/write |
6
|
Envía
datos a los pines |
Enable |
7
|
Pines
de datos (8-bit) |
DB0 |
8
|
DB1 |
|
9
|
DB2 |
|
10
|
DB3 |
|
11
|
DB4 |
|
12
|
DB5 |
|
13
|
DB6 |
|
14
|
DB7 |
|
15
|
Luz
trasera VCC (5V) |
Led+ |
16
|
Luz
trasera Ground (0V) |
Led- |
Montaje:
El montaje es el siguiente:
Los dos dispositivos mencionados están
conectados a la placa pingüino. El sensor de distancia HC-SR04
conecta sus 2 pines a los pines 11 y 12 de pingüino. El dispositivo
LCD tiene más pines para conectar. Los pines de RS y EN se conectan
a los pines 8 y 9. El pin “VEE” llevará una resistencia variable
para controlar el contraste de la pantalla. Por otro lado los pines
de datos desde DB4 hasta DB7 Irán en los pines desde el 0 hasta el 3
de pinguino. Vamos a utilizar este LCD sólo con 4 bits. Los pines de
5 voltios y tierra no los he conectado para que se vea más claro
Programa:
Los programas en pingüino (como en arduino) se
componen de dos partes: el setup (parte del código que solo se
ejecuta una vez) y el loop (que se ejecuta repetidas veces sin
parar).
SETUP
En el setup vamos a meter la inicialización de
los dispositivos enchufados a pingüino y la inicialización de las
variables que vamos a usar en el programa.
La inicialización del dispositivo LCD se hace
con las instrucciones:
lcd.pins(8,9,0,1,2,3,0,0,0,0);
lcd.begin(16, 2);
La primera de ellas indica a pingüino en que
pines se le enchufa la pantalla LCD
lcd.pins(rs, enable,
DB0, DB1, DB2, DB3, DB4, DB5, DB6, DB7);
La segunda indica
que se trabaja con un lcd de 16 columnas y 2 filas.
Las siguientes lineas nos sirven para configurar
como entrada o salida los pines de pingüino.
pinMode(int pin, int mode);
Nosotros necesitamos una de entrada y una de
salida para conectar el sensor de distancia (SR04).
El resto son inicializaciones de variables que
usaremos en el loop.
LOOP
El loop se va a ejecutar infinitas veces.
Lo que va a hacer es enviar un pulso por el pin
12 y recuperarlo por el pin 11. Este tiempo se calcula gracias a la
función “pulseIn”. Una vez que sabemos el tiempo que tarda
podemos calcular la distancia mediante la formula:
distancia= 0.017*tiempo;
La segunda parte del programa va a consistir en
averiguar si hay un objeto en el campo de visión del sensor. Para
ello tenemos una variable llamada umbral que nos sirve como limite de
visión del aparato. Es decir, si algún objeto pasa a una distancia
menor que el umbral, el programa lo contará como que ha pasado y lo
sumará al contador, todo lo que esté más lejos del umbral lo
obviará.
La ultima parte es la que escribe los datos en
el LCD y serán visibles para el usuario.
La forma de imprimir es mediante las funciones:
lcd.setCursor(0,0);
lcd.print("Texto");
La primera de ellas indica a pingüino en que
ubicación del LCD va a empezar a escribir (columna y fila de la
pantalla).
La segunda de ellas hace la impresión en sí.
El programa que podéis copiar y compilar en
pingüino (insisto, también os valdría para arduino) es el
siguiente:
#include <stdlib.h>
int distancia;
long tiempo;
u8 buffer[5];
int cont;
int umbral;
boolean hayobjeto;
void setup() {
//run once:
// Se inicializa el lcd con lcd.pins
//Indca los pines: RS, E, D4 ~ D8
lcd.pins(8,9,0,1,2,3,0,0,0,0);
// Indicamos el numero de columnas y de filas
lcd.begin(16, 2);
//pin 12 como salida: para el pulso ultrasónico
pinMode(12, OUTPUT);
//pin 11 como entrada: tiempo que tarda e pulso en rebotar
pinMode(11, INPUT);
//Inicializamos las variables
cont=0;
umbral = 100;
hayobjeto = false;
}
void loop() {
//run repeatedly:
//Ponemos en el pin que envia el pulso a 0
digitalWrite(12,LOW);
delayMicroseconds(5);
//Ahora mandamos 1 para activar el pulso del sensor
digitalWrite(12, HIGH);
delayMicroseconds(10);
//Recogemos el tiempo que ha tardado el pin 11 en recoger el impulso del sonar (ya rebotado)
tiempo=pulseIn(11, HIGH, 3000);
//Formula para calcular la distancia mediante el tiempo que tarda en volver el impulso
distancia= 0.017*tiempo;
//Si la distancia > umbral (no detecta objeto)
if (distancia > umbral)
{
//si antes habia objeto, ahora ya no está
if (hayobjeto == true)
{
hayobjeto = false;
}
}
//Sino, detecta un objeto
else
{
//Si antes no habia objeto, ahora lo hay y por lo tanto sumamos 1 al contador
if (hayobjeto == false)
{
hayobjeto = true;
cont = cont+1;
}
}
//Escribimos en el LCD la distancia
itoa (distancia,buffer,10);
lcd.setCursor(0,0);
lcd.print("Distancia: ");
lcd.print(buffer);
lcd.print(" cm. ");
//Escribimos en el LCD el contador de objetos
itoa (cont,buffer,10);
lcd.setCursor(0,1);
lcd.print("Cont: ");
lcd.print(buffer);
//hacemos un retardo de 1 segundo para evitar posibles variaciones
delay(1000);
}
Aquí os dejo un vídeo explicativo del proyecto con un ejemplo de funcionamiento.