Obstacle Avoiding Robot

An Obstacle Avoiding Robot is a type of robot that is capable of detecting and avoiding obstacles in its path. These robots are equipped with sensors that allow them to detect obstacles and take action to avoid them. The purpose of this type of robot is to be able to navigate around obstacles in an efficient and safe manner, without getting stuck or causing damage to its surroundings.

The design of an obstacle avoiding robot can vary greatly depending on the intended use and environment in which it will be operating. For example, robots designed for indoor use may have a smaller size and lighter weight, while robots intended for outdoor use may be larger and more rugged to withstand rough terrain.

One common design used in obstacle avoiding robots is the use of infrared sensors, which can detect obstacles by sensing changes in the infrared radiation emitted by objects in the environment. The robot can then use this information to determine the best course of action to avoid the obstacle, such as changing its direction or slowing down.

Another design used in obstacle avoiding robots is the use of ultrasonic sensors, which emit high frequency sound waves that bounce off objects and return to the robot. The robot can then use this information to determine the distance of the obstacle and adjust its course accordingly.

Regardless of the design, obstacle avoiding robots are useful for a variety of applications, including exploration, surveillance, and delivery. They can be used in hazardous environments, such as disaster zones, where human intervention is too dangerous. They can also be used in repetitive tasks, such as cleaning and maintenance, freeing up human workers for more important tasks.

Circuit Diagram

Obstacle Avoiding Robot – Code

//ARDUINO OBSTACLE AVOIDING CAR//
// Before uploading the code you have to install the necessary library//
//AFMotor Library https://learn.adafruit.com/adafruit-motor-shield/library-install //
//NewPing Library https://github.com/livetronic/Arduino-NewPing// 
//Servo Library https://github.com/arduino-libraries/Servo.git //
// To Install the libraries go to sketch >> Include Library >> Add .ZIP File >> Select the Downloaded ZIP files From the Above links //


#include <AFMotor.h> 
#include <NewPing.h>
#include <Servo.h>

#define TRIG_PIN A0 
#define ECHO_PIN A1 
#define MAX_DISTANCE 200 
#define MAX_SPEED 190 // sets speed of DC motors
#define MAX_SPEED_OFFSET 20

NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);

AF_DCMotor motor1(1, MOTOR12_1KHZ); 
AF_DCMotor motor2(2, MOTOR12_1KHZ);
AF_DCMotor motor3(3, MOTOR34_1KHZ);
AF_DCMotor motor4(4, MOTOR34_1KHZ);
Servo myservo;

boolean goesForward=false;
int distance = 100;
int speedSet = 0;

void setup() {

myservo.attach(10); 
myservo.write(115); 
delay(2000);
distance = readPing();
delay(100);
distance = readPing();
delay(100);
distance = readPing();
delay(100);
distance = readPing();
delay(100);
}

void loop() {
int distanceR = 0;
int distanceL = 0;
delay(40);

if(distance<=15)
{
moveStop();
delay(100);
moveBackward();
delay(300);
moveStop();
delay(200);
distanceR = lookRight();
delay(200);
distanceL = lookLeft();
delay(200);

if(distanceR>=distanceL)
{
turnRight();
moveStop();
}else
{
turnLeft();
moveStop();
}
}else
{
moveForward();
}
distance = readPing();
}

int lookRight()
{
myservo.write(50); 
delay(500);
int distance = readPing();
delay(100);
myservo.write(115); 
return distance;
}

int lookLeft()
{
myservo.write(170); 
delay(500);
int distance = readPing();
delay(100);
myservo.write(115); 
return distance;
delay(100);
}

int readPing() { 
delay(70);
int cm = sonar.ping_cm();
if(cm==0)
{
cm = 250;
}
return cm;
}

void moveStop() {
motor1.run(RELEASE); 
motor2.run(RELEASE);
motor3.run(RELEASE);
motor4.run(RELEASE);
} 

void moveForward() {

if(!goesForward)
{
goesForward=true;
motor1.run(FORWARD); 
motor2.run(FORWARD);
motor3.run(FORWARD); 
motor4.run(FORWARD); 
for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2) // slowly bring the speed up to avoid loading down the batteries too quickly
{
motor1.setSpeed(speedSet);
motor2.setSpeed(speedSet);
motor3.setSpeed(speedSet);
motor4.setSpeed(speedSet);
delay(5);
}
}
}

void moveBackward() {
goesForward=false;
motor1.run(BACKWARD); 
motor2.run(BACKWARD);
motor3.run(BACKWARD);
motor4.run(BACKWARD); 
for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2) // slowly bring the speed up to avoid loading down the batteries too quickly
{
motor1.setSpeed(speedSet);
motor2.setSpeed(speedSet);
motor3.setSpeed(speedSet);
motor4.setSpeed(speedSet);
delay(5);
}
}

void turnRight() {
motor1.run(FORWARD);
motor2.run(FORWARD);
motor3.run(BACKWARD);
motor4.run(BACKWARD); 
delay(500);
motor1.run(FORWARD); 
motor2.run(FORWARD);
motor3.run(FORWARD);
motor4.run(FORWARD); 
} 

void turnLeft() {
motor1.run(BACKWARD); 
motor2.run(BACKWARD); 
motor3.run(FORWARD);
motor4.run(FORWARD); 
delay(500);
motor1.run(FORWARD); 
motor2.run(FORWARD);
motor3.run(FORWARD);
motor4.run(FORWARD);
}

Download Library File

https://www.mediafire.com/folder/mkevljzuq4ayd/Library

In conclusion, obstacle-avoiding robots are an important aspect of robotics and automation, offering a wide range of benefits and opportunities for both personal and commercial use. Whether you are looking to build a robot for your own use or for a larger project, an obstacle-avoiding robot is a great place to start.