Sensores ultrasónicos HC-SR04 en una placa Arduino Uno

Colocado en 2019-09-17

Sensores ultrasónicos HC-SR04 en una placa Arduino Uno

Leer un sensor HC-SR04 en una placa Arduino es relativamente fácil, pero ¿qué sucede si desea leer varios sensores? ¿Cómo se hace eso de manera eficiente? Este artículo explica mediante un ejemplo cómo puede leer de manera eficiente en 4 sensores y cómo puede expandirlo aún más a múltiples sensores.

Cree 4 sensores ultrasónicos HC-SR04 en una placa Arduino Uno

¿Qué es un HC-SR04?

La HC-SR04 es una placa de ruptura con sensores ultrasónicos. En este letrero hay dos objetos cilíndricos, uno de los cuales está marcado con la letra "T", que significa "Transmisor", que significa "emisor", mientras que el otro está marcado con la letra "R" de "Receptor", que significa "receptor". El transmisor envía una onda de sonido ultrasónica y el receptor "escucha" que esta onda de sonido colisione con un objeto y se refleje. El tiempo que transcurre entre la transmisión y la recepción indica a qué distancia se encuentra ese objeto del sensor. Los murciélagos, los delfines, las ballenas y el sonar en los barcos funcionan con un principio similar, y este principio a menudo se denomina "ubicación de eco".

Placa de conexiones HC-SR04

¿Puedes escuchar una onda de sonido ultrasónico?

A menos que tenga las orejas de su perro, no puede escuchar las ondas de sonido ultrasónicas. El HC-SR04 utiliza una onda de sonido con una frecuencia de 40 kHz, mientras que el oído humano solo puede escuchar 16 kHz y las personas más jóvenes pueden escuchar hasta 20-22 kHz. Muy por debajo de la frecuencia de una onda de sonido ultrasónico.

Además, una onda de sonido ultrasónico no es una onda de radio (como las ondas de un teléfono inteligente) y es completamente inofensiva para la salud.

¿Cómo funciona el HC-SR04?

Como se mencionó anteriormente, el HC-SR04 emite un sonido ultrasónico, que choca con un objeto y regresa al sensor. El sensor cuenta el tiempo que transcurre entre el envío y la recepción de esta señal. Si conoce la velocidad del sonido, puede calcular la distancia entre el sensor y el objeto. Por supuesto, el sonido no viaja infinitamente lejos y debido a que la onda de sonido del sensor es relativamente débil, el rango de medición también es bastante limitado. El HC-SR04 puede medir distancias de hasta aproximadamente 400 cm (4 m). El "ángulo de visión" o "ángulo de medición" del sensor tampoco es infinito. El sensor no puede detectar los objetos que caen fuera de un ángulo de 15°. Por eso a veces es interesante utilizar varios sensores, que se colocan en círculo, por ejemplo. De esta manera puede aumentar el ángulo de medición.

Leer el sensor

Para leer el HC-SR04, debe generar un pulso de inicio en el pin "disparador" del sensor. La respuesta del sensor aparecerá en su pin de "eco". Ambos pines están conectados a los pines de E/S digital del Arduino .

Desencadenar

Para generar un pulso de inicio, debe completar los siguientes pasos

El pin del gatillo debe estar bajo durante al menos 2 µs (microsegundos).
El pasador del gatillo debe estar alto durante 10 µs.
Pasador de gatillo hacia atrás bajo

Con el Arduino puedes hacer esto fácilmente con el siguiente código:

HC-SR04 "Trigger"

// Zend start signaal "trigger"
digitalWrite(2, LOW);   // Zet pin 2 LAAG
delayMicroseconds(2);   // Wacht 2µs
digitalWrite(2, HIGH);  // Zet pin 2 HOOG
delayMicroseconds(10);  // Wacht 10µs
digitalWrite(2, LOW);   // Zet pin 2 terug LAAG

Eco

La respuesta que aparece en el pin de eco del sensor es un pulso cuya duración es igual al tiempo entre la transmisión y la recepción de la onda sonora ultrasónica, expresado en µs (microsegundos). Una posibilidad de medir tal pulso en el Arduino es con la función “pulseIn”:

Meet "echo"

reistijd_geluidsgolf = pulseIn(2, HIGH);   // Meet de tijd dat de puls HOOG (true) is op pin 2

Calcular distancia

Por supuesto, después de todo esto, solo conoce el tiempo de viaje de la onda de sonido, pero esto no significa que conozca la distancia. Afortunadamente, se conoce la velocidad del sonido y la distancia se puede calcular con esto:

distancia [m] = velocidad_sonido [m/s] * tiempo [s]

y la velocidad del sonido es de 343 m/s, entonces

distancia [m] = 343 [m/s] * tiempo [s]

Sin embargo, el HC-SR04 da el tiempo en µs, y para contar fácilmente la distancia en cm sería más conveniente, pero con algunos cálculos, la fórmula se puede ajustar a

distancia [cm] = 0,0343 [cm/µs] * tiempo [µs]

El único problema que queda ahora es que el tiempo que indica el HC-SR04 es el tiempo que el pulso viaja de ida y vuelta, y como solo sirve la distancia al objeto, solo hay que dividir el tiempo entre 2:

distancia = 0.0343 * (tiempo/2)

Configuración de prueba sencilla

Se puede realizar una configuración de prueba rápida para probar el funcionamiento del HC-SR04 con el siguiente esquema y código:

Un sensor HC-SR04 en el Arduino Uno

Eenvoudige code voor het testen van een HC-SR04 op een Arduino Uno

#define triggerPin 4      // Pin voor de trigger
#define echoPin 2         // Pin voor de echo
#define soundSpeed 343.0  // Snelheid van het geluid (m/s)

// Init variables
long echoTime = 0;
float distance = 0;

// Eenmalige doorloop (setup)
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
    ; // Wacht op seriele monitor
  }
  Serial.println("--- Seriele monitor gestart ---");
  pinMode(triggerPin, OUTPUT);  // Zet trigger pin als uitgang
  pinMode(echoPin, INPUT);      // Zet echo pin als ingang
}

// Continue doorloop (loop)
void loop()
{
  // Zend startpuls (trigger)
  digitalWrite(triggerPin, LOW);    // Make sure trigger pin is low
  delayMicroseconds(2);             // for at least 2µs
  digitalWrite(triggerPin, HIGH);   // Set trigger pin HIGH
  delayMicroseconds(10);            // for at least 10µs
  digitalWrite(triggerPin, LOW);    // Set LOW again

  // Meet lengte van de echo puls
  echoTime = pulseInLong(echoPin, HIGH);
  // en bereken hiermee de aftsand (in cm)
  distance = float(echoTime) / 2 * (soundSpeed / 10000.0);
  // Geef weer op de seriele monitor
  Serial.print("Afstand = ");
  Serial.print((String)distance);
  Serial.println(" cm");
  // And wacht 500ms
  delay(500);
}

Multi HC-SR04

A partir de aquí se vuelve un poco más difícil. Debido a que la función "pulseIn" pausa el código y no es lo suficientemente precisa, el código extendido usa registros de puerto e interrupciones. Si esto le suena desconocido, puede encontrar más información en el sitio web del autor de este artículo: http://kunoichi.be/projects/
(el sitio web solo está disponible en inglés)

Múltiples sensores

Para utilizar varios sensores, puede proceder de tres maneras:

gatillo separado por sensor; eco separado por sensor
disparador común; eco separado por sensor
gatillo separado por sensor; eco común

gatillo separado por sensor; eco separado por sensor

La forma más fácil y menos eficiente es conectar cada pin de disparo y eco de cada sensor a un pin separado en el Arduino .
En otras palabras, 2 pines en el Arduino por sensor.

disparador común; eco separado por sensor

Otra forma es conectar todos los disparadores de los sensores y conectarlos a 1 pin en el Arduino . El pin de eco de cada sensor debe conectarse a un pin separado en el Arduino . La ventaja, así como la desventaja, es que todos los sensores envían su respuesta al mismo tiempo. Existe la posibilidad de que los sensores interfieran entre sí, y también necesita un pin de interrupción separado para cada sensor (el Arduino Uno solo tiene 2). Podría usar pines normales, pero luego la precisión disminuiría un poco.

gatillo separado por sensor; eco común

Si no es necesaria una lectura súper rápida, aún puede lograr una muy buena precisión con el tercer método, y no tiene la desventaja de que los sensores interfieran entre sí.
Cada pin de activación del sensor está conectado por separado al Arduino , y todos los pines de eco están conectados a 1 solo pin Arduino . Este pin se llama pin de interrupción. Debido a que usted decide qué disparador se controla, sabe cuál es la respuesta del sensor al pin de eco común.
Esta es la forma más eficiente de usar múltiples sensores HC-SR04 en una sola placa Arduino .

Esquema

Una pequeña desventaja con el método del pin de eco común es que los sensores pueden interferir entre sí en este pin, pero eso se puede remediar fácilmente usando diodos. La estructura del sistema es la siguiente:

Esquema 4 sensores HC-SR04 en pin de eco común

El diagrama de tiempo muestra cómo progresan las señales.

Se envía el pulso de inicio (disparador) para el sensor 4.
Esto responde al pin de eco.
Se envía el pulso de inicio (disparador) para el sensor 3.
Responde al mismo pin de eco, pero dado que se monitorea el pulso de inicio, se sabe de qué sensor proviene la respuesta.
Se envía el pulso de inicio (disparador) para el sensor 2.
...
Repita desde el paso 1

El resto es literalmente copiar/pegar, y puede extenderse fácilmente a múltiples (o menos) sensores de esta manera.

Gráfico de tiempo 4 disparadores, 1 eco

El código para leer los sensores es el siguiente:
(La explicación del código se proporciona a través de campos de comentarios en el propio código)

Uitbreidbare code voor het uitlezen van meerdere sensoren

#define tSENS 4            // Totaal aantal sensoren
#define echoPin 2          // Pin van de gemeenschappelijke echo --> Dit is een interrupt PIN !
#define pingDelay 50       // Tijd tussen elke nieuwe meting (best > 5ms houden)
#define soundSpeed 343.0   // Snelheid van het geluid in m/s

volatile unsigned long startEcho;     // Place to store start time (interrupt)
volatile unsigned long stopEcho;      // Place to store stop time (interrupt)
float distancesCm[tSENS];             // Distances in cm

// Plaats de pin nummers van de trigger pinnen hier (aantal = tSENS !)
int triggerPins[tSENS] = {4, 5, 6, 7};      // Trigger pin voor elke sensor

// Poll timer
unsigned long lastPingMillis;

/****************************************************************
      SETUP
****************************************************************/
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
    ; // Wait for Serial
  }
  Serial.println("--- Serial monitor started ---");
  // Zet alle trigger pinnen als uitgangen
  for (int i = 0; i < tSENS; i++) {
    pinMode(triggerPins[i], OUTPUT);
  }
  // Set echo pin
  pinMode(echoPin, INPUT);                  // Zet echo pin as ingang (geen pullup bij diodes !)
  attachInterrupt(0, ISR_ECHO, CHANGE );    // Definieer interrupt call voor echo pin
  lastPingMillis = millis();
}

/****************************************************************
      LOOP
****************************************************************/
void loop()
{
  // Ping elke x ms
  if (millis() - lastPingMillis >= pingDelay)
  {
    doMeasurement();  // Roep meet procedure op
    // Toon metingen op seriele monitor
    Serial.println(String(distancesCm[0]) + " - " + String(distancesCm[1]) + " - " + String(distancesCm[2])  + " - " + String(distancesCm[3]));
    lastPingMillis = millis();
  }
}

/****************************************************************
      Retrieve measurement and set next trigger
****************************************************************/
void doMeasurement()
{
  // Eerste uitlezing is fout of 0
  unsigned long startWait;
  unsigned long timeout = 30; // 30ms is de max tijd wachten op echo (23ms = 4m = buiten bereik)
  // Voor elke sensor ...
  for (int s = 0; s < tSENS; s++)
  {
    startEcho = 0;  // Reset start tijd
    stopEcho = 0;   // Reset stop tijd
    // Start volgende trigger
    // digitalWrite(triggerPins[s], LOW);  // Hier niet nodig
    // delayMicroseconds(2);
    digitalWrite(triggerPins[s], HIGH);    // HOOG gedurende min. 10µs
    delayMicroseconds(10);
    digitalWrite(triggerPins[s], LOW);    // Terug LAAG
    startWait = millis();   // Onthoud de start tijd "wachten op echo"
    while (startEcho == 0 or stopEcho == 0) {
      // Doorloop tot start en stoptijd verschillend is van 0, of timeout optreedt
      if (startWait + timeout < millis())
      {
        // Forceer resultaat naar 0
        startEcho = 0;
        stopEcho = 0;
        break;  // onderbreak de while cycles
      }
    }
    noInterrupts();   // cli()
    distancesCm[s] = (stopEcho - startEcho) * (float)soundSpeed / 1000.0 / 10.0 / 2.0;   // in cm
    interrupts();   // sei();
  }
}

/****************************************************************
      INTERRUPT handling (keep as fast(=short) as possible)
****************************************************************/
void ISR_ECHO()
{
  // For ATmega328(P) chips, INT0 as at pin PD2
  byte pinRead = PIND >> 2 & B0001;  // Lees de status van de interrupt pin 2 (Arduino Uno)
  if (pinRead)  {
    // Pin = HOOG -> Onthoud de start tijd
    startEcho = micros();
  }
  else {
    // Pin is LAAG -> Onthoud de stop tijd
    stopEcho = micros();
  }
}
//EINDE

Aunque este no es el método más rápido, y con largas distancias y muchos sensores el tiempo de entrega puede ser relativamente alto, este método ofrece algunas ventajas

solo se necesita 1 pin de interrupción
muy fácilmente ampliable
los sensores no interfieren entre sí
uso óptimo de la cantidad de sensores en comparación con los pines de E/S disponibles

Nota sobre la fuente de alimentación

Debido a que el pin de 5 V del Arduino puede suministrar una corriente limitada, se recomienda proporcionar una fuente de alimentación adicional de 5 V CC para alimentar los sensores. Por esta razón, se incluye una "fuente de alimentación Breadbard" en la lista de componentes, pero en esencia puede reemplazarse por cualquier fuente de alimentación de 5 V CC.

Componentes

Los componentes utilizados en este proyecto están disponibles en Opencircuit, y se enumeran a continuación:

HC-SR04 Módulo de detección de distancia ultrasónica Agotado € 2,25 Breadboard 830 puntos - blanco En stock € 3,05 Conjunto jersey macho-masculino 65 piezas En stock € 2,95 Fuente de alimentación de la placa de pruebas Agotado € 2,20 Arduino Uno R3 - clon En stock € 11,50 Diodo rectificador 1N4004 400V 1A - 50 piezas En stock € 2,50 Total € 31,20

Publicado por Arashi Sitio web

Sensores ultrasónicos HC-SR04 en una placa Arduino Uno