Kit Iniciante | Radar

Radar Ultrassônico com Servo

Projeto: varredura com servo + sensor ultrassônico + visualização em Processing (radar 2D)

View this post on Instagram

A post shared by RoboCore Tecnologia (@robocore)

Resumo

Este tutorial mostra como montar um radar simples usando um servo, um sensor ultrassônico (HC-SR04 ou similar) e um Arduino. Os dados são enviados via serial para o Processing, que desenha o radar em uma janela gráfica.

Materiais utilizados do Kit Iniciante

1x BlackBoard UNO
1x Servo Motor(SG90)
1x Sensor Ultrassônico
Cabos jumpers
Protoboard
Pc com Processing instalado

Monstagem do Projeto

Instalação do Processing

Baixe o Processing em processing.org/download.
Extraia o arquivo ZIP e abra o executável.

Montagem do Circuito

Monte o circuito no protoboard conectando o servo motor no pino digital escolhido, o sensor ultrassônico nos pinos de trig/echo e a alimentação nos pinos 5V e GND do Arduino.

Servo: Sinal → pino digital 9, VCC → 5V, GND → GND
HC-SR04: VCC → 5V, GND → GND, Trig → pino 7, Echo → pino 6

Fluxo de Funcionamento

O Arduino movimenta o servo de um ângulo mínimo até um ângulo máximo.
Para cada ângulo, mede a distância do objeto com o sensor ultrassônico.
Envia os dados pela porta serial para o computador.
O Processing lê esses dados e desenha na tela uma linha verde indicando a posição atual do radar e linhas vermelhas quando encontra obstáculos.

Dicas de Uso

Use uma superfície plana para evitar leituras erradas do ultrassônico.
Se quiser que o radar seja mais rápido, reduza o tempo de espera entre as medições no código do Arduino.
Deixe o Arduino conectado durante toda a execução do Processing.

Código para Arduino IDE

/*******************************************************************************
  Copyright 2025 RoboCore.
  Escrito por Thaina Almeida (22/08/2025).

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/
  
#include <Servo.h>

Servo myServo;

const int trigPin = 7;
const int echoPin = 6;
const int servoPin = 9;

// Limites de varredura
const int MIN_ANGLE = 40;   // ângulo mínimo
const int MAX_ANGLE = 172;  // ângulo máximo

const unsigned long measureDelay = 20; // tempo para servo estabilizar antes da medição
const int sweepStep = 2;              // passo em graus

const unsigned long timeoutMicros = 30000UL; // timeout do pulseIn (30ms)

void setup() {
  Serial.begin(9600);
  myServo.attach(servoPin);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  digitalWrite(trigPin, LOW);
  delay(200);
}

long measureDistanceCM() {
  // Pulso de trigger
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Captura eco
  unsigned long duration = pulseIn(echoPin, HIGH, timeoutMicros);
  if (duration == 0) return -1; // sem eco

  return duration / 58; // converte para cm
}

void loop() {
  // Sweep de ida
  for (int angle = MIN_ANGLE; angle <= MAX_ANGLE; angle += sweepStep) {
    myServo.write(angle);
    delay(measureDelay);

    long d1 = measureDistanceCM();
    delay(20);
    long d2 = measureDistanceCM();

    long dist;
    if (d1 < 0 && d2 < 0) dist = -1;
    else if (d1 < 0) dist = d2;
    else if (d2 < 0) dist = d1;
    else dist = (d1 + d2) / 2;

    Serial.print(angle);
    Serial.print(",");
    Serial.println(dist);
    delay(5);
  }

  // Sweep de volta
  for (int angle = MAX_ANGLE; angle >= MIN_ANGLE; angle -= sweepStep) {
    myServo.write(angle);
    delay(measureDelay);

    long d1 = measureDistanceCM();
    delay(20);
    long d2 = measureDistanceCM();

    long dist;
    if (d1 < 0 && d2 < 0) dist = -1;
    else if (d1 < 0) dist = d2;
    else if (d2 < 0) dist = d1;
    else dist = (d1 + d2) / 2;

    Serial.print(angle);
    Serial.print(",");
    Serial.println(dist);
    delay(5);
  }
}
  
</code></pre>
<div class="note">Ajuste <code class="converted">MIN_ANGLE</code>, <code class="converted">MAX_ANGLE</code>, <code class="converted">measureDelay</code> e <code class="converted">sweepStep</code> para otimizar velocidade vs resolução.</div>
</section>


<section class="card">
<h2>Código Processing (visualização)</h2>
<p>Copie e cole esse sketch no Processing. Ajuste a porta serial (ex.: <code class="converted">COM7</code>) conforme necessário.</p>
<pre><code>

Código para o Processing


/*******************************************************************************
  Copyright 2025 RoboCore.
  Escrito por Thaina Almeida (22/08/2025).

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

import processing.serial.*;

Serial myPort;

String angle = "";
String distance = "";
String data = "";
int iAngle = 0;
int iDistance = -1;

PFont orcFont;

void setup() {
  size(1366, 700);
  smooth();

  // Ajuste a porta e velocidade para combinar com o Arduino
  myPort = new Serial(this, "COM7", 9600); // TROQUE AQUI PELA SUA PORTA COM
  myPort.bufferUntil('\n'); // Espera uma linha inteira antes de processar
}

void draw() {
  fill(0, 20); // efeito de "rastro"
  noStroke();
  rect(0, 0, width, height);

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

// Recebe dados do Arduino
void serialEvent(Serial myPort) {
  data = myPort.readStringUntil('\n');
  if (data != null) {
    data = trim(data); // remove espaços e quebras
    int commaIndex = data.indexOf(',');
    if (commaIndex > 0) {
      angle = data.substring(0, commaIndex);
      distance = data.substring(commaIndex+1);
      iAngle = int(angle);
      iDistance = int(distance);
    }
  }
}

// Desenha a base do radar
void drawRadar() {
  pushMatrix();
  translate(683, 700);
  noFill();
  strokeWeight(2);
  stroke(98, 245, 31);

  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);

  for (int a = 0; a <= 180; a += 30) {
    line(0, 0, 700*cos(radians(a)), -700*sin(radians(a)));
  }
  popMatrix();
}

// Linha do scanner (usa ângulo do Arduino)
void drawLine() {
  pushMatrix();
  strokeWeight(3);
  stroke(30, 250, 60);
  translate(683, 700);
  line(0, 0, 700*cos(radians(iAngle)), -700*sin(radians(iAngle)));
  popMatrix();
}

// Obstáculo detectado
void drawObject() {
  if (iDistance <= 0) return; // nada detectado

  pushMatrix();
  translate(683, 700);
  strokeWeight(9);
  stroke(255, 10, 10);

  float pixsDistance = iDistance * 17; // ajuste de escala
  if (pixsDistance > 700) pixsDistance = 700; // não sai da tela

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

// Textos
void drawText() {
  fill(0);
  noStroke();
  rect(0, 660, width, 40);

  fill(98, 245, 31);
  textSize(20);
  text("Ângulo: " + iAngle + "°", 20, 680);
  if (iDistance > 0) {
    text("Distância: " + iDistance + " cm", 200, 680);
  } else {
    text("Sem obstáculo", 200, 680);
  }
}