Como usar um sensor de distância ultrassônico HC-SR04 com Arduino

Tempo de leitura: 12 minutes

O HC-SR04 é um sensor de distância ultrassônico barato e fácil de usar, com um alcance de 2 a 400 cm. É comumente usado em robôs evitando obstáculos e projetos de automação. Neste tutorial, você aprenderá como o sensor funciona e como usá-lo com o Arduino.

Incluí 5 exemplos com um diagrama de ligação e código para que você possa começar a fazer experiências com seu sensor. Veremos primeiro um exemplo que não usa uma biblioteca Arduino. A seguir, mostrarei como você pode usar a biblioteca NewPing para criar um código mais compacto.

Sensores ultrassônicos de distância/proximidade baratos são ótimos, mas em alguns projetos, pode ser necessário um sensor à prova d’água como o JSN-SR04T ou um sensor infravermelho que não seja influenciado por mudanças de temperatura.

 

Suprimentos

Componentes de hardware

Sensor HC-SR04 × 1
Arduino Uno Rev 3 × 1
ProtoBoard × 1
Fios de jumpers ~ 10
Cabo USB tipo A/B × 1
LCD I2C de 20×4 caracteres × 1
Sensor DHT11 x 1

 

Como funciona um sensor ultrassônico de distância?

Os sensores ultrassônicos funcionam emitindo ondas sonoras com uma frequência muito alta para um ser humano ouvir. Essas ondas sonoras viajam pelo ar com a velocidade do som, cerca de 343 m / s. Se houver um objeto na frente do sensor, as ondas sonoras são refletidas de volta e o receptor do sensor ultrassônico as detecta. Medindo quanto tempo passou entre o envio e o recebimento das ondas sonoras, a distância entre o sensor e o objeto pode ser calculada.

Princípio de funcionamento dos sensores ultrassônicos de distância. Fonte: https://www.maxbotix.com/

A 20°C, a velocidade do som é de aproximadamente 343 m/s ou 0,034 cm/µs. Digamos que o tempo entre o envio e o recebimento das ondas sonoras seja de 2.000 microssegundos. Se você multiplicar a velocidade do som pelo tempo que as ondas sonoras viajaram, obterá a distância que as ondas sonoras percorreram.

Distância = Velocidade x Tempo

Mas não é esse o resultado que procuramos. A distância entre o sensor e o objeto é, na verdade, apenas metade dessa distância porque as ondas sonoras viajaram do sensor para o objeto e de volta do objeto para o sensor. Portanto, você precisa dividir o resultado por dois.

Distância (cm) = Velocidade do som (cm/µs) × Tempo (µs)/2

E assim, para o exemplo, isso se torna:

Distância (cm) = 0,0343 (cm/µs) × 2000 (µs)/2 = 34,3 cm

 

Dependência da temperatura da velocidade do som

A velocidade do som, na verdade, depende fortemente da temperatura e, em um grau muito menor, da umidade do ar. A Wikipedia afirma que a velocidade do som aumenta em cerca de 0,6 m/s por grau Celsius. Para a maioria dos casos, a 20°C, você pode usar apenas 343 m/s, mas se quiser obter leituras mais precisas, você pode calcular a velocidade do som com a seguinte fórmula:

V (m/s) = 331,3 + (0,606 × T)

V = Velocidade do som (m/s)
T = Temperatura do Ar (°C)

Esta fórmula não inclui a umidade, pois seu efeito na velocidade do som é apenas muito pequeno.

Abaixo você pode encontrar um tutorial sobre como usar um sensor de temperatura e umidade DHT11 para calibrar a velocidade do som e obter uma leitura de distância mais precisa com o HC-SR04.

 

Como funciona o HC-SR04

Na frente do sensor HC-SR04, você encontra dois cilindros de prata (transdutores ultrassônicos), um é o transmissor das ondas sonoras e o outro é o receptor. Para permitir que o sensor gere uma explosão sônica, você precisa definir o pino Trig alto para pelo menos 10 µs. O sensor então cria uma explosão de ultrassom de 8 ciclos a 40 kHz.

Este estouro sônico viaja na velocidade do som e retorna e é recebido pelo receptor do sensor. O pino Echo então emite o tempo que as ondas sonoras viajaram em microssegundos.

Você pode usar a função pulseIn() no código do Arduino para ler o comprimento do pulso do pino Echo. Depois disso, você pode usar a fórmula mencionada acima para calcular a distância entre o sensor e o objeto.

 

Especificações HC-SR04

Tensão operacional 5 V
Corrente operacional 15 mA
Frequência 40 kHz
Faixa de medição 2 – 400 cm
Resolução 3 mm
Ângulo de medição 15 degrees
Sinal de entrada do gatilho 10 µs high pulse
Custo Preço Aproximado 14 a 20R$

Para mais informações, você pode verificar o datasheet aqui:

 

Conectando HC-SR04 ao Arduino UNO

O diagrama de ligação abaixo mostra como conectar o sensor HC-SR04 ao Arduino.

HC-SR04 com diagrama de ligação Arduino

Os exemplos de código abaixo usam os pinos digitais 2 e 3 para o gatilho e o pino de eco, respectivamente, mas é claro que você pode alterar isso para qualquer pino digital que desejar.

 

Conexões HC-SR04

HC-SR04 Arduino
VCC 5 V
Trig Pin 2
Echo Pin 3
GND GND

Código de exemplo para HC-SR04 com Arduino

Agora que você conectou o sensor, é hora de conectar o Arduino ao computador e carregar algum código. Você pode fazer o upload do seguinte código de exemplo para seu Arduino usando o IDE do Arduino. A seguir, explicarei como o código funciona.

/* Código de exemplo para sensor de distância ultrassônico HC-SR04 com Arduino. Nenhuma biblioteca necessária. */
// Definir Trig e Echo pin:
#define trigPin 2
#define echoPin 3
// Definir variáveis:
long duration;
int distance;
void setup() {
  // Definir entradas e saídas:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  // Comece a comunicação serial a uma taxa de transmissão de 9600:
  Serial.begin(9600);
}
void loop() {
  // Limpe o trigPin configurando-o como LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  // Acione o sensor definindo o trigPin alto por 10 microssegundos:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Leia o echoPin, pulseIn() retorna a duração (comprimento do pulso) em microssegundos:
  duration = pulseIn(echoPin, HIGH);
  // Calcule a distância:
  distance = duration * 0.034 / 2;
  // Imprima a distância no Monitor Serial (Ctrl + Shift + M):
  Serial.print("Distance = ");
  Serial.print(distance);
  Serial.println(" cm");
  delay(50);
}

 

Como funciona o código

Primeiro, o pino de disparo e o pino de eco são definidos. Eu os chamo de trigPin e EchoPin. O pino de disparo é conectado ao pino digital 2 e o pino de eco ao pino digital 3 no Arduino.

A instrução #define é usada para dar um nome a um valor constante. O compilador substituirá todas as referências a esta constante pelo valor definido quando o programa for compilado. Portanto, sempre que você mencionar trigPin, o compilador o substituirá pelo valor 2 quando o programa for compilado.

// Definir Trig e Echo pin:
#define trigPin 2
#define echoPin 3

Em seguida, defini duas variáveis: duration e distance. Duração armazena o tempo entre o envio e o recebimento das ondas sonoras. A variável de distância é usada para armazenar a distância calculada.

// Definir variáveis:
long duration;
int distance;

Em setup(), você começa definindo trigPin como saída e echoPin como entrada. Em seguida, você inicializa a comunicação serial a uma taxa de transmissão de 9600. Posteriormente, você exibirá a distância medida no monitor serial, que pode ser acessado com Ctrl + Shift + M ou Tools > Serial Monitor. Certifique-se de que a taxa de transmissão também esteja definida como 9600 no monitor serial.

void setup() {
  // Definir entradas e saídas:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  //Comece a comunicação serial em uma taxa de transmissão de 9600:
  Serial.begin(9600);
}

No loop(), você aciona o sensor definindo trigPin HIGH para 10 µs. Observe que, para obter um sinal limpo, você começa limpando o trigPin definindo-o como LOW por 5 microssegundos.

void loop() {
  // Limpe o trigPin configurando-o como LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  // Acione o sensor definindo o trigPin alto por 10 microssegundos:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

Em seguida, você precisa ler a duração do pulso enviado pelo echoPin. Eu uso a função pulseIn() para isso. Esta função espera que o pino vá de BAIXO para ALTO, começa a cronometrar, depois espera que o pino vá para BAIXO e para de cronometrar.

Depois disso, você pode calcular a distância usando a fórmula mencionada na introdução deste tutorial.

// Leia o echoPin, pulseIn () retorna a duração (comprimento do pulso) em microssegundos:
duration = pulseIn(echoPin, HIGH);
// Calcule a distância:
distance = duration * 0.034 / 2;

Por fim, a distância calculada é impressa no monitor serial.

// Imprima a distância no Monitor Serial (Ctrl + Shift + M):
Serial.print("Distância = ");
Serial.print(distance);
Serial.println(" cm");
delay(50);
}

 

 

Exemplo de código HC-SR04 com Arduino e biblioteca NewPing

A biblioteca NewPing escrita por Tim Eckel pode ser usada com muitos sensores ultrassônicos de distância. A versão mais recente desta biblioteca pode ser baixada aqui em bitbucket.org. Você pode notar que o código abaixo, que usa a biblioteca NewPing, é muito mais curto do que o código que usamos antes. Além disso, a biblioteca NewPing inclui alguns outros recursos interessantes. Ele permite que você defina uma distância máxima para ler, não demorará um segundo inteiro quando nenhum eco for recebido e tem um filtro de mediana integrado.

Você pode instalar a biblioteca acessando Sketch > Incluir Biblioteca > Adicionar Biblioteca .ZIP no IDE do Arduino.

Ou baixe direto do site do Arduino IDE em Sketch > Incluir Biblioteca > Gerenciar Biblioteca como na foto abaixo.

A biblioteca inclui alguns exemplos que você pode usar, mas terá que modificá-los para corresponder à configuração do seu hardware. Incluí um código de exemplo modificado abaixo que pode ser usado com a mesma configuração de ligação de antes.

/* Sensor de distância ultrassônico HC-SR04 com código de exemplo da biblioteca NewPing. */
// Incluir a biblioteca:
#include <NewPing.h>
// Definir pinos e distância máxima:
#define trigPin  2
#define echoPin  3
#define MAX_DISTANCE 350 // Distância máxima para a qual queremos pingar (em centímetros). A distância máxima do sensor é estimada em 400-500cm.
NewPing sonar(trigPin, echoPin, MAX_DISTANCE); // Configuração de NewPing de pinos e distância máxima.
float duration, distance;
void setup() {
  Serial.begin(9600); // Abra o monitor serial a 9600 baud para ver os resultados do ping.
}
void loop() {
  delay(50); // Aguarde 50ms entre os pings (cerca de 20 pings/seg). 29 ms deve ser o menor atraso entre os pings.
  
  duration = sonar.ping();
  distance = (duration / 2) * 0.0343;
  
  Serial.print("Distância = ");
  Serial.print(distance); // Distance will be 0 when out of set max range.
  Serial.println(" cm");
}

Você também pode usar distance = sonar.ping_cm() ou distance = sonar.ping_in() que retorna a distância medida em centímetros ou polegadas inteiras. Com esta função, você não precisa fazer uma medição de duração e calcular a distância.

Exemplo de código HC-SR04 com I2C LCD e Arduino

Para exibir a distância medida em um LCD I2C 2004 ou 1602, tudo que você precisa fazer é fazer as seguintes conexões e carregar o código abaixo. O sensor HC-SR04 é conectado da mesma forma que antes.

HC-SR04 com Arduino e diagrama de ligação LCD I2C.

 

Conexões LCD I2C

I2C LCD Arduino
GND GND
VCC 5 V
SDA A4
SCL A5

Se você não estiver usando um Arduino Uno, os pinos SDA e SCL podem estar em um local diferente. Um Arduino UNO com layout R3 (pinagem 1.0), também tem os cabeçalhos de pinos SDA (linha de dados) e SCL (linha de clock) próximos ao pino AREF. Verifique a tabela abaixo para mais detalhes.

Placa SDA SCL
Arduino Uno A4 A5
Arduino Nano A4 A5
Arduino Micro 2 3
Arduino Mega 2560 20 21
Arduino Leonardo 2 3
Arduino Due 20 21

Locais de pinos I2C para diferentes placas Arduino

O código usa a biblioteca LiquidCrystal_I2C, que você pode baixar aqui no GitHub. Certifique-se de ter esta biblioteca exata instalada! Também inclui a biblioteca Wire.h, que permite a comunicação com dispositivos I2C. Esta biblioteca deve vir pré-instalada com o Arduino IDE.

/*
Sensor de distância ultrassônico HC-SR04 com código de exemplo Arduino e I2C LCD.
*/
// Include the libraries:
#include <Wire.h> 
// Biblioteca para comunicação I2C 
#include <LiquidCrystal_I2C.h> 
// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3
// Ligação: o pino SDA está conectado ao A4 e o pino SCL ao A5.
// Conecte ao LCD via I2C, endereço padrão 0x27 (A0-A2 sem jumpers) 
// Inicializa o display no endereço 0x27
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

// Definir variáveis:
long duration;
int distance;
void setup() {
  // Definir entradas e saídas:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 
  // Inicializa o display LCD 16x2
  //lcd.begin (16, 2); para 
  // Inicializa o display LCD 20x4
  lcd.begin (20, 4);
  // Liga a luz de fundo do LCD
  lcd.setBacklight(HIGH); 
}
void loop() {
  // Limpe o trigPin configurando-o como LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  // Acione o sensor definindo o trigPin alto por 10 microssegundos:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Leia o echoPin. Isso retorna a duração (comprimento do pulso) em microssegundos:
  duration = pulseIn(echoPin, HIGH);
  // Calcule a distância:
  distance = duration*0.034/2;
  // Exibe a distância no LCD:
  lcd.setCursor(0,0); // Defina o cursor para a coluna 1, linha 1 (a contagem começa em zero)
  lcd.print("Distance = "); // Imprime a string "Display =" no LCD
  lcd.print(distance); // Imprime a distância medida
  lcd.print(" cm  "); // Imprime "cm" no LCD, espaços extras são necessários para limpar os caracteres exibidos anteriormente
  
  delay(50);
}

Observe que usei um display LCD 20×4. Se você tiver um LCD de tamanho diferente (16×2 também é comum), será necessário alterar a linha lcd.begin(16,2);. Se o seu LCD não tiver o endereço I2C padrão, 0x27, verifique o tutorial I2C completo onde explico como você pode descobrir qual é o endereço.

 

Exemplo de código HC-SR04 com sensor de temperatura DHT11 e Arduino

Como mencionado anteriormente, a velocidade do som depende fortemente da temperatura do ar. Se você deseja medir distâncias longas (3-4 m), pode ser uma boa ideia adicionar um sensor de temperatura e umidade DHT11 ou DHT22 à sua configuração. Isso permitirá que você calibre a velocidade do som em tempo real e, assim, aumente a precisão de suas medições.

Adicionar um sensor DHT11 é realmente simples. O diagrama de fiação abaixo mostra quais conexões você precisa fazer. Observe que estou usando um DHT11 com uma placa de breakout, portanto, só preciso conectar 3 pinos. Certifique-se de verificar a etiqueta do sensor, a ordem dos pinos pode ser diferente dependendo do fabricante. O sensor HC-SR04 é conectado da mesma forma que antes.

HC-SR04 com diagrama de ligação Arduino e DHT11.

Conexões DHT11

DHT11 Arduino
VCC (+) 5 V
Signal (s) Pin 4
GND (-) GND

O código abaixo usa a biblioteca Adafruit DHT Humidity & Temperature Sensor, que você pode baixar aqui no GitHub. Esta biblioteca só funciona se você também tiver a biblioteca Adafruit_Sensor instalada, que também está disponível no GitHub.

/*
Sensor de distância ultrassônico HC-SR04 com código de exemplo DHT11 e Arduino.
*/
// Incluir biblioteca de sensores Adafruit:
#include <Adafruit_Sensor.h> //https://github.com/adafruit/Adafruit_Sensor
// Include Adafruit DHT library:
#include <DHT.h> //https://github.com/adafruit/DHT-sensor-library
// Definir Trig pin, Echo pin e DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4
// Defina o tipo de sensor DHT:
#define DHTType DHT11
// Definir variáveis:
long duration;
int distance;
float speedofsound;
// Crie um objeto de sensor DHT:
DHT dht = DHT(DHTPin,DHTType);
void setup() {
  // Definir entradas e saídas:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 
  dht.begin();
  // Comece a comunicação serial:
  Serial.begin(9600); // Inicia a comunicação serial
}
void loop() {
  // Limpe o trigPin configurando-o como LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  // Acione o sensor definindo o trigPin alto por 10 microssegundos:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Leia o echoPin. Isso retorna a duração (comprimento do pulso) em microssegundos:
  duration = pulseIn(echoPin, HIGH);
  // Leia a temperatura:
  float temperature = dht.readTemperature();
  // Calcule a velocidade do som em m/s:
  speedofsound = 331.3+(0.606*temperature);
  // Calcule a distância em cm:
  distance = duration*(speedofsound/10000)/2;
  // Imprima a distância e temperatura no Monitor Serial:
  Serial.print("Temperatura = ");
  Serial.print(temperature);
  Serial.print(" Celsius");
  Serial.print(", Distância = ");
  Serial.print(distance);
  Serial.println("cm");
  delay(100);
}

 

Exemplo de código HC-SR04 com DHT11 e I2C LCD

Exemplo de código HC-SR04 com DHT11 e I2C LCD

O código abaixo pode ser usado para combinar todos os 3 exemplos acima. Ele exibe a temperatura, a velocidade do som e a distância medida no LCD.

/*
Sensor de distância ultrassônico HC-SR04 com código de exemplo DHT11, LCD I2C e Arduino.
*/
// Incluir biblioteca de sensores Adafruit:
#include <Adafruit_Sensor.h> // https://github.com/adafruit/Adafruit_Sensor
// Inclui a biblioteca Adafruit DHT:
#include <DHT.h> // https://github.com/adafruit/DHT-sensor-library
#include <Wire.h> // Biblioteca para comunicação I2C
#include <LiquidCrystal_I2C.h> // Biblioteca para LCD
// Definir Trig pin, Echo pin e DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4
// Biblioteca para LCD 
// Ligação: o pino SDA está conectado ao A4 e o pino SCL ao A5.
// Conecte ao LCD via I2C, endereço padrão 0x27 (A0-A2 sem jumpers) 
// Inicializa o display no endereço 0x27
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// Defina o tipo de sensor DHT:
#define DHTType DHT11
// Definir variáveis:
long duration;
int distance;
float speedofsound;
// Crie um objeto de sensor DHT:
DHT dht = DHT(DHTPin,DHTType);
void setup() {
  // Definir entradas e saídas:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 
  dht.begin();
  // Inicializa o display LCD 16x2
  //lcd.begin (16, 2); para 
  // Inicializa o display LCD 20x4
  lcd.begin (20, 4);
  // Liga a luz de fundo do LCD
  lcd.setBacklight(HIGH); 
  // Comece a comunicação serial a uma taxa de transmissão de 9600:
  Serial.begin(9600);
}
void loop() {
  // Limpe o trigPin configurando-o como LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  // Acione o sensor definindo o trigPin alto por 10 microssegundos:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Leia o echoPin. Isso retorna a duração (comprimento do pulso) em microssegundos:
  duration = pulseIn(echoPin, HIGH);
  // Leia a temperatura:
  int temperature = dht.readTemperature();
  // Calcule a velocidade do som em m/s:
  speedofsound = 331.3+(0.606*temperature);
  // Calcule a distância em cm:
  distance = duration*(speedofsound/10000)/2;
  // Imprima a distância e temperatura no Monitor Serial:
  lcd.setCursor(0,0);
  lcd.print("Temperatura: ");
  lcd.print(temperature);
  lcd.print(" " "\xDF" "C");
  lcd.setCursor(0,1);
  lcd.print("Velocidade: ");
  lcd.print(speedofsound);
  lcd.print(" m/s ");
  lcd.setCursor(0,2);
  lcd.print("Distância: ");
  lcd.print(distance);
  lcd.print(" cm  ");
  delay(100);
}

 

 

Dimensões HC-SR04

Abaixo você encontra as dimensões do sensor ultrassônico HC-SR04. Percebi que existem algumas pequenas diferenças entre os fabricantes, portanto, recomendo verificar o seu próprio sensor.

.

 

Conclusão

Neste artigo, mostrei como o sensor de distância ultrassônico HC-SR04 funciona e como você pode usá-lo com o Arduino. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônicos!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com o sensor de distância HC-SR04. Se você tiver alguma dúvida, sugestão ou se achar que falta algo neste tutorial, por favor, deixe um comentário abaixo.

Visits: 2 Visits: 1191107