Tutorial para hacer un medidor de distancia ultrasónico con Arduino

En este proyecto vamos a aprender a crear un medidor de distancia utilizando un el sensor ultrasónico HC-SR04. Vas a poder observar que mientras acercamos o alejamos la caja del sensor, la distancia marcada en el display va a ir reflejando el dato de la distancia calculada.

El tutorial estará dividido en dos partes. La primera parte estará enfocada en ver cómo conectar el sensor a nuestro arduino y hacerlo funcionar. En la segunda parte vamos a conectar un display lcd de 16 por 2 para desplegar la información de medición a través de él.

Materiales

-1 Protoboard

-1 Pantalla LCD de 16×2

-1 Adaptador I2C a LCD

-1 Sensor HC-SR04

-1 Arduino UNO

-8 Jumpers

Conexiones

Iniciamos el proyecto con la conexión del sensor al arduino. En la imagen podemos observar el diagrama de conexión. Veamos a ver cómo conectar paso a paso los componentes.

Iniciemos con el sensor, éste lo vamos a colocar mirando hacia el exterior del protoboard. La imagen del diagrama se ve un poco rara, pero se tuvo que dibujar así para que coincidiera con la forma en la que estamos colocando el sensor. Éste tiene cuatro patas, las cuales encajaremos en el protoboard.

El siguiente paso es conectar los pines marcados con VCC al canal positivo y el GND al riel negativo del protoboard. En la imagen de la derecha vemos cómo hacer esta conexión físicamente.

Luego tendremos que conectar las patas echo y trig del sensor al arduino con el fin de poder programar el sensor. Iniciamos con la pata llamada echo. Conectaremos un jumper, en este caso de color café, en uno de los rieles de la salida del conector llamado echo.

Llevaremos este jumper al pin número 10 del arduino, procedamos ahora a conectar.

En el conector llamado trig conectaremos un jumper en mi caso color amarillo a la salida del conector en el protoboard.

Este cable lo llevaremos hasta el pin número 9 de nuestro arduino.

Para finalizar esta sección de armado, vamos a conectar el pin del arduino que dice 5V al carril positivo del protoboard y uno de los pines marcados con GND al carril negativo.

Así es como se ve la conexión físicamente de ambos cables, y las conexiones en el arduino.

Con esto estamos listos para crear nuestro sketch y probar nuestro sensor ultrasónico, vamos a ello.

En la imagen que se muestra a continuación, podemos apreciar nuestro Arduino y un sketch recién creado. Lo primero que haremos, es declarar un par de constantes que van a representar los pines de nuestro Sensor HC-SR04.

Vamos a declarar lo que es una primera constante de tipo entero, la cual se llamará trigPin = 9. (Debes recordar el pin que decía trig, lo conectamos en nuestro arduino al pin número 9).

Seguidamente, vamos a declarar una segunda constante que también será de tipo entera y le llamaremos echoPin = 10. Estas dos constantes son las únicas que ocuparemos por el momento.

El segundo paso es inicializar estos pines dentro del método setup. Le vamos a indicar mediante la función pinMode, que deseamos especificar que trigPin tenga un valor output, y también vamos a indicar un pinMode, de echoPin de valor input. (En esta parte se debe escribir punto y coma en lugar de coma).

Si te preguntas por qué estamos especificando el valor output para trigPin, y el valor de input a echoPin; es debido a que nuestro sensor tiene dos componentes, un transmisor y un receptor.

En la siguiente imagen podrás notar que el transmisor va a ser el encarado de lanzar una onda ultrasónica, para que en cuanto choque con uno de los objetos, la onda se regrese y sea recepcionada por nuestro receiver.

En este caso, el transmisor está especificado por trig y el receptor está especificado como echo. Ahora bien, si lanzamos una señal de onda desde el transmisor, quiere decir que necesitamos colocar el pin como output, ya que vamos a lanzar hacia el exterior algún tipo de onda. Entonces, como vamos a recibir en el receptor la onda que acabamos de lanzar, debemos entonces indicar que el pin de echo tiene que estar especificado con un modo input, esto debido a que recibimos la información desde el exterior.

Finalmente, lo que haremos es inicializar nuestro monitor, sería a través de la instrucción Serial.begin(9600). De esta manera tenemos listo nuestro método setup.

Ahora bien, el siguiente paso es medir la distancia que va a existir entre nuestro sensor y el objeto que estemos detectado.

En la imagen que se presenta a continuación, podrás notar que tenemos una distancia, la cual necesitamos obtener, para de esta manera lograr identificar a que distancia se encuentra un objeto.

Ahora bien, debemos saber que nuestro sensor no mide realmente la distancia como tal, el modo en que se recibirá la información será conociendo el tiempo que se tarda la onda en realizar el recorrido hasta el objeto.

Para medir esta información, como parte de la documentación de arduino, tenemos un método llamado pools.

En la descripción podemos observar que se trata sobre el pulso, bien sea en su valor high o su valor low para un pin. Por ejemplo, si un valor está especificado como valor high, dice que este método comienza un timing y luego espera a que el pin regrese a su estado original low para detener el temporizador.

Finalmente retorna el largo o la duración del pulso en microsegundos, y es el valor que vamos a recibir.

Otro punto importante es que dice que se trabaja en pulsos, iniciando desde 10 microsegundos hasta 3 minutos de duración. Entonces, este método va a ser uno de los componentes clave en nuestro proyecto, ya que nos va a permitir medir precisamente cuánto tiempo se va a tardar este pulso en ir y regresar.

Vamos entonces a regresar a nuestro sketch de Arduino y vamos a proceder a declarar una nueva variable, esta va a ser de tipo long y se va a llamar duración.

Ahora nos iremos a nuestra a nuestra función que se llama loop y vamos entonces a comenzar a trabajar con nuestro sensor.

Lo primero que vamos a hacer es apagar nuestro sensor (si es que se encuentra encendido).

Para llevar a cabo esta tarea vamos a hacer un digital writing, y le vamos a indicar trigPin, y vamos asignarle un valor low.

Seguidamente para asegurarnos de darle el tiempo suficiente para que se propague la onda, vamos a utilizar una función que se llama delay microseconds, la cual es muy parecida a la función delay, la diferencia es que trabaja con microsegundos en vez de milisegundos. Entonces, vamos a indicarle que deseamos apagar este sensor por 2 microsegundos.

El siguiente paso va a ser encender de nuevo nuestro sensor, para que envíe una onda ultrasónica. Esto lo haremos a través de digital write y vamos a indicar entonces trigPing con un valor high (esto con el fin de que mandemos la onda sonora), y posteriormente vamos a indicar que deseamos enviar esta onda durante 10 microsegundos.

Esto se hace con el propósito de que nuestra función pulse funcione correctamente, (si recuerdas el valor mínimo para que funcione correctamente son 10 microsegundos), por lo tanto se debe indicar delay micro seconds y se pasará el valor de 10. Posteriormente se debe indicar que deseamos apagar el sensor a través de digital Write, y envió el valor low.

Ya especificado lo del envío de la onda, debemos configurar la parte en la cual recibimos la onda de regreso, para ello lo que vamos a hacer es indicar que su duración es igual a lo que diga la función pulseIn, y vamos a ocupar esta función trabajando con echoPing, el cual es el encargado de recibir la onda ultrasónica.

Vamos a medir cuánto se tarda en enviar y recibir la onda, por lo tanto le vamos a configurar con el valor high. Con esto ya podemos empezar a probar nuestro sensor.

Podemos escribir la intrucción Serial.printIn(duracion) para mostrar la duración (si tienes conectado actualmente tu arduino con la configuración de los componentes que vimos anteriormente puedes validar primero el sketch). Una vez haya sido compilado puedes enviar el sketch.

En la imagen a continuación se muestra el monitor serie, en el que podras observar que obtenemos una serie de valores, los cuales son los que se obtienen de la duración de la onda en microsegundos.

Si comienzas a mover el sensor, podrás notar como tenemos un cambio en las distancias o en la duración, en otras palabras, en la detección de la onda ultrasónica.

Sabemos entonces cuál es el tiempo de duración que se tarda una onda en ir y regresar a nuestro sensor, es por ello, que vamos a determinar cuál es la distancia a partir de este tiempo que hemos recibido.

si prestaste atención a tus clases física, sabrás que existen tres fórmulas para trabajar con la velocidad, la distancia y el tiempo, que son estas que se muestran a continuación.

Esta variable que se llama tiempo y tal vez no lo sepas pero también tenemos esta variable que se llama velocidad y sabemos que por default la velocidad del sonido viaja a 340 metros sobre segundo. Nuestra onda es una onda ultrasónica por lo tanto va a respetar lo que es esta velocidad del sonido pero como no estamos trabajando con metros sobre segundos y no estamos trabajando con microsegundos vamos a trabajar con este valor 0.034 centímetros sobre microsegundos y ya con esto entonces tenemos lo que es la velocidad y tenemos también lo que es el tiempo por lo cual podemos determinar cuál es la distancia.

Sabemos entonces que la distancia va a ser igual a 0.034 por la duración que recibamos por parte de la función pulse in. Sin embargo, esta duración es el tiempo que se tarda la onda en ir y venir y realmente lo que nos interesa a nosotros es saber la distancia que existe únicamente entre el sensor y el objeto por lo tanto tendremos que dividir este resultado entre dos, ya que no deseamos saber la distancia desde el sensor hacia el objeto y viceversa.

Sabiendo lo anterior vamos a proceder a crear lo que es una nueva variable, la cual será de tipo entera y se llamará distancia.

Ahora nos vamos a nuestro método loop, y una vez que hemos obtenido la duración del ir y regresar de la onda, vamos a indicar la distancia es igual a y entre paréntesis vamos a colocar duración por 0.034 / 2.

Ahora, subimos el sketch a nuestro arduino, y como puedes apreciar ya se tienen valores más pequeños, los cuales corresponden a los centímetros o la distancia de un objeto.

Si procedemos a mover el sensor, podrás notar cómo se incrementa el valor mientras más lejos tenga algún tipo de objeto.

Con esto hemos concluido la primera parte de nuestro proyecto, ahora pasaremos a integrarle un display LCD. Esto va a permitir desplegar la información obtenida en una pantalla LCD, sin necesidad de tener el monitor encendido.

Para desplegar la información obtenida en una pantalla LCD, sin necesidad de tener el monitor encendido. Para este propósito utilizaremos un adaptador I2C a lcd, con el fin de minimizar la complejidad de las conexiones, tanto el display como el adaptador I2C. (Regularmente vienen de soldados por lo que tendrás que soldar el adaptador en las ranuras de la pantalla lcd).

Se procede a instalar la pantalla lcd en un mini protoboard.

Luego insertaremos el adaptador I2C que regularmente ya incluye soldado los pines. Debes fijarte de que coincidan con los pines del display respecto a los pines del adaptador.

Una vez que hemos conectado el adaptador a la pantalla, el siguiente paso será conectar los pines del adaptador. Iniciando por el pin marcado con gnd,

el cual llevaremos al carril negativo de nuestra placa de pruebas. Fíjate que lo conectes en un lugar donde tengas continuidad. Como podemos apreciar en la placa de pruebas que yo tengo la continuidad es cortada en el centro de dicha placa, lo que está representado por estas líneas que vemos en la imagen.

Ahora vamos a conectar el pin marcado con VCC, conectamos un jumper, pero en este caso rojo,

 

Este mismo lo llevamos al carril positivo del protoboard.

Ahora vamos con el pin marcado con SDA, le conectaremos un jumper, en este caso de color gris,

 

Éste jumper lo llevaremos al pin llamado a 4 del arduino.

Por último conectemos el pin marcado con ssl del adaptador, y le conectaremos un jumper, en este caso de color blanco,

 

Vamos a conectarlo en nuestro arduino en el pin marcado como A5.

Con estas últimas conexiones listas, vamos a codificar la visualización de los resultados en el display LCD de nuestro proyecto.

Vamos a integrar la pantalla LCD a nuestro proyecto, para lograrlo, lo primero que debes hacer, es encontrar la dirección física de la pantalla LCD, para poderlo utilizar como parte de nuestro proyecto.

Afortunadamente contamos con una página web dentro del playground de arduino que se llama i2c_scanner, la cual nos va a permitir precisamente detectar la conexión física de nuestro display.

En esta página podrás ver el código fuente del sketch, el cual tendrás que copiar.

Ahora, nos regresamos a nuestro arduino y crearemos un nuevo sketch temporal. Pegamos el código que hemos copiado de la página de arduino, y vamos a proceder a subir el sketch a nuestro arduino.

Una vez subido, vamos a abrir el monitor serie y te podrás fijar que nos indica que se ha encontrado un dispositivo tipo 12 en la dirección 0 x 27 (este dato lo debes tomar en cuenta).

Cerramos el monitor serie y el siguiente paso que vamos a hacer es instalar una biblioteca que nos va a permitir trabajar precisamente con este adaptador i2c, para esto, nos debemos dirigir a herramientas, administrar bibliotecas.

En el filtro de búsqueda debes escribir liquidCrystali2c. Seguidamente debes buscar precisamente una que se llama liquidCrystali2c, cuyo autor es Frank de Brabander. En este caso aparece como instalado, pero en tu caso debes dar clic al botón que dice instalar.

Hora vamos a proceder a importar un par de bibliotecas dentro de nuestro sketch de arduino.

Para esto, nos debemos dirigir a la parte de de arriba del sketch, y vamos a escribir include <wire.h>.

Seguidamente escribiremos include <LiquidCrystal_I2C.h>, (fíjate escribir bien esta biblioteca, ya que de lo contrario, será como si nunca hubieses importado esta biblioteca, por lo tanto podrás tener muchos errores).

El siguiente paso es crear un objeto de tipo liquidcrystal de esta biblioteca. Para ello, debemos escribir LiquidCrystal_I2C lcd. Luego entre paréntesis, debes indicar la dirección física que encontramos del sketch anterior, en este caso era 0x27. Luego con una coma, le indicaremos la cantidad de filas y columnas de nuestro display. En este caso es un display de 16 por 2, por lo tanto coloco estos datos.

Ya creado el objeto, hay que inicializarlo dentro de la parte de del top. Después de inicializar el serial, vamos a indicar lcd.init, para inicializar nuestro objeto. Seguidamente, vamos a escribir lcd.backlight, para de esta manera, encender nuestro display. Realizado esto, hemos inicializado nuestro objeto.

Ahora regresemos al método loop, y nos vamos a dirigir hasta la parte de abajo, después de llevar a cabo la impresión en el monitor serie, vamos a escribir lcd.setCursor (0,0). Esto nos va a servir para posicionar donde vamos a comenzar a escribir la información.

Vamos a indicar que deseamos escribir en el primer carácter disponible, cuando el primer espacio disponible de nuestro display, a través de la instrucción lcd.setCursor (0,0).

Posteriormente vamos a imprimir una cadena a través de print y vamos a escribir lcd.print (“Distancia: “). Este mensaje va a aparecer por default en todos los mensajes o vamos a escribir, como una cadena específica que parte del mensaje que posteriormente vamos a escribir en el lcd.print, y vamos a imprimir de nuevo la variable que se llama distancia.

Por último y para que se vea bien, vamos a aplicar un delay, para que no se vea mal cuando se lleve a cabo la impresión de la nueva información.

Vamos a enviar el sketch a nuestra placa de arduino y aquí tenemos funcionando lo que es nuestro sketch.

Ahora, vamos a declarar una nueva variable que sea tipo entera y que se llame última distancia, le asignaremos un valor por default de cero.

La idea de esta variable es que podamos comparar el valor con la distancia anterior (si se encuentra un nuevo valor que se lleva a cabo), es el borrado de información de la pantalla, y si no se encuentra un nuevo valor simplemente no se va a hacer nada.

Vamos entonces a regresar a la sección donde llevamos a cabo la impresión al lcd, a la pantalla y vamos a preguntar, si distancia no es igual a última distancia.

Vamos a cortar y pegar el contenido que teníamos creado previamente.

Fíjate que delay queda fuera de if, entonces si se encuentra un nuevo valor vamos a indicar que deseamos borrar la pantalla a través de lcd.clear.

Por último después de esta última impresión, indicaremos última distancia es igual a distancia. Esto para que se actualice la variable, y la siguiente comprobación se haga contra la última medición realizada.

Ahora vamos a verificar nuestro programa para ver que todo compila correctamente. Una vez que se encuentra compilado el proyecto vamos a subir el código a la placa de arduino.

En las imágenes a continuación, se puede apreciar el funcionamiento de nuestro proyecto.

Podrás notar que cada vez que un objeto lo acercamos más, los valores del display van cambiando, por lo tanto ya tenemos nuestro proyecto completo.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

3 × 1 =