Sensores ultrassônicos HC-SR04 em uma placa Arduino Uno

Colocado sobre 2019-09-17

Sensores ultrassônicos HC-SR04 em uma placa Arduino Uno

A leitura em um sensor HC-SR04 em uma placa Arduino é relativamente fácil, mas e se você quiser ler em vários sensores? Como fazer isso de maneira eficiente? Este artigo explica, usando um exemplo, como você pode ler com eficiência em 4 sensores e como pode expandir isso para vários sensores.

Construa 4 sensores ultrassônicos HC-SR04 em uma placa Arduino Uno

O que é um HC-SR04

O HC-SR04 é uma placa break-out com sensores ultrassônicos. Neste sinal estão dois objetos cilíndricos, um dos quais está marcado com a letra “T”, que significa “Transmissor”, que significa “transmissor”, enquanto o outro está marcado com a letra “R” para “Receptor”, que significa “receptor”. O transmissor envia uma onda sonora ultrassônica e o receptor “escuta” essa onda sonora colidir com um objeto e ser refletida de volta. O tempo decorrido entre a transmissão e a recepção indica a que distância aquele objeto está do sensor. Morcegos, golfinhos, baleias e sonares em navios funcionam de acordo com um princípio semelhante, e esse princípio é frequentemente chamado de "localização de eco".

Placa de fuga HC-SR04

Você pode ouvir uma onda sonora ultrassônica

A menos que você tenha as orelhas do seu cachorro, você não pode ouvir ondas sonoras ultrassônicas. O HC-SR04 usa uma onda sonora com frequência de 40kHz, enquanto um ouvido humano pode ouvir apenas 16kHz e os mais jovens podem ouvir até 20-22kHz. Muito abaixo da frequência de uma onda sonora ultrassônica.

Além disso, uma onda sonora ultrassônica não é uma onda de rádio (como as ondas de um smartphone) e é totalmente inofensiva à saúde.

Como funciona o HC-SR04

Como mencionado anteriormente, o HC-SR04 emite um som ultrassônico, que colide com um objeto e retorna ao sensor. O sensor conta o tempo decorrido entre o envio e o recebimento desse sinal. Se você conhece a velocidade do som, pode calcular a distância entre o sensor e o objeto. Obviamente, o som não viaja infinitamente longe e, como a onda sonora do sensor é relativamente fraca, a faixa de medição também é bastante limitada. O HC-SR04 pode medir distâncias de até aproximadamente 400 cm (4 m). O “ângulo de visão” ou “ângulo de medição” do sensor também não é infinito. Objetos fora de um ângulo de 15° não podem ser detectados pelo sensor. É por isso que às vezes é interessante usar vários sensores, que você coloca em um círculo, por exemplo. Desta forma, você pode aumentar o ângulo de medição.

Leia o sensor

Para ler o HC-SR04 você precisa gerar um pulso de início no pino “trigger” do sensor. A resposta do sensor aparecerá em seu pino “eco”. Ambos os pinos são conectados aos pinos de E/S digitais do Arduino .

Acionar

Para gerar um pulso de início, você deve concluir as seguintes etapas

O pino de disparo deve estar baixo por pelo menos 2µs (microssegundos).
O pino de disparo deve então ser alto por 10µs
Pino de gatilho para baixo

Com o Arduino , você pode fazer isso facilmente com o seguinte trecho de 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

A resposta que aparece no pino de eco do sensor é um pulso cuja duração é igual ao tempo entre a transmissão e a recepção da onda sonora ultrassônica, expressa em µs (microssegundos). Uma possibilidade de medir tal pulso no Arduino é com a função “pulseIn”:

Meet "echo"

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

Calcular distância

Claro, depois de tudo isso você só sabe o tempo de viagem da onda sonora, mas isso não significa que você sabe a distância. Felizmente, a velocidade do som é conhecida e a distância pode ser calculada com isso:

distância [m] = velocidade_som [m/s] * tempo [s]

e a velocidade do som é 343m/s, então

distância [m] = 343 [m/s] * tempo [s]

No entanto, o HC-SR04 fornece o tempo em µs e, para facilitar a contagem, a distância em cm seria mais conveniente, mas com alguns cálculos a fórmula pode ser ajustada para

distância [cm] = 0,0343 [cm/µs] * tempo [µs]

O único problema que resta agora é que o tempo indicado pelo HC-SR04 é o tempo que o pulso viaja para frente e para trás, e como apenas a distância até o objeto é útil, basta dividir o tempo por 2 :

distância = 0,0343 * (tempo/2)

Configuração de teste simples

Uma configuração de teste rápido para testar a operação do HC-SR04 pode ser realizada com o seguinte esquema e código:

Um sensor HC-SR04 no 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 daqui fica um pouco mais difícil. Como a função “pulseIn” pausa o código e não é suficientemente precisa, o código estendido usa registradores de porta e interrupções. Se isso soa estranho, você pode encontrar mais informações no site do autor deste artigo: http://kunoichi.be/projects/
(o site está disponível apenas em inglês)

Vários sensores

Para usar vários sensores, você pode proceder de três maneiras:

gatilho separado por sensor; eco separado por sensor
gatilho comum; eco separado por sensor
gatilho separado por sensor; eco comum

gatilho separado por sensor; eco separado por sensor

A maneira mais fácil, e menos eficiente, é conectar cada gatilho e pino de eco de cada sensor a um pino separado no Arduino .
Em outras palavras, 2 pinos no Arduino por sensor.

gatilho comum; eco separado por sensor

Outra forma é conectar todos os triggers dos sensores e conectá-los a 1 pino do Arduino . O pino de eco de cada sensor deve então ser conectado a um pino separado no Arduino . A vantagem, assim como a desvantagem, é que todos os sensores enviam sua resposta ao mesmo tempo. Existe a possibilidade dos sensores interferirem entre si, e você também precisa de um pino de interrupção separado para cada sensor (o Arduino Uno tem apenas 2). Você poderia usar pinos comuns, mas a precisão cairia um pouco.

gatilho separado por sensor; eco comum

Se a leitura super rápida não for necessária, você ainda pode obter uma precisão muito boa com o terceiro método e não tem a desvantagem de os sensores interferirem uns nos outros.
Cada pino de disparo do sensor é conectado separadamente ao Arduino , e todos os pinos de eco são conectados a 1 único pino Arduino . Este pino é chamado de pino de interrupção. Como você decide qual gatilho é controlado, você sabe qual é a resposta do sensor ao pino de eco comum.
Esta é a maneira mais eficiente de usar vários sensores HC-SR04 em uma única placa Arduino .

Esquema

Uma pequena desvantagem com o método de pino de eco comum é que os sensores podem interferir uns com os outros neste pino, mas isso pode ser facilmente remediado usando diodos. A estrutura do sistema é a seguinte:

Esquema 4x sensores HC-SR04 no pino de eco comum

O diagrama de tempo mostra como os sinais progridem.

O pulso de início (trigger) para o sensor 4 é enviado.
Isso responde ao pino de eco.
O pulso de início (trigger) para o sensor 3 é enviado.
Ele responde ao mesmo pino de eco, mas como o pulso inicial é monitorado, sabe-se de qual sensor vem a resposta.
O pulso de início (trigger) para o sensor 2 é enviado.
...
Repita a partir do passo 1

O resto é literalmente copiar/colar e pode ser facilmente estendido para vários (ou menos) sensores dessa maneira.

Gráfico de tempo 4 gatilhos, 1 eco

O código para leitura dos sensores é o seguinte:
(A explicação do código é fornecida por meio de campos de comentários no próprio 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

Embora este não seja o método mais rápido, e com longas distâncias e muitos sensores o tempo de espera pode ser relativamente alto, este método oferece algumas vantagens

apenas 1 pino de interrupção necessário
muito facilmente expansível
sensores não interferem uns com os outros
uso ideal do número de sensores versus pinos de E/S disponíveis

Nota sobre a fonte de alimentação

Como o pino de 5 V no Arduino pode fornecer corrente limitada, é recomendável fornecer uma fonte de alimentação extra de 5 V CC para alimentar os sensores. Por esta razão, uma “fonte de alimentação Breadbard” está incluída na lista de componentes, mas, em essência, ela pode ser substituída por qualquer fonte de alimentação de 5 V CC.

Componentes

Os componentes utilizados neste projeto estão todos disponíveis em Opencircuit, e estão listados abaixo:

Módulo de detecção de distância ultrassônica HC-SR04 Em estoque € 2,25 Protoboard 830 pontos - branco Fora de estoque € 3,05 Conjunto jumper Masculino-Masculino 65 peças Em estoque € 3,00 Fonte de alimentação da placa de ensaio Fora de estoque € 2,25 Arduino Uno R3 - clone Em estoque € 11,70 Diodo retificador 1N4004 400V 1A - 50 peças Fora de estoque € 2,55 Total € 31,55

postado por Arashi Local na rede Internet

Sensores ultrassônicos HC-SR04 em uma placa Arduino Uno