Radar Ultrassônico com Arduino e Processing 1

Neste projeto você vai aprender a construir um radar ultrassônico utilizando a placa de desenvolvimento Arduino e o software Processing.  Iremos usar o nosso conhecimento de programação com o sensor ultrassônico no Arduino (para mais informações, acesse o post “Como conectar o Sensor Ultrassônico ao Arduino“) e substituir a sua leitura da tela no monitor serial pela leitura gráfica, parecida com as usadas na aviação.

Dessa forma, iremos identificar o ângulo e distância que o objeto está de nossa máquina (robô, drone, carro, braço robótico).

Para o projeto, iremos utilizar um sensor ultrassônico fixo em um servo motor. Eles serão responsáveis por realizar uma varredura do ambiente em busca de obstáculos. Os dois componentes serão conectados ao Arduino, o qual coordena o movimento do servo, realiza a leitura do sensor e envia o resultado para o Processing. No Processing será gerado um gráfico como o abaixo:

O Processing, além de software, é uma linguagem de programação de código aberto, assim como o Arduino. Se essa é sua primeira vez utilizando o Processing recomendo a leitura do post “Integrando Processing e Arduino – Criando Interface no Processing“.

Materiais Necessários

Abaixo está a lista com os materiais necessários para o projeto:

• 1 x Arduino Nano (ou outro similar)
• 1 x Cabo USB
• 1 x Micro Servo Motor 9G
• 1 x Sensor Ultrassônico HC-SR04
• 1 x Protoboard 400 Pontos
• 4 x Cabos Jumper Macho-Fêmea
• 4 x Cabos Jumper Macho-Macho

Esquemático Eletrônico

Abaixo segue o esquema de ligação dos componentes:

O jumper de sinal do servo (amarelo) deve ser conectado ao pino 12 do Arduino. O pinos ECHO e TRIG do sensor ultrassônico devem ser conectados nos 10 e 11 do Arduino, respectivamente. Tanto o servo motor quanto o sensor ultrassônico devem ser alimentados com 5 V, como pode ser visto na imagem acima.

Código do Radar Ultrassônico na IDE Arduino

Para testar o funcionamento do circuito, vamos utilizar o código abaixo. Ele é responsável por movimentar o servo motor entre 15º e 165º e calcular a distância entre o sensor ultrassônico e o objeto.

#include <Servo.h>. 

const int trigPin = 11;
const int echoPin = 10;

long tempo;
int distancia;

Servo servo; 

void setup() {
  
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 
  Serial.begin(9600);
  servo.attach(12);

}

void loop() {
  
  for(int i=15;i<=165;i++){  
  servo.write(i);
  delay(30);
  distancia = calculoDistancia();
  Serial.print(i); 
  Serial.print(","); 
  Serial.print(distancia); 
  Serial.print("."); 
  }
  
  for(int i=165;i>15;i--){  
  servo.write(i);
  delay(30);
  distancia = calculoDistancia();
  Serial.print(i);
  Serial.print(",");
  Serial.print(distancia);
  Serial.print(".");
  }

}

int calculoDistancia(){ 
  
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH); 
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  tempo = pulseIn(echoPin, HIGH); 
  distancia= tempo*0.034/2;
  return distancia;

}

Após carregar o código para a placa, abra o Monitor Serial e selecione a velocidade de 9600. Você verá algo assim:

Como você pode ver acima, a visualização no Monitor Serial não é muito intuitiva. É importante lembrar que nosso objetivo não é ler a distância na Arduino IDE mas sim imprimir um gráfico no Processing. Por esse motivo, a saída deve ser como visto acima, para a correta interpretação pelo Processing.

Código do Radar Ultrassônico no Processing

Abaixo está o código completo do Radar Ultrassônico com Arduino e Processing:

import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;

Serial myPort; 

String angle="";
String distance="";
String data="";
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1=0;
int index2=0;
PFont orcFont;

void setup() {

  size (1366, 700);
  smooth();
  myPort = new Serial(this, "COM11", 9600);
  myPort.bufferUntil('.');
}

void draw() {

  fill(98, 245, 31);

  noStroke();
  fill(0, 4);
  rect(0, 0, width, 1010); 

  fill(98, 245, 31); // yeþil renk

  drawRadar(); 
  drawLine();
  drawObject();
  drawText();
}

void serialEvent (Serial myPort) { 

  data = myPort.readStringUntil('.');
  data = data.substring(0, data.length()-1);

  index1 = data.indexOf(",");
  angle= data.substring(0, index1);
  distance= data.substring(index1+1, data.length()); 

  iAngle = int(angle);
  iDistance = int(distance);
}

void drawRadar() {
  pushMatrix();
  translate(683, 700);
  noFill();
  strokeWeight(2);
  stroke(98, 245, 31);
  // draws the arc lines
  arc(0, 0, 1300, 1300, PI, TWO_PI);
  arc(0, 0, 1000, 1000, PI, TWO_PI);
  arc(0, 0, 700, 700, PI, TWO_PI);
  arc(0, 0, 400, 400, PI, TWO_PI);
  // draws the angle lines
  line(-700, 0, 700, 0);
  line(0, 0, -700*cos(radians(30)), -700*sin(radians(30)));
  line(0, 0, -700*cos(radians(60)), -700*sin(radians(60)));
  line(0, 0, -700*cos(radians(90)), -700*sin(radians(90)));
  line(0, 0, -700*cos(radians(120)), -700*sin(radians(120)));
  line(0, 0, -700*cos(radians(150)), -700*sin(radians(150)));
  line(-700*cos(radians(30)), 0, 700, 0);
  popMatrix();
}

void drawObject() {
  pushMatrix();
  translate(683, 700);
  strokeWeight(9);
  stroke(255, 10, 10); // kýrmýzý renk
  pixsDistance = iDistance*22.5; 
  // 40 cm ye kadar ölçer
  if (iDistance<40) {

    line(pixsDistance*cos(radians(iAngle)), -pixsDistance*sin(radians(iAngle)), 700*cos(radians(iAngle)), -700*sin(radians(iAngle)));
  }
  popMatrix();
}

void drawLine() {
  pushMatrix();
  strokeWeight(9);
  stroke(30, 250, 60);
  translate(683, 700);
  line(0, 0, 700*cos(radians(iAngle)), -700*sin(radians(iAngle)));
  popMatrix();
}

void drawText() { 

  pushMatrix();
  if (iDistance>40) {
    noObject = "Out of Range";
  } else {
    noObject = "In Range";
  }
  fill(0, 0, 0);
  noStroke();
  rect(0, 1010, width, 1080);
  fill(98, 245, 31);
  textSize(25);
  text("10cm", 800, 690);
  text("20cm", 950, 690);
  text("30cm", 1100, 690);
  text("40cm", 1250, 690);
  textSize(40);
  text("Object: " + noObject, 240, 1050);
  text("Angle: " + iAngle +" °", 1050, 1050);
  text("Distance: ", 1380, 1050);
  if (iDistance<40) {
    text("        " + iDistance +" cm", 1400, 1050);
  }
  textSize(25);
  fill(98, 245, 60);
  translate(390+960*cos(radians(30)), 780-960*sin(radians(30)));
  rotate(-radians(-60));
  text("30°", 0, 0);
  resetMatrix();
  translate(490+960*cos(radians(60)), 920-960*sin(radians(60)));
  rotate(-radians(-30));
  text("60°", 0, 0);
  resetMatrix();
  translate(630+960*cos(radians(90)), 990-960*sin(radians(90)));
  rotate(radians(0));
  text("90°", 0, 0);
  resetMatrix();
  translate(760+960*cos(radians(120)), 1000-960*sin(radians(120)));
  rotate(radians(-38));
  text("120°", 0, 0);
  resetMatrix();
  translate(840+900*cos(radians(150)), 920-960*sin(radians(150)));
  rotate(radians(-60));
  text("150°", 0, 0);
  popMatrix();
}

Se preferir, você pode fazer o download do código “Radar com sensor ultrassônico” no GitHub.

Conectando a IDE Processing com a IDE Arduino

Agora precisamos comunicar o Arduino com o programa no Processing que acabamos de desenvolver. Abaixo estão algumas passos desse processo:

1. Na Arduino IDE, verifique qual porta “COM” o Arduino está conectado. Para isso, com o Arduino conectado ao computador, vá em Ferramentas > Porta.

2. Na IDE do Processing, altere a linha abaixo para a porta “COM” que o Arduino está conectado.

myPort = new Serial(this, "COM11", 9600);

3. Certifique que a tela do Monitor Serial está fechada.

4. Na IDE do Processing click no botão “PLAY” conforme figura abaixo.

Resultado Final

O resultado final do projeto Radar Ultrassônico com Arduino e Processing deve ficar semelhante ao apresentando no vídeo abaixo:

Gostou de aprender a construir um Radar Ultrassônico com Arduino e Processing? Deixe um comentário abaixo dizendo que achou.