INTRODUCTION

Radar, electromagnetic sensor used for detecting, locating, tracking, and recognizing
objects of various kinds at considerable distances. It operates by transmitting
electromagnetic energy toward objects, commonly referred to as targets, and observing
the echoes returned from them. The targets may be aircraft, ships, spacecraft,
automotive vehicles, and astronomical bodies, or even birds, insects, and rain. Besides
determining the presence, location, and velocity of such objects, radar can sometimes
obtain their size and shape as well. What distinguishes radar from optical and infrared
sensing devices is its ability to detect faraway objects under adverse weather conditions
and to determine their range, or distance, with precision.

Radar is an “active” sensing device in that

it has its own source of illumination (a transmitter) for locating targets. It typically
operates in the microwave region of the electromagnetic spectrum—measured
in hertz (cycles per second), at frequencies extending from about 400 megahertz (MHz)
to 40 gigahertz (GHz). It has, however, been used at lower frequencies for long-range
applications (frequencies as low as several megahertz, which is the HF [high-
frequency], or shortwave, band) and at optical and infrared frequencies (those of laser
radar, or lidar). The circuit components and other hardware of radar systems vary with
the frequency used, and systems range in size from those small enough to fit in the palm
of the hand to those so enormous that they would fill several football fields.

Radar underwent rapid development during the 1930s and ’40s to meet
the needs of the military. It is still widely employed by the armed forces, where many
technological advances have originated. At the same time, radar has found an increasing
number of important civilian applications, notably air traffic control, weather
observation, remote sensing of the environment, aircraft and ship navigation, speed
measurment for industrial applications and for law enforcement, space surveillance, and
planetary observation.

2
 Working of radar sensor

Radio detection and ranging is the meaning of the term RADAR. Radar is an object detection system
that uses microwaves to determine the range, altitude, direction, and speed of objects within
about a 100-mile radius of their location.

The radar antenna transmits radio waves or microwaves that bounce off any object in their path. Due
to this, we can easily determine the object in the radar range.

The basic operation principle is:

A radar is an electromagnetic sensor that is used to detect and locate an object.

Radio waves or microwaves are radiated out from the radar into free space. Some of these waves
are intercepted by reflecting objects.

These intercepted radio waves hit the target and are reflected in many different directions. Some of
these waves can be directed back toward the radar, where they are received and amplified.

If these waves are received again at their origin, then it means an object is in the propagation
direction.

The modern radar system is very advanced and used in highly diverse applications such as air traffic
control, air defense systems, radar astronomy, antimissile systems, outer space surveillance
systems, and many more.

3
 Components required for radar system

Arduino UNO
The Arduino UNO is a standard board of Arduino. Here UNO means 'one' in Italian. It
was named as UNO to label the first release of Arduino Software. It was also the first
USB board released by Arduino. It is considered as the powerful board used in various
projects. Arduino.cc developed the Arduino UNO board.

Arduino UNO is based on an ATmega328P microcontroller. It is easy to use compared

to other boards, such as the Arduino Mega board, etc. The board consists of digital and
analog Input/Output pins (I/O), shields, and other circuits.

The Arduino UNO includes 6 analog pin inputs, 14 digital pins, a USB connector, a
power jack, and an ICSP (In-Circuit Serial Programming) header. It is programmed
based on IDE, which stands for Integrated Development Environment. It can run on
both online and offline platforms.

The IDE is common to all available boards of Arduino.

Breadboard
A breadboard, solderless breadboard, or protoboard is a construction base used to
build semi-permanent prototypes of electronic circuits. Unlike
a perfboard or stripboard, breadboards do not require soldering or destruction of tracks

4
and are hence reusable. For this reason, breadboards are also popular with students and
in technological education.

A variety of electronic systems may be prototyped by using breadboards, from small

analog and digital circuits to complete central processing units (CPUs).
Compared to more permanent circuit connection methods, modern breadboards have
high parasitic capacitance, relatively high resistance, and less reliable connections,
which are subject to jostle and physical degradation. Signaling is limited to about 10
MHz, and not everything works properly even well below that frequency.

Ultrasonic Sensor
An ultrasonic sensor is a proximity sensor that is used to measure the distance of a target
or object. It detects the object by transmitting ultrasonic waves and converts the reflected
waves into an electrical signal. These sound waves travel faster than the speed of the
sound that humans can hear.

It has two main components: the transmitter and

the receiver. The transmitter emits the sound using a piezoelectric crystal, and the
receiver encounters the sound after it has traveled to and from the target

For the calculation of the object distance, the sensor measures the time taken by the signal
to travel from the transmission of the sound by the transmitter to the reflection back
toward the receiver.

The formula for this calculation is,

D=½TxC

Where,

 D = distance,
 T = time

5
  C = speed of sound, which is 343 meters per second.

These sensors are mostly found in automobile self-parking technology and anti-collision
safety systems; they are also used in robotic obstacle detection systems, manufacturing
technology, and many more. To know more about the ultrasonic sensor, refer to
the ultrasonic sensor working principle.

Servo Motor
The servo motor is a simple DC motor that can be controlled for specific angular rotation
with the help of additional servomechanism. This motor will only rotate as much as we
want and then stop. The servo motor is a closed-loop mechanism that uses positional
feedback to control the speed and position.

This closed-loop system includes a control circuit, servo

motor, shaft, potentiometer, drive gears, amplifier, and either an encoder or resolver.

The servo motor is unlike a standard electric motor, which starts and stops according
to the power input. According to the signal, the servo motor will work.

Nowadays, servo motors are widely used in industrial and robotics applications. They are
also commonly seen in remote-controlled toy cars, RC planes, and CD or DVD
players. Besides these, we see hundreds of applications in our daily lives that use a servo
motor. To know more about the servo motor, refer to the servo motor working principle.

6
 Connection of Radar System

We made a simple structure with cardboard to mount the ultrasonic sensor with a servo
motor.

Hardware Connection for the Arduino Radar Project:

The below image shows the connection to the Arduino radar project. The connections
are very simple. Here, we have interfaced the ultrasonic sensor and servo motor with an
Arduino Uno. The connection details of the Arduino radar project are:

Arduino Ultrasonic Servo

Uno Sensor Motor

Vcc Vcc Vcc

Gnd Gnd Gnd

D10 Trig -

D11 Echo -

D12 - Signal

Arduino radar project pinout

Arduino Radar Project connections

Software Installation and Code for the Arduino Radar Project:We need to use two pieces
of software to complete this Arduino radar project. One is the Arduino IDE, and the other
is the Processing IDE. Download both programs from the below links.

7
  Arduino IDE 1.8.13
 Processing IDE

Processing applications are visual arts-based software for learning to code. After
downloading, extract the zip file, and you will get the processing application (.exe file).

In this Arduino radar project, we are using two codes: one for Arduino UNO and the other
for Processing.

8
 Source Code

Here is the Arduino source code for the Arduino radar project:

// 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
}
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(",");

9
 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;
}

 Here is the processing code for the Arduino radar project:

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,"COM5", 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.

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

11
 // 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";
}

12
 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("Robu.in", 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);

13
 popMatrix();
}

Output of Arduino Radar Project:

After uploading the code, the servo motors start running from 0 to 180 degrees and again
back to 0 degrees. An ultrasonic sensor also rotates along with the servo as it is mounted
on the motor.

Now, open the processing application and paste the above code. In this code, update
the COM port number where your Arduino board is connected.

Now, run this processing code. If your code is right, then you will get a new window.
This is the graphical representation of data from the ultrasonic sensor, which is
represented on a radar-type display.

If an ultrasonic sensor detects any object within its range, you can see the same in the
graphical representation. The below gif shows the output of the Arduino radar project.

14