Construindo um Radar com Sensor Ultrassônico

Olá, tudo bem? No post hoje vamos estar construindo um super radar com sensor ultrassônico igual aqueles que aparecem nos filmes. Para isso vamos utilizar um sensor ultrassônico, um servo motor e um software chamando de Processing.

Vamos buscar controlar o movimento do servo para poder simular aquela movimentação que um radar realiza e representar tudo isso graficamente utilizando o Processing.

Para isso, você precisa estar bem familiarizado com os componentes do nosso projeto de hoje. Sendo assim, aconselho você que antes de iniciar este projeto, passar para dar uma olhada nos seguintes post:

• Aprenda a utilizar o Sensor de Distância Ultrassônico HC-SR04 com Arduino;
• Aprenda a utilizar servo motor com Arduino.

Mas se você já leu cada um dos post que eu coloquei maravilha, então bora montar esse super radar!

Construindo radar com Sensor Ultrassônico: Conhecendo o projeto 

Como já disse, o nosso projeto de hoje vai se basear no modelos famosos de radares que normalmente aparecem nos filmes que você já assistiu. Ele é muito parecido com a imagem abaixo, mas para isso acontecer, precisamos conhecer a ferramenta que utilizaremos para criar esse efeito com o nosso Arduino.

Fonte: Ritchie

Que ferramenta é essa?

Eu estou falando do Processing, que basicamente segue a mesma filosofia do software do Arduino, entretanto, essa ferramenta trabalha com artes visuais, ou seja, você pode escolher entre ver um led piscar na sua protoboard ou na tela do seu computador. Que louco não? Dessa forma, tudo aquilo que você vê em sua protoboard ou em seu display LCD, você pode colocar na tela do seu computador utilizando o processing.

Sabe o que é melhor? Ela é um software aberto, ou seja, basta apenas baixar instalar e pronto! Você já pode sair fazendo muitas animações utilizando o  Arduino. Para isso, basta realizar o download dessa ferramenta através do processing.org, depois basta apenas descompactar o arquivo e abri-lo, simples assim!

Materiais utilizados

• 1x Ardunio UNO
• 1x Sensor Ultrassônico HC-SR04
• 1x Servo Motor SG90
• 1x Protoboard
• Alguns Jumpers

Montagem do Circuito

Fonte: AutoCore Robótica

Código do Projeto Comentado

No projeto de hoje, vamos precisar programar nos dois programas: Arduino e Processing. Isso porque, no Arduino vamos programar o giro do servo motor e também fazer o sensor ultrassônico retornar a distância do objeto que ele está detectando.

Código no Arduino

Dessa forma, segue abaixo o código que iremos utilizar no projeto de hoje, ele está bem comentado para que você entenda detalhadamente cada parte de todo o código beleza? Então basta colar o código na IDE do Arduino e realizar o upload.

//////////////////////////////////////////////////////////////////////////
//            ------ AutoCore Robótica -------         
//               Projeto: Radar com HC-SR04            
//               Autor: Danilo Nogueira                
//               Data: 20/08/2018                      
/////////////////////////////////////////////////////////////////////////

#include <Servo.h>.

  // Aqui vamos definir o pino de Echo e Trigger do HC-SR04
  const int trig_Pino = 10;
  const int echo_Pino = 11;

  // Vamos criar duas variáveis para calcular a distancia do objeto
  long tempo;
  int distancia;

  // Aqui criamos um objeto chamado 'Radar_Servo' o qual vamos controlar
  Servo Radar_Servo;

void setup() {
  
  // Vamos começar definindo o trigger como saída
  // e o Echo como entrada, além de iniciar a serial e o servo
  pinMode(trig_Pino, OUTPUT);
  pinMode(echo_Pino, INPUT);

  Serial.begin(9600);
  Radar_Servo.attach(12); // Aqui eu defino em qual pino o servo está conectado
}

void loop() {
  
  // Aqui estamos fazendo um for para o servo girar de 15° até 165°
    for(int i = 0; i <= 180; i++){
    Radar_Servo.write(i);
    delay(30);
    
    // Nessa parte, enquanto o servo gira, o sensor verifica
    // Se tem algum objeto e qual a distancia
    // Chamando a função 'CalculandoDistancia()'
    distancia = calculandoDistancia();
   
    Serial.print(i);        // Mostra na serial qual o angulo de giro o servo está naquele momento
    Serial.print(",");      // Aqui vamos separar o angulo da distancia calculada com uma vírgula
    Serial.print(distancia); // Mostra a distancia que o sensor está calculando
    Serial.print(".");      // Coloca um '.' depois da distancia para indexar no processing a distancia
    }

    // Os mesmos passos que fizemos para ele ir de 15° --> 165°
    // Vamos utilizar para ele voltar de 165° --> 15°
    for(int i = 180; i > 0 ; i--){
    Radar_Servo.write(i);
    delay(30);
    
    // Nessa parte, enquanto o servo gira, o sensor verifica
    // Se tem algum objeto e qual a distancia
    // Chamando a função 'CalculandoDistancia()'
    distancia = calculandoDistancia();
    
    Serial.print(i);
    Serial.print(",");
    Serial.print(distancia);
    Serial.print(".");
  }
}

    // Aqui vamos criar a função que utilizamos ali em cima
    // Para poder calcular a distancia sabe?
    int calculandoDistancia(){
 
    digitalWrite(trig_Pino, LOW);  // Aqui vou desligar o trigger para poder realizar os pulsos
    delayMicroseconds(2);

    // Aqui é onde um ligo o trigger por 10 ms
    // Que é o tempo para calcular a distancia
    digitalWrite(trig_Pino, HIGH);
    delayMicroseconds(10);
    digitalWrite(trig_Pino, LOW);
    
    tempo = pulseIn(echo_Pino, HIGH);  // Aqui setamos o Echo para capitar o pulso ultrassonico e voltar o tempo que ele demorou
    
    distancia = tempo*0.034/2;  // Por fim, esta é a fórmula que utilizamos para converter o tempo na distancia do objeto até o sensor
    return distancia;
}

Código no Processing

Agora que já fez o upload em seu Arduino, você precisa fazer o upload também no Processing, mas porque? Isso acontece pois o processing irá pegar o código que você realizou o upload e transformar esse movimento do servo motor que você programou no Arduino em algo visual, no nosso caso, será o super radar! Então basta abrir o processing e realizar o upload do código a seguir:

////////////////////////////////////////////////////////////////////////////
//            ------ AutoCore Robótica -------         
//               Projeto: Radar com HC-SR04            
//               Autor: Danilo Nogueira                
//               Data: 20/08/2018                      
///////////////////////////////////////////////////////////////////////////
// Aqui vou apenas explicar os principais comandos do programa a seguir
// Mas prometo fazer posts explicando cada comando utilizando aqui combinado?

import processing.serial.*;       // Importa as bibliotecas para comunicação de Serie
import java.awt.event.KeyEvent;   // Importa as bibliotecas para ler a informação da entrada de serie
import java.io.IOException;
Serial Porta_serial;             // Define o objeto Serial

// Definindo as variáveis
String angulo="";
String distancia="";
String dados="";
String noObject;

float pixsDistancia;
int iAngulo, iDistancia;

int index1=0;
int index2=0;

PFont orcFont;    // Variavel para configurar a fonte do radar

void setup() {
 
size (1355, 725); // Aqui é onde você coloca a resolução da sua tela
smooth();

// Aqui tem um detalhe importante:
// onde tem 'Serial.list()[0]', caso dê algum erro
// troque isso pela porta que se Arduino está tipo "COM3" ok?

Porta_serial = new Serial(this,Serial.list()[0], 9600);   // Começa a comunicação Serie
Porta_serial.bufferUntil('.');                             // Lê o Serial Monitor até ao ponto final (lembra do ponto que falamos no cód do Arduino?

orcFont = loadFont("ArialMT-48.vlw");   // Fonte utilizada no radar
}

void draw() {

// Desenha os efeitos do radar
fill(98,245,31);        //Aqui você coloca a cor (no caso é verde)
textFont(orcFont);

// Simula o movimento das linhas
noStroke();
fill(0,4);
rect(0, 0, width, height-height*0.065);
 
fill(98,245,31);


// Chama as funções Radar, line, Object, Text
// Aqui é onde a mágica acontece
drawRadar();
drawLine();
drawObject();
drawText();
}

// Aqui vamos começar a ler a serial do Arduino
void serialEvent (Serial Porta_serial) {

//Lê a informação de Serie até ao caracter '.', esta informação é atribuida a uma string chamada "dados".
dados = Porta_serial.readStringUntil('.');
dados = dados.substring(0,dados.length()-1);
 
index1 = dados.indexOf(","); //
angulo= dados.substring(0, index1);
distancia= dados.substring(index1+1, dados.length());
 
// Converte as variaveis string em Integer
iAngulo = int(angulo);
iDistancia = int(distancia);
}
void drawRadar() {

  pushMatrix();
translate(width/2,height-height*0.074); // Move as coordenadas iniciais para outro local
noFill();
strokeWeight(2);
stroke(98,245,31);

// Desenha os semicirculos
  arc(0,0,(width-width*0.0625),(width-width*0.0625),PI,TWO_PI);
  arc(0,0,(width-width*0.27),(width-width*0.27),PI,TWO_PI);
  arc(0,0,(width-width*0.479),(width-width*0.479),PI,TWO_PI);
  arc(0,0,(width-width*0.687),(width-width*0.687),PI,TWO_PI);

// Desenha as linhas dos angulos
  line(-width/2,0,width/2,0);
  line(0,0,(-width/2)*cos(radians(30)),(-width/2)*sin(radians(30)));
  line(0,0,(-width/2)*cos(radians(60)),(-width/2)*sin(radians(60)));
  line(0,0,(-width/2)*cos(radians(90)),(-width/2)*sin(radians(90)));
  line(0,0,(-width/2)*cos(radians(120)),(-width/2)*sin(radians(120)));
  line(0,0,(-width/2)*cos(radians(150)),(-width/2)*sin(radians(150)));
  line((-width/2)*cos(radians(30)),0,width/2,0);
popMatrix();
}

void drawObject() {
pushMatrix();
translate(width/2,height-height*0.074); // Move as coordenadas iniciais para outro local
strokeWeight(9);
stroke(255,10,10);  // Caso algum objeto seja identificado desenha retangulos vermelhos

pixsDistancia = iDistancia*((height-height*0.1666)*0.025); // cobre a distancia entre o sensor e o objeto

// limite de faixa 40 cm, ou seja, se o objeto estiver a menos de 40 cm, ele aparece na tela.
if(iDistancia<40){

  // Desenha o objeto de acordo com a distancia e o angulo
line(pixsDistancia*cos(radians(iAngulo)),-pixsDistancia*sin(radians(iAngulo)),(width-width*0.505)*cos(radians(iAngulo)),-(width-width*0.505)*sin(radians(iAngulo)));
}
popMatrix();
}


void drawLine() {
pushMatrix();
strokeWeight(9);
stroke(30,250,60);

translate(width/2,height-height*0.074); // Move as coordenadas iniciais para outro local
line(0,0,(height-height*0.12)*cos(radians(iAngulo)),-(height-height*0.12)*sin(radians(iAngulo))); // Desenha a linha de acordo com o angulo
popMatrix();
}

// Aqui vamos criar os textos que aparecem na tela
void drawText() {
 
pushMatrix();
if(iDistancia>40) {
noObject = "Nenhum objeto no Radar";
}
else {
noObject = "Objeto Detectado!";
}
fill(0,0,0);
noStroke();
rect(0, height-height*0.0648, width, height);
fill(98,245,31);
textSize(25);
 
text("10cm",width-width*0.3854,height-height*0.0833);
text("20cm",width-width*0.281,height-height*0.0833);
text("30cm",width-width*0.177,height-height*0.0833);
text("40cm",width-width*0.0729,height-height*0.0833);

textSize(40);
text("Objeto: " + noObject, width-width*0.960, height-height*0.0277);
text("Ângulo: " + iAngulo +" °", width-width*0.48, height-height*0.0277);
text("Distancia: ", width-width*0.30, height-height*0.0277);
if(iDistancia<40) {
text("          " + iDistancia +" cm", width-width*0.225, height-height*0.0277);
}
textSize(25);


fill(98,245,60);
translate((width-width*0.4994)+width/2*cos(radians(30)),(height-height*0.0907)-width/2*sin(radians(30)));
rotate(-radians(-60));
text("30°",0,0);
resetMatrix();

translate((width-width*0.503)+width/2*cos(radians(60)),(height-height*0.0888)-width/2*sin(radians(60)));
rotate(-radians(-30));
text("60°",0,0);
resetMatrix();

translate((width-width*0.507)+width/2*cos(radians(90)),(height-height*0.0833)-width/2*sin(radians(90)));
rotate(radians(0));
text("90°",0,0);
resetMatrix();

translate(width-width*0.513+width/2*cos(radians(120)),(height-height*0.07129)-width/2*sin(radians(120)));
rotate(radians(-30));
text("120°",0,0);
resetMatrix();

translate((width-width*0.5104)+width/2*cos(radians(150)),(height-height*0.0574)-width/2*sin(radians(150)));
rotate(radians(-60));
text("150°",0,0);
popMatrix();
}

Conclusão

Por fim, após de realizar o upload do código no processing, deve abrir uma tela como essa:

Fonte: AutoCore Robótica

Ao abri-la basta agora colocar o seu sensor em cima do servo motor (crie um suporte para isso) e basta agora testar o seu radar colocando coisas na frente do sensor ultrassônico e verificando na tela do radar se mostra alguma mancha vermelha. Mas para ilustrar melhor o resultado do projeto, deixo logo abaixo o vídeo do nosso canal da AutoCore que mostra o funcionamento do projeto!

Mas eai? Gostou? Espero que tenha dado tudo certo, mas caso tenha ficado alguma dúvida ou ocorrido algum problema com você, comente abaixo 📝 que irei te responder rapidão, pode confiar!

Dicas? 😯 Dúvidas? 🤔 Idéias de post?💭 Críticas? 😱 Só comentar ok? 😉

Forte abraço!