Acknowledgement

First and foremost, I would like to take this opportunity to thank our professor
Pushpendra Dwiwedi for his guidance and advice on this project.

We would like to thank our institute, Bhagalpur College of Engineering, for having
granted us the resources, freedom and opportunity to embark on a project of our
choice, which has taught us so much.

Thank You.
Abstract

This project is about Radar System controlled via Arduino. This Radar system consists
of an Ultrasonic Sensor and Servo Motor, these are the major components of the
system. Basic working of the system is that it have to detect objects in its defined
range. Ultra-sonic sensor is attached to the servo motor it rotates about 180 degree
and gives visual representation on the software called processing IDE. Processing IDE
gives graphical representation and it also gives angle or position of the obzject and
distance of the object. This system is controlled through Arduino. Arduino UNO board
is sufficed to control ultrasonic sensor and also to interface the sensor and display
device. While researching, we learned about existing navigation and obstacle
detection innovations and different systems where ultrasonic sensors are used
efficiently. Main application of this RADAR system comes into different field of
navigation, positioning, object identification, mapping, spying or tracking and different
applications. These less investment system are also suitable for indoor applications.
Table of Contents

1.Abstract

2.Acknowledgement

3. Introduction

4. History

5. Project Aim

6. Hardware Requirements

7.Software Requirements

8. Description of the Hardware Requirements

9.Methodology

10. Connections

11. Working

12. Discussion and Result

13. Pros and Cons

14.Application

15. Conclusions

16.References

Appendix A

Appendix B

Chapter 1
1.1 Introduction

RADAR system is an object detection or tracking system which uses radio waves to
decide or get the range, height, heading, or speed of items or objects. Radar
frameworks or system arrive in an assortment of sizes and have distinctive
performance particulars. Some radars are utilized for aviation authority at air
terminals and others are utilized for long range observation and early cautioning
frameworks. There are some ways to show radar working data. There are also some
modified radar systems. Which have advance technology of handling the systems.
These modified system are used at higher levels to get or extract the helpful or
important data Our proposed system’s working principle is linked by the following
components which are is ultra-sonic sensor connected to the microcontroller (we have
chosen Arduino) digital input and output pins. Then we have servo motor which is also
connected to digital output and input pins. Our both main components ultra-sonic
sensor and servo motor are connected simultaneously, so that when our servo motor
rotates from 0 degree to 180 degree from extreme right to extreme left the motor will
rotate nearby its axis. We utilize Computer screen to demonstrate the data (distance
and angle) through software called “Processing development Environment”.

1.2 History
It is a common assumption that radar is a by-product of World War II, brought about
by military necessity. According to Hiser (Radar Meteorology, Third Edition, 1970), this
is true only to the extent that the war produced radar equipment in great quantities
suitable for practical use. Actually, the fundamental principle underlying all radars was
first observed in 1886 by the physicist Heinrich Hertz when he found that
electromagnetic waves could be reflected from various objects, and even focused into
beams by appropriate reflectors.

In 1904, a German engineer, Hulsmeyer, was granted a patent in several countries on

a proposed method of using electromagnetic waves in an obstacle detector and
navigation aid for ships. In 1922, Marconi urged the use of “short waves” for radio
detection. From these beginnings, radar gradually evolved; it was not a science which
was suddenly discovered. Various experimenters in electromagnetic waves during the
following years reflected these waves from the upper atmosphere, and verified the
existence of a series of ionized layers known as the ionosphere.
1.3 Project Aim

The aim of the project is to design and develop an object detection system which
could determine the presence of objects in its vicinity.
Chapter 2

2.1 Hardware Requirements

1. Microcontroller Board- Arduino UNO

2. Jumper Wires

3. Connecting Wires

4. Sensor- HC-SR04 Ultrasonic Sensor

5. Actuator Micro-Servo Motor

6. Display Device (Laptop)

2.2 Software Requirements

1. Arduino IDE

2. Processing IDE
 2.3.1 The Arduino UNO

Arduino is an open source electronics platform for fast prototyping of projects for
users with minimal knowledge or experience in electronics and programming. We
have used the Arduino UNO, the most widely used variant of the Arduino.

Technically, Arduino Uno is a microcontroller board based on the 8-bit ATMega328P

microcontroller. With 14 digital input/output pins (including 6 PWM outputs), 6 Analog
inputs, a 16 MHz ceramic resonator, a USB connection, a power jack, an ICSP header,
and a reset button, it has everything needed to support the microcontroller, we simply
have to connect it to a computer with a USB cable or power it with a AC-to-DC adapter
or battery to get started. Arduino also comes with the Arduino IDE, in which we can
write code and upload to the

Arduino. The programming language used for an Arduino, called the Arduino
Programming language, is very similar to C/C++ except that we can use inbuilt
functions of the Arduino libraries which keep the code very simple and short

Why Arduino?

We had the following reasons strongly backing our decision to choose the Arduino
UNO Support Thanks to its simple and accessible user experience,

Arduino has been used in thousands of different projects and applications. The
Arduino software is easy-to-use for beginners, yet flexible enough for advanced users.
It runs on Mac, Windows, and Linux.
One important advantage of using the UNO is that unlike most previous
programmable circuit boards, the Arduino UNO does not need a separate piece of
hardware (called a programmer) in order to load new code onto the board we can
simply use a USB cable. The ATmega328 on the Arduino Uno comes pre- programmed
with a bootloader that allows us to upload new code to it without the use of an
extemal hardware programmer.

Moreover, the components we have used work under the same operating voltage and
current conditions as an Arduino, especially considering the fact that such
components are nowadays sold with their compatibility with Arduino in mind.

Considering the above factors, we found Arduino UNO to be the most appropriate
microcontroller board to work with for this project.

Operation of Arduino

Once a program written for an Arduino, called a “Sketch is uploaded to the board via
the Arduino IDE, the Arduino environment performs some small transformations to
make sure that the code is correct C/C++, It then gets passed to a compiler, which
turns the human readable code into machine readable instructions (object files). Then,
the code gets combined with (linked against) the standard Arduino libraries that
provide basic functions like digitalWrite() or Serial.print(). The result is a single Intel
lex file, which contains the specific bytes that need to be written to the program
(flash) memory of the chip on the Arduino board. This file is then uploaded to the
board: transmitted over the USB or serial connection via the bootloader already on the
chip or with external programming hardware.
2.3.2 The HC-SR04 Ultrasonic Sensor

Figure 1.2: HC-SR04 Ultrasonic sensor

Appendix A: 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
}
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;
}

Appendix B: Processing 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,"COM3", 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(ra
dians(30)));
line(0,0,(-width/2)*cos(radians(60)),(-width/2)*sin(ra
dians(60)));
line(0,0,(-width/2)*cos(radians(90)),(-width/2)*sin(ra
dians(90)));
line(0,0,(-width/2)*cos(radians(120)),(-width/2)*sin(r
adians(120)));
line(0,0,(-width/2)*cos(radians(150)),(-width/2)*sin(r
adians(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("Middle Class Engineer ", 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();
}