Arduino Tutorial - Ultrasonic Sensor

About: Este é um canal para homemakers e DIY onde vai encontrar tutoriais úteis acerca de Electrónica, Arduíno, Robótica e Impressão 3D. Estes têm explicações simples e práticas que podem ser utilizadas para concre...

Bem vindos a mais um tutorial sobre o Arduino hoje vamos falar e explicar o funcionamento de um sensor de ultrasons podendo este ter varias aplicações em diversos projectos de robótica ou instrumentação, para isso vamos mostrar-vos uma montagem que irá permitir medir distâncias em linha recta, pois a principal função deste tipo de sensor é detectar e quantificar a distância que existe entre este e um objecto que se encontre à sua frente.

Este tipo de sensor para determinar a distância até um objecto através de sons ou neste caso de ultrasons, como sabemos o som não é mais que a propagação de ondas de compressão do ar, sendo este fenómeno designado por ondas sonoras.

Visto isto o sensor irá emitir então os ultrasons que posteriormente serão reflectidos num qualquer objecto de seguida este realizará uma contagem de tempo entre a emissão dos ultrasons e a recepção dos ultrasons reflectidos pelo objecto.

A frequência dos ultrasons emitidos pelo sensor encontram-se no intervalo dos 40KHz, pois estas frequências garantem uma direcção mais concentrada das ondas sonoras, isto deve-se ao facto de um som com frequências altas ter a tendência de se dissipar menos no ambiente envolvente.

Um sensor ultrasons típico para determinar as distâncias é normalmente constituído por 2 pequenas membranas, uma membrana que emite o som e outra que recebe o seu eco, ou seja uma será espécie de coluna e a outra um microfone.

Para determinar então o tempo entre estes 2 eventos este tem também um cronometro de alta precisão, sendo assim possível saber quanto tempo demora o sinal desde a sua emissão até a sua recepção, no entanto, para sabermos a distância apenas precisamos da metade do tempo medido pelo cronometro, assim utilizamos o cálculo D = (Vs x T)/2 em que: (Ver imagem acima)

  • D = Distância;
  • Vs = Velocidade do som;
  • T = Tempo entre a emissão e recepção do sinal pelo sensor.

Determinado o tempo cronometrado, basta sabermos agora a velocidade do som, normalmente a velocidade do som não é considerada como um constante, sendo determinada a 340m/s, assumindo claro a numa temperatura do ar normalizada a 20ºC e como se estivéssemos nível do mar.

Agora como esta montagem será de um instrumento de medida é desejável que este seja o mais preciso possível, logo assumimos que a velocidade do som poderá variar principalmente por intermédio da temperatura ambiente (ver cálculos acima).

Para que seja possível então sabermos qual a temperatura ambiente vamos utilizar um sensor sensor de temperatura, que normalmente é constituído por uma resistência NTC"Negative Temperature Coefficient", diminuindo a sua resistência eléctrica com o aumento de temperatura, mas também se poderá utilizar uma PTC"Positive Temperature Coefficient", que por sua vez aumenta a sua resistência eléctrica com o aumento de temperatura (Ver gráfico acima).

Por fim, utilizamos também um LCD"Liquid Crystal Display", onde será escrita a distância que o sensor irá determinar, apesar de a principal unidade de medida para este sensor ser em m (metros) iremos capacitar a montagem de também poder representar a distância em cm (centímetros) e in (polegadas).

Caso queiram saber mais sobre o sensor de ultrasons ou o LCD vejam as suas datasheet (Ver ficheiros abaixo), alem destes vejam também as especificações detalhadas do Arduino UNO, através da seguinte ligação https://store.arduino.cc/arduino-uno-rev3.

Step 1: Montagem

Na montagem começamos por utilizar uma "Breadboard" onde vamos colocar os componentes e onde serão distribuídas as alimentações positivas e negativas fornecidas pelo Arduino.

Assim começamos por colocar o LCD na montagem, pois este é o componente que necessita de mais ligações, depois o botão e a sua respectiva resistência eléctrica sendo este o responsável pela alteração das unidades de medidas e por fim o nosso sensor de ultrasons e o sensor de temperatura (Ver imagem acima).

Material necessário:

  • 1x Arduino UNO;
  • 1x Cabo USB;
  • 1x Breadboard;
  • 1x LCD1602;
  • 1x Resistência 220Ω;
  • 1x Sensor de Ultrasons HC-SR04;
  • 1x Resistência 10KΩ;
  • 1x Sensor de temperatura NTC 10KΩ;
  • 1x Resistência variavel 10KΩ;
  • 1x Botão (Push Button);
  • 1x Resistência de 1KΩ.

Instalação do LCD 1602:

Cada pino do LCD tem uma função especifica e como podem observar na imagem da montagem completa não são utilizamos todos os seus pinos, assim para explicar mais facilmente o funcionamento do LCD, agrupamos os seus pinos em 3 grupos, o grupo Pinos de Alimentação, o de Pinos de Comunicação e de Pinos de Informação (Ver legenda acima).

Pinos de Alimentação:

  • Gnd;
  • Vcc;
  • V0;
  • LED - ou A (Anodo);
  • LED + ou K (Catodo).

A alimentação do LCD é realizada através dos pinos GND e VCC, devendo ter o pino VCC uma tensão de 5V que será fornecida pelo Arduino UNO, pois este os seus pinos de alimentação tem tensões estáveis e protegidas não permitindo que existam sobrecargas ou curto-circuitos.

O Pino V0 tem como função ajustar o contraste dos caracteres do LCD, para podermos controlar esse ajuste ligamos neste pino uma resistência variável de 10KΩ com uma montagem de um divisor de tensão, alterando assim a tensão a tensão no pino V0 entre os 0 e 5V (Ver imagem acima).

Este tipo de LCD tem um LED como luz de fundo sendo este alimentado através dos pinos A e K fornecida também pelo Arduino, no entanto, como explicado em tutoriais anteriores devemos ligar o LED em série com uma resistência de 220Ω, para que o brilho não seja demasiado intenso e reduzir a probabilidade de este se danificar.

Pinos de Comunicação:

  • RS (Register Select);
  • R/W (Read / Write);
  • E (Enable).

Nos pinos de comunicação apenas teremos de ter mais atenção ao pino R/W, pois este deve estar ligado a GND para que seja permitido escrever no LCD, aparecendo assim os caracteres, caso contrario podemos estar a ler o dados guardados na sua memoria interna ficando o LCD em branco.

Pinos de Informação:

  • D0;
  • D1;
  • D2;
  • D3;
  • D4;
  • D5;
  • D6;
  • D7.

Nesta montagem são utilizados todos os pinos de alimentação e comunicação, no entanto, apenas utilizamos metade dos pinos de informação, isto é possível através da utilização no código da biblioteca LiquidCrystal.h, esta permite ler o "Byte" ou 8bits de informação enviado pelo Arduino, através da divisão deste em 2 partes, ou seja, são lidos 4bits de cada vez.

Para isso esta biblioteca utiliza os pinos de comunicação, de modo a que o LCD consiga saber qual é a forma que irá receber a informação, ou seja, se com 8bits através dos pinos D0 a D7 ou com 4bits através dos pinos D4 a D7.

Instalação do botão:

Terminada a instalação do LCD, colocamos na "Breadboard" o botão de pressão e a sua respectiva resistência de 1KΩ, depois este é ligado a um dos pinos de sinal digital do Arduino, ficando este responsável pela alteração das das unidades de medida visualizadas através do LCD.

Para saber mais sobre os pinos de sinal digital do Arduino definidos como entradas e onde são explicamos esta características mais detalhadamente, verifiquem um tutorial anterior:

Arduino Tutorial - Digital Input - Button - Monitor Serial

https://www.instructables.com/id/Arduino-Tutorial-Digital-Input-Button-Monitor-Seri/

Instalação do Sensor de Ultrasons HC-SR04:

Para cronometrar rigorosamente o tempo decorrido entre o envio e a recepção dos ultrasons é necessário um mecanismo que faça desencadear esse processo, a isso chama-se gatinho ou "Trigger". Agora alem dos pinos de alimentação o nosso sensor tem mais 2 pinos, um dos quais é o pino designado por TRIGGER, sendo este o pino que irá receber o sinal digital do Arduino, iniciando assim o processo de leitura da distancia e o seu cronometro, já o outro pino designa-se por ECHO sendo através deste que será enviada a informação do sensor para o Arduino indicar então tempo deste processo.

Como estes pinos irão receber e enviar sinais digitais estes terão de ser ligados aos pinos de sinal digital do Arduino, no entanto cada um terá de ser programado individualmente de forma a que um seja entrada e o outro saída de sinal (Ver imagem acima).

Para que o sensor comece a contabilizar o tempo que os ultrasons demoram a percorrer a distancia até a um objecto, accionamos o "Trigger" através um pulso de sinal digital no pino TRIGGER do sensor. Logo de seguida o sensor emite então os ultrasons com uma frequência de cerca de 40KHz que posteriormente será reflectido pelo objecto e consequentemente recebido novamente pelo nosso sensor.

Depois o sensor calcula o tempo deste processo e envia essa informação através do pino ECHO, colocando em nível alto um sinal de pulso digital com a particularidade de que este estará em nível alto o mesmo tempo que o cronometro determinou entre a emissão e a recepção dos ultrasons (Ver gráfico abaixo).

Instalação do sensor de temperatura:

No entanto como a velocidade dos ultrasons emitos pelo sensor podem alterar dependendo de factores exteriores, como por exemplo a temperatura ou a humidade ambiente, uma das das formas de eliminar esse possivel erro é colocar no cálculo da determinação da distância os valores de temperatura ambiente, colocando na nossa montagem um sensor de temperatura sendo escolhido neste caso um sensor resistivo do tipo NTC.

Para que o Arduino possa realizar a leitura do sensor de temperatura, este deve ser montado num circuito divisor de tensão e como segundo as especificações do fabricante a resistência do nosso sensor é de cerca de 10KΩ, logo a resistência que iremos utilizar para o nosso divisor de tensão tambem terá de ter 10KΩ (Ver imagem acima).

Depois o ponto em comum do divisor de tensão é ligado a qualquer um pinos de sinal analógico do Arduino, sendo neste caso selecionado o pino A0. Agora á medida que a temperatura ambiente alterar, a tensão no pino A0 também irá variar entre 0 e 5V o que posteriormente traduzido pelo Arduino em valores de 0 a 1023, sendo estes utilizados para o cálculo da temperatura.

Caso tenham duvidas ou queiram saber mais sobre as características e configurações do LCD1602 ou o Sensor de temperatura NTC, vejam os seguintes tutoriais:

Arduino Tutorial - LCD - Temperature Sensor

https://www.instructables.com/id/Arduino-Tutorial-LCD-Temperature-Sensor/

Step 2: Código:

Com a montagem terminada, ligamos o cabo USB e vamos carregar o respectivo código no Arduino, mas iremos explicar as suas funções. Em primeiro lugar iremos importar todas as bibliotecas necessárias para a nossa montagem, que são as bibliotecas thermistor.h e a LiquidCrystal.h.

Para importar estas bibliotecas utilizamos o gestor de bibliotecas do Arduino IDE, as bibliotecas são facilitadores para a programação do nosso código, pois contêm comandos e funções criadas especificamente para determinados componentes.

A biblioteca thermistor.h permite-nos apenas com uma função configurar o sensor de temperatura com apenas uma função.

#include "thermistor.h"	//Importar a "thermistor" library

//Esta função define:
THERMISTOR SENSOR (Pino_Sensor, 10000, 3950, 10000);

	//Pino de entrada do sensor;
	//Resistência nominal a 25ºC do sensor;
	//Coeficiente beta do sensor;
	//Valor da resistência do sensor.

Agora para realizar a leitura do sensor de temperatura, utilizamos o comando sensor.read(), devolvendo o valor numérico relativo à temperatura em graus Celsius (ºC), no entanto, esse valor não tem casas decimais o que obriga a um pequeno cálculo. Para utilizar termos valores com casa decimais teremos de utilizar para os cálculos variáveis declaradas como float.

void loop(){
	//Leitura do sensor de temperatura.
	Valor_Temp = sensor.read();
	//Calculo do valor da temperatura com casas decimais.
	Valor_Temp= Valor_Temp/10;
}

Já a biblioteca LiquidCrystal.h também facilita muito a programação do LCD, sendo apenas necessário configurar 2 funções para que este fique a funcionar em pleno, o que caso contrario seria muitas mais.

//Definir os pinos de comunicação e informação do LCD:
LiquidCrystal lcd ("RS", "E", "D7", "D6", "D5", "D4");

e

void setup(){
	//Inicia a comunicação com LCD 16x2:
	lcd.begin(2, 16);
}

Para escrever no LCD será necessário primeiro definir o local onde se começará a escrever, ou seja, qual a coluna e a linha, só depois imprimimos o texto que queremos, tendo em atenção que este LCD apenas tem 16 colunas e 2 linhas, no caso do texto passar esses limites do LCD não serão visíveis todos caracteres.

void loop(){
	//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
	lcd.setCursor(0, 0);
	
	//Escreve no LCD:
	lcd.print("Temperatura:");
}

Agora só faltam as funções para o código relativas ao sensor de ultrasons HC-SR04, como explicado anteriormente este é ligado ao Arduino através dos seus pinos de sinal digital, no entanto um funciona como entrada TRIGGER e o outro como saída de sinal ECHO.

Para isto utilizamos a função PinMode, que tem como objectivo configurar os pinos de sinal digital como saídas ou entradas, bastando apenas colocar a palavra "OUTPUT" ficando assim o pino definido como saída, caso contrário se a palavra for "INPUT" o pino fica definido como entrada.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup(){

	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Pino_Trig, OUTPUT);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Pino_Echo, INPUT);
}

Depois quando o sensor realiza uma leitura existem 2 momentos distintos, o momento em que o sensor envia um sinal de ultrasons e o outro momento em que este recebe o eco desse mesmo sinal. No momento iniciamos a leitura colocando em nível alto o pino de entrada digital ligado ao pino TRIGGER pelo menos durante 10µS, é aconselhada a exista uma pequena pausa entre leituras assim o sinal deve ser colocado em nível baixo cerca de 5µS (Ver gráfico acima).

De seguida o sensor irá receber o eco contabilizando o tempo que este demora a percorrer até ao objecto e voltar. Depois no momento é enviado um sinal de pulso digital com exactamente o mesmo tempo que o sensor contabilizou nos ultrasons, sendo agora necessário realizar os cálculos para determinar a distância até ao objecto.

Para realizar os cálculos começamos por utilizar a função PulseIn, esta contabiliza o tempo em que um pino ECHO está em nível alto, agora termos de dividir esse tempo por 2, pois o sensor apenas consegue contabilizar o totalidade do tempo que os ultrasons demoram a percorrer do sensor até ao objecto e depois do objecto novamente até ao sensor, ou seja, apenas queremos a metade do tempo entre o sensor e o objecto (Ver cálculos acima).

//Correr a função LOOP repetidamente:
void loop(){

	//Processo de funcionamento do sensor de Ultrasons:
	
	//Pausa entre leituras.
	digitalWrite(Pino_Trig,LOW);	//Desligar a pulsação ultrasónica;
	delayMicroseconds(5);	//Pausa de 5 microsegundos para estabilização;
	
	//Início da leitura.
	digitalWrite(Pino_Trig, HIGH);	//Ligar a pulsação ultrasónica;
	delayMicroseconds(10);	//Pausa de 10 microsegundos para estabilização;
	
	//Contagem em microsegundos do Tempo entre o envio e a recepção do sinal enviado.
	Tempo = pulseIn(Pino_Echo, HIGH); 
	//Cálculo da conversão do Tempo de microsegundos para segundos.
	Tempo = Tempo / 1000000;

	//Cálculo do valor da distância medida.
	Valor_Distancia = Velocidade_Som / 2;
	Valor_Distancia = Valor_Distancia * Tempo;
}

Este é o código completo para esta montagem, onde são utilizados todos os conceitos descritos anteriormente, estando já inseridas a funcionalidade de alteração das unidades de medida, podendo estas serem alteradas através de um botão.

#include "thermistor.h"	//Importar a "thermistor" library.
#include <LiquidCrystal.h>	//Importar a LCD library.

//Definir os pinos de comunicação e informação do LCD.
LiquidCrystal lcd (5, 7, 9, 10, 11, 12);

int Pino_Sensor_Temp = A0;	//Variável para selecção do pino de entrada analógica.
float Valor_Temperatura = 0;	//Variável para o calculo da temperatura com números decimais.

//Definir o pino do sensor;
//Resistência nominal a 25ºC;
//Coeficiente beta do sensor;
//Valor da resistência do sensor.
THERMISTOR sensor(Pino_Sensor_Temp, 10000, 3950, 10000);

int Pino_Sensor_Trig = 3;	//Variável para selecção do pino Trigger do sensor.
int Pino_Sensor_Echo = 2;	//Variável para selecção do pino Echo do sensor.

float Velocidade_Som;	//Variável para o cálculo da velocidade do som.
float Tempo;	//Variável o cálculo do tempo de resposta do sensor.
float Valor_Distancia;	//Variável para o cálculo da distância.

int Botao_Menu = 13;	//Variável para selecção do pino digital (Botão Menu).
int Menu = 0;	//Variável para selecção da unidade de medida.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup(){  
	//Inicia a Comunicação com LCD 16x2:
	lcd.begin(2, 16);
  
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Pino_Sensor_Trig, OUTPUT);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Pino_Sensor_Echo, INPUT);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Botao_Menu, INPUT);
}

//Correr a função LOOP repetidamente:
void loop(){
	//Processo de funcionamento do sensor de Ultrasons:

	//Pausa entre leituras.
	digitalWrite(Pino_Sensor_Trig,LOW);	//Desligar a pulsação ultrasónica;
	delayMicroseconds(5);	//Pausa de 5 microsegundos para estabilização;

	//Início da leitura.
	digitalWrite(Pino_Sensor_Trig, HIGH);	//Ligar a pulsação ultrasónica;
	delayMicroseconds(10);	//Pausa de 10 microsegundos para estabilização;
	
	//Contagem em microsegundos do Tempo entre o envio e a recepção do sinal enviado.
	Tempo = pulseIn(Pino_Sensor_Echo, HIGH); 
	//Cálculo da conversão do Tempo de microsegundos para segundos.
	Tempo = Tempo / 1000000;
  
	//Leitura do sensor de temperatura.
	Valor_Temperatura = sensor.read();
	//Cálculo do valor da temperatura em Celsius.
	Valor_Temperatura = Valor_Temperatura/10;
  
	//Cálculo da conversão do valor da temperatura de Celsius em Kelvin.
	Valor_Temperatura = Valor_Temperatura + 273.15;
	//Calculo da Velocidade do Som relacionado com a Temperatura ambiente em m/seg:
	Velocidade_Som = Valor_Temperatura / 273.15;
	Velocidade_Som = sqrt(Velocidade_Som);
	Velocidade_Som = 331.45 * Velocidade_Som;
	
	//Condição para abrir página:
	if (Menu == 0){
		//Apaga a informação do LCD.
		lcd.clear();
  
		//Cálculo do valor da distância medida:
		Valor_Distancia = Velocidade_Som / 2;
		Valor_Distancia = Valor_Distancia * Tempo;
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: 
		lcd.setCursor(0, 0);
		//Escreve no LCD:
		lcd.print("Distancia: ");
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: 
		lcd.setCursor(0, 1);
		//Escreve no LCD:
		lcd.print(Valor_Distancia);
		lcd.print(" m");
		//Atraso para o próximo passo.
		delay(1000);
    
		//Condição para acção do Botão Menu:
		if (digitalRead(Botao_Menu) == HIGH){
			//Altera o valor de selecção do título do menu.
			Menu = Menu + 1;
		}
		//Condição para selecionar página:
		if (Menu > 2){
			//Altera o valor de selecção do título do menu.
			Menu = 0;
		} 
	}
  
	//Condição para abrir página:
	else if (Menu == 1){
		//Apaga a informação do LCD.
		lcd.clear();

		//Cálculo da conversão do valor da Velocidade do Som de m/seg em cm/seg.
		Velocidade_Som = Velocidade_Som * 100;
		//Cálculo do valor da distância medida:
		Valor_Distancia = Velocidade_Som / 2;
		Valor_Distancia = Valor_Distancia * Tempo;
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: 
		lcd.setCursor(0, 0);
		//Escreve no LCD:
		lcd.print("Distancia: ");
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: 
		lcd.setCursor(0, 1);
		//Escreve no LCD:
		lcd.print(Valor_Distancia);
		lcd.print(" cm");
		//Atraso para o próximo passo.
		delay(1000);
  
		//Condição para acção do Botão Menu:
		if (digitalRead(Botao_Menu) == HIGH){
			//Altera o valor de selecção do título do menu.
			Menu = Menu + 1;
		}
		//Condição para selecionar página:
		if (Menu > 2){
			//Altera o valor de selecção do título do menu.
			Menu = 0;
		} 
	} 
  
	//Condição para abrir página:
	else if (Menu == 2){
		//Apaga a informação do LCD.
		lcd.clear();
	
		//Cálculo da conversão do valor da Velocidade do Som de m/seg em in/seg.
		Velocidade_Som = Velocidade_Som * 39.37;

		//Cálculo do valor da distância medida:
		Valor_Distancia = Velocidade_Som / 2;
		Valor_Distancia = Valor_Distancia * Tempo;
		
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
		lcd.setCursor(0, 0);
		//Escreve no LCD:
		lcd.print("Distancia: ");
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: 
		lcd.setCursor(0, 1);
		//Escreve no LCD:
		lcd.print(Valor_Distancia);
		lcd.print(" in");
		//Atraso para o próximo passo.
		delay(1000);

		//Condição para acção do Botão Menu:
		if (digitalRead(Botao_Menu) == HIGH){
			//Altera o valor de selecção do título do menu.
			Menu = Menu + 1;
		}
		//Condição para selecionar página:
		if (Menu > 2){
			//Altera o valor de selecção do título do menu.
			Menu = 0;
		}
	}
}

Para saber mais ou caso tenham dúvidas sobre estas e outras referências no código, vejam a sua explicação detalhada no site oficial do Arduino, através da ligação https://www.arduino.cc/en/Reference/HomePage.


Procurem os nossos tutoriais acerca do Arduino, onde explicamos diversas montagens como também o funcionamento dos seus componentes e já agora visitem o nosso canal no Youtube, Instagram, Facebook ou Twitter.

Abraço e bons projectos.

Share

    Recommendations

    • Sensors Contest

      Sensors Contest
    • Fandom Contest

      Fandom Contest
    • Classroom Science Contest

      Classroom Science Contest

    2 Discussions

    0
    None
    Crazy Taz ProjectsQu3d45

    Reply 1 year ago

    Obrigado pelo comentário. Espero continuar a ajudar.

    Abraço e bons projectos.