EEEL303 Microprocessors and Microcontrollers Lab

Radar System Using Arduino UNO and

Ultrasonic Sensor

Submitted by
Contents
Introduction to Radar System
Radar is a long-range object detection system that uses radio waves to determine
parameters such as range, speed, and position of an object. This project employs sonar
technology using an ultrasonic sensor to detect objects within a specific range,
simulating radar functionality. Radar systems typically use microwaves to determine
the range, altitude, direction, or speed of objects. These waves bounce off objects in
their path, allowing the radar to detect and measure objects within its range.

Principle of Operation
Radar systems operate by transmitting a signal that reflects off an object and returns
to the radar receiver. The time delay between transmission and reception, along with
the angle of the returned signal, allows the system to calculate the object's distance
and position. Doppler radar systems also measure the frequency shift of the returned
signal to determine the object's speed.

Components and their Description

HARDWARE

• Arduino UNO : A microcontroller used to process data and control the system.
➢ Specifications: ATmega328P microcontroller, 14 digital I/O pins, 6 analog input
pins, 32 KB flash memory.
➢ Role: Acts as the brain of the radar system, processing input from the sensor
and controlling the servo motor.
• HC-SR04 Ultrasonic Sensor : Measures the distance to objects using ultrasonic waves.
➢ Specifications: Operating voltage 5V, measuring angle 15 degrees, ranging
distance 2 cm to 400 cm.
➢ Role: Sends out ultrasonic waves and receives the reflected waves to measure
distance.
• Servo Motor : Rotates the ultrasonic sensor to scan the area.
➢ Specifications: Operating voltage 4.8V-6V, torque 2.5kg/cm, rotation angle 0°
to 180°.
➢ Role: Moves the ultrasonic sensor to different angles for scanning.
• Jumper Cables + USB Cable (for Arduino) : Used for connections and power.
➢ Role: Facilitates the connection of components and power supply.
SOFTWARE

• Arduino IDE : Platform for writing and uploading code to the Arduino.
➢ Features : Code editor, serial monitor, integrated libraries for various sensors
and actuators.
➢ Role : Develops and uploads the control code to the Arduino UNO.
• Processing Application : Software for visualizing the radar data.
➢ Features : Graphics library, serial communication capabilities, interactive
display.
➢ Role : Receives data from the Arduino and displays it in a visual format.

Circuit Diagram
Working Principle
The system's objective is to determine the distance, position, and speed of obstacles. The
ultrasonic sensor sends out waves and detects the reflected waves from objects. The
Arduino processes these signals and determines the distance and angle of the object. This
data is displayed on a screen using the Processing application.

Detailed Working Steps

➢ Initialization: The Arduino initializes the servo motor and sets the ultrasonic sensor
pins as input and output.
➢ Scanning: The servo motor rotates the ultrasonic sensor from 0° to 180°, pausing at
each step to take a distance measurement.
➢ Distance Measurement: At each step, the ultrasonic sensor sends out a 40 kHz pulse.
The time taken for the echo to return is measured.
➢ Data Processing: The Arduino calculates the distance based on the time delay and
sends this data, along with the angle, to the Processing application via serial
communication.
➢ Visualization: The Processing application plots the distance and angle on a polar
coordinate system, creating a real-time radar display

Arduino Code
// Includes the Servo library
#include <Servo.h>
// Defines Tirg and Echo pins of the Ultrasonic Sensor
const int trigPin = 10;
const int echoPin = 11;
// Variables for the duration and the distance
long duration;
int distance;
Servo myServo; // Creates a servo object for controlling the servo motor
void setup() {
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
Serial.begin(9600);
myServo.attach(12); // Defines on which pin is the servo motor attached
myServo.write(0);
}
void loop() {
// rotates the servo motor from 15 to 165 degrees
for(int i=15;i<=165;i++){
myServo.write(i);
delay(30);
distance = calculateDistance();// Calls a function for calculating the distance measured by the Ultrasonic
sensor for each degree

Serial.print(i); // Sends the current degree into the Serial Port

Serial.print(","); // Sends addition character right next to the previous value needed later in the Processing
IDE for indexing
Serial.print(distance); // Sends the distance value into the Serial Port
Serial.print("."); // Sends addition character right next to the previous value needed later in the Processing
IDE for indexing
}
// Repeats the previous lines from 165 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(".");
}
}
// Function for calculating the distance measured by the Ultrasonic sensor
int calculateDistance(){

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH); // Reads the echoPin, returns the sound wave travel time in microseconds
distance= duration*0.034/2;
return distance;
}

Processing Software Code

import processing.serial.*; // imports library for serial communication
import java.awt.event.KeyEvent; // imports library for reading the data from the serial port
import java.io.IOException;
Serial myPort; // defines Object Serial
// defubes variables
String angle="";
String distance="";
String data="";
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1=0;
int index2=0;
PFont orcFont;
void setup() {

size (1200, 700); // **CHANGE THIS TO YOUR SCREEN RESOLUTION**

smooth();
myPort = new Serial(this,"COM6", 9600); // starts the serial communication
myPort.bufferUntil('.'); // reads the data from the serial port up to the character '.'. So actually it reads this:
angle,distance.
}
void draw() {

fill(98,245,31);
// simulating motion blur and slow fade of the moving line
noStroke();
fill(0,4);
rect(0, 0, width, height-height*0.065);

fill(98,245,31); // green color

// calls the functions for drawing the radar
drawRadar();
drawLine();
drawObject();
drawText();
}
void serialEvent (Serial myPort) { // starts reading data from the Serial Port
// reads the data from the Serial Port up to the character '.' and puts it into the String variable "data".
data = myPort.readStringUntil('.');
data = data.substring(0,data.length()-1);

index1 = data.indexOf(","); // find the character ',' and puts it into the variable "index1"
angle= data.substring(0, index1); // read the data from position "0" to position of the variable index1 or thats
the value of the angle the Arduino Board sent into the Serial Port
 distance= data.substring(index1+1, data.length()); // read the data from position "index1" to the end of the
data pr thats the value of the distance

// converts the String variables into Integer

iAngle = int(angle);
iDistance = int(distance);
}
void drawRadar() {
pushMatrix();
translate(width/2,height-height*0.074); // moves the starting coordinats to new location
noFill();
strokeWeight(2);
stroke(98,245,31);
// draws the arc lines
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);
// draws the angle lines
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); // moves the starting coordinats to new location
strokeWeight(9);
stroke(255,10,10); // red color
pixsDistance = iDistance*((height-height*0.1666)*0.025); // covers the distance from the sensor from cm to
pixels
// limiting the range to 40 cms
if(iDistance<40){
// draws the object according to the angle and the distance
line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),(width-
width*0.505)*cos(radians(iAngle)),-(width-width*0.505)*sin(radians(iAngle)));
}
popMatrix();
}
void drawLine() {
 pushMatrix();
strokeWeight(9);
stroke(30,250,60);
translate(width/2,height-height*0.074); // moves the starting coordinats to new location
line(0,0,(height-height*0.12)*cos(radians(iAngle)),-(height-height*0.12)*sin(radians(iAngle))); // draws the
line according to the angle
popMatrix();
}
void drawText() { // draws the texts on the screen

pushMatrix();
if(iDistance>40) {
noObject = "Out of Range";
}
else {
noObject = "In Range";
}
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("Indian Lifehacker ", width-width*0.875, height-height*0.0277);
text("Angle: " + iAngle +" °", width-width*0.48, height-height*0.0277);
text("Distance: ", width-width*0.26, height-height*0.0277);
if(iDistance<40) {
text(" " + iDistance +" 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();
}

Applications
Radar is an electromagnetic system for the detection and location of target objects
such as aircraft, ships, spacecraft, vehicles, people, and the natural environment. It
uses electromagnetic radio waves to determine the angle, range, or velocity of
objects. The modern radar system is more advanced, and the uses of radar are highly
diverse, including:
➢ Air Traffic Control: Ensuring the safe and efficient movement of aircraft.
➢ Defence Systems: Detecting and tracking potential threats.
➢ Weather Monitoring: Tracking weather patterns and predicting storms.
➢ Automotive Safety: Providing features like adaptive cruise control and
collision avoidance.

Future Enhancements
➢ Enhanced Range and Accuracy: Upgrading the ultrasonic sensor to one with a
higher range and accuracy.
➢ Multiple Sensors Integration: Using multiple sensors to cover a larger area and
provide more detailed data.
➢ Advanced Data Processing: Implementing machine learning algorithms to
predict the behaviour of detected objects.
➢ Real-Time Data Transmission: Integrating wireless communication modules to
transmit data to remote systems in real-time.
Conclusions
This project demonstrates the basic principles of radar technology using costeffective
components and open-source software. By integrating an ultrasonic sensor with
Arduino UNO and displaying the data using Processing, we have created a functional
radar system capable of detecting and measuring the distance and position of
objects. This project serves as an educational tool for understanding radar
technology and its applications.

References
➢ Electronics Hub: Arduino Radar Project
➢ Students Heart: Arduino-Based Radar Project
➢ How to Mechatronics: Arduino Radar Project
➢ Mohamad Mahdi Abdulkareem, Qusay Adil Mohammed, Muhammad
Mahmood Shakir - “A Short Range Radar System “Rangefinder”
➢ Srijan Dubey, Supragya Tiwari, Simit Roy - “Implementation of Radar Using
Ultrasonic Sensor” Indian J.Sci.Res. 2017