Hoje o assunto do nosso post é o sensor ultrasônico HC-SR04. Vamos aprender a utilizar esse sensor com Arduino, seus princípios de funcionamento e aplicações. Sensores ultrassônicos são aplicados como um detectores de objetos e são muito populares principalmente na robótica, onde são utilizados para identificar obstáculos e corrigir continuamente o trajeto feito por um robô.
Por meio da emissão de sinais Ultrassônicos (veja na próxima seção o que são esses sinais), é possível especificar à distância do sensor até um determinado obstáculo. O range de atuação é da ordem de 4 metros, com distância mínima de medição de 2 cm e incluindo obstáculos dentre de um ângulo de abertura de 15 graus. Vamos conhecer esse sensor e aprender a como interfaceá-lo com nosso Arduino.
O princípio de funcionamento do HC-SR04 consiste na emissão de sinais ultrassônicos pelo sensor e na leitura do sinal de retorno (reflexo/eco) desse mesmo sinal. A distância entre o sensor e o objeto que refletiu o sinal é calculada com base no tempo entre o envio e leitura de retorno.
” Sinais Ultrassônicos são ondas mecânicas com frequência acima de 40 KHz“
Como ouvido humano só consegue identificar ondas mecânicas até a frequência de 20KHz, os sinais emitidos pelo sensor Ultrassônico não podem ser escutados por nós.
O sensor HC-SR04 é composto de três partes principais:
O funcionamento consiste em três etapas:
Por meio desse pulso de saída cujo tempo é igual a duração entre emissão e recepção, nós calculamos a distância entre o sensor e o objeto/obstáculo, por meio da seguinte equação:
Distância = (Tempo de duração do sinal de saída × velocidade do som) / 2
Em que:
Repare que as unidades devem estar coerentes para o resultado da conta ser correto. Assim, se a velocidade do som é dada em metros/segundo, o tempo de duração do sinal de saída deve estar em segundos para que possamos encontrar a distância em metros.
Sensor Ultrassônico com indicação de pinagem. Créditos: Eletrogate
Na figura 1 podemos ver os quatro pinos do sensor HC-SR04. Temos um pino de VCC, alimentado com 5V, um GND, e os dois pinos de controle e leitura do sensor: O Trigger, no qual nós aplicamos o sinal para comandar o envio dos pulsos ultrassônicos, e o Echo, que retorna para o Arduino os pulsos com o tempo de duração entre o envio e recepção do sinal de retorno. A corrente elétrica de operação do sensor é de 15mA, portanto é uma aplicação de baixo consumo energético.
Os sensores ultrassônicos podem medir variáveis como enchimento e altura sem ter que entrar em contato com os elementos do meio, o que é uma grande vantagem quando comparado com outros tipos de sensores. Uma outra vantagem é que o sensor ultrassônico não possui sua operação prejudicada pela transparência, poeira, sujeira ou vapores/gases presentes no ambiente. Desde que o objeto reflita as ondas sonoras, é possível usar um sensor ultrassônico independentemente de seu acabamento superficial ou cor. Existem sensores que podem medir distâncias de dezenas de metros com ótima precisão. Devido a todas essas características, os sensores ultrassônicos são amplamente utilizados na indústria e em vária aplicações de robótica e automação.
As principais aplicações são:
Aqui no nosso projeto, vamos mostrar um circuito simples de como controlar o sensor HC-SR04 e calcular distâncias, e vamos mostrar uma aplicação muito legal. Um carrinho controlado por Joystick que utiliza o HC-SR04 para identificar e desviar de obstáculos.
Primeiro, vamos montar um circuito para ligar o HC-SR04 com Arduino UNO e utilizá-lo para medir distâncias. Assim você vai aprender passo a passo a como utilizar o sensor e a aplicá-lo a qualquer projeto. Depois, vamos mostrar uma aplicação avançada (códigos serão disponibilizados nas próximas seções) na qual o sensor é usado para evitar que um carrinho controlado por Joystick bata em obstáculos durante a sua aplicação.
Materiais necessários para o projeto com Sensor Ultrassônico HC-SR04 e Arduino
A montagem para controlar o sensor com o Arduino é fácil e não exige componentes adicionais. Com a montagem abaixo você pode facilmente identificar objetos e calcular distâncias. No nosso caso, vamos usar o terminal serial da IDE Arduino para mostrar as distâncias calculadas.
Figura 2: Montagem Sensor HC-SR04 com arduino
O software para utilizar o HC-SR04 não é complicado. O pulso de disparo do sensor é fácil de ser implementado. Para ler o tempo de duração do pino de output nós dispomos da função nativa PulseIn(). A equação para calcular a distância a partir do tempo medido também é simples.
Na figura 3 temos a primeira parte do software. As variáveis declaradas são para determinar os pinos de trigger(pino 2) e de leitura do sensor(pino 3). Temos três variáveis do tipo float utilizadas para medir o tempo do pulso no output do sensor e calcular a distância.
int PinTrigger = 2; // Pino usado para disparar os pulsos do sensor
int PinEcho = 3; // pino usado para ler a saida do sensor
float TempoEcho = 0;
const float VelocidadeSom_mpors = 340; // em metros por segundo
const float VelocidadeSom_mporus = 0.000340; // em metros por microsegundo
void setup(){
// Configura pino de Trigger como saída e inicializa com nível baixo
pinMode(PinTrigger, OUTPUT);
digitalWrite(PinTrigger, LOW);
pinMode(PinEcho, INPUT); // configura pino ECHO como entrada
// Inicializa a porta serial
Serial.begin(9600);
delay(100);
}
Na função void setup(), inicializamos o pino 2 como saída e o 3 com entrada. Além disso, configuramos a comunicação serial para 9600 de baud rate.
Na figura 4 temos a função void loop(), onde o programa será executado continuamente. O corpo do programa consiste em três partes:
void loop(){
// Envia pulso para o disparar o sensor
DisparaPulsoUltrassonico();
// Mede o tempo de duração do sinal no pino de leitura(us)
TempEcho = pulseIn(PinEcho, HIGH);
Serial.println("Distancia em metros: ");
Serial.println(CalculaDistancia(TempoEcho));
Serial.println("Distancia em centimetros: ");
Serial.println(CalculaDistancia(TempoEcho)*100);
// aguarda um pouco antes de começar tudo de novo
delay(2000);
}
Por fim, temos as duas funções que implementamos. Uma para enviar o pulso de trigger do sensor e outra para calcular a distância entre o sensor e o obstáculo.
// Funçao para enviar o pulso de trigger
void DisparaPulsoUltrassonico(){
// Para fazer o HC-SR04 enviar um pulso ultrassonico, nos temos
// que enviar para o pino de trigger um sinal de nivel alto
// com pelo menos 10us de duraçao
digitalWrite(PinTrigger, HIGH);
delayMicroseconds(10);
digitalWrite(PinTrigger, LOW);
}
}
A função DisparaPulsoUltrassonico() apenas ativa o pino 2 em nível alto, espera 10 microsegundos e volta a setar o pino para nível baixo. Lembre que 10us é o tempo mínimo que o pulso deve perdurar para disparar o sensor HC-SR04.
// Função para calcular a distancia em metros
float CalculaDistancia(float tempo_us){
return((tempo_us*VelocidadeSom_mporus)/2);
}
A função CalculaDistancia recebe como parâmetro o tempo do pulso no pino Echo do sensor. Com esse tempo nós usamos a equação informada no datasheet(ver seção de introdução) para calcular a distância entre o sensor e o obstáculo.
Você também pode conferir o código completo e atualizado visitando o repositório desse post no GitHub da Eletrogate.
Com o software e montagem das duas seções anteriores, nós temos a seguinte saída na porta serial:
Figura 7: Saída no terminal serial
Veja que estamos mostrando a distância em centímetros e em metros também!
O carrinho trata-se de um chassi como esse, com uma série de componentes eletrônicos embarcados. Os principais deles são:
Materiais necessários para o projeto Carrinho com Sensor Ultrassônico HC-SR04 e Arduino
O funcionamento é da seguinte forma. À medida que o carrinho anda pelo terreno, ele identifica os obstáculos e evita o encontro com os mesmos e corrige a rota de acordo com os comandos do Joystick. As figuras 8 e 9 mostram a montagem de todos os componentes juntos e montados no chassi.
Figura 8: Carrinho com Sensor Ultrassônico HCSR-04 controlado por Joystick
Figura 9: Carrinho com Sensor Ultrassônico HCSR-04 controlado por Joystick
Aqui você pode acessar os códigos usados no carrinho. São basicamente dois. O primeiro é para o Arduino que vai no carrinho controlando o sensor Ultrassônico e o servo (módulo receptor). O segundo vai no arduino que controla o Joystick (módulo transmissor).
Além do firmware, você vai precisar também de duas bibliotecas adicionais para fazer o controle do módulo RF. São elas a “nRF24L01.h” e”RF24.h“. Você pode fazer o download das duas bibliotecas neste link.
Basicamente, o firmware faz a leitura dos sinais analógicos do JoyStick com duas entradas, uma para o eixo x e outra para o eixo y. Essas duas entradas são usadas para calcular os movimentos feitos pelo usuário. Uma entrada digital é usada para ler se o JoyStick foi pressionado ou não. Essas três variáveis são declaradas dentro de uma estrutura usada para definir o tipo Controle, por meio da diretiva typedef.
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
typedef struct{
int eixo_x;
int eixo_y;
int bot;
}
Controle;
Controle c;
int bot_01 = 2;
// Define o endereço para comunicação entre os módulos
const uint64_t pipe = 0xF0F0F0F0D2LL;
void setup(){
RF24 readio(9,10); // Inicializa o NRF24L01 nos pinos 9 e 10
pinMode(2, INPUT); // botao_01
Serial.begin();
readio.begin();
radio.openWritingPipe(pipe);
}
As três variáveis da estrutura c, do novo tipo definido Controle, são constantemente monitoradas e enviadas via RF para o módulo receptor instalado no carrinho. Essa parte do código está na função void loop().
void loop(void){
// Faz as leituras
c.eixo_x = analogRead(0);
c.eixo_y = analogRead(1);
c.bot = digitalRead(bot_01);
// envia mensagem
radio.write(&c, sizeof(c));
// Exibe dados enviados
Serial.print("Dados enviados: ");
Serial.print(c.eixo_x);
Serial.print(",");
Serial.print(c.eixo_y);
Serial.print(",");
Serial.println(c.bot);
}
Para software receptor, além das bibliotecas anteriores, você vai precisar também de adicionar a “Ultrasonic.h”, que pode ser encontrada aqui. Novamente vamos declarar uma variável do tipo Controle a partir da instrução typedef, na qual teremos os valores correspondentes ao eixo x e y do joystick, bem como se o mesmo está pressionado ou não.
Na função void loop(), constantemente recebemos os dados do transmissor e avaliamos os valores das coordenadas. Dependendo desses valores, isto é, dependendo da posição de como o joystick é manuseado, nós chamamos alguma das funções abaixo:
Cada uma dessas funções aciona os motores do carrinho de forma a realizar a manobra desejada. Em todas elas o sensor ultrassônico é usado para avaliar se há algum obstáculo ou não. Caso um obstáculo seja detectado, a manobra não é realizada. Caso o caminho esteja livre, os motores nas rodas do carrinho são acionados normalmente.
E aí, o que achou de aprender a usar o sensor ultrassônico e conhecer essa aplicação do carrinho controlado por Joystick?! O sensor HC-SR04 pode ser usado em várias outras aplicações, e agora você já sabe tudo que precisa para poder implementar aplicações com ele.
Quando fizer o seu projeto, mande as fotos e comentários para a gente. E se tiver alguma dúvida sobre o post, deixe seu comentário aqui no Blog! Até a próxima!
Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!
Rua Rio de Janeiro, 441 - Sala 1301
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
Eletrogate Componentes Eletrônicos
CNPJ: 18.917.521/0001-73
