Arduino Radar with HC-SR04 Ultrasonic Sensor and Servo Motor: Complete DIY Build Guide

In this Arduino radar tutorial, you will build an ultrasonic radar that detects nearby objects and shows them on screen. The setup uses an Arduino Uno, an HC-SR04 ultrasonic distance sensor, and a servo motor. A servo sweeps the sensor across 180 degrees while the Arduino measures the distance to objects at each angle. All that data gets sent over serial to your computer, and if you want, a Processing sketch can turn it into a live radar display.

I like this project because it pulls together several different skills at once: reading a sensor, controlling a motor, formatting serial data, and (optionally) drawing graphics. It works well as a weekend build, and the individual pieces (servo control, ultrasonic sensing, serial output) come up again and again in other Arduino projects.

What You Will Learn

• How an ultrasonic radar system works using the time-of-flight principle
• How to wire an HC-SR04 ultrasonic sensor and a servo motor to an Arduino Uno
• How to write Arduino code that sweeps the servo and measures distance at each angle
• How serial data is formatted and sent from the Arduino to a computer
• How to add a buzzer as an optional obstacle alert
• How to visualize the radar scan in real time using the Processing IDE (optional)
• How to calibrate, test, and troubleshoot your radar system

Project Overview: How the Arduino Radar System Works

Before you start building, first take a quick look at how the whole thing fits together. The Arduino ultrasonic radar has four main parts that run in a loop.

The servo motor rotates the HC-SR04 sensor back and forth, sweeping from 15 to 165 degrees. If you haven’t worked with servos before, our Arduino servo motor control guide covers the basics of wiring and control.

At each degree, the HC-SR04 ultrasonic sensor fires a pulse and listens for the echo to figure out how far away the nearest object is. If you want a deeper look at the HC-SR04, check out our Arduino ultrasonic distance sensor tutorial.

The Arduino Uno runs everything. It tells the servo where to point, triggers the sensor, calculates the distance, and sends the angle and distance data over serial to your computer. If you are new to Arduino programming, our Arduino programming basics guide covers setup(), loop(), variables, and the Serial Monitor.

Optional Add-Ons

On the computer side, a Processing sketch (optional) reads the serial data and draws a sweeping radar display with arcs, scan lines, and object indicators. This is the fun visual part of the project, but the radar works fine without it. You can verify all readings in the Arduino Serial Monitor.

You can also wire up a piezo buzzer to sound an audible alert whenever the sensor detects an object within a set distance.

The Principle of Ultrasonic Sensing

An ultrasonic sensor sends out a high-frequency sound pulse at 40 kHz (well above human hearing) and then listens for the echo that bounces back from nearby objects. The time between the pulse and the echo tells you how far away the object is. This is also the same principle bats use to navigate in the dark, and engineers call it the time-of-flight method.

How the HC-SR04 Measurement Cycle Works

The HC-SR04 has two cylindrical transducers on the front. One is the transmitter (sends the pulse) and the other is the receiver (picks up the echo). A single measurement cycle goes through four stages.

Transmission: First, the Arduino sends a 10-microsecond HIGH pulse to the TRIG pin. In response, the HC-SR04 fires a burst of eight 40 kHz sound waves that spread outward in a cone about 15 degrees wide.

Reflection: When the sound wave hits an object, it bounces back toward the sensor. Hard, flat surfaces reflect sound well. Soft or angled surfaces scatter the signal, which can weaken the echo or cause missed readings.

Reception: Next, the receiver transducer picks up the returning echo, and the HC-SR04 holds its ECHO pin HIGH for a duration equal to the round-trip travel time of the sound wave.

Distance calculation: Finally, the Arduino reads the ECHO pin duration using pulseIn() and then applies the formula: Distance = (Time x Speed of Sound) / 2. Sound travels at roughly 0.034 cm per microsecond (340 m/s). You divide by 2 because the sound goes to the object and back, covering the distance twice. In code: distance = duration * 0.034 / 2.

Why the Servo Creates a Radar Sweep

A stationary ultrasonic sensor only measures distance in one direction. But if you mount it on a servo and sweep from 15 to 165 degrees, you get a distance reading at every angle. The Arduino then pairs each measurement with the servo angle and sends it over serial. Plot all those angle-distance pairs and you get a top-down, radar-style view of whatever is in front of the sensor.

Components and Bill of Materials

Here is every component you need for the core build, along with the optional buzzer and Processing visualization upgrades. These are all common, cheap parts that are also easy to find at any electronics retailer.

Component	Purpose	Required?	Notes
Arduino Uno	Main microcontroller board	Yes	Any Uno-compatible board works
HC-SR04 Ultrasonic Sensor	Measures distance via ultrasonic pulses	Yes	Range 2 cm to 400 cm
SG90 Servo Motor	Sweeps the sensor across a 180-degree arc	Yes	Standard micro servo
Breadboard	Solderless prototyping platform	Yes	Half-size or full-size
Jumper Wires (M-M, M-F)	Connecting all components	Yes	At least 10 wires
USB Cable (Type A to B)	Upload code and serial data link	Yes	Standard Arduino USB cable
Piezo Buzzer	Audible alert for close objects	Optional	Active or passive buzzer
3D Printer and Filament (PLA/ABS)	Custom sensor and servo mounts	Optional	Breadboard mounting also works
Computer with Arduino IDE	Writing and uploading Arduino code	Yes	Download Arduino IDE
Computer with Processing IDE	Radar visualization on screen	Optional	Free download at processing.org

Designing and 3D Printing Custom Mounts (Optional)

If you have a 3D printer, custom mounts make the build more stable and look cleaner. Any CAD software works for this (Autodesk Fusion 360, Tinkercad, etc.). But if you do not have a 3D printer, that is fine too. Tape, hot glue, or zip ties will hold the HC-SR04 on the servo horn just as well.

Sensor mount: Design a bracket that holds the HC-SR04 snugly. Leave the front open so that both transducers can “see” out without obstruction. The back needs a slot or screw hole to attach it to the servo horn.

Servo mount: Create a base that holds the servo body firmly. Make it wide and flat enough to sit on a table or bolt to a platform. Keep the servo horn accessible at the top so the sensor can rotate freely. For 3D printing tips and design ideas, see our introduction to 3D printing and 3D design.

Assembling the Hardware

Once you have your components (and optional mounts), here is how to then put it all together.

Step 1 — Mount the sensor: Secure the HC-SR04 in its 3D-printed bracket, or tape it to the servo horn. Make sure nothing covers either transducer.

Step 2 — Mount the servo: Place the servo motor into its base bracket. If you are not using a printed mount, press the servo body into the breadboard area or secure it to the table with adhesive putty.

Step 3 — Attach sensor to servo: Connect the sensor bracket to the servo horn with the small screw included with the servo, or use a snap-fit design. Make sure the sensor rotates smoothly when the servo moves.

Step 4 — Connect the wiring: Follow the wiring table in the next section to connect all components to the Arduino using the breadboard and jumper wires.

Wiring Diagram and Pin Connections

The wiring for this project is simple. Use the table below for the core build, and if you are adding the buzzer, include the buzzer row too. All components need to share a common ground through the Arduino GND pin.

Core Radar Wiring

Component	Component Pin	Arduino Pin	Notes
SG90 Servo	Signal (Orange/Yellow)	Pin 8	PWM control wire
SG90 Servo	VCC (Red)	5V	Power supply for servo
SG90 Servo	GND (Brown/Black)	GND	Common ground
HC-SR04	VCC	5V	Sensor power
HC-SR04	GND	GND	Common ground
HC-SR04	TRIG	Pin 9	Trigger pulse output
HC-SR04	ECHO	Pin 10	Echo pulse input

Optional Buzzer Wiring

Component	Component Pin	Arduino Pin	Notes
Piezo Buzzer	Positive (+)	Pin 12	Signal wire for tone output
Piezo Buzzer	Negative (−)	GND	Common ground

Important: All GND connections (servo, sensor, buzzer) must go to the same Arduino GND rail because separate ground paths cause erratic sensor readings and servo jitter. Use the breadboard power rails to distribute 5V and GND.

Arduino Code: Core Radar Sketch

The sketch below is the core of the radar. It sweeps the servo from 15 to 165 degrees and back, taking a distance measurement at each degree. Each reading goes out over serial in the format angle,distance. so that the Processing sketch (or Serial Monitor) can parse it.

/**
 * Arduino Ultrasonic Radar — Core Sketch
 * Author: Omar Draidrya
 * Date: 2024/05/09
 * This code controls a servo motor and measures distance
 * using an HC-SR04 ultrasonic sensor.
 */

#include <Servo.h>

Servo myServo;

const int trigPin = 9;
const int echoPin = 10;

long duration;
int distance;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
  myServo.attach(8);
}

void loop() {
  // Forward sweep: 15 to 165 degrees
  for (int i = 15; i <= 165; i++) {
    myServo.write(i);
    delay(30);
    distance = calculateDistance();
    Serial.print(i);
    Serial.print(",");
    Serial.print(distance);
    Serial.print(".");
  }
  // Return sweep: 165 back to 15 degrees
  for (int i = 165; i > 15; i--) {
    myServo.write(i);
    delay(30);
    distance = calculateDistance();
    Serial.print(i);
    Serial.print(",");
    Serial.print(distance);
    Serial.print(".");
  }
}

int calculateDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = duration * 0.034 / 2;
  return distance;
}

How the Arduino Radar Code Works

Servo sweep logic: Two for loops handle the sweep. One goes from 15 to 165 degrees, the other returns from 165 back to 15. The range is 15-165 instead of 0-180 because most cheap servos have dead zones at the extremes, and also because the HC-SR04 reads poorly when aimed back at its own mounting base. The 30 ms delay between each degree gives the servo time to settle before the next measurement.

Distance calculation with pulseIn(): The calculateDistance() function sends a 10-microsecond HIGH pulse on the TRIG pin, then calls pulseIn(echoPin, HIGH). That function blocks until the ECHO pin goes HIGH and returns the pulse duration in microseconds, which is the round-trip travel time of the ultrasonic wave. Multiplying by 0.034 converts microseconds to centimeters (since sound travels about 0.034 cm/us). Dividing by 2 gives the one-way distance.

Serial Output and Testing

Serial output format: Each reading is sent as angle,distance. For example, 90,25. means the sensor is at 90 degrees and sees an object at 25 cm. The period . is the delimiter that tells the Processing sketch where one reading ends and the next starts. You can check this output in the Arduino IDE Serial Monitor at 9600 baud after uploading.

Testing with Serial Monitor: Before setting up Processing, upload this sketch and open the Serial Monitor (Tools > Serial Monitor) at 9600 baud. You should see a continuous stream of angle-distance pairs like 15,40.16,38.17,35. scrolling across the screen. If you only see zeros or very large numbers, check your wiring and see the Troubleshooting section below.

Optional Upgrade: Adding a Buzzer for Obstacle Alerts

Once the core radar works, you can add a piezo buzzer so you get an audible warning when an object gets too close. Think of it like a parking sensor for your desk.

/**
 * Arduino Ultrasonic Radar — Buzzer Upgrade
 * Author: Omar Draidrya
 * Date: 2024/05/09
 * Adds a buzzer alert when an obstacle is within threshold distance.
 */

#include <Servo.h>

Servo myServo;

const int trigPin = 9;
const int echoPin = 10;
const int buzzerPin = 12;
const int alertThreshold = 10; // cm — change this value to adjust sensitivity

long duration;
int distance;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  Serial.begin(9600);
  myServo.attach(8);
}

void loop() {
  for (int i = 15; i <= 165; i++) {
    myServo.write(i);
    delay(30);
    distance = calculateDistance();
    Serial.print(i);
    Serial.print(",");
    Serial.print(distance);
    Serial.print(".");

    if (distance <= alertThreshold) {
      tone(buzzerPin, 2000);
    } else {
      noTone(buzzerPin);
    }
  }
  for (int i = 165; i > 15; i--) {
    myServo.write(i);
    delay(30);
    distance = calculateDistance();
    Serial.print(i);
    Serial.print(",");
    Serial.print(distance);
    Serial.print(".");

    if (distance <= alertThreshold) {
      tone(buzzerPin, 2000);
    } else {
      noTone(buzzerPin);
    }
  }
}

int calculateDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = duration * 0.034 / 2;
  return distance;
}

How the buzzer works: After each distance measurement, the code checks if the reading is at or below alertThreshold (10 cm by default). If it is, tone(buzzerPin, 2000) drives the buzzer at 2000 Hz. Otherwise, noTone() turns it off. You can change alertThreshold to whatever distance you want. For example, set it to 20 cm for earlier warnings, or 5 cm if you only want it to trigger for very close objects.

Optional Upgrade: Real-Time Radar Visualization with Processing

The Arduino radar works fine with just the Serial Monitor, but it is a lot more satisfying to see a live radar screen. That is where Processing comes in. Processing is a free, open-source programming environment built for visual and interactive projects. Because it reads serial data from the Arduino and draws graphics in real time, it is a natural fit here.

Important: The radar system is fully functional without Processing. If you just want the hardware and serial output, skip this section.

What the Processing Sketch Does

The Processing code opens a serial connection to the Arduino at 9600 baud, reads the incoming angle,distance. data stream, and then parses each reading to draw a radar display. As a result, detected objects show up as colored lines within arc rings that represent distance ranges. A text overlay also shows the current angle and measured distance.

How to Set Up Processing

Step 1: Download and install the Processing IDE from processing.org.

Step 2: Close the Arduino IDE Serial Monitor if it is open. Only one program can use the serial port at a time.

Step 3: Copy the Processing code below into a new sketch and run it.

Step 4: If the radar screen appears but shows no scan line, you then need to change the serial port index. In the line String portName = Serial.list()[0];, change the [0] to [1] or [2] depending on which port your Arduino is on. You can print Serial.list() to the Processing console to see all available ports.

Processing Radar Code

/**
 * Arduino Radar — Processing Visualization
 * Date: 2024/05/09
 * Reads serial data from Arduino and draws a radar display.
 */

import processing.serial.*;

Serial communicationPort;
String serialData = "";
float scanAngle = 0;
float scanDistance = 0;
int radarRadius = 800;
int maxDistance = 40; // cm

void setup() {
  size(1920, 1080);
  smooth();
  String portName = Serial.list()[0]; // Adjust index if needed
  communicationPort = new Serial(this, portName, 9600);
  communicationPort.bufferUntil('.');
  background(0);
}

void draw() {
  drawRadarBackground();
  if (serialData.length() > 0) {
    parseSerialData();
    drawDetection();
  }
  displayInfo(scanDistance, scanAngle);
}

void drawRadarBackground() {
  pushMatrix();
  translate(width / 2, height - 200);
  noFill();
  stroke(80);
  strokeWeight(1);
  for (int i = 0; i < 5; i++) {
    float r = radarRadius * (i + 1) / 5.0;
    arc(0, 0, r * 2, r * 2, PI, TWO_PI);
  }
  for (int i = 0; i < 180; i += 10) {
    float x = radarRadius * cos(radians(i));
    float y = radarRadius * sin(radians(i));
    line(0, 0, x, -y);
    if (i % 30 == 0) {
      fill(255);
      textSize(16);
      text(i + "°", x + 5, -y + 5);
    }
  }
  popMatrix();
}

void parseSerialData() {
  String[] tokens = serialData.split(",");
  if (tokens.length >= 2) {
    scanAngle = float(tokens[0]);
    scanDistance = float(tokens[1]);
  }
}

void drawDetection() {
  float angle = radians(scanAngle);
  float distance = scanDistance;
  float x = distance * 20;
  float fullX = radarRadius * cos(angle);
  float fullY = radarRadius * sin(angle);

  pushMatrix();
  translate(width / 2, height - 200);
  strokeWeight(4);
  noStroke();
  fill(0, 20);
  rect(-radarRadius, -radarRadius, radarRadius * 2, radarRadius);

  if (distance > 0 && distance <= maxDistance) {
    stroke(0, 0, 255);
    line(0, 0, x * cos(angle), -x * sin(angle));
    stroke(255, 165, 0);
    line(x * cos(angle), -x * sin(angle), fullX, -fullY);
  } else {
    stroke(0, 0, 255);
    line(0, 0, fullX, -fullY);
  }
  popMatrix();
  serialData = "";
}

void displayInfo(float distance, float angle) {
  fill(0);
  noStroke();
  rect(10, 10, 260, 80);
  fill(255);
  textSize(20);
  text("Angle: " + nf(angle, 1, 2) + "°", 30, 30);
  text("Distance: " + nf(distance, 1, 2) + " cm", 30, 60);
}

void serialEvent(Serial p) {
  serialData = p.readStringUntil('.');
  serialData = serialData.substring(0, serialData.length() - 1);
}

Understanding the Serial Data Format

The Arduino sends data in the exact format angle,distance. For example, 45,18.. The Processing sketch uses bufferUntil('.') to collect characters until it hits the period delimiter, and then splits on the comma to get the angle and distance. If the format changes even slightly, parsing breaks. Even adding a single space is enough to kill the display, so keep the Arduino output and the Processing parser in sync.

Calibration, Accuracy, and Limitations

Once the radar is running, you will notice that real-world performance is messier than you might expect. Knowing the limitations helps you read the data correctly and troubleshoot when things look off.

Servo alignment: Most hobby servos are not perfectly calibrated out of the box, so angle 90 might not point straight ahead on your particular servo. If the radar display looks rotated or offset, adjust the sensor bracket on the horn or add a small offset in code.

Ultrasonic cone width: The HC-SR04 emits sound in a cone roughly 15 degrees wide, so it cannot tell two objects apart if they sit close together within that cone. You may also notice the sensor picking up the edge of a large object even when it is not directly ahead.

Reflective and soft surfaces: Hard flat surfaces like walls and boxes produce strong echoes. But soft fabrics, angled surfaces, and thin objects like chair legs tend to absorb or deflect the pulse, so you may get missed readings or wrong distances.

Range, Noise, and Sweep Speed

Practical maximum range: The HC-SR04 datasheet says 400 cm, but reliable readings top out around 200 cm. Beyond that, echoes get too weak. The Processing sketch defaults to 40 cm, which works well for tabletop demos.

Noisy or jumping readings: Occasional spikes in the distance data are normal because multipath reflections, electrical noise, and lingering echoes from previous pulses all cause them. A simple fix is to add a short averaging filter in your Arduino code that takes three readings and then uses the median.

Sweep speed versus update rate: The 30 ms delay per degree means a full forward sweep takes about 4.5 seconds. If you drop the delay, the sweep gets faster, but the servo has less time to settle and readings get noisier. On the other hand, if you raise it, measurements stabilize but the radar refreshes slower. It is a tradeoff you can tune to your needs.

Troubleshooting Common Issues

If something is off, work through this checklist before swapping any hardware.

Servo not moving: First, check that the signal wire is on pin 8 and that VCC and GND go to the Arduino 5V and GND. Then try a basic sweep sketch from the Arduino Servo examples to figure out if the problem is the servo itself or the radar code.

HC-SR04 always reads 0 or maximum distance: First, verify TRIG is on pin 9 and ECHO is on pin 10. Then make sure the sensor runs on 5V, not 3.3V. Also check that the mount is not blocking the transducers. Point the sensor at a flat wall about 20 cm away and check the Serial Monitor.

Noisy or jumping distance values: First, make sure all grounds are connected to the same rail, because long jumper wires can pick up electrical noise. If readings still jump around, add a 10 uF capacitor between the sensor VCC and GND pins to stabilize the power.

Buzzer always on or never triggers: Make sure the buzzer is wired to pin 12 and check the alertThreshold value in the code. If the sensor reads wrong distances (see above), the buzzer logic will misbehave too. Fix the sensor first.

Processing and Serial Troubleshooting

Processing not connecting or showing a blank screen: First, close the Arduino Serial Monitor before running the Processing sketch, since only one program can use the serial port at a time. If the sketch runs but the radar stays blank, change the port index in Serial.list()[0] to [1] or [2]. Print Serial.list() to the Processing console to find the right port.

Serial format mismatch: The Processing sketch expects exactly angle,distance. with no spaces. If you change the Arduino Serial.print() statements in any way (for example, by adding units, extra delimiters, or spaces), the Processing parser will break. So always keep both sketches in sync.

Power issues or erratic behavior when servo moves: The SG90 servo can draw up to 500 mA under load, so if the Arduino runs on USB power alone, the servo can cause voltage drops that reset the Arduino or corrupt sensor readings. To fix this, power the servo from an external 5V supply with a common ground to the Arduino.

Frequently Asked Questions (FAQ)

Related Resources

These links cover the individual components used in this project, and they can also help you find your next build.

• Arduino Ultrasonic Distance Sensor: HC-SR04 Tutorial with Wiring and Code — Covers the HC-SR04 in detail, including wiring, code, and common pitfalls.
• Arduino Servo Control Guide: SG90, PWM, and PCA9685 — Everything about driving servo motors with Arduino, including the PCA9685 driver for multi-servo projects.
• Arduino Programming Basics: Complete Beginner Guide — If you are new to Arduino code, start here for setup(), loop(), variables, and the Serial Monitor.
• What is Arduino? — A beginner-friendly overview of the Arduino platform, boards, and ecosystem.
• Introduction to 3D Printing and 3D Design with Inventor — Learn how to design and print your own parts for electronics projects.
• Building an Obstacle-Avoiding Robot Car with Arduino — Another project that uses the HC-SR04 and a servo for autonomous navigation.
• Building a Line Following Robot with KY-033 Sensors — A beginner robotics project to try after completing the radar.
• DIY 6-DOF Robotic Arm — 3D Print, Wire, and Program — An advanced multi-servo project that builds on the servo skills used in this tutorial.

Conclusion and Next Steps

Because the skills from this project (sensor reading, motor control, serial communication, data display) show up in most robotics and embedded systems projects, you will have a solid foundation for whatever you build next.

For something different, try building an obstacle-avoiding robot car that uses the same ultrasonic sensor and servo combo to navigate on its own. More Arduino and robotics tutorials are on the OmArTronics homepage.

Download the 3D Print Files (STL)

All 3D-printable STL files for this project are available for download from our shop or on Cults3D:

• OmArTronics Shop: Download project files from OmArTronics — Get the complete project package including STL files, wiring diagrams, and source code delivered to your email.
• Cults3D: View on Cults3D — Browse and download the 3D model files on Cults3D.