Sistema para estacionamiento de un auto y para evitar acercarse demasiado a otro vehículo

Utilizando sensores ultrasónicos, los autos modernos nos dan una útil ayuda en el momento de maniobrar, especialmente al estacionarlos en espacios limitado. Podemos hacer nuestro sistema detector con un Arduino UNO y unos pocos componentes de bajo costo

Cómo funciona el sensor ultrasónico HC-SR04

El sensor ultrasónico HC-SR04 nos permite medir distancias por medio de emisión y rebote de ultrasonidos. Para medir distancias con Arduino podemos hacerlo de diferentes maneras.

Por orden de costo, hay un sensor que mide con el rebote de un láser; luego un sensor de infrarrojos que utiliza el paralaje del regreso de un haz de luz para calcular la distancia; y por último el más barato, el sensor ultrasónico HC-SR04, muy utilizado con Arduino, que utiliza la velocidad de propagación del sonido para medir distancia.

Para que no sea molesto al oído humano, utiliza ultrasonido a una frecuencia de 40 kHz. Estas ondas sonoras tienen una frecuencia muy por encima del espectro audible por los seres humanos.
El sensor funciona como un sonar, por rebote de la onda. El emisor del HC-SR04 envía un tren de ondas ultrasónicas cuando se activa la señal de disparo (trigger). Este sonido se refleja contra el objeto y retorna. El receptor detecta el momento en que retorna la onda y lo indica en la salida eco (echo).

Midiendo el tiempo de viaje podemos calcular la distancia.

La velocidad del sonido en la atmósfera terrestre es de 343,2 m/s a 20° C de temperatura, con 50% de humedad y a nivel del mar. Si necesitamos una gran exactitud, podemos agregar al diseño sensores BMP180 o BMP280, que nos aportan datos de altitud y temperatura, e incluso agregar un medidor de humedad, y por supuesto aplicar una fórmula más compleja. Pero para este diseño no necesitamos tanta precisión.

La fórmula de la velocidad es:

velocidad = espacio/tiempo

De donde despejamos la variable espacio, que necesitamos conocer:

espacio = velocidad x tiempo

La velocidad es conocida: la del sonido. El tiempo lo obtenemos con el sensor ultrasónico. Con ambos datos, podemos calcular la incógnita: a qué distancia se encuentra un objeto.

El zumbador o buzzer

Para simular correctamente un medidor de distancia de un automóvil utilizamos un buzzer (zumbador) pasivo. No hay que confundirlo con el zumbador activo, que tiene un oscilador interno, y por lo tanto una frecuencia fija y polaridad en sus pines de conexión.

Este reproductor no tiene un rango tan amplio de emisión de sonido como el del oído humano, ni mucho menos, pero es suficiente para diferenciar la distancia con frecuencias diferentes dentro de lo que es capaz de emitir. Además de los pequeños (como el de la foto), que vienen incluidos en los kits de Arduino, hay otros con mayor diámetro de diafragma (por ejemplo en el desarme de viejos modems), que ofrecen más volumen y un rango de frecuencias más amplio.

Sistema de alerta con leds y zumbador

Si bien al maniobrar no estaremos mirando hacia un indicador, sino atentos a los tonos de aviso, agregaremos al diseño un sistema de alerta visual. Nos dará una indicación aún más efectiva de si estamos cerca o lejos de un obstáculo. Con tres leds (verde, amarillo y rojo) conseguimos determinar si estamos a distancia sin riesgo, acercándonos, o en zona de peligro. Pero se podría ampliar la indicación con más leds y más comparaciones en el programa.

Componentes:

Arduino UNO, protoboard, cables para conexiones, resistores de 330 O, led verde, led amarillo, led rojo, sensor ultrasónico Arduino (HC-SR04), buzzer

Circuito:

Los resistores son de 330 O y van en serie con los LEDs. El sensor ultrasónico se conecta a dos pines digitales, uno para el trigger o disparador y otro para el echo, o receptor. El buzzer se conecta a una salida PWM y a GND. La salida PWM entregará distintas frecuencias según la indicación del programa, por medio de la función tone().

Programando el detector de distancia

Diagrama del programa

Los umbrales para la decisión se fijan como constantes, uno para cada situación. Podemos medir la distancia con una regla y determinarlos.

¦ UmbralAlejado: está en zona verde desde 50 cm a 30 cm.
¦ UmbralMedio: está en zona amarilla, desde 30 cm a 10 cm.
¦ UmbralCerca: está en zona roja, menos de 10 cm.

Estos umbrales no son definitivos: se pueden cambiar a gusto del usuario.

El programa debe analizar la medición dividida en 4 zonas: fuera de rango (más de 50 cm, ninguna indicación), entre 50 cm y 30 cm (zona verde), entre 30 cm y 10 cm (zona amarilla), entre 10 cm e impacto (zona roja).

¦ Luego de medir la distancia se la compara con el umbral que indica fuera de rango (50 cm).
¦ Si la distancia es menor a ese valor está en zona verde: se enciende el led verde y emite el tono de 2000 c/s.
¦ Si la distancia es menor a 30 cm y mayor a 10 cm está en zona amarilla: enciende el led amarillo y emite el tono de 2500 c/s.
¦ Si la distancia es menor a 10 cm está en zona roja: enciende el led rojo y emite el tono de 3000 c/s.

Programa

// Pines
#define ledVerde 2
#define ledAmarillo 3
#define ledRojo 4
#define Trigger 7
#define Echo 6
#define Buzzer 11
 
// Constantes
// Velocidad del sonido en cm/s
const float sonido = 34300.0;
// limites 
const float umbralAlejado = 50.0;
const float umbralMedio = 30.0;
const float umbralCerca = 10.0;
 
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);

  // Preparar el sensor de ultrasonido
  digitalWrite(Trigger, LOW);
}
 
void loop() {
  // Ponemos el pin Trigger a estado alto 
  digitalWrite(Trigger, HIGH);
  delayMicroseconds(10); // y esperamos 10 us
  digitalWrite(Trigger, LOW);
 
  // Obtener la distancia
  // con la función pulseIn
  unsigned long tiempo = pulseIn(Echo, HIGH);
 
  // Obtener la distancia en cm.
  // Se multiplica por 0,000001
  // ya que se necesita segundos y
  // esta en microsegundos.

  float distancia = tiempo * 0.000001 * sonido / 2.0;
  Serial.print(distancia);
  Serial.println(" cm");
 
  // Emitir alerta si el valor esta
  // dentro del rango de riesgo
  if (distancia < umbralAlejado)
  {
    if (distancia >= umbralMedio)
    {
      digitalWrite(ledVerde, HIGH); // Encender LED verde
      digitalWrite(ledAmarillo, LOW);
      digitalWrite(ledRojo, LOW);
      tone(Buzzer, 2000, 200);
    }
    else if (distancia < umbralMedio && distancia > umbralCerca)
    {
      digitalWrite(ledAmarillo, HIGH); // Encender LED amarillo
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledRojo, LOW);
      tone(Buzzer, 2500, 200);
    }
    else if (distancia <= umbralCerca)
    {
      digitalWrite(ledRojo, HIGH); // Encender LED rojo
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledAmarillo, LOW);
      tone(Buzzer, 3000, 200);
    }
  }
  delay(500);
}

// Pines

#define ledVerde 2

#define ledAmarillo 3

#define ledRojo 4

#define Trigger 7

#define Echo 6

#define Buzzer 11

// Constantes

// Velocidad del sonido en cm/s

const float sonido = 34300.0;

// limites

const float umbralAlejado = 50.0;

const float umbralMedio = 30.0;

const float umbralCerca = 10.0;

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);

// Preparar el sensor de ultrasonido

digitalWrite(Trigger, LOW);

}

void loop() {

// Ponemos el pin Trigger a estado alto

digitalWrite(Trigger, HIGH);

delayMicroseconds(10); // y esperamos 10 us

digitalWrite(Trigger, LOW);

// Obtener la distancia

// con la función pulseIn

unsigned long tiempo = pulseIn(Echo, HIGH);

// Obtener la distancia en cm.

// Se multiplica por 0,000001

// ya que se necesita segundos y

// esta en microsegundos.

float distancia = tiempo * 0.000001 * sonido / 2.0;

Serial.print(distancia);

Serial.println(" cm");

// Emitir alerta si el valor esta

// dentro del rango de riesgo

if (distancia < umbralAlejado)

{

if (distancia >= umbralMedio)

{

digitalWrite(ledVerde, HIGH); // Encender LED verde

digitalWrite(ledAmarillo, LOW);

digitalWrite(ledRojo, LOW);

tone(Buzzer, 2000, 200);

}

else if (distancia < umbralMedio && distancia > umbralCerca)

{

digitalWrite(ledAmarillo, HIGH); // Encender LED amarillo

digitalWrite(ledVerde, LOW);

digitalWrite(ledRojo, LOW);

tone(Buzzer, 2500, 200);

}

else if (distancia <= umbralCerca)

{

digitalWrite(ledRojo, HIGH); // Encender LED rojo

digitalWrite(ledVerde, LOW);

digitalWrite(ledAmarillo, LOW);

tone(Buzzer, 3000, 200);

}

delay(500);

}

Para esta determinación de rangos, es importante buscar en la hoja de especificaciones técnicas el rango de funcionamiento del sensor de ultrasonidos que disponemos. Para este artículo se usó uno que puede medir de 2 cm a 400 cm.