Sensor de distancia HC-SR04 para Arduino

Sensor de distancia HC-SR04 para Arduino – Tutorial paso a paso

Comparte en RRSS

En este tutorial vamos a enseñar cómo se puede usar un sensor de distancia para Arduino, este esta presente en muchos aparatos electrónicos actuales, desde robot/aspiradoras hasta los coches mas actuales.

Los sensores de distancia miden la distancia con los objetos y evita que el objeto que tenga instalado este sensor se choque con otros o los encuentre por ejemplo un coche equipado con sensores de distancia hace que al aparcar nos ayude a no chocarnos contra la pared, otros coches o esas columnas indeseables de los parking.

A continuación vamos a mostrar cómo podemos crear un sensor de distancia con unos led que miden la distancia a la que se encuentra un objeto, pero antes vamos a conocer un poco más este sensor de distancia.

¿Qué es el sensor HC-SR04?

HC-SR04 sensor

Este sensor de distancia, como su propio nombre indica, nos sirve para medir la distancia cuando un objeto esta enfrente de este sensor pero, ¿realmente cómo funciona?

El funcionamiento es bastante simple, como vemos en la imagen el sensor tiene dos “ojos”, estos son un emisor y un receptor. El emisor (Trigger) lanza una onda ultrasonido, esta onda rebota sobre un objeto y la recibe el receptor (Echo), sí contamos el tiempo en el que se lanza la onda y vuelve podemos calcular la distancia a la que se encuentra el objeto.

HC-SR04 Función

Una vez que ya conocemos un poquito más el funcionamiento del sensor, ahora vamos con el tutorial.

Componentes necesarios

Todos los componentes están disponibles en nuestra tienda online.

Placa Arduino (Para este tutorial usaremos Arduino Uno) – Ver en la tienda
Sensor HC-SR04 – Ver en la tienda
LEDs verdes x5 – Ver en la tienda
LEDs amarillos x3 – Ver en la tienda
LEDs rojos x4 – Ver en la tienda
Botón pulsador – Ver en la tienda
Resistencias de 220 Ω – Ver en la tienda
Cables de macho a hembra – Ver en la tienda

Disponemos de un kit que ya incluye todos los componentes necesarios – Ver en la tienda

Conectar el sensor HC-SR04

Para conectar el sensor de sonido a la placa lo debemos conectar de la siguiente manera

Vcc -> 5v
Trig -> A0
Echo -> A1
GND -> GND

Circuito sensor HC-SR04

Conexión del botón pulsador

El botón pulsador lo usaremos para calibrar el circuito, un botón tiene dos pines, uno de ellos lo conectaremos al PIN A2 y el otro al GND

Circuito Botón pulsador

Conexión LEDs

Los led hay que conectarlos en orden, los led ocupan desde el pin D2 hasta el D13, empezaremos conectando los LED verdes, luego los amarillos y por último los rojos.

Circuito de LEDs

Todo el circuito debería verse algo así

Circuito completo

Esquema Circuito completo sensor de distancia

Hora de programar nuestro Sensor de distancia

Ahora tenemos que pasar al código:

#include // Librería para el sensor de distancia sonar. #include // Esto nos permite acceder a la memoria

// Establecer los pines led por color
const int G1 = 2;
const int G2 = 3;
const int G3 = 4;
const int G4 = 5;
const int G5 = 6;
const int G6 = 7;
const int G7 = 8;
const int G8 = 9;
const int R1 = 10;
const int R2 = 11;
const int R3 = 12;
const int R4 = 13;
// Establecer el pin del sensor en A0 (Trig)
const int trigPin = A0;
// Establecer el sonar en el pin A1 (Echo)
const int echoPin = A1;
// Establecer el botón
const int buttonPin = A2;

// activamos el sensor de distancia
NewPing sonar(trigPin, echoPin, 300);

const int minDeviation = 5; // Número de pulgadas para contar como movimiento
const int timeout = 10; // Número de segundos para mantener los leds encendidos después de que se detenga el movimiento
const int ledDistance = 6; // La distancia en pulgadas que cubre cada led
const int calibrationDelay = 750; // Este es el tiempo que cada led permanecerá encendido durante la cuenta regresiva de calibración

int idealDistance = 5; // La distancia ideal(la distancia que consideramos que esta muy cerca)
int rawSonar; // Datos del sensor de distancia
int distance; // La distancia a la que se encuentra el objeto
int prevDistance = 0; // Distancia previa del objeto
unsigned long lastMoved = 0; // Lectura del último movimiento

void setup() {
// Configuramos los Pines
pinMode(13, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);

pinMode(buttonPin, INPUT_PULLUP); // Establecemos el boton

if (EEPROM.read(0) != 255) { // Lectura de la memoria, leerá 255 si nunca se ha escrito
idealDistance = EEPROM.read(0); // Establecemos cual sería la distancia ideal
}

Serial.begin(9600);
}

void loop() {
delay(100); // Espera 100ms para obtener lecturas precisas

rawSonar = sonar.ping_median(5); // Obtenemos 5 lecturas
if (rawSonar != 0) { // El sensor de distancia envía un 0 cuando no hay nada dentro del rango
distance = rawSonar / US_ROUNDTRIP_IN; // Convertir los datos en pulgadas
distance -= idealDistance; // Resta la distancia ideal de la lectura, dándonos la distancia a recorrer.
}
else { // Cuando no detecta nada
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Apagado de los LED
}

if (abs(distance - prevDistance) >= minDeviation) { // Si el objeto se ha movido desde la última lectura
lastMoved = 0; // Reset de timer

prevDistance = distance; // Reset de la ultima distancia leída

if (distance < ledDistance * 9 && distance >= ledDistance * 8) { // si está en el rango del 1er led
setLEDs(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
else if (distance < ledDistance * 8 && distance >= ledDistance * 7) { // si está en el rango del 2er led
setLEDs(1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
else if (distance < ledDistance * 7 && distance >= ledDistance * 6) { // si está en el rango del 3er led
setLEDs(1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
else if (distance < ledDistance * 6 && distance >= ledDistance * 5) { // si está en el rango del 4er led
setLEDs(1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0);
}
else if (distance < ledDistance * 5 && distance >= ledDistance * 4) { // si está en el rango del 5er led
setLEDs(1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0);
}
else if (distance < ledDistance * 4 && distance >= ledDistance * 3) { // si está en el rango del 6er led
setLEDs(1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0);
}
else if (distance < ledDistance * 3 && distance >= ledDistance * 2) { // si está en el rango del 7er led
setLEDs(1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0);
}
else if (distance < ledDistance * 2 && distance >= ledDistance) { // si está en el rango del 8er led
setLEDs(1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0);
}
else if (distance <= idealDistance) { // Cunando esta el la posicion ideal (Cuando estamos muy cerca) setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1); } } else { // si el objeto no se mueve if (lastMoved == 0) { // si el timer nunca se empezó lastMoved = millis(); // establecemos el timer } if (lastMoved != 0 && millis() - lastMoved >= timeout * 1000) { // Si el timer fué inicializado pero pasó el tiempo de espera
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // apagado de los led
lastMoved = 0; // apagamos el timer
}
}

// Comprobaciones del botón
if (digitalRead(buttonPin) == LOW) { // Si el botón es presionado
calibrationCountdown(); // Cuenta regrasiva del LED

rawSonar = sonar.ping_median(30); // obtener 30 lecturas

if (rawSonar != 0) { // el sensor de distancia envía un 0 cuando no hay nada dentro del rango
distance = rawSonar / US_ROUNDTRIP_IN; // Convertir los datos en pulgadas

EEPROM.write(0, distance); // Escribir la distancia en la memoria
idealDistance = distance; // establecer la distancia ideal

flashGreen(); // mostrar que todo ha ido correctamente
}
else { // si esta fuera de rango
flashRed(); // mostramos el error
}
}
}

void calibrationCountdown() {
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Apagamos todos los LED
setLEDs(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Encendemos el primer led
delay(calibrationDelay); // pausa
setLEDs(1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Continuar con el patrón...
delay(calibrationDelay);
setLEDs(1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Continuar con el patrón...
delay(calibrationDelay);
setLEDs(1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0); // Continuar con el patrón...
delay(calibrationDelay);
setLEDs(1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0); // Continuar con el patrón...
delay(calibrationDelay);
setLEDs(1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0); // Continuar con el patrón...
delay(calibrationDelay);
setLEDs(1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0); // Continuar con el patrón...
delay(calibrationDelay);
setLEDs(1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0); // Continuar con el patrón...
delay(calibrationDelay);
}

void flashGreen() { // Cuando todo es correcto hacemos unos flashes con los leds
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // apagamos los led
setLEDs(1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0); // Encendemos los leds, menos los rojos
delay(500); //wait
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Apagamos
delay(500); //wait
setLEDs(1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0); // Encendemos los leds, menos los rojos
delay(500); //wait
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Apagamos
}

void flashRed() { // Cuando hay un error, hacemos flashes con los leds rojos
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Apagamos los leds
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1); // Encendemos los leds rojos
delay(500); //wait
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Apagamos
delay(500); //wait
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1); // Encendemos los leds rojos
delay(500); //wait
setLEDs(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); // Apagamos
}

// Esta función simplemente establece los leds a los parámetros que se envían
void setLEDs(int led1, int led2, int led3, int led4, int led5, int led6, int led7, int led8, int led9, int led10, int led11, int led12) {
digitalWrite(G1, led1);
digitalWrite(G2, led2);
digitalWrite(G3, led3);
digitalWrite(G4, led4);
digitalWrite(G5, led5);
digitalWrite(G6, led6);
digitalWrite(G7, led7);
digitalWrite(G8, led8);
digitalWrite(R1, led9);
digitalWrite(R2, led10);
digitalWrite(R3, led11);
digitalWrite(R4, led12);
}

Resultado final del Sensor de distancia

Cuando ya hemos creado el circuito y programado la placa de Arduino ya tendríamos todo listo!! Ahora al ir acercando un objeto al sensor vemos como los led se van encendiendo

Calibrado del sensor

Si lo que queremos es establecer a qué distancia se tienen que encender los led rojos, lo único que tenemos que hacer es poner el objeto donde queremos que se enciendan los led rojos y pulsar el botón pulsador. Al pulsar el botón pulsador, se encenderán uno a uno los led verdes y amarillos y cuando esto se complete puede pasar dos cosas, si todo es correcto, los led verdes y amarillos parpadearán y en el caso contrario se encenderán los rojos

¡Sigue todas las novedades de Flexbot en Facebook y Twitter!

18/06/2019

By Fermín Ortega

Blog, Nivel Rookie maker (ESO), Tutoriales online

actividades, adolescentes, Arduino, kits de Flexbot, profesores, Proyectos, recursos, robótica educativa

Sensor de distancia HC-SR04 para Arduino – Tutorial paso a paso