PROJECT REPORT (EEN101)

A report submitted in partial fulfilment of the requirement for the course

Electrical And Electronics Engineering Practice

Part of the degree of
BACHELOR OF COMPUTER SCIENCE
ENGINEERING

Submitted to: Submitted by:

Dr. Mohamed Samir Piyush Gaurav
Assistant Professor Satyam Ujjain
Ayush Gupta
Naman Kaushik

SCHOOL OF ENGINEERING & TECHNOLOGY

DIT UNIVERSITY, DEHRADUN
(State private university through state legislative Act No. 10 of 2023 of Uttarakhand and approved by UGC)

Mussoorie Diversion Road, Dehradun, Uttarakhand – 248009, India.

 AUGUST- DECEMBER 2024
STUDENTS INVOLVED IN THE PROJECT

1.Piyush Gaurav (1000025085)

2.Satyam Ujjain (1000025565)
3.Ayush Gupta (1000025271)
4.Naman Kaushik (1000024341)

RADAR SYSTEM USING ARDUINO

INTRODUCTION

1. Description:
The main objective of this project is to design and implement a basic radar
system using Arduino, which detects objects and displays their presence using
a rotating servo motor and an ultrasonic sensor. This radar system simulates a
simple detection radar, capable of scanning a defined area and indicating the
detected object.

2. Goals:
1. Detect objects in a defined area using ultrasonic waves.
2. Measure distance to detected objects accurately.
3. Simulate radar functionality by rotating the sensor with a servo motor
4. Develop troubleshooting skills

3. Key Features:
Servo Motor rotates the sensor for area scanning (180°).
 Arduino controls the sensor and processes data.
Real-time object detection and distance calculation.
Visual Feedback via serial monitor or LED indicator.
Non-contact detection using ultrasonic waves.
Cost-effective and simple to build.

4. Components Required:
Arduino Uno: Microcontroller for controlling the system.
Sonar Sensor : For distance measurement.
Servo Motor : To scan the area.
Jumper wires: For connecting the components.
Breadboard: For circuit assembly.

5. Safety Considerations:
1. Electrical Safety:
2. Handle electrical components with care.
3. Use insulated wires and connections.
4. Avoid short circuits.
5. Ensure proper voltage and current ratings.
6. Use fuses or circuit breakers.
Servo Motor Handling:
1. Avoid excessive torque
2. Use an appropriate servo
Power Supply Safety:
1. Use a suitable power supply (voltage, current).
2. Ensure proper polarity.
3. Avoid overheating.
 4. Use a power supply with overcurrent protection.

MAJOR COMPONENTS:
1. ARDUINO UNO
The Arduino Uno is a microcontroller board based on the ATmega328P. It is the
central processing unit for your project, used to control the components (such
as the servo motor and ultrasonic sensor) through programming. It features
digital and analog input/output pins, a USB interface for programming, and
runs on 5V power.
2. SERVO MOTOR
A servo motor is a small, precise motor used for controlled rotation. Unlike
regular motors that rotate continuously, a servo can rotate within a fixed range,
typically 0° to 180°, and can be precisely controlled by varying the pulse width
of its control signal. In this project, it is used to rotate the ultrasonic sensor to
scan an area for detecting objects.

3. BREADBOARD
A breadboard is a reusable, temporary circuit-building platform used for
prototyping and testing electronic circuits. Breadboards are an essential tool
for electronics makers, and professionals, allowing for quick and easy circuit
prototyping and testing.

4. WIRES
Wires are essential components in electronic and electrical systems, serving as
the backbone for signal transmission and power distribution. They consist of
conductive materials, typically copper or aluminum, surrounded by insulation
to prevent electrical shock and interference.

5. SONAR SENSOR
A sonar sensor, often referred to as an ultrasonic sensor, is a device that
measures distance by emitting high-frequency sound waves (ultrasound) and
measuring the time it takes for the sound waves to bounce back from an
object.

THEORY:
In this project, a Radar System is created using an Arduino and an sonar
sensor. The system operates by emitting ultrasonic sound waves through the
sensor, which bounce off objects and return to the sensor. The Arduino
measures the time it takes for the sound waves to return and calculates the
distance to the object using the speed of sound. The servo motor rotates the
sensor to scan a 180° area, simulating a radar system. The Arduino processes
the data and displays the distance, allowing the system to detect objects within
a defined range. This setup offers a basic radar-like functionality, with potential
applications in robotics and object detection.

WORKING:
1. Rotation Mechanism:
A servo motor is used to rotate the ultrasonic sensor in a horizontal plane,
allowing it to scan an area in a 180° arc.

2. Distance Measurement:
The ultrasonic sensor emits sound waves and measures the time taken for the
sound to return after bouncing off an object. Using this time, the Arduino
calculates the distance to the object.

3. Detection Process:
The radar system continuously scans and checks for objects in the scanned
area. If an object is detected within a specified range, an indication (e.g., a
blinking LED or serial output) is triggered.
4. Display:
The results can be shown on a serial monitor, or optionally, an LED indicator
can blink when an object is detected within the radar's range.

CIRCUIT DIAGRAM:

Arduino Code used for radar system:

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

Processing code for radar system:

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(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("SciCraft ", 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();
}
Picture:

CONCLUSION:
This mini-project successfully demonstrates the basics of radar functionality
using an Arduino-based system. The radar detects objects in a defined range
and displays the distance in real-time. While the project is a simple prototype,
it lays the foundation for more advanced radar systems with better sensors and
broader scanning capabilities.