Como usar um Sensor de Distância Ultrassónico HC-SR04 com Arduino

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

Incluí 5 exemplos com um diagrama de ligação e código para que possas começar a experimentar com o teu sensor. Primeiro, vamos ver um exemplo que não usa uma biblioteca Arduino. Depois, vou mostrar-te como podes usar a biblioteca NewPing para criar um código mais compacto.

Materiais necessários

Componentes de hardware

	HC-SR04 sensor	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	USB cable type A/B	× 1	Amazon
	20×4 character I2C LCD (opcional)	× 1	Amazon
	DHT11 sensor (opcional)	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

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

Os sensores ultrassónicos funcionam emitindo ondas sonoras com uma frequência demasiado alta para o ouvido humano. Estas ondas sonoras viajam pelo ar à velocidade do som, cerca de 343 m/s. Se houver um objeto à frente do sensor, as ondas sonoras são refletidas e o receptor do sensor ultrassónico deteta-as. Medindo o tempo que passou entre o envio e a receção das ondas sonoras, pode-se calcular a distância entre o sensor e o objeto.

A 20°C, a velocidade do som é aproximadamente 343 m/s ou 0,034 cm/µs. Suponhamos que o tempo entre o envio e a receção das ondas sonoras é de 2000 microssegundos. Se multiplicares a velocidade do som pelo tempo que as ondas sonoras viajaram, obténs a distância percorrida pelas ondas sonoras.

Distância = Velocidade × Tempo

Mas esse não é 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 até ao objeto e depois voltaram do objeto ao sensor. Por isso, é necessário dividir o resultado por dois.

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

Assim, para o exemplo, fica:

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

Dependência da velocidade do som em relação à temperatura

A velocidade do som depende fortemente da temperatura e, em muito menor grau, da humidade do ar. A Wikipedia indica que a velocidade do som aumenta cerca de 0,6 m/s por grau Celsius. Na maioria dos casos, a 20°C podes usar 343 m/s, mas se quiseres obter leituras mais precisas, podes 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 humidade, pois o seu efeito na velocidade do som é muito pequeno.

A seguir podes encontrar um tutorial sobre como usar um DHT11 sensor de temperatura e humidade 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, encontras dois cilindros prateados (transdutores ultrassónicos), um é o transmissor das ondas sonoras e o outro é o receptor. Para fazer o sensor gerar um pulso sónico, precisas de colocar o pino Trig em nível alto durante pelo menos 10 µs. O sensor cria então um pulso de 8 ciclos de ultrassons a 40 kHz.

Este pulso sónico viaja à velocidade do som, reflete-se e é recebido pelo receptor do sensor. O pino Echo emite então o tempo que as ondas sonoras viajaram, em microssegundos.

Podes usar a pulseIn() função no código Arduino para ler a duração do pulso do pino Echo. Depois, podes usar a fórmula mencionada acima para calcular a distância entre o sensor e o objeto.

Especificações do HC-SR04

Tensão de funcionamento	5 V
Corrente de funcionamento	15 mA
Frequência	40 kHz
Alcance de medição	2 – 400 cm
Resolução	3 mm
Ângulo de medição	15 graus
Sinal de entrada Trigger	Pulso alto de 10 µs
Custo	Check price

Para mais informações, podes consultar a folha de dados abaixo:

Ligação – Conectar HC-SR04 ao Arduino UNO

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

Os exemplos de código abaixo usam os pinos digitais 2 e 3 para o trigger e echo, respetivamente, mas claro que podes mudar para qualquer pino digital que queiras.

Ligações do HC-SR04

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

Exemplo de código para HC-SR04 com Arduino

Agora que ligaste o sensor, é hora de conectar o Arduino ao computador e carregar algum código. Podes carregar o seguinte exemplo de código no teu Arduino usando o Arduino IDE. Depois, vou explicar como o código funciona.

/* Example code for HC-SR04 ultrasonic distance sensor with Arduino. 
   No library required. More info: https://www.makerguides.com */

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);
  // Calculate the distance:
  distance = duration * 0.034 / 2;

  // Print the distance on the Serial Monitor (Ctrl+Shift+M):
  Serial.print("Distance = ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(50);
}

Como o código funciona

Primeiro, definem-se o pino trigger e o pino echo. Eu chamo-lhes trigPin e EchoPin. O pino trigger está ligado ao pino digital 2 e o pino echo 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. Assim, sempre que mencionares trigPin, o compilador substituirá pelo valor 2 quando o programa for compilado.

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

De seguida, defini duas variáveis:  duration e distance. Duration guarda o tempo entre o envio e a receção das ondas sonoras. A variável distance é usada para guardar a distância calculada.

// Define variables:
long duration;
int distance;

No setup(), começas por definir o trigPin como saída e o echoPin como entrada. Depois, inicializas a comunicação serial a uma taxa de 9600 baud. Mais tarde, vais mostrar a distância medida no monitor serial, que pode ser acedido com Ctrl+Shift+M ou Tools > Serial Monitor. Certifica-te de que a taxa de baud está também definida para 9600 no monitor serial.

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

No loop(), ativar o sensor definindo o trigPin como HIGH durante 10 µs. Nota que, para obter um sinal limpo, começas por limpar o trigPin definindo-o como LOW durante 5 microssegundos.

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

De seguida, precisas de ler a duração do pulso enviado pelo echoPin. Eu uso a função pulseIn() para isso. Esta função espera que o pino passe de LOW para HIGH, começa a contar o tempo, depois espera que o pino volte a LOW e para a contagem.

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

// Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
duration = pulseIn(echoPin, HIGH);
// Calculate the distance:
distance = duration * 0.034 / 2;

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

// Print the distance on the Serial Monitor (Ctrl+Shift+M):
Serial.print("Distance = ");
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 de distância ultrassónicos. A versão mais recente desta biblioteca pode ser descarregada aqui em bitbucket.org. Podes 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 algumas funcionalidades interessantes. Permite definir uma distância máxima para leitura, não fica bloqueada durante um segundo inteiro quando não recebe eco e tem um filtro mediano incorporado.

Podes instalar a biblioteca indo a Sketch > Include Library > Add .ZIP Library no Arduino IDE.

A biblioteca inclui alguns exemplos que podes usar, mas terás de os modificar para corresponder à tua configuração de hardware. Incluí um exemplo de código modificado abaixo que pode ser usado com a mesma ligação que antes.

/* HC-SR04 ultrasonic distance sensor with 
   NewPing library example code. 
   More info: www.www.makerguides.com */

// Include the library:
#include "NewPing.h"

// Define pins and max distance:
#define trigPin  2
#define echoPin  3
#define MAX_DISTANCE 350 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(trigPin, echoPin, MAX_DISTANCE); // NewPing setup of pins and maximum distance.
float duration, distance;

void setup() {
  Serial.begin(9600); // Open serial monitor at 9600 baud to see ping results.
}

void loop() {
  delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
  
  duration = sonar.ping();
  distance = (duration / 2) * 0.0343;
  
  Serial.print("Distance = ");
  Serial.print(distance); // Distance will be 0 when out of set max range.
  Serial.println(" cm");
}

Podes também usar distance = sonar.ping_cm() ou distance = sonar.ping_in() que retorna a distância medida em centímetros inteiros ou polegadas. Com esta função não precisas de medir a duração nem calcular a distância.

Interligar sensores ultrassónicos em modo de 3 pinos

A biblioteca NewPing também facilita a interligação com sensores ultrassónicos usando apenas 1 pino I/O. Isto pode ser útil se tiveres poucos pinos I/O disponíveis ou se quiseres usar um sensor ultrassónico de 3 pinos como o Parallax Ping.

Para criar uma configuração de 3 pinos (GND, 5V e SIG) tens de ligar tanto o pino trigger como o pino echo ao mesmo pino digital no Arduino. No código, a única coisa que tens de mudar é a linha 6-7, definindo o mesmo pino para trigPin e echoPin. Por exemplo, o pino digital 2.

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 2

Como usar o filtro digital ping_median()

O que mais gosto na biblioteca NewPing é que tem um filtro mediano incorporado. Este filtro pode melhorar muito a precisão das leituras do HC-SR04. A função ping_median() faz várias medições de duração seguidas, descarta as leituras fora do intervalo e depois calcula a média das restantes. Por defeito, faz 5 leituras, mas podes especificar quantas queres. Substitui a linha 19 pelas linhas abaixo.

int iterations = 5;
duration = sonar.ping_median(iterations);

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

Para mostrar a distância medida num 2004 ou 1602 LCD I2C, só tens de fazer as seguintes ligações e carregar o código abaixo. O sensor HC-SR04 está ligado da mesma forma que antes.

Ligações do LCD I2C

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

Se não estiveres a usar um Arduino Uno, os pinos SDA e SCL podem estar noutro local. Um Arduino UNO com layout R3 (pinout 1.0) tem também os pinos SDA (linha de dados) e SCL (linha de relógio) perto do pino AREF. Consulta 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

O código usa a biblioteca LiquidCrystal_I2C que podes descarregar em GitHub. Certifica-te de que tens esta biblioteca exata instalada! Ela inclui também a biblioteca Wire.h que permite comunicar com dispositivos I2C. Esta biblioteca deve vir pré-instalada com o Arduino IDE.

Se quiseres aprender mais sobre como controlar um LCD I2C com Arduino, podes consultar o nosso tutorial sobre How to control a character I2C LCD with Arduino.

/* HC-SR04 ultrasonic distance sensor with 
   Arduino and I2C LCD example code.
   More info: https://www.makerguides.com
*/

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define SDA and SCL pin for LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4); //Change to (0x27,16,2) for 1602 LCD 

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Calculate the distance:
  distance = duration*0.034/2;

  // Display the distance on the LCD:
  lcd.setCursor(0,0); // Set the cursor to column 1, line 1 (counting starts at zero)
  lcd.print("Distance = "); // Prints string "Display = " on the LCD
  lcd.print(distance); // Prints the measured distance
  lcd.print(" cm  "); // Prints "cm" on the LCD, extra spaces are needed to clear previously displayed characters
  
  delay(50);
}

Nota que usei um ecrã LCD 20 x 4. Se tiveres um LCD de tamanho diferente (16 x 2 também é comum), precisas de mudar a linha 20 para LiquidCrystal_I2C lcd(0x27,16,2);. Se o teu LCD não tiver o endereço I2C padrão, 0x27, consulta o tutorial completo de I2C onde explico como 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 muito da temperatura do ar. Se quiseres medir distâncias longas (3-4 m), pode ser boa ideia adicionar um sensor de temperatura e humidade DHT11 ou DHT22 ao teu setup. Isto permite calibrar a velocidade do som em tempo real e assim aumentar a precisão das tuas medições.

Adicionar um sensor DHT11 é muito simples. O diagrama de ligação abaixo mostra as conexões que precisas de fazer. Nota que estou a usar um DHT11 com placa breakout, por isso só preciso de ligar 3 pinos. Certifica-te de verificar a etiqueta do sensor, a ordem dos pinos pode ser diferente dependendo do fabricante. O sensor HC-SR04 está ligado da mesma forma que antes.

Ligações do DHT11

DHT11	Arduino
VCC (+)	5 V
Sinal (s)	Pino 4
GND (-)	GND

O código abaixo usa a biblioteca Adafruit DHT Humidity & Temperature Sensor que podes descarregar em GitHub. Esta biblioteca só funciona se também tiveres instalada a biblioteca Adafruit_Sensor, que também está disponível em GitHub. Podes também descarregar as duas bibliotecas clicando nos botões abaixo:

Podes clicar no botão no canto superior direito do campo de código para copiar o código.

/* HC-SR04 ultrasonic distance sensor with 
   DHT11 and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" //https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" //https://github.com/adafruit/DHT-sensor-library

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Begin Serial communication:
  Serial.begin(9600); // Starts the serial communication
}

void loop() {
  //  Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  float temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  Serial.print("Temperature = ");
  Serial.print(temperature);
  Serial.print(" Celsius");
  Serial.print(", Distance = ");
  Serial.print(distance);
  Serial.println("cm");
  delay(100);
}

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

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

/* HC-SR04 ultrasonic distance sensor with 
   DHT11, I2C LCD and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" // https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" // https://github.com/adafruit/DHT-sensor-library
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define SDA and SCL pin from LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via i2c, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4);

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();

  // Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  int temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  lcd.setCursor(0,0);
  lcd.print("Temperature: ");
  lcd.print(temperature);
  lcd.print(" " "\xDF" "C");
  lcd.setCursor(0,1);
  lcd.print("Speed: ");
  lcd.print(speedofsound);
  lcd.print(" m/s ");
  lcd.setCursor(0,2);
  lcd.print("Distance: ");
  lcd.print(distance);
  lcd.print(" cm  ");
  delay(100);
}

Dimensões do HC-SR04

Abaixo podes encontrar as dimensões do sensor ultrassónico HC-SR04. Notei que existem pequenas diferenças entre fabricantes, por isso recomendo verificar com o teu próprio sensor.

CAD do HC-SR04

Criei desenhos CAD básicos do sensor ultrassónico HC-SR04 que podes descarregar abaixo.

Conclusão

Neste artigo, mostrei-te como funciona o sensor de distância ultrassónico HC-SR04 e como podes usá-lo com Arduino.

Projeto pessoal: Há algum tempo construí uma instalação interativa de parede com alguns amigos. Usámos cerca de 30 sensores de distância ultrassónicos para detetar pessoas a passar em frente à parede. A parede incluía luzes e efeitos sonoros que mudavam conforme a distância das pessoas.

Sensores de distância/proximidade ultrassónicos baratos são ótimos, mas em alguns projetos podes precisar de um sensor à prova de água como o JSN-SR04T ou um sensor IR que não seja influenciado por variações de temperatura. Nesse caso, os artigos abaixo podem ser úteis:

• Waterproof JSN-SR04T Ultrasonic Distance Sensor with Arduino Tutorial
• How to use a SHARP GP2Y0A21YK0F IR Distance Sensor with Arduino
• How to use a SHARP GP2Y0A710K0F IR Distance Sensor with Arduino
• MaxBotix MB7389 weather-resistant distance sensor tutorial
• MaxBotix MB1240 ultrasonic distance sensor Arduino tutorial

Se tiveres alguma dúvida, sugestão ou achares que falta algo neste tutorial, deixa um comentário abaixo.