Projetos II: junho 2025

P11 - Radar Ultrassônico ARDUINO: ISABELLA FERNANDA STEFANUTO, RAFAELA LIMA MORAES, YASMIN DE SOUZA, PALOMA ARAÚJO OLIVEIRA e THAINARA NASCIMENTO DOS SANTOS

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 a figura ao lado.

O datasheet da placa Arduino UNO R3 está disponível em: Manual Arduino® UNO R3.

Micro Servo Motor SG90

O Micro Servo Motor SG90 9g é um item essencial para este e outros projetos de robótica, mecatrônica e diversos outros projetos. Na robótica, o servo motor é responsável por movimentar braços, pernas e mãos dos robôs. No automodelismo o servo motor é utilizado para virar as rodas dianteiras dos carrinhos e no aeromodelismo é utilizado para controlar os flaps das asas dos aviões.

O manual do Micro Servo Motor 9g SG90 está disponível em: Micro Servo Motor 9g SG90 .

Software Processing

O Processing, além de software, é uma linguagem de programação de código aberto, assim como o Arduino, ele é utilzado para mostrar informações do Arduino na tela do computador. Faça o download do Processing diretamente do site oficial do programa, no endereço: Processing .

Se essa é sua primeira vez utilizando o Processing recomendo a leitura do post “Integrando Processing e Arduino – Criando Interface no Processing“, de Mauricio Gavina do blog da MakerHero.

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 Base Mini Radar Staction;

1 x Tela TFT 7'';

1x Fonte 5V;

20 x Parafusos e porcas M3;

1 x Protoboard 400 Pontos;

4 x Cabos Jumper Macho-Fêmea;

4 x Cabos Jumper Macho-Macho;

Esquemático Eletrônico

Na figura acima está o esquema de ligação dos componentes: Esquema de ligação do Arduino Nano com o Sensor Ultrassônico fixo no Servo Motor 9G montado por Sandro Mesquita.

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
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();
}

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.
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 acima: Código do radar ultrassônico no processing

Funcionamento:

O servo varre 15° a 165°;
Em cada posição, o HC-SR04 mede a distância;
Os dados (ângulo + distância) são enviados via serial;
A linha de varredura é desenhada em verde;
Os objetos são desenhados em linha vermelha, a partir do ponto de detecção;
O Processing visualiza os objetos em tempo real;

Limitações:

Alcance máximo: ~4m (HC-SR04);
Ângulo de detecção: 15° (sensor);
Precisão reduzida em superfícies irregulares;

Resultado Final

Este projeto é ideal para demonstrar princípios de sensoriamento, processamento de dados e visualização. Para aplicações profissionais, considere sensores LIDAR ou radares de alta frequência.

O resultado final do projeto Radar Ultrassônico com Arduino e Processing deve ficar semelhante ao apresentando acima.

Referência: Radar Ultrassônico com Arduino e Processing - Sandro Mesquita - MakerHero® .

Projetos II

segunda-feira, 30 de junho de 2025

2EL - B - Projeto 11 - Radar Ultrassônico controlado através Arduino e o software Processing