BUILDBOT Blog

Como utilizar o sensor ultrasônico HC-SR04

Sensor de Distância Ultrassónico HC-SR04

Vamos conhecer melhor o sensor ultrasônico HC-SR04, um sensor que pode ser utilizado como um detector de objetos ou na área de robótica um componente que pode ser usado para encontrar/evitar obstáculos ou corrigir rotas na movimentação do robô.

Esse sensor utiliza sinais ultrasônicos (40 Khz, acima da capacidade de audição do ouvido humano, que é de 20 Khz), para determinar a distância entre o sensor e o obstáculo. Ele pode medir distâncias entre 2 cm e 4 m, com precisão de 3mm.  Seu ângulo de detecção é de aproximadamente 15 graus, segundo informações do datasheet do sensor.

Pinagem e funcionamento do HC-SR04

O módulo possui 4 pinos : Vcc (alimentação 5V), Trigger, Echo e GND, sendo ideal para utilização em projetos compactos, já que consome apenas 15mA, se adaptando bem à projetos que utilizam as placas e microcontroladores mais comuns do mercado como Arduino, Raspberry e PIC.

Modulo-HC-SR04-Pinagem

Seu funcionamento consiste basicamente em enviar um sinal que, ao atingir um objeto, volta para o sensor e com base nesse tempo entre o envio e recebimento, é calculada a distância entre o sensor e o objeto.

Analisando com mais detalhes esse processo de medição,  que ocorre em 3 etapas:

  1. É enviado um sinal com duração de 10 us (microsegundos) ao pino trigger, indicando que a medição terá início
  2. Automaticamente, o módulo envia 8 pulsos de 40 KHz e aguarda o retorno do sinal pelo receptor
  3. Caso haja um retorno de sinal (em nível HIGH), determinamos a distância entre o sensor e o obstáculo utilizando a seguinte equação: Distancia = (pulso em nível alto x velocidade do som (340m/s) /2

 

A divisão por 2 é necessária já que estamos contando o tempo de ida e volta do sinal.

A ilustração abaixo mostra, graficamente, esse processo :

Diagrama-tempo-hc-sr04

Utilização do HC-SR04 com Arduino

A utilização mais comum do sensor ultrasônico HC-SR04 com o Arduino é na montagem de medidores de distância, onde o valor da distância é mostrado em um display lcd ou mesmo no serial monitor do próprio Arduino. Dependendo do seu projeto, você pode utilizar um Arduino Mini ou Arduino Micro e montar um medidor de distância portátil, utilizando um circuito como esse, montado com um Arduino Uno:

Circuito-HC-SR04-1-sensor

O programa para esse circuito utiliza a biblioteca Ultrasonic, que funciona muito bem quando você precisa trabalhar com apenas um sensor HC-SR04 no seu projeto. Você pode baixar a biblioteca Ultrasonic nesse link. Descompacte o arquivo e coloque a pasta dentro da pasta libraries da IDE do seu Arduino. Em seguida, carregue o programa abaixo :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//Programa : Teste HC-SR04 e biblioteca Ultrasonic
//Autor : Adilson Thomsen

#include <Ultrasonic.h>

//Define os pinos do Arduino ligados ao Trigger e Echo
#define PINO_TRG  7
#define PINO_ECHO 6

//Inicializa o sensor ultrasonico nos pinos especificados
Ultrasonic ultrasonic(PINO_TRG, PINO_ECHO);

void setup()
{
  //Inicializa a serial
  Serial.begin(9600);
}

void loop()
{
  //Variaveis para guardar os valores em 
  //cm (cmSec) e polegadas (inMsec)
  float cmMsec, inMsec;
  
  //Le os valores do sensor ultrasonico
  long microsec = ultrasonic.timing();
  //Atribui os valores em cm ou polegadas as variaveis
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
  
  //Mostra os valores na serial
  Serial.print("Centimetros: ");
  Serial.print(cmMsec);
  Serial.print(" - Polegadas: ");
  Serial.println(inMsec);
  
  //Aguarda 1 segundo e reinicia o processo
  delay(1000);
}

 

Esse programa lê as informações do sensor e as envia para o serial monitor, mostrando a distância do sensor ao objeto em centímetros e também em polegadas.

Serial-monitor-programa1

Com pequenas alterações no programa, podemos fazer com que uma determinada saída do Arduino seja acionada somente quando o objeto estiver entre duas distâncias pré-estabelecidas, por exemplo, entre 50 e 60 cm. Se o objeto estiver fora dessa faixa, a saída não será acionada. Esse exemplo pode ser utilizado como base para construção de um sensor de presença :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//Programa : HC-SR04 - Distancias minima e maxima
//Autor : Adilson Thomsen

#include <Ultrasonic.h>

//Define os pinos do Arduino ligados ao Trigger e Echo
#define PINO_TRG  7
#define PINO_ECHO 6

//Distancias em centimetros
float distancia_minima = 20;
float distancia_maxima = 60;

//Pino a ser acionado em caso de deteccao
int pino_saida = 10;

//Inicializa o sensor ultrasonico nos pinos especificados
Ultrasonic ultrasonic(PINO_TRG, PINO_ECHO);

void setup()
{
  //Inicializa a serial
  Serial.begin(9600);
  pinMode(pino_saida, OUTPUT);
}

void loop()
{
  //Variaveis para guardar os valores em 
  //cm (cmSec) e polegadas (inMsec)
  float cmMsec, inMsec;
  
  //Le os valores do sensor ultrasonico
  long microsec = ultrasonic.timing();
  //Atribui os valores em cm ou polegadas as variaveis
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);

  if (cmMsec > distancia_minima && cmMsec < distancia_maxima)
  {
    //Aciona a porta de saida
    digitalWrite(pino_saida, HIGH);
  }
   
  delay(1000);
}

 

Altere o valor das variáveis distancia_minima e distância_máxima para que o objeto seja detectado apenas dentro de um determinado intervalo.

Utilização de 2 ou mais sensores no mesmo circuito

Dependendo do seu projeto, entretanto, você pode precisar de 2 ou mais sensores HC-SR04, para detectar obstáculos com mais facilidade ou monitorar vários pontos de um ambiente. Nesse caso, teremos um circuito como este :

Circuito-HC-SR04-2-sensoresAqui, você pode utilizar a biblioteca NewPing (download), que permite o controle de até 15 sensores ao mesmo tempo.

Para determinar quantos sensores você está usando no circuito, altere o valor da linha abaixo :

#define SONAR_NUM <numero de sensores>

Depois, adicione uma linha como essa para cada sensor, especificando três parâmetros : o pino trigger, o pino echo e a distância máxima na qual esse sensor vai atuar :

NewPing(<pino trigger>, <pino echo>, <distancia maxima>)

Um loop faz uma varredura em todos os sensores, mostrando os valores medidos no serial monitor:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//Programa : Controle de 2 sensores HC-SR04 - NewPing
//Autor : Adilson Thomsen

//Inicializa as bibliotecas do sensor Ultrasonico
#include <NewPing.h>

//Determina o numero de sensores no circuito
#define SONAR_NUM     2
//Determina a distancia maxima de deteccao
#define MAX_DISTANCE 10
//Intervalo de tempo entre as medicoes - valor minimo 29ms
#define PING_INTERVAL 33

//Armazena a quantidade de vezes que a medicao deve ocorrer, para cada sensor
unsigned long pingTimer[SONAR_NUM];
//Armazena o numero de medicoes
unsigned int cm[SONAR_NUM];
// Armazena o numero do sensor ativo
uint8_t currentSensor = 0;          

NewPing sonar[SONAR_NUM] = 
{ 
  //Inicializa os sensores nos pinos especificados
  //(pino_trigger, pino_echo, distancia_maxima)
  //Sensor 1
  NewPing(7, 6, MAX_DISTANCE),
  //Sensor 2
  NewPing(10, 9, MAX_DISTANCE),
};

void setup() 
{
  Serial.begin(9600);
  //Inicia a primeira medicao com 75ms
  pingTimer[0] = millis() + 75;
  //Define o tempo de inicializacao de cada sensor
  for (uint8_t i = 1; i < SONAR_NUM; i++)
    pingTimer[i] = pingTimer[i - 1] + PING_INTERVAL;
}

void loop() 
{
  //Faz um loop entre todos os sensores
  for (uint8_t i = 0; i < SONAR_NUM; i++) { // Loop entre todos os sensores
    if (millis() >= pingTimer[i]) {         
      pingTimer[i] += PING_INTERVAL * SONAR_NUM;  
      if (i == 0 && currentSensor == SONAR_NUM - 1) oneSensorCycle();
      sonar[currentSensor].timer_stop();
      currentSensor = i;
      cm[currentSensor] = 0;
      sonar[currentSensor].ping_timer(echoCheck);
    }
  }
}

void echoCheck() 
{ 
  //Se receber um sinal (eco), calcula a distancia
  if (sonar[currentSensor].check_timer())
    cm[currentSensor] = sonar[currentSensor].ping_result / US_ROUNDTRIP_CM;
}

void oneSensorCycle() 
{ 
  // Ciclo de leitura do sensor
  for (uint8_t i = 0; i < SONAR_NUM; i++) 
  {
    //Imprime os valores lidos pelos sensores, no serial monitor
    Serial.print("Sensor : ");
    Serial.print(i); 
    Serial.print(" = ");
    Serial.print(cm[i]);
    Serial.print(" cm - ");
  }
  Serial.println();
}

 

Uma sugestão de uso desse sensor você encontra no vídeo abaixo, onde um sensor HC-SR04 foi colocado em uma haste giratória, fazendo uma varredura do ambiente à procura de objetos e coordenando a movimentação das rodas do robô:

Category: Artigos
  • Guilherme Daros says:

    Boa tarde estou realizando um projeto com Pic16f877a. As informações acima são para arduini.no. seria possível encaminhar uma biblioteca para o pic??

    27/04/2015 at 15:31
  • João Cláudio Caleffi says:

    Será que é possível alterar o tipo de sinal enviado por este sensor? Gostaria de enviar um sinal e dB (decibéis) e ver quanto retorna.

    20/08/2015 at 17:49
  • Julio says:

    A leitura do meu sensor está sempre errada, conforme a imagem.
    https://www.dropbox.com/s/0cjtegkea772mww/Captura%20de%20tela%202015-09-03%2017.31.20.png?dl=0
    O que pode ser?

    03/09/2015 at 20:32

Your email address will not be published. Required fields are marked *

*