Guia do Sensor de distância ultrassônico JSN-SR04T à prova d’água com Arduino

O JSN-SR04T é um sensor de distância ultrassônico à prova d’água fácil de usar com um alcance de 25 a 450 cm. Se você está planejando construir um sistema de medição do nível de água ou se precisa fazer outras medições de distância no exterior, então este é o sensor de que você precisa!

Neste guia, incluí um diagrama de ligação e códigos de exemplo para que você possa começar a fazer experiências com seu sensor. Após cada exemplo, eu analiso e explico como o código funciona, então você não deve ter problemas para modificá-lo para atender às suas necessidades.

Primeiro, veremos um exemplo que não usa uma biblioteca Arduino. A seguir, abordarei a biblioteca NewPing fácil de usar que possui alguns recursos integrados interessantes.

Ao comprar este sensor, você pode encontrar a versão atualizada, o JSN-SR04T-2.0. Esta versão mais recente funciona exatamente da mesma forma, mas é classificada para 3-5 V em vez de 5 V. No entanto, alguns usuários encontraram problemas ao usar os sensores em uma tensão mais baixa. Usar um pulso de disparo mais longo de pelo menos 20 µs em vez de 10 µs parece ajudar se você estiver tendo leituras incorretas.

Sobre o sensor

O sensor vem com um cabo de 2,5 m de comprimento que se conecta a uma placa de breakout que controla o sensor e faz todo o processamento do sinal. Observe que apenas o sensor e o próprio cabo são à prova d’água. Se você derramar água na placa de fuga, o sensor pode parar de funcionar.

Um sensor ultrassônico de distância funciona enviando ondas ultrassônicas. Essas ondas de ultrassom são refletidas de volta por um objeto e o sensor ultrassônico as detecta. Ao cronometrar quanto tempo passou entre o envio e o recebimento das ondas sonoras, você pode calcular a distância entre o sensor e um objeto.

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

Onde Tempo é o tempo entre o envio e o recebimento das ondas sonoras em microssegundos.

Então, quais são as diferenças entre este sensor e o HC-SR04? A principal diferença, além de ser à prova d’água, é que esse sensor utiliza apenas um transdutor ultrassônico em vez de dois. Este transdutor atua como transmissor e receptor das ondas de ultrassom.

Para obter mais informações sobre como os sensores ultrassônicos funcionam, você pode verificar meu artigo sobre o HC-SR04. Neste artigo, os princípios de funcionamento de um sensor de distância ultrassônico são explicados com muito mais detalhes.

Especificações JSN-SR04T

Para mais informações, você pode verificar a ficha técnica aqui.

Conectando JSN-SR04T ao Arduino UNO

O diagrama de ligação/esquema abaixo mostra como conectar o sensor JSN-SR04T ao Arduino. A placa de circuitos do JSN-SR04T tem exatamente a mesma pinagem do HC-SR04, portanto, pode ser usada como um substituto drop-in. O cabo do próprio sensor pode ser conectado ao conector na parte de trás da placa circuitos.

Os exemplos de código abaixo usam os pinos digitais 2 e 3 para o gatilho e o pino de eco, mas é claro que você pode alterar isso para qualquer pino digital que desejar.

Conexões JSN-SR04T

Exemplo de código para sensor JSN-SR04T com Arduino

Agora que você conectou o sensor, é hora de conectar o Arduino ao computador e carregar algum código. O sensor pode ser usado sem uma biblioteca Arduino. Posteriormente, mostrarei um exemplo com a biblioteca NewPing, que torna o código muito mais curto.

Você pode fazer o upload do seguinte código de exemplo para seu Arduino usando o IDE do Arduino. A seguir, explicarei como o código funciona. Este código também funciona para JSN-SR04T-2.0.

Você pode copiar o código clicando no botão no canto superior direito do campo do código.

/* Sketch de exemplo do Arduino para controlar um sensor de distância ultrassônico JSN-SR04T com o Arduino. Nenhuma biblioteca necessária. */
// Defina o Trig e o pino de eco:
#define trigPin 2
#define echoPin 3
// Defina as variáveis:
long duration;
int distance;
void setup() {
  // Definir entradas e saídas
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  
  // Comece a comunicação serial a uma taxa de transmissão de 9600:
  Serial.begin(9600);
}
void loop() {
  // Limpe o trigPin configurando-o como LOW:
  digitalWrite(trigPin, LOW);
  
  delayMicroseconds(5);
  // Acione o sensor definindo o trigPin alto por 10 microssegundos:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Leia o echoPin. pulseIn() retorna a duração (comprimento do pulso) em microssegundos:
  duration = pulseIn(echoPin, HIGH);
  
  // Calcule a distância:
  distance = duration*0.034/2;
  
  // Imprima a distância no Monitor Serial (Ctrl + Shift + M):
  Serial.print("Distancia = ");
  Serial.print(distance);
  Serial.println(" cm");
  
  delay(100);
}

Você deve ver a seguinte saída no monitor serial:

Como funciona o código

Primeiro, o pino de disparo e o pino de eco são definidos. Eu os chamo de trigPin e EchoPin. O pino de disparo é conectado ao pino digital 2 e o pino de eco 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. Portanto, sempre que você mencionar trigPin, o compilador o substituirá pelo valor 2 quando o programa for compilado.

#define trigPin 2
#define echoPin 3

A seguir, defini duas variáveis: duração e distância. Duração armazena o tempo entre o envio e o recebimento das ondas sonoras. A variável de distância é usada para armazenar a distância calculada.

long duration;
int distance;

Em setup(), você começa definindo trigPin como saída e echoPin como entrada. Em seguida, você inicializa a comunicação serial a uma taxa de transmissão de 9600. Posteriormente, você exibirá a distância medida no monitor serial, que pode ser acessado com Ctrl + Shift + M ou Ferramentas> Monitor Serial. Certifique-se de que a taxa de transmissão também esteja definida como 9600 no monitor serial.

void setup() {
  // Definir entradas e saídas
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  
  // Comece a comunicação serial a uma taxa de transmissão de 9600:
  Serial.begin(9600);
}

No loop(), você aciona o sensor definindo trigPin HIGH para 20 µs. Observe que, para obter um sinal limpo, você começa limpando o trigPin definindo-o como LOW por 5 microssegundos.

void loop() {
  // Limpe o trigPin configurando-o como LOW:
  digitalWrite(trigPin, LOW);
  
  delayMicroseconds(5);
  // Acione o sensor definindo o trigPin alto por 10 microssegundos:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

Em seguida, você precisa ler a duração do pulso enviado pelo echoPin. Eu uso a função pulseIn() para isso. Esta função espera que o pino vá de BAIXO para ALTO, começa a cronometrar, depois espera que o pino vá para BAIXO e para de cronometrar.

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

// Leia o echoPin. pulseIn () retorna a duração (comprimento do pulso) em microssegundos:
duration = pulseIn(echoPin, HIGH);

// Calcule a distância:
distance = duration*0.034/2;

Por fim, imprima a distância calculada no monitor serial.

  // Imprima a distância no Monitor Serial (Ctrl + Shift + M):
  Serial.print("Distancia = ");
  Serial.print(distance);
  Serial.println(" cm");
  
  delay(100);
}

Exemplo de código JSN-SR04T com Arduino e biblioteca NewPing

A biblioteca NewPing escrita por Tim Eckel pode ser usada com muitos sensores ultrassônicos de distância. A versão mais recente desta biblioteca pode ser baixada aqui em bitbucket.org. Você pode notar que o código abaixo, que usa a biblioteca NewPing, é muito mais curto do que o código que usamos antes.

Download da Library NewPing (Aqui)

Você pode instalar a biblioteca acessando Sketch> Incluir Biblioteca> Adicionar Biblioteca .ZIP no IDE do Arduino.

A biblioteca inclui alguns exemplos que você pode usar, mas terá que modificá-los para corresponder à configuração do seu hardware. Incluí um código de exemplo modificado abaixo que pode ser usado com a mesma configuração de ligação de antes.

/* Sketch de exemplo do Arduino para controlar um sensor de distância ultrassônico JSN-SR04T com a biblioteca NewPing e Arduino. */
// Incluir a biblioteca:
#include <NewPing.h>
// Defina o Trig e o pino de eco:
#define trigPin 2
#define echoPin 3
// Defina a distância máxima para a qual queremos fazer o ping (em centímetros). A distância máxima do sensor é avaliada em 400-500 cm:
#define MAX_DISTANCE 400
// Configuração de NewPing de pinos e distância máxima.
NewPing sonar = NewPing(trigPin, echoPin, MAX_DISTANCE);
void setup() {
  // Abra o Monitor Serial a 9600 baudrate para ver os resultados do ping:
  Serial.begin(9600);
}
void loop() {
  // Aguarde 50ms entre os pings (cerca de 20 pings / seg). 29 ms deve ser o menor atraso entre os pings:
  delay(50); 
  
  // Meça a distância e imprima no Monitor Serial:
  Serial.print("Distancia = ");
 // Enviar ping, obter a distância em cm e imprimir o resultado (0 = fora da faixa de distância definida):
  Serial.print(sonar.ping_cm()); 
  Serial.println(" cm");
}

Conclusão

Neste guia, mostrei como usar um Sensor de distância ultrassônico JSN-SR04T com o Arduino. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônica e de fazer coisas!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com esse sensor JSN-SR04T. Se você tiver alguma dúvida, sugestão ou se achar que falta algo neste tutorial, por favor, deixe um comentário abaixo.