IMPLEMENTACION DE UN SENSOR ULTRASÓNICO,

MIDIENDO LA DISTANCIA EN UN SISTEMA DE

APARCAMIENTO

RESUMEN

El sensor ultrasónico Arduino nos permite medir distancias a través de los

ultrasonidos. Es muy común encontrar este tipo de sensores en los coches actuales.
El objetivo es mostrar cómo podemos construir sistemas reales con esta placa de
prototipado. Se explicará el conexionado de los componentes y el código necesario
para hacerlo funcionar y ponerlo en funcionamiento para el uso en la vida real, uno
de los objetivos principales es la implementación del prototipo en vehículos no
modernos y así poder medir distancias cuando uno quiere hacer el retrocedo
correspondiente.

1. JUSTIFICACIÓN

La implementación de un sensor ultrasónico, midiendo la distancia en un

sistema de aparcamiento implica mostrar al publico en general que se puede
construir un sistema real con una placa Arduino para poder medir distancias
a través de los sonidos ultrasónicos para poder saber si hay objetos atrás que
dificulten el paso de retroceso del vehiculo.

2. OBJETIVOS
 OBJETIVO GENERAL

Implementar de un sensor ultrasónico, midiendo la distancia en un

sistema de aparcamiento

 OBJETIVOS ESPECIFÍCOS

Implementar un sensor ultrasónico.

Comparación de sensores.

IEGNE “CORAZÓN DE JESÚS 2017”

 3. MARCO TEÓRICO

Cómo funciona el sensor ultrasónico Arduino: Para medir distancias con

Arduino podemos hacerlo de diferentes maneras. Existen el sensor de
infrarrojos, que utilizan las propiedades de la luz para calcular la distancia, y
el sensor ultrasónico Arduino utiliza las propiedades de propagación del
sonido para medir distancias. Más concreto utiliza los ultrasonidos. Este tipo
de ondas sonoras se encuentran por encima del espectro audible por los seres
humanos.

El funcionamiento es muy sencillo. El sensor envía una onda ultrasónica a

través del disparador o trigger, revota contra el objeto y el receptor o echo
detecta la onda. Sabiendo cuánto ha tardado en viajar dicha onda, podemos
saber la distancia.

IEGNE “CORAZÓN DE JESÚS 2017”

 Solo hace falta utilizar la famosa fórmula de la velocidad que aprendimos en
el colegio.

Donde s es el espacio y t es el tiempo. Si despejamos es espacio que es lo

que necesitamos saber, nos quedaría de la siguiente manera.

La velocidad es conocida, el sonido viaja a 343 metros por segundo. El tiempo

nos lo devolverá el propio sensor ultrasónico Arduino a través de la API de
Arduino. Con todo esto ya podemos calcular a qué distancia se encuentra un
objeto.
La velocidad del sonido es 343 m/s a una temperatura de 20ºC. La velocidad
aumenta o disminuye 0,6 m/s por grado centígrado. Podemos ser más
exactos si utilizamos un sensor de temperatura como el LM35.

El zumbador o buzzer Arduino: Para simular correctamente el sensor de

distancia vamos a utilizar un buzzer Arduino. Estos componentes utilizan la
piezoelectricidad, un fenómeno físico que afecta en determinados cristales (el
cuarzo es el más común). Al someter un cristal de este tipo, se deforman y
vibran. Si conseguimos que esa vibración tenga una frecuencia dentro del
espectro audible, conseguiremos un sonido.

IEGNE “CORAZÓN DE JESÚS 2017”

 Por lo tanto, es importante conocer las frecuencias del espectro audible. No
vamos a ver una masterclass sobre este tipo de señales, solo debemos
quedarnos con el rango de frecuencias va de 20 Hz (hercios) a 20 kHz
(kilohercio).

Cerca de los 20 Hz el sonido es muy grave. Cuando vamos subiendo de

frecuencia, el sonido se va haciendo cada vez más agudo. Esto nos servirá
para alertar de que nos estamos acercando a un obstáculo al aparcar.

Tampoco podemos esperar un sistema de alta fidelidad con un buzzer

Arduino, pero nos da la posibilidad de generar tonos audibles para alarmas e
incluso alguna melodía musical fácilmente reconocible.

Sistema de alerta con LEDs: Por último, incorporamos el sistema de alerta

visual para el sensor ultrasónico Arduino. Esto nos permite visualizar si
estamos cerca o lejos de un obstáculo. Con 3 LEDs (verde, amarillo y rojo)
conseguimos determinar si estamos lejos, cerca o en zona de peligro.

4. PARTE EXPERIMENTAL

MATERIALES:

 Arduino nano.
 Protoboard donde conectaremos los componentes
 Cables para hacer las conexiones
 3 resistencias de 220 Ω
 1 LED verde
 1 LED amarillo
 1 LED rojo
 1 sensor ultrasónico Arduino (HC-SR04)
 1 buzzer

IEGNE “CORAZÓN DE JESÚS 2017”

 5. RESULTADOS Y CONCLUSIONES

Sensor ultrasónico, montando el circuito

Se trata de un circuito muy sencillo. Por un lado, vamos a tener toda la parte
de alertas, acústica y visual, y por otra parte el sensor de ultrasonidos. En el
siguiente esquema te muestro el conexionado.

Cosas a tener en cuenta. Las resistencias son de 220 Ω y se colocan en serie

con los LEDs. El sensor ultrasónico Arduino se conecta a dos pines digitales,
uno para el trigger o disparador y otro para el echo o receptor. El buzzer
Arduino se conecta a una salida PWM.

Programando el sensor ultrasónico Arduino para medir distancia

Vamos a empezar por la programación. Lo primero es una breve descripción

de lo que queremos conseguir. Esto nos ayudará a plantear el problema
general y posteriormente dividirlo en trozos más pequeños. A esto se le llama
pensamiento computacional y si eres usuario asiduo de este blog, ya estarás
familiarizado con este concepto.

El sistema de aparcamiento consiste en detectar un objeto a través del sensor

ultrasónico y avisar con señales de luz y sonido. Por lo tanto, ya tenemos la
primera división, detectar el obstáculo y alertas con sonido y luces.

Lo primero que haré será plantear el algoritmo del sistema de detección de

obstáculos.

IEGNE “CORAZÓN DE JESÚS 2017”

 Comprobar la distancia de los objetos
¿Está dentro del rango para avisar?
Si
Lanzar alarma visual y sonora
Continuar
No
Continuar

El algoritmo del sistema de alerta visual y sonora sería el siguiente.

¿Está en zona verde?

Si
Encender LED verde
Emitir sonido 1
Salir
No
Continuar

¿Está en zona amarilla?

Si
Encender LED amarillo
Emitir sonido 2
Salir
No
Continuar

¿Está en zona roja?

Si
Encender LED rojo
Emitir sonido 2
Salir
No
Continuar

De los dos algoritmos anteriores, deducimos que vamos a necesitar varios

umbrales de decisión, uno para cada situación. Podemos coger una simple
regla y determinarlos.

 Umbral 1: está en zona verde desde 30 cm a 20 cm.

 Umbral 2: está en zona amarilla, desde 20 cm a 10 cm.
 Umbral 3: está en zona roja, menos de 10 cm.

Variables y constantes

A través del sensor de ultrasonidos vamos a detectar el obstáculo.

Comenzamos a programar declarando las variables y constantes. Siempre
que trabajemos con pines digitales o analógicos, es una buena práctica
declarar una constante por cada uno de ellos.

IEGNE “CORAZÓN DE JESÚS 2017”

 // Pines utilizados
#define LEDVERDE 2
#define LEDAMARILLO 3
#define LEDROJO 4
#define TRIGGER 5
#define ECHO 6
#define BUZZER 9

// Constantes
const float sonido = 34300.0; // Velocidad del sonido en cm/s
const float umbral1 = 30.0;
const float umbral2 = 20.0;
const float umbral3 = 10.0;

Definimos los pines para los LEDs, para el sensor de ultrasonidos y para el
buzzer Arduino. Siempre debemos fijarnos en el esquema eléctrico mostrado
anteriormente. Luego declaramos 4 constantes. La primera es la velocidad
del sonido convirtiendo de metros por segundo a centímetros por segundo.
Esto lo hacemos multiplicando por 100. Las siguientes constantes son los
umbrales de decisión que hemos marcado antes.

Función setup

En la función setup iniciamos el monitor serie y ponemos los pines en el modo

correspondiente. Los LEDs, el Trigger del sensor de ultrasonidos y el buzzer
son en modo salida (OUTPUT). El pin Echo del sensor ultrasónico en modo
entrada (INPUT).

Por último, vamos a empezar desde un estado conocido, todos los LEDs
apagados. He creado una función para realizar esta tarea.

void setup() {
// Iniciamos el monitor serie
Serial.begin(9600);

// Modo entrada/salida de los pines

pinMode(LEDVERDE, OUTPUT);
pinMode(LEDAMARILLO, OUTPUT);
pinMode(LEDROJO, OUTPUT);
pinMode(ECHO, INPUT);
pinMode(TRIGGER, OUTPUT);
pinMode(BUZZER, OUTPUT);

// Apagamos todos los LEDs

apagarLEDs();

IEGNE “CORAZÓN DE JESÚS 2017”

 // Apaga todos los LEDs
void apagarLEDs()
{
// Apagamos todos los LEDs
digitalWrite(LEDVERDE, LOW);
digitalWrite(LEDAMARILLO, LOW);
digitalWrite(LEDROJO, LOW);
}

Función Loop

La función loop() contiene el código que se repetirá una y otra vez. Aquí es
donde vamos a ir poniendo todo nuestro algoritmo, el que hemos detallado
anteriormente. He dividido esta función en varias funciones para hacer el
código más legible.

void loop() {
// Preparamos el sensor de ultrasonidos
iniciarTrigger();

// Obtenemos la distancia
float distancia = calcularDistancia();

// Apagamos todos los LEDs

apagarLEDs();

// Lanzamos alerta si estamos dentro del rango de peligro

if (distancia < umbral1)
{
// Lanzamos alertas
alertas(distancia);
}
}

A continuación te describo cada una de las funciones que ejecutamos en el

loop().

Iniciar sensor ultrasónico

Lo primero que hacemos es preparar el sensor de ultrasonidos. Esto lo

hacemos con la función iniciarTrigger() que manda un pulso. Comienza en
estado bajo durante 2 milisegundos, luego 10 milisegundos estado alto y por
último ponemos en estado bajo. Esto indica que a continuación se mandará
la señal para que la capte el echo.

IEGNE “CORAZÓN DE JESÚS 2017”

 // Método que inicia la secuencia del Trigger para comenzar a medir
void iniciarTrigger()
{
// Ponemos el Triiger en estado bajo y esperamos 2 ms
digitalWrite(TRIGGER, LOW);
delayMicroseconds(2);

// Ponemos el pin Trigger a estado alto y esperamos 10 ms

digitalWrite(TRIGGER, HIGH);
delayMicroseconds(10);

// Comenzamos poniendo el pin Trigger en estado bajo

digitalWrite(TRIGGER, LOW);
}

Calcular la distancia de los objetos

Una vez que está preparado el sensor, ya podemos utilizarlo para calcular la
distancia. Eso lo hacemos con la función calcularDistancia(). Es una función
particular ya que nos va a devolver un valor. Eso se hace poniendo al final (o
donde quieras) la palabra reservada return seguido del valor que quieres
devolver. Todo el código que haya por debajo del return no se ejecuta así que
precaución. En este caso yo devuelvo la distancia calculada dentro de la
función que es una variable del tipo float.

Para calcular el tiempo se utiliza la función nativa de Arduino pulseIn. Esta

función nos devuelve el tiempo transcurrido hasta que cambia de estado.
Anteriormente hemos preparado el sensor dejando el pin, donde tenemos
conectado el trigger, en estado bajo. Cuando la onda ultrasónica viaja por el
aire, rebota en el objeto y es detectada por el echo, el pin cambia de estado
a alto (HIGH).

La función pulseIn detecta eso precisamente, y devuelve el tiempo

transcurrido en microsegundos. Por este motivo se debe convertir a segundos
multiplicando por 0,000001 que es lo mismo que dividir por 1.000.000. Con
esta información ya podemos aplicar la fómula para calcular la distancia en
función del tiempo y la velocidad.

// Método que calcula la distancia a la que se encuentra un objeto.

// Devuelve una variable tipo float que contiene la distancia
float calcularDistancia()
{
// La función pulseIn obtiene el tiempo que tarda en cambiar entre estados,
en este caso a HIGH
unsigned long tiempo = pulseIn(ECHO, HIGH);

// Obtenemos la distancia en cm, hay que convertir el tiempo en segudos

ya que está en microsegundos
// por eso se multiplica por 0.000001
float distancia = tiempo * 0.000001 * sonido / 2.0;
Serial.print(distancia);

IEGNE “CORAZÓN DE JESÚS 2017”

 Serial.print("cm");
Serial.println();
delay(500);

return distancia;
}

Lanzar alertas

Una vez tenemos la distancia calculada ya podemos decidir si estamos en la

situación de enviar alerta o no. Siempre que la distancia esté por debajo del
primer umbral (umbral del LED verde y el menos restrictivo), lanzaremos la
correspondiente alerta visual y sonora.

Antes de hacer nada es conveniente apagar todos los LEDs. Esto lo hacemos
llamando a la función que hemos generado anteriormente.

Para reproducir un sonido con buzzer, utilizamos la función nativa de Arduino

tone(pin, frecuencia, duración). Esta función admite hasta 3 parámetros
aunque con los 2 primeros, sería suficiente.

 pin: es el pin donde hemos conectado el buzzer. Recuerda que debe

ser un pin PWM.
 frecuencia: podemos poner un valor entre 20 Hz y 20.000 Hz. Juega
con estos valores hasta conseguir un sonido adecuado.
 duración: la duración en milisegundos que quieres que dure el sonido.

La función comprueba que tipo de alerta hay que lanzar. Si está dentro del
rango umbral 1 y umbral 2, enciende el LED verde y reproduce un sonido de
2.000 Hz durante 200 milisegundos. Si está dentro del rango umbral 2 y
umbral 3, enciende el LED amarillo y reproduce un sonido de 2.500 Hz
durante 200 milisegundos y si está por debajo de umbral 3, enciende el LED
rojo y reproduce un sonido de 3.000 Hz durante 200 milisegundos.

// Función que comprueba si hay que lanzar alguna alerta visual o sonora
void alertas(float distancia)
{
if (distancia < umbral1 && distancia >= umbral2)
{
// Encendemos el LED verde
digitalWrite(LEDVERDE, HIGH);
tone(BUZZER, 2000, 200);
}
else if (distancia < umbral2 && distancia > umbral3)
{
// Encendemos el LED amarillo
digitalWrite(LEDAMARILLO, HIGH);
tone(BUZZER, 2500, 200);
}
else if (distancia <= umbral3)

IEGNE “CORAZÓN DE JESÚS 2017”

 {
// Encendemos el LED rojo
digitalWrite(LEDROJO, HIGH);
tone(BUZZER, 3000, 200);
}
}

CONCLUSIÓN

En este proyecto de implementación hemos visto un ejemplo de la vida real,

un sensor de aparcamiento asistido. Gracias a placa como Arduino podemos
descubrir cómo funciona el mundo.

6. FUENTES DE INFORMACIÓN

WIKIPEDIA
WEB ARDUINO
LIBROS ARDUINO

IEGNE “CORAZÓN DE JESÚS 2017”