Usando um Sensor Ultrassônico de Distância HC-SR04 com Arduino

Sensor Ultrassônico HC-SR04

Neste tutorial vamos mostrar como funciona o sensor ultrassônico de distância HC-SR04 e como usá-lo para detectar a distância de objetos com um Arduino.

Sensor Ultrassônico

Um sensor de ultrassom funciona emitindo um pulso sonoro em uma frequência acima da faixa audível pelo ser humano (aproximadamente 20.000 Hz), o qual viaja pelo ar até atingir um obstáculo, sendo então refletido de volta e detectado pelo sensor.

Desta forma, conhecendo-se a velocidade de propagação do som no ar e medindo o tempo entre a transmissão e a recepção do pulso sonoro, é possível calcular a que distância se encontra o objeto que refletiu o som.

O sensor considerado (HC-SR04) é um módulo de baixo custo que opera na faixa dos 40 kHz (40.000 Hz), e possui um alcance de detecção de cerca de 2cm até 4m de distância, de acordo com seu datasheet.

Sensor de ultrassom HC-SR04

Sensor de distância por ultrassom HC-SR04

Esse módulo sensor possui quatro pinos:

  • VCC - Alimentação do sensor (5V)
  • GND - Comum (Ground)
  • Trig - Trigger (disparo), pino usado para transmitir um pulso de ultrassom
  • Echo - Eco, pino que recebe e detecta o pulso de ultrassom refletido por um obstáculo

Características do HC-SR04

As principais características do sensor HC-SR04 são as seguintes, de acordo com seu datasheet: 

Parâmetro Valor
Tensão de operação 5v DC
Corrente de operação 15 mA
Frequência de operação 40 kHz
Alcance mínimo 2 cm
Alcance máximo 4 m
Ângulo de medição 15º
Sinal de entrada de disparo Pulso TTL de 10 μs

Funcionamento do HC-SR04

O sensor ultrassônico consiste em dois componentes distintos - um circuito que gera e emite o sinal e outro que detecta o sinal refletido de volta. Além disso, o HC-SR04 possui um pequeno microcontrolador responsável por determinar o intervalo de tempo entre o envio e o recebimento do sinal sonoro. Esse intervalo de tempo corresponde a um valor de tensão elétrica: quanto maior o tempo, maior a tensão.

Para gerar o ultrassom o pino Trig deve ser colocado em nível alto por um intervalo de tempo de alguns microssegundos, o que permitirá enviar uma sequência de pulsos sonoros, viajando na velocidade do som e que serão detectados eventualmente pelo pino Echo. O pino Echo retorna a duração de tempo em microssegundos (μs) dos pulsos recebidos.

Por exemplo, suponha que um obstáculo esteja localizado a 20cm de distância do sensor. A velocidade do som no ar é de 340 m/s, ou 0,034 cm/μs, ou ainda aproximadamente 29,4 μs por centímetro percorrido. Assim, as ondas sonoras terão de viajar por cerca de 588 μs entre o sensor e o obstáculo, de acordo com a fórmula:

t = s/v

Onde t é o tempo, s é o espaço percorrido pela onda de ultrassom e v é sua velocidade de propagação no ar.

Ou seja:

T = 20cm / 0,034cm/μs = 588,23 μs

Na prática, o tempo total de viagem do pulso, medido ida e volta, será o dobro desse valor. Em nosso exemplo, o tempo total decorrido entre a transmissão do pulso de ultrassom e seu recebimento será de:

588,23 μs x 2 = 1176,46 μs

Assim, para obter a distância real até o objeto, devemos dividir o valor medido por 2. Desta maneira, a fórmula para determinação da distância até o objeto será:

s = t x 0,034 / 2

Ou ainda:

s = microssegundos / 29,4 / 2

Aplicando as fórmulas em nosso exemplo:

s = 1176,46 x 0,034 / 2 = 20 cm

ou

s = 1176,46 / 29,4 / 2 = 20 cm

Podemos usar qualquer uma dessas fórmulas em nosso programa.

Sensor de distância HC-SR04

Funcionamento do sensor de distância HC-SR04

Resumindo o funcionamento:

  1. Configuramos em nível baixo (LOW) os pinos Trig e Echo quando o módulo é inicializado
  2. Transmitimos um pulso em nível alto (HIGH) por pelo menos 10 μs ao pino Trig, que equivale a oito ondas quadradas de 40 kHz.
  3. Esperamos a captura da saída da borda de subida pelo pino Echo (valor HIGH). Simultaneamente, iniciar um timer para começar a contar o tempo (função pulseIn no Arduino).
  4. Capturar a borda de descida no pino Echo, e ao mesmo tempo, ler o contador, que indica o tempo de deslocamento do sinal ultrassônico.
  5. Finalmente, aplicando a fórmula ao valor lido, calculamos a distância até o obstáculo, e então tomamos uma decisão sobre o que fazer (acender um LED, emitir um alarme sonoro, etc).

A seguir podemos visualizar o diagrama de temporização do sensor (retirado de seu datasheet):

Diagrama de Temporização do sensor HC-SR04

Diagrama de Temporização do sensor HC-SR04 (Fonte: Datasheet da ElecFreaks)

Aplicações de sensores ultrassônicos

Os sensores de ultrassom são empregados em uma variedade de aplicações, em diversas áreas, como:

  • Medição de distância (nosso objetivo aqui)
  • Medição de profundidade ou espessura
  • Visualização de imagens
  • Polimento e limpeza
  • Solda ultrassônica

entre outras. Neste artigo empregaremos um sensor de ultrassom de baixo custo para detectar e medir a distância de um objeto (obstáculo).

Montando o circuito

Para este projeto precisaremos dos seguintes componentes:

  • Sensor HC-SR04
  • Arduino
  • Fios e matriz de contatos

A figura a seguir mostra a conexão dos componentes usando a breadboard. Basicamente, ligamos o pino 8 do Arduino ao pino Trig do sensor, o pino 7 ao pino Echo, e conectamos VCC e GND aos pinos correspondentes no microcontrolador:

Sensor de distância HC-SR04 com Arduino Código do sketch

A seguir temos o código do Arduino para a aplicação do sensor de distância, comentado:

/*
Sensor Ultrassônico HC-SR04
Fábio dos Reis
www.bosontreinamentos.com.br */

// Definir os números dos pinos
const int trigger = 8;
const int eco = 7;

// Definir as variáveis
long duracao;
float dist;

void setup() {
 pinMode(trigger, OUTPUT); // Configura o pino trigger como saída
 pinMode(eco, INPUT); // Configura o pino eco como entrada.
 Serial.begin(9600); // Inicia a comunicação serial
}

void loop() {
 // Limpa o trigger
 digitalWrite(trigger, LOW);
 delayMicroseconds(5);

 // Configurar o trigger para nível alto para transmissão de sinais
 digitalWrite(trigger, HIGH);
 delayMicroseconds(10); // tempo para envio do sinal
 digitalWrite(trigger, LOW);

 // Inicia contagem de tempo e lê o pino de eco
 duracao = pulseIn(eco, HIGH);

 // Calcular a distância
 dist = duracao * 0.034 / 2;

 // Mostrar a distância no monitor serial
 if (dist >= 400 || dist <= 2) {
   Serial.println("Valor fora do alcance");
 }
 else {
   Serial.print("Distancia em cm: ");
   Serial.println(dist);
 }

 // Aguardar 100ms antes da próxima leitura para evitar interferência
 delay(100);
}

Explicando o código:

  • Primeiramente definimos os pinos de trigger e eco, que serão respectivamente os pinos 8 e 7.
  • Criamos então duas variáveis: duracao, para armazenar a duração do pulso lido pelo sensor, e dist, onde será armazenado o valor da distância calculada até o objeto.
  • Na função setup() configuramos os modos de operação dos pinos, sendo modo de saída para o pino trigger e entrada para o pino de eco. Inicializamos também o monitor serial.
  • Na função principal, loop(), começamos limpando o trigger ao colocá-lo em nível baixo por cerca de 5 us (suficiente).
  • Em seguida, colocamos o trigger em nível alto por 10 us (função delayMicroseconds), para que seja gerado o sinal ultrassônico e enviado, e então colocamos o pino de volta ao nível LOW.
  • Os pulsos de ultrassom são enviados, batem em um obstáculo e são refletidos de volta (eco). Devemos agora ler o valor detectado no pino de eco, usando para isso a função do Arduino pulseIn (veja quadro abaixo a respeito dessa função).
  • Calculamos a distância usando a fórmula dist = duracao * 0,034 / 2
  • E finalmente mostramos a distância calculada no monitor serial (ou realizamos outra tarefa). Caso a distância do objeto seja maior ou igual a 4m (400cm) ou menor ou igual a 2cm (limites de detecção do sensor), será exibida a mensagem "Valor fora do alcance".
  • Aguardamos 100 ms antes do próximo ciclo de detecção (varie à vontade esse valor, para obter mais ou menos leituras por segundo; idealmente, não use um valor abaixo de 60 ms para que não haja interferência entre os sinais enviados e recebidos pelo sensor).

A função pulseIn()

A função pulseIn() ("pulse input") lê um pulso presente em um pino, tanto em nível alto quanto baixo, e retorna a duração desse pulso.

Sintaxe:

pulseIn(pino, valor)

ou

pulseIn(pino, valor, timeout)

Parâmetros:

  • pino - número do pino a partir de onde será lido o pulso
  • valor - tipo de pulso que será lido: HIGH (nível alto) ou LOW (nível baixo)
  • timeout - parâmetro opcional, indica o número de microssegundos a esperar até que o pulso se inicie; o padrão é um segundo

Por exemplo, se valor for estabelecido como HIGH (nível alto), a função espera o valor do pino ir a alto, começa a contar o tempo (temporização), e então espera o pino ir a nível baixo (LOW) para parar a contagem de tempo. Desta forma é retornada a duração do pulso recebido em microssegundos.
Caso nenhum pulso seja detectado, retorna o valor 0.
Essa função opera melhor com pulsos entre 10 μs e 3 minutos de duração; pulsos mais longos podem induzir erros de leitura.

Exemplo:
Queremos determinar a duração de um pulso aplicado ao pino 10 do Arduino:

int pino = 10;
unsigned long duracao;
void setup()
{
  pinMode(pino, INPUT);
  Serial.begin(9600);
}
void loop()
{
  duracao = pulseIn(pino, HIGH);
  Serial.println(duracao);
}

É isso aí! Nos próximos projetos vamos explorar mais o sensor de distância HC-SR04. Até! 

 

Sobre Fábio dos Reis (1199 Artigos)
Fábio dos Reis trabalha com tecnologias variadas há mais de 25 anos, tendo atuado nos campos de Eletrônica, Telecomunicações, Programação de Computadores e Redes de Dados. É um entusiasta de Unix, Linux e Open Source em geral, adora Eletrônica e Astronomia, e estuda idiomas, além de ministrar cursos e palestras sobre diversas tecnologias em São Paulo e outras cidades do Brasil.
Contato: Website

Escreva um comentário

Seu e-mail não será divulgado


*