Tutorial: sensor ultrasonidos HC-SR04

El sensor de ultrasonidos se enmarca dentro de los sensores para medir distancias o

superar obstáculos, entre otras posibles funciones.
En este caso vamos a utilizarlo para la medición de distancias. Esto lo consigue enviando
un ultrasonido (inaudible para el oído humano por su alta frecuencia) a través de uno de la
pareja de cilindros que compone el sensor (un transductor) y espera a que dicho sonido
rebote sobre un objeto y vuelva, retorno captado por el otro cilindro.

Este sensor en concreto tiene un rango de distancias sensible entre 3cm y 3m con una
precisión de 3mm.

¿Qué recibimos en el sensor?

El tiempo que transcurre entre el envío y la recepción del ultrasonido.

¿Cómo vamos a traducir dicho tiempo en distancia?

Aprovechando que la velocidad de dicho ultrasonido en el aire es de valor 340 m/s, o

0,034 cm/microseg (ya que trabajaremos con centímetros y microsegundos). Para calcular
la distancia, recordaremos que v=d/t (definición de velocidad: distancia recorrida en un
determinado tiempo).
De la fórmula anterior despejamos d, obteniendo d=v·t, siendo v la constante
anteriormente citada y t el valor devuelto por el sensor a la placa Arduino.
También habrá que dividir el resultado entre 2 dado que el tiempo recibido es el tiempo de
ida y vuelta.

Material

Sensor ultrasonidos HC-SR04 de Electrohobby

Placa Arduino UNO
Cables
Cable USB
Protoboard

Conexiones

El sensor consta de 4 pines: "VCC" conectado a la salida de 5V de la placa, "Trig"

conectado al pin digital de la placa encargado de enviar el pulso ultrasónico, "Echo" al pin
de entrada digital que recibirá el eco de dicho pulso y "GND" a tierra.

Programa
long distancia;
long tiempo;
void setup(){
Serial.begin(9600);
pinMode(9, OUTPUT); /*activación del pin 9 como salida: para el pulso
ultrasónico*/
pinMode(8, INPUT); /*activación del pin 8 como entrada: tiempo del
rebote del ultrasonido*/
}
void loop(){
digitalWrite(9,LOW); /* Por cuestión de estabilización del sensor*/
delayMicroseconds(5);
digitalWrite(9, HIGH); /* envío del pulso ultrasónico*/
delayMicroseconds(10);
tiempo=pulseIn(8, HIGH); /* Función para medir la longitud del pulso
entrante. Mide el tiempo que transcurrido entre el envío
del pulso ultrasónico y cuando el sensor recibe el rebote, es decir: de
sde que el pin 12 empieza a recibir el rebote, HIGH, hasta que
deja de hacerlo, LOW, la longitud del pulso entrante*/
distancia= int(0.017*tiempo); /*fórmula para calcular la distancia
obteniendo un valor entero*/
/*Monitorización en centímetros por el monitor serial*/
Serial.println("Distancia ");
Serial.println(distancia);
Serial.println(" cm");
delay(1000);
}

Vídeo

Os animamos a subir vuestros vídeos del tutorial funcionando en nuestro Facebook o

nombrándonos en Twitter.

P.

Tutorial de Arduino y sensor ultrasónico

HC-SR04
Posted by Tutoriales 0 Comments
En muchos de nuestros proyectos, tenemos la necesidad de sensar nuestro entorno,
saber si en frente hay un obstáculo y a que distancia se encuentra, el sensor HC-
SR04 nos permite hacer eso.
En este tutorial, vamos a conocer de forma detallada las características del sensor
HC-SR04, como calibrar el sensor, como conectarlo y como utilizarlo con Arduino.
El sensor HC-SR04 es un sensor de distancia de bajo costo, su uso es muy frecuente
en la robótica, utiliza transductores de ultrasonido para detectar objetos.
Su funcionamiento consiste en emitir un sonido ultrasónico por uno de sus
transductores, y esperar que el sonido rebote de algún objeto presente, el eco es
captador por el segundo transductor. La distancia es proporcional al tiempo que
demora en llegar el eco.
Para empezar a utilizar el sensor HC-SR04 solo necesitas una placa Arduino, en este
tutorial utilizaremos un Arduino Uno R3, pero puedes utilizar cualquier placa de
Arduino, el procedimiento es el mismo.
Empezamos insertando el sensor ultrasónico en un protoboard y con cables hacemos
las siguientes conexiones:
- Trigger del sensor al pin 2 del arduino
- Echo del sensor al pin 3 del arduino

También puedes conectar el modulo directamente al Arduino sin usar el protoboard.

Todas las conexiones se realizan con el Arduino Apagado (desconectado de la PC o

de cualquier fuente externa):
Ahora abrimos el entorno de programación de Arduino, en Herramientas ->Tarjeta,
y seleccionamos el modelo de placa Arduino que estemos utilizando. Nosotros
seleccionaremos Arduino Uno.

Una vez configurado el IDE, empezamos a programar nuestro sketch, explicaremos

paso a paso el código para sea más comprensible:

Primero configuramos los pines y la comunicación serial a 9800 baudios

const int Trigger = 2; //Pin digital 2 para el Trigger del sensor
const int Echo = 3; //Pin digital 3 para el echo del sensor

void setup() {
Serial.begin(9600);//iniciailzamos la comunicación
pinMode(Trigger, OUTPUT); //pin como salida
pinMode(Echo, INPUT); //pin como entrada
digitalWrite(Trigger, LOW);//Inicializamos el pin con 0
}

Ahora en el bucle void loop() empezamos enviando un pulso de 10us al Trigger del
sensor
digitalWrite(Trigger, HIGH);
delayMicroseconds(10); //Enviamos un pulso de 10us
digitalWrite(Trigger, LOW);
Seguidamente recibimos el pulso de respuesta del sensor por el pin Echo, para medir
el pulso usamos la función pulseIn(pin, value)
t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso

La variable t, tiene el tiempo que dura en llegar el eco del ultrasonido, el siguiente
paso es calcular la distancia entre el sensor ultrasónico y el objeto

Partimos de la siguiente formula:

Donde Velocidad es la velocidad del sonido 340m/s, pero usaremos las unidades en
cm/us pues trabajaremos en centímetros y microsegundos, tiempo es el tiempo que
demora en llegar el ultrasonido al objeto y regresar al sensor, y la distancia
recorrida es dos veces la distancia hacia el objeto, reemplazando en la formula
tenemos:

Finalmente enviamos serialmente el valor de la distancia y terminamos poniendo

una pausa de 100ms, que es superior a los 60ms recomendado por los datos técnicos
del sensor
A continuación se muestra el código completo del programa.
const int Trigger = 2; //Pin digital 2 para el Trigger del sensor
const int Echo = 3; //Pin digital 3 para el Echo del sensor

void setup() {
Serial.begin(9600);//iniciailzamos la comunicación
pinMode(Trigger, OUTPUT); //pin como salida
pinMode(Echo, INPUT); //pin como entrada
digitalWrite(Trigger, LOW);//Inicializamos el pin con 0
}
void loop()
{

long t; //timepo que demora en llegar el eco

long d; //distancia en centimetros

digitalWrite(Trigger, HIGH);
delayMicroseconds(10); //Enviamos un pulso de 10us
digitalWrite(Trigger, LOW);

t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso

d = t/59; //escalamos el tiempo a una distancia en cm

Serial.print("Distancia: ");
Serial.print(d); //Enviamos serialmente el valor de la distancia
Serial.print("cm");
Serial.println();
delay(100); //Hacemos una pausa de 100ms
}

Conecte el Arduino Uno y cargue el programa.

Después de esto el Arduino y sensor ya deben estar trabajando, para poder visualizar
los datos vaya a herramientas y habrá el monitor serial
En el monitor serial le aparecerán los valores de la distancia que sensa el HC-SR04,
ponga un objeto al frente y varíe su distancia respecto al sensor y verifique que la
distancia mostrada en el monitor serial sea la correcta.

Si tiene problemas de compilación o de configuración del IDE Arduino puede

revisar el siguiete tutorial.

Instalación del IDE Arduino

HC-SR04 Arduino – Tutorial Con Código Incluido
por Enrique | Tutoriales de Arduino

El sensor HC-SR04 es uno de los dispositivos más utilizados por los usuarios de Arduino. Se
trata de un pequeño módulo de ultrasonidos bastante simple con el que se pueden hacer
desde detectores de obstáculos hasta un pequeño radar de andar por casa con unas pocas
líneas de código (si todavía no tienes el tuyo puedes adquirir un HC-SR04 a través de
mi link de referido por un precio irrisorio).
 En este post te explicaré el funcionamiento del sensor ultrasónico y te proporcionaré un código
comentado para que lo puedas aplicar en tus proyectos con Arduino.

El Sensor Ultrasónico HC-SR04

Lo primero que deberías pensar antes de ponerte a utilizar este o cualquier otro sensor de
Arduino es si te va a servir para el proyecto que estás llevando a cabo. Para ello, debes
entender el funcionamiento del sensor y conocer sus características técnicas (el Datasheet).
Funcionamiento
El funcionamiento del HC-SR04 es realmente simple y se basa en un sistema de ecos:
1. Se envía un pulso digital alto (de al menos 10μs) al pin del disparador (Trig).
2. El HC-SR04 lanza 8 ondas de 40kHz.
3. Se establece en alto la señal de eco (Echo) hasta que se recibe el rebote las ondas.
4. Se cuenta el tiempo que tardó en recibirse la señal.
Sabiendo que la velocidad del sonido en el aire es aproximadamente de 340m/s y
conociendo el tiempo que ha tardado en ir volver la onda, se calcula la distancia.
Características
 Voltaje de trabajo: 5V.
 Corriente de trabajo: 15mA.
 Frecuencia de trabajo: 40Hz.
 Distancia máxima: 4m.
 Distancia mínima: 2cm.
 Ángulo de apertura: 15º.
 Precisión: 3mm.
Como puedes ver, los valores son perfectos para acoplar el sensor HC-SR04 con tu placa
Arduino directamente (sin necesidad de circuitería intermedia).
Un dato importante que debes tener en cuenta para evitar medidas erróneas es el tiempo de
cada ciclo de medida. Lo recomendable es que dejes al menos 60ms entre cada toma de
datos (lo puedes hacer con un simple delay).
Código
/*Pines a utilizar por Arduino. Puedes modificarlos por los pines digitales que desees*/
int Trig=4;
int Echo=3;
//Variable en la que se va a almacenar el valor correspondiente a la distancia
int Dist;
void setup() {
pinMode (Trig, OUTPUT);
pinMode (Echo, INPUT);
}
//Este módulo calcula y devuelve la distancia en cm.
/*
Puedes poner el código del módulo directamente en el loop o utilizar el módulo
para reducir el número de líneas de código del loop o reutilizar el código
*/
void ultrasonido (int &Distancia){
//Para estabilizar el valor del pin Trig se establece a LOW
digitalWrite (Trig, LOW);
delay(10);
//Se lanzan los 8 pulsos
digitalWrite (Trig, HIGH);
delay(10);
digitalWrite (Trig, LOW);
/*
Se mide el tiempo que tarda la señal en regresar y se calcula la distancia.
Observa que al realizar pulseIn el valor que se obtiene es tiempo, no distancia
Se está reutilizando la variable Distancia.
*/
Distancia= pulseIn (Echo, HIGH);
Distancia=Distancia/58;
delay(100);
}
void loop() {
ultrasonido (Dist);
delay (250);
}
Espero que este post te haya sido útil y que te animes a probar este sensor con tu Arduino.
El código es muy básico (como has podido ver) y sin duda son muchas las mejoras que se
pueden realizar. Una de las que yo suelo utilizar consiste tomar varias medidas y hacer la
mediana de los valores obtenidos para conseguir un poco más de precisión. Eso lo dejo a tu
elección.
Si utilizas un código diferente, se te ocurre alguna mejora o simplemente quieres contar tu
experiencia o tus dudas con este sensor ultrasónico, deja un comentario.

MEDIR DISTANCIAS CON SENSOR US-100 o HC-SR04 PARA ARDUINO

1 – MEDIR DISTANCIAS CON ARDUINO

Para este montaje vamos a necesitar los siguientes elementos:

– Una Placa Protoboard.

– Una Placa Arduino (En mi caso uso la Arduino UNO).

– Un Módulo sensor ultrasonidos US-100 o HC-SR04 (Desconozco si existen otros módulos

de ultrasonidos similares).

– Un Display LCD 16×2.

– Dos Potenciómetros de 10Kohm.

– Unos cuantos Cables para protoboard.

Tenemos que asegurarnos de que quitamos el jumper del modulo de ultrasonidos que esta
colocado en los pines “UART Select”, una vez hecho esto hacemos el siguiente montaje:
Con los potenciómetros regulamos el brillo y el contraste del LCD en el que visualizaremos la
distancia medida con el sensor de ultrasonidos.

El programa que he utilizado para realizar la medida y mostrarla es el siguiente:

?
1 //http://zygzax.com/webproyectos/websensorus-100/

2 #include <LiquidCrystal.h>

3 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

4
const int trigger=10;
5
const int echo=13;
6

7
float distance;
8

9
void setup(){
10
Serial.begin(9600);
11
pinMode(trigger,OUTPUT);
12 pinMode(echo,INPUT);

13 lcd.begin(16,2);

14 }

15

16 void loop(){

17 //Inicializamos el sensor

digitalWrite(trigger,LOW);
18
delayMicroseconds(5);
19
// Comenzamos las mediciones
20
// Enviamos una señal activando la salida trigger durante 10 microsegundos
21
digitalWrite(trigger,HIGH);
22
delayMicroseconds(10);
23 digitalWrite(trigger,LOW);

24 // Adquirimos los datos y convertimos la medida a metros

25 distance=pulseIn(echo,HIGH); // Medimos el ancho del pulso

26 // (Cuando la lectura del pin sea HIGH medira

27 // el tiempo que transcurre hasta que sea LOW

distance=distance*0.0001657;
28
// Enviamos los datos medidos a traves del puerto serie y al display LCD
29
Serial.println(distance);
30
lcd.setCursor(0,0);
31
lcd.print(distance);
32
delay(100);
33 }

34

35

36

2 – ALARMA CON EL SENSOR DE ULTRASONIDOS

Esta alarma sonará cuando la distancia leída baje de un determinado limite que
estableceremos con un potenciómetro. Para usar el sensor de ultrasonidos como una alarma,
que se active cuando la distancia baja de un determinado umbral establecido con un
potenciómetro tendremos que añadir al circuito del apartado anterior un altavoz piezoeléctrico
y un potenciómetro. Las conexiones serían las
siguientes:
En el código del programa tendremos que añadir la lectura de la entrada analógica del
potenciómetro y su adaptación de bits (0-1023) a metros (0-3). También tendremos que
configurar una salida pwm que haga sonar el altavoz.

1 //http://zygzax.com/webproyectos/websensorus-100/

#include <LiquidCrystal.h>
2
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
3

4
const int trigger=10;
5
const int echo=13;
6
const int altavoz=9;
7
const int potAlarma=0;
8

9 float distance;

10 int val;

11 float lim;

12

13 void setup(){

14 Serial.begin(9600);

pinMode(trigger,OUTPUT);
15
pinMode(echo,INPUT);
16
lcd.begin(16,2);
17
}
18

19
void loop(){
20

21
//Leemos el valor del potenciometro que nos indica el limite de la alarma
22 val=analogRead(potAlarma);
23 lim=val*0.00293;

24 //Inicializamos el sensor

digitalWrite(trigger,LOW);
25
delayMicroseconds(5);
26
// Comenzamos las mediciones
27
// Enviamos una señal activando la salida trigger durante 10 microsegundos
28
digitalWrite(trigger,HIGH);
29
delayMicroseconds(10);
30 digitalWrite(trigger,LOW);

31 // Adquirimos los datos y convertimos la medida a metros

32 distance=pulseIn(echo,HIGH); // Medimos el ancho del pulso

33 // (Cuando la lectura del pin sea HIGH medira

// el tiempo que transcurre hasta que sea LOW

34
distance=distance*0.0001657;
35
//Alarma
36
if(distance<lim){
37
analogWrite(altavoz,100);
38
}
39 else{analogWrite(altavoz,0);}

40

41 // Enviamos los datos medidos a traves del puerto serie y al display LCD

42 Serial.println(distance);

43 lcd.clear();

44 lcd.setCursor(0,0);

lcd.print(&quot;Distancia:&quot;);
45
lcd.setCursor(12,0);
46
lcd.print(distance);
47
lcd.setCursor(0,1);
48 lcd.print(&quot;Limite:&quot;);

49 lcd.setCursor(9,1);

lcd.print(lim);
50
delay(50);
51
}
52

53

54

55

56

57

Para ver como leer los datos del sensor con Matlab por el puerto serie: Tutorial leer datos de
Arduino con Matlab por el puerto serie.

utorial Sensor Ultrasónico HC-SR04 y

Arduino
por Jesus Ruben | May 16, 2014 | Tutoriales Arduino | 25 Comments
En este tutorial explicaremos como utilizar un sensor ultrasónico HC-SR04 y arduino para
la medición de distancia. Ya hemos explicado con anterioridad como se realiza la instalación
de una librería para poder controlar algún periférico con nuestro arduino, en esta ocasión
utilizaremos lo aprendido en aquel tutorial para ayudarnos a poner en funcionamiento
un sensor ultrasónico HC-SR04.
El sensor HC-SR04 es un módulo que incorpora un par de transductores de ultrasonido que
se utilizan de manera conjunta para determinar la distancia del sensor con un objeto colocado
enfrente de este. Quizá la característica más destacada del HC-SR04 es que puede ser
adquirido por una baja suma de dinero y esto mismo lo ha hecho muy popular.
Afortunadamente el módulo HC-SR04 es bastante fácil de utilizar a pesar de su bajo precio y
 no demanda grán cantidad de trabajo ponerlo a funcionar, mucho menos si utilizamos
una librería para sensores ultrasónicos.
Como todas las cosas en el mundo de la programación, poner en marcha este sensor es una
meta a la cual se puede llegar de mil maneras distintas. En este artículo te enseñaremos a
hacerlo funcionar de la forma que consideramos más rápida y sencilla: Utilizando una librería
ya hecha para este fin que esta accesible en internet.
En la foto de portada observamos el sensor ultrasónico HC-SR04 y Arduino UNO con
los que hemos montado el circuito de prueba.

Conceptos Básicos.
Primeramente debemos armar el circuito de prueba para el sensor, el cual consiste
únicamente en proveer alimentación al módulo y asignarle 2 pines de interfaz con el Arduino
(echo y trigger). Este tipo de módulos para medición de distancia por ultrasonidos se divide en
2 grandes grupos: Interfaz mediante pulso de eco e interfaz serial (I2C o UART). El HC-
SR04 cae dentro del primer grupo, por lo que explicaremos su funcionamiento brevemente en
las siguientes lineas.
La interfaz digital se logra mediante 2 pines digitales: el pin de trigger (disparo) y echo
(eco).
 El primero recibe un pulso de habilitación de parte del microcontrolador, mediante el cual se le
indica al módulo que comience a realizar la medición de distancia.
 A través de un segundo pin (echo) el sensor “muestra” al microcontrolador un puso cuyo
ancho es proporcional al tiempo que tarda el sonido en viajar del transductor al obstaculo y
luego de vuelta al módulo.
Mediante una sencilla formula puede estimarse entonces la distancia entre el sensor y el
obstáculo si se conoce el tiempo de viaje del sonido así como la velocidad de propagación de
la onda sonora. La siguiente imagen muestra los pulsos recibidos y enviados por el sensor, de
acuerdo a la hoja de datos elaborada por Itead Studio.

Como se puede observar, el HC-SR04 genera un pulso en el pin marcado como

“echo” cuya duración es proporcional a la distancia medida por el sensor. Para obtener la
 distancia en centímetros, solamente debemos dividir el tiempo en microsegundos entre 58 o
para obtener la distancia.

Materiales Necesarios.
 Tarjeta Arduino UNO R3
 Módulo sensor ultrasónico HC-SR04
 Cables tipo dupont para conexiones
 Protoboard (opcional)
En la foto del artículo vemos los materiales que hemos utilizado y que tenemos disponibles en
nuestra tienda virtual. Nosotros utilizamos nuestro protoboard, pero vale cualquier otra forma
de montar y conectar los componentes, incluso un simple juego de cables dupont funciona
perfecto, con la ventaja de resultar mucho más compacto.

Diagrama de conexiones para el HC-SR04 y

arduino
El siguiente circuito es el mínimo necesario para hacer funcionar el sensor ultrasonido HC-
SR04 y Arduino. Podemos utilizar cables Dupont o bien utilizar un protoboard y alambres.

Cabe aclarar que nosotros hemos utilizado los pines 11 y 12, pero vale cualquier otra
combinación de pines. No hay mucho más que decir, ya que es bastante fácil de conectar,
solamente tener cuidado con la polaridad y posición de las señales.
 El sketch para sensor ultrasónico HC-SR04 y
Arduino.
El primer paso es descargar e instalar la librería newPing desde el playground de Arduino. El
proceso de instalación de una librería ya lo hemos cubierto en un tutorial anterior y no lo
expondremos nuevamente en esta entrada. El enlace de descarga de la librería y su
documentación se encuentran en esta web:
 http://playground.arduino.cc/Code/NewPing
Ya que tengamos la librería NewPing instalada, copiamos el siguiente código para probar su
funcionamiento. Hay que recordar que si cambiamos los pines de conexión con el
sensor, es necesario retocar las primeras lineas para que las señales puedan llegar a
los pines correspondientes.
Los pines de conexión deben coincidir perfectamente para que el sensor HC-SR04 y Arduino
puedan funcionar en conjunto, de lo contrario, podemos causar daños y sobrecalentamiento a
cualquiera de las dos placas: Arduino o sensor.

1 #include <NewPing.h>

3 /*Aqui se configuran los pines donde debemos conectar el sensor*/

4 #define TRIGGER_PIN 12

5 #define ECHO_PIN 11

6 #define MAX_DISTANCE 200

8 /*Crear el objeto de la clase NewPing*/

9 NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

10

11 void setup() {

12 Serial.begin(9600);

13 }

14

15 void loop() {

16 // Esperar 1 segundo entre mediciones

17 delay(1000);

18 // Obtener medicion de tiempo de viaje del sonido y guardar en variable uS

19 int uS = sonar.ping_median();

20 // Imprimir la distancia medida a la consola serial

21 Serial.print("Distancia: ");

22 // Calcular la distancia con base en una constante

23 Serial.print(uS / US_ROUNDTRIP_CM);

24 Serial.println("cm");

25 }

El código realizado con la librería NewPing queda bastante sencillo y además de aceptar
el sensor ultrasónico HC-SR04 permite utilizar la gran mayoría de los sensores que utilizan
interfaz del tipo Interfaz “con pulsos” con 3 y 4 pines.

Conclusión
Como hemos visto a lo largo de este artículo, utilizar el sensor HC-SR04 y arduino es bastante
sencillo. Con el uso de una librería se facilita en gran medida el desarrollo de aplicaciones. Sin
embargo, podemos desarrollar también nuestro propio código que optimice el uso del tiempo
del CPU, utilizando incluso interrupciones y eventos. Si eres de esas personas curiosas que
siempre quieren saber como funcionan las cosas, en otra ocasión desarrollamos un programa
para microcontroladores PIC en lenguaje C que puedes revisar para ver como funciona el
algoritmo de comunicación con este tipo de sensores.