Arduino Tutorial - Ultrasonic Sensor

Published

Introduction: 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ç&oti...

Bem vindos a mais um tutorial acerca do Arduino e os seus sensores, neste tutorial explicamos o funcionamento e características de um sensor de ultrasons tendo este varias aplicações em vários tipos de projectos como robótica ou instrumentação.

Assim, iremos explicar as funcionalidades deste sensor através de uma montagem que permite medir distâncias em linha recta, pois as suas função principal é detectar e quantificar a distância que existe entre este e um objecto que esteja à sua frente.

Este tipo de sensor determina a distância entre um objecto, através da contagem de tempo que o som emitido pelo sensor demora a percorrer até ao objecto. A frequência deste som emitido encontra-se no intervalo dos ultrasons, cerca de 40 KHz, garantindo uma direcção mais concentrada da onda sonora, pois um som com frequência alta, tende em dissipa-se menos no ambiente envolvente.

Um sensor ultrasons típico que determina distâncias, normalmente é constituído por 2 membranas, uma membrana que emite o som e outra que recebe o seu eco, ou seja, é um sensor constituído por uma coluna e um microfone. Durante este processo o sensor funciona também como uma espécie de cronometro de alta precisão, sendo possível saber-mos quanto tempo o sinal levou desde a sua emissão até o seu retorno (Ver imagem acima).

Esta distância é possível de calcular através de "D = (Vs x T) / 2" em que (Ver cálculos acima):

  • D = Distância;
  • Vs = Velocidade do som;
  • T = Tempo que o som demora a percorrer desde a sua emissão até à sua recepção.

No entanto, frequentemente a velocidade do som não é considerada como variável, sendo normalizada a 340m/s, assumindo que a temperatura do ar está a 20ºC e ao nível do mar, mas como esta montagem será de um instrumento de medida é desejável que esta seja o mais precisa possível. Assim, assumimos que a velocidade do som pode variar, consoante vários factores, sendo um deles a temperatura ambiente (ver cálculos acima).

Para eliminar o erro por variação de temperatura utilizamos um sensor, este sensor normalmente é constituído por uma resistência NTC (Negative Temperature Coefficient), que diminui a sua resistência eléctrica com o aumento de temperatura, ou então, uma PTC (Positive Temperature Coefficient), que aumenta a sua resistência eléctrica com o aumento de temperatura (Ver gráfico acima).

Para que seja possível cronometrar rigorosamente o tempo, entre o envio e a recepção do sinal acústico, é necessário activar o mecanismo de emissão desse sinal, o nosso gatilho, isto é possível através de um sinal digital inserido no pino designado por TRIGGER, seguidamente o sensor ao receber o sinal acústico reflectido coloca um sinal digital no pino ECHO, sendo assim possível calcular a distância do objecto através do tempo em que este sinal digital está em nível alto.

Por fim, utilizamos também um LCD 1602 (Liquid Crystal Display), que como a sua referencia indica tem 16 colunas e 2 linhas, o objectivo deste LCD é representar a distância que o sensor determina, podendo neste caso, ser representada em várias unidades de medidas, como m (metros), cm (centímetros) ou in (polegadas).

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

Step 1: Montagem

Nesta montagem utilizamos uma Breadboard onde colocamos os componentes e onde são distribuídas as suas alimentações positivas e negativas, os componentes são um pequeno botão de pressão, tendo este botão a função de alterar as unidades de medida (metros, centímetros ou polegadas), depois realizamos as ligações do nosso LCD 1602, o nosso sensor de ultrasons e por ultimo o sensor de temperatura (Ver montagem 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 Potenciómetro 10KΩ.

Instalação do LCD 1602:

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

Pinos de Alimentação:

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

As alimentações do LCD (Gnd e Vcc) são feitas através dos pinos Gnd e +5V do Arduino UNO, pois são estáveis e protegidas não permitindo que existam sobrecargas ou curto-circuitos.

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

Os pinos de alimentação do LED de luz de fundo do LCD (A e K) são também ligados aos pinos de Gnd e +5V do Arduino UNO, no entanto, ligamos em série uma resistência de 220Ω para que o brilho não seja demasiado intenso, não permitindo que os LED internos do LCD se danifiquem.

Pinos de Comunicação:

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

Nos pinos de comunicação apenas teremos de ter atenção ao pino R/W, pois este deve estar ligado a Gnd para que seja permitido escrever no LCD aparecendo assim o 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 utilizamos todos os pinos de alimentação e comunicação, no entanto, utilizamos apenas 4 dos 8 possíveis pinos de informação, pois podemos realizar esta montagem com metade dos pinos de dados. Isto é possível através da Biblioteca LiquidCrystal.h que colocamos no código, permitindo ler o Byte (Byte = 8 bits) de informação enviado pelo Arduino dividido em 2 partes, ou seja, 4 bits de cada vez.

Isto porque esta Biblioteca controla os pinos de comunicação, de forma a que o LCD saiba qual o tipo são e quais serão os pinos que receberão a informação (Pinos D4 a D7).

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

Agora com o LCD e as ligações mais complexas montadas, passamos para o nosso sensor de ultrasons, este tem 4 pinos, sendo 2 de alimentação e 2 de informação. A sua alimentação será fornecida pelo Arduino, pois sensor é alimentado a 5V DC. Os pinos de informação são ligados aos pinos digitais do Arduino, sendo digitais os sinais recebidos e emitidos pelo sensor (Ver imagem acima).

Como explicado anteriormente, o funcionamento deste sensor consiste em enviar um sinal acústico, que ao atingir um objecto é reflectido e assim detectado pelo receptor. Para o sensor contabilizar o tempo que esse sinal acústico demora a percorrer entre o objecto é necessário activar e sincronizar esse emissor de sinal acústico, para isso introduzimos sinal digital no pino TRIGGER do sensor de cerca com cerca de 10µ Seg, vindo neste caso do Arduino (Ver gráfico abaixo).

De seguida, o sensor envia o respectivo sinal acústico com uma frequência de 40K Hz, ao enviar este sinal o sensor activa o cronometro, começando deste modo a contabilizar o tempo até que o sinal reflectido num objecto seja recebido novamente pelo sensor. Cronometrado o tempo, o sensor coloca em nível alto um sinal digital no seu pino ECHO, com a particularidade que estará em nível alto o mesmo tempo que o cronometro entre a emissão e a recepção do sinal acústico (Ver gráfico acima).

Instalação do sensor de temperatura:

No entanto este sinal acústico pode alterar a sua velocidade dependendo de factores exteriores, como por exemplo a temperatura ou humidade do ar, alterando assim a sua precisão. Para eliminar um desses factores influenciadores, utilizamos na nossa montagem um sensor resistivo NTC (Negative Temperature Coefficient), ou seja, diminui a sua resistência à medida que a temperatura aumenta.

Para que o Arduino possa realizar a leitura do sensor de temperatura, temos de o montar num circuito divisor de tensão. Segundo o fabricante as especificações do fabricante a resistência deste sensor é de 10KΩ, logo teremos de colocar também uma resistência de 10KΩ no divisor de tensão (Ver imagem acima). Este divisor de tensão está ligado um dos pinos de entrada analógica do Arduino, neste caso o pino A0, assim à medida que a temperatura varia, a tensão nesse pino também altera entre 0 e 5V, sendo possível ao Arduino realizar a leitura.

Caso queiram saber mais sobre as entradas digitais e analógicas do Arduino, vejam os tutoriais "Arduino Tutorial - Analog Input - Resistive sensors - Monitor serial", ou sobre o LCD 16x2 e o sensor de Temperatura, vejam tutorial "Arduino Tutorial - LCD - Temperature Sensor".

Step 2: Código:

Com a montagem terminada, ligamos o cabo USB e carregamos o respectivo código na placa do Arduino. Como nesta montagem é utilizado um sensor de temperatura e um LCD 1602, começamos por importar as bibliotecas thermistor.h e a LiquidCrystal.h, através do gestor de bibliotecas do software do Arduino. Estas bibliotecas facilitam a programação, 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.

Para realizar a leitura do sensor de temperatura, utilizamos o comando "sensor.read()", devolvendo o valor relativo à temperatura em ºC, no entanto, esse valor não tem casas decimais o que obriga a um pequeno calculo. Não esquecer que para utilizar variáveis com casas decimais, estas variáveis terão de ser 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;
}

No caso da biblioteca LiquidCrystal.h também facilita a configuração do LCD, nesta biblioteca é apenas necessário 2 funções para que este funcione 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 é necessário definir o local onde se começará a escrever, ou seja, a coluna e a linha, depois imprimimos o texto que queremos tendo em atenção que este LCD apenas tem 16 colunas e 2 linhas, caso o texto passe esses limites não aparecerão os 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ó falta colocar o código para a leitura do sensor de UltrasonsHC-SR04, este sensor é ligado a 2 dos pinos digitais do Arduino, tendo cada um deles uma função distinta, funcionando um como saída e o outro 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);
}

Este sensor quando realiza uma leitura existem 2 momentos distintos, o momento em que o sensor envia um sinal acústico e outro momento que é quando este recebe o eco desse mesmo sinal. Para isso é necessário activar a activar a leitura, colocando em nível alto o pino de entrada digital Trigger, que tem de estar nessa condição pelo menos 10µ Segundos. É aconselhado que exista uma pequena pausa entre leituras para isso deve ser colocado 5µ Segundos em nível baixo (Ver gráfico acima).

De seguida, realiza-se a contagem de tempo e os seus respectivos cálculos, para isso utilizamos a função "PulseIn" que contabiliza o tempo em que um pino Echo está em nível alto. Depois como o tempo contabilizado pela função "PulseIn" é o tempo que o sinal acústico demora no percurso entre o sensor até ao objecto e o seu regresso o tempo será sensivelmente o dobro do desejado, ou seja, apenas nos interessa metade do percurso logo é necessário dividir esse tempo por 2 (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 a nossa montagem, onde são utilizados os conceitos descritos anteriormente e colocamos a funcionalidade de alteração das unidades de medida, podendo estas serem alteradas através de um pequenos botão e as funcionalidades das entradas digitais do nosso Arduino. Para isso vejam o tutorial "Arduino Tutorial - Digital Input - Button - Monitor Serial"

#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;
		}
	}
}

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


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

Abraço e bons projectos.

Share

    Recommendations

    • Creative Misuse Contest

      Creative Misuse Contest
    • Water Contest

      Water Contest
    • Oil Contest

      Oil Contest

    2 Discussions

    0
    user
    Qu3d45

    3 months ago

    Obrigado! Esta muito bom. Abraço!

    1 reply

    Obrigado pelo comentário. Espero continuar a ajudar.

    Abraço e bons projectos.