Sensor ultrasónico, mideindo la distancia

en un sistema de aparcamiento
Comentarios(20)
Luis del Valle Hernández

El sensor ultrasónico Arduino nos permite medir distancias a través de los ultrasonidos.
Si ya tienes un kit seguramente tengas este tipo de sensor. En este tutorial te voy a enseñar
cómo puedes construir un sistema de aparcamiento asistido.

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. Te
explicaré el conexionado de los componentes y el código necesario para hacerlo funcionar.

Indice de contenidos

 1 Cómo funciona el sensor ultrasónico Arduino

 2 El zumbador o buzzer Arduino
 3 Sistema de alerta con LEDs
 4 Componentes necesarios
 5 Sensor ultrasónico, montando el circuito
 6 Programando el sensor ultrasónico Arduino para medir distancia
 7 Conclusión

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.

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.

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 grabe. 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.

Componentes necesarios
Ya hemos visto una breve explicación de lo que vamos a necesitar. La siguiente lista te
muestra todo el material necesario.

 Arduino UNO
 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

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.

Intenta poner el sensor ultrasónico Arduino lo más al borde posible de la protoboard.

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.

1. Comprobar la distancia de los objetos

1. ¿Está dentro del rango para avisar?
1. Si
1. Lanzar alarma visual y sonora
2. Continuar
2. No
1. Continuar

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

1. ¿Está en zona verde?

1. Si
1. Encender LED verde
2. Emitir sonido 1
3. Salir
2. No
1. Continuar
2. ¿Está en zona amarilla?
1. Si
1. Encender LED amarillo
2. Emitir sonido 2
3. Salir
2. No
1. Continuar
3. ¿Está en zona roja?
1. Si
1. Encender LED rojo
2. Emitir sonido 2
3. Salir
2. No
1. 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.

Es importante conocer el rango de funcionamiento del sensor de ultrasonidos. Va de 2 cm

a 400 cm según la hoja de especificaciones técnicas.
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.

1 // Pines utilizados
2 #define LEDVERDE 2
3 #define LEDAMARILLO 3
4 #define LEDROJO 4
5 #define TRIGGER 5
6 #define ECHO 6
7 #define BUZZER 9
8
9 // Constantes
10 const float sonido = 34300.0; // Velocidad del sonido en cm/s
11 const float umbral1 = 30.0;
12 const float umbral2 = 20.0;
13 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.

1 void setup() {
2 // Iniciamos el monitor serie
3 Serial.begin(9600);
4
5 // Modo entrada/salida de los pines
6 pinMode(LEDVERDE, OUTPUT);
7 pinMode(LEDAMARILLO, OUTPUT);
8 pinMode(LEDROJO, OUTPUT);
9 pinMode(ECHO, INPUT);
10 pinMode(TRIGGER, OUTPUT);
11 pinMode(BUZZER, OUTPUT);
12
13 // Apagamos todos los LEDs
14 apagarLEDs();
15
16 }

digitalWrite(LEDVERDE, LOW);
digitalWrite(LEDAMARILLO, LO
digitalWrite(LEDROJO, LOW);

1 // Apaga todos los LEDs

2 void apagarLEDs()
3{
4 // Apagamos todos los LEDs
5 digitalWrite(LEDVERDE, LOW);
6 digitalWrite(LEDAMARILLO, LOW);
7 digitalWrite(LEDROJO, LOW);
8}
Las funciones son muy útiles por dos razones, nos permiten ordenar el código para que sea
más legible y también reutilizar el código. En este caso vamos a necesitar apagar todos los
LEDs más de una vez y es más fácil escribir una llamada a una función con una línea de
código que hacer las 3 llamadas a la función digitalWrite para apagar cada LED.

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.

1 void loop() {
2 // Preparamos el sensor de ultrasonidos
3 iniciarTrigger();
4
5 // Obtenemos la distancia
6 float distancia = calcularDistancia();
7
8 // Apagamos todos los LEDs
9 apagarLEDs();
10
11 // Lanzamos alerta si estamos dentro del rango de peligro
12 if (distancia < umbral1)
13 {
14 // Lanzamos alertas
15 alertas(distancia);
16 }
17
18 }

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.

1 // Método que inicia la secuencia del Trigger para comenzar a medir

2 void iniciarTrigger()
3 {
4 // Ponemos el Triiger en estado bajo y esperamos 2 ms
5 digitalWrite(TRIGGER, LOW);
6 delayMicroseconds(2);
7
8 // Ponemos el pin Trigger a estado alto y esperamos 10 ms
9 digitalWrite(TRIGGER, HIGH);
10 delayMicroseconds(10);
11
12 // Comenzamos poniendo el pin Trigger en estado bajo
13 digitalWrite(TRIGGER, LOW);
14 }

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.

1 // Devuelve una variable tipo float que contiene la distancia
2 float calcularDistancia()
3 {
4 // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este
5 caso a HIGH
6 unsigned long tiempo = pulseIn(ECHO, HIGH);
7
8 // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está
9 en microsegundos
10 // por eso se multiplica por 0.000001
11 float distancia = tiempo * 0.000001 * sonido / 2.0;
12 Serial.print(distancia);
13 Serial.print("cm");
14 Serial.println();
15 delay(500);
16
17 return distancia;
}
El tiempo obtenido por la función pulseIn debe ser dividido por 2. Esto es devido a que
recorre dos veces la distancia, va hacia el objeto, rebota y vuelve hasta el sensor y por lo
tanto tarda el doble.

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.

Si no utilizas el parámetro de duración, el sonido se reproducirá continuamente hasta que

llames a la función noTone(pin).
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.

1 // Función que comprueba si hay que lanzar alguna alerta visual o sonora
2 void alertas(float distancia)
3 {
4 if (distancia < umbral1 && distancia >= umbral2)
5 {
6 // Encendemos el LED verde
7 digitalWrite(LEDVERDE, HIGH);
8 tone(BUZZER, 2000, 200);
9 }
10 else if (distancia < umbral2 && distancia > umbral3)
11 {
12 // Encendemos el LED amarillo
13 digitalWrite(LEDAMARILLO, HIGH);
14 tone(BUZZER, 2500, 200);
15 }
16 else if (distancia <= umbral3)
17 {
18 // Encendemos el LED rojo
19 digitalWrite(LEDROJO, HIGH);
20 tone(BUZZER, 3000, 200);
21 }
22 }

Código final

Aquí te dejo todo el código de este ejercicio para que lo utilices cómo y cuando quiera.
Recuerda que la mejor manera de aprender es practicando así que no lo copies entero e
intenta escribirlo tu mismo.

1 // Pines utilizados
2 #define LEDVERDE 2
3 #define LEDAMARILLO 3
4 #define LEDROJO 4
5 #define TRIGGER 5
6 #define ECHO 6
7 #define BUZZER 9
8
9 // Constantes
10 const float sonido = 34300.0; // Velocidad del sonido en cm/s
11 const float umbral1 = 30.0;
12 const float umbral2 = 20.0;
13 const float umbral3 = 10.0;
14
15 void setup() {
16 // Iniciamos el monitor serie
17 Serial.begin(9600);
18
19 // Modo entrada/salida de los pines
20 pinMode(LEDVERDE, OUTPUT);
21 pinMode(LEDAMARILLO, OUTPUT);
22 pinMode(LEDROJO, OUTPUT);
23 pinMode(ECHO, INPUT);
24 pinMode(TRIGGER, OUTPUT);
25 pinMode(BUZZER, OUTPUT);
26
27 // Apagamos todos los LEDs
28 apagarLEDs();
29
30 }
31
32 void loop() {
33 // Preparamos el sensor de ultrasonidos
34 iniciarTrigger();
35
36 // Obtenemos la distancia
37 float distancia = calcularDistancia();
38
39 // Apagamos todos los LEDs
40 apagarLEDs();
41
42 // Lanzamos alerta si estamos dentro del rango de peligro
43 if (distancia < umbral1)
44 {
45 // Lanzamos alertas
46 alertas(distancia);
47 }
48
49 }
50
51 // Apaga todos los LEDs
52 void apagarLEDs()
53 {
54 // Apagamos todos los LEDs
55 digitalWrite(LEDVERDE, LOW);
56 digitalWrite(LEDAMARILLO, LOW);
57 digitalWrite(LEDROJO, LOW);
58 }
59
60 // Función que comprueba si hay que lanzar alguna alerta visual o sonora
61 void alertas(float distancia)
62 {
63 if (distancia < umbral1 && distancia >= umbral2)
64 {
65 // Encendemos el LED verde
66 digitalWrite(LEDVERDE, HIGH);
67 tone(BUZZER, 2000, 200);
68 }
69 else if (distancia < umbral2 && distancia > umbral3)
70 {
71 // Encendemos el LED amarillo
72 digitalWrite(LEDAMARILLO, HIGH);
73 tone(BUZZER, 2500, 200);
74 }
75 else if (distancia <= umbral3)
76 {
77 // Encendemos el LED rojo
78 digitalWrite(LEDROJO, HIGH);
79 tone(BUZZER, 3000, 200);
80 }
81 }
82
83 // Método que calcula la distancia a la que se encuentra un objeto.
84 // Devuelve una variable tipo float que contiene la distancia
85 float calcularDistancia()
86 {
87 // La función pulseIn obtiene el tiempo que tarda en cambiar entre estados, en este
88 caso a HIGH
89 unsigned long tiempo = pulseIn(ECHO, HIGH);
90
91 // Obtenemos la distancia en cm, hay que convertir el tiempo en segudos ya que está
92 en microsegundos
93 // por eso se multiplica por 0.000001
94 float distancia = tiempo * 0.000001 * sonido / 2.0;
95 Serial.print(distancia);
96 Serial.print("cm");
97 Serial.println();
98 delay(500);
99
100 return distancia;
101 }
102
103 // Método que inicia la secuencia del Trigger para comenzar a medir
104 void iniciarTrigger()
105 {
106 // Ponemos el Triiger en estado bajo y esperamos 2 ms
107 digitalWrite(TRIGGER, LOW);
108 delayMicroseconds(2);
109
110 // Ponemos el pin Trigger a estado alto y esperamos 10 ms
111 digitalWrite(TRIGGER, HIGH);
112 delayMicroseconds(10);
113
114 // Comenzamos poniendo el pin Trigger en estado bajo
digitalWrite(TRIGGER, LOW);
}