Obstacle Avoidance Car

Automatic Obstacle Avoidance car.

Jul 26, 2020

•

3882 views

•

0 respects

cars

Components and supplies

Arduino UNO

MAXREFDES89# Full-Bridge DC Motor Driver mbed Shield

9V battery (generic)

Jumper wires (generic)

SG90 Micro-servo motor

AA Batteries

Ultrasonic Sensor - HC-SR04 (Generic)

DC Motor, 12 V

4xAA battery holder

9V Battery Clip

Project description

Code

Obstacle Avoidance_Car

arduino

1//Surapaneni Sai Shnamukkha - Obstacle Avoidance Algorithm
2#include
3  <AFMotor.h>  //Motor Driver shield Management Library
4#include <NewPing.h>  //Ultrasonic
5  sensor Library
6#include <Servo.h>   //Servo Motor Library
7
8#define TRIG_PIN
9  A0 
10#define ECHO_PIN A1 
11#define MAX_DISTANCE 200 
12#define MAX_SPEED 200
13  
14#define MAX_SPEED_OFFSET 20
15
16NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);
17  
18
19AF_DCMotor motor1(1, MOTOR12_1KHZ); 
20AF_DCMotor motor2(2, MOTOR12_1KHZ);
21AF_DCMotor
22  motor3(3, MOTOR34_1KHZ);
23AF_DCMotor motor4(4, MOTOR34_1KHZ);
24Servo myservo;
25   
26
27boolean goesForward=false;
28int distance = 100;
29int speedSet = 0;
30
31void
32  setup() {
33
34  myservo.attach(10);  
35  myservo.write(115); 
36  delay(2000);
37
38  distance = readPing();
39  delay(100);
40  distance = readPing();
41  delay(100);
42
43  distance = readPing();
44  delay(100);
45  distance = readPing();
46  delay(100);
47}
48
49void
50  loop() {
51 int distanceR = 0;
52 int distanceL =  0;
53 delay(40);
54 
55
56  if(distance<=15)
57 {
58  moveStop();
59  delay(100);
60  moveBackward();
61
62  delay(300);
63  moveStop();
64  delay(200);
65  distanceR = lookRight();
66
67  delay(200);
68  distanceL = lookLeft();
69  delay(200);
70
71  if(distanceR>=distanceL)
72
73  {
74    turnRight();
75    moveStop();
76  }else
77  {
78    turnLeft();
79
80    moveStop();
81  }
82 }else
83 {
84  moveForward();
85 }
86 distance =
87  readPing();
88}
89
90int lookRight()
91{
92    myservo.write(50); 
93    delay(500);
94
95    int distance = readPing();
96    delay(100);
97    myservo.write(115); 
98
99    return distance;
100}
101
102int lookLeft()
103{
104    myservo.write(170);
105  
106    delay(500);
107    int distance = readPing();
108    delay(100);
109    myservo.write(115);
110  
111    return distance;
112    delay(100);
113}
114
115int readPing() { 
116  delay(70);
117
118  int cm = sonar.ping_cm();
119  if(cm==0)
120  {
121    cm = 250;
122  }
123  return
124  cm;
125}
126
127void moveStop() {
128  motor1.run(RELEASE); 
129  motor2.run(RELEASE);
130
131  motor3.run(RELEASE);
132  motor4.run(RELEASE);
133  } 
134  
135void moveForward()
136  {
137
138 if(!goesForward)
139  {
140    goesForward=true;
141    motor1.run(FORWARD);
142      
143    motor2.run(FORWARD);
144    motor3.run(FORWARD); 
145    motor4.run(FORWARD);
146     
147   for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2) 
148   {
149
150    motor1.setSpeed(speedSet);
151    motor2.setSpeed(speedSet);
152    motor3.setSpeed(speedSet);
153
154    motor4.setSpeed(speedSet);
155    delay(5);
156   }
157  }
158}
159
160void
161  moveBackward() {
162    goesForward=false;
163    motor1.run(BACKWARD);      
164
165    motor2.run(BACKWARD);
166    motor3.run(BACKWARD);
167    motor4.run(BACKWARD);
168  
169  for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2) 
170  {
171    motor1.setSpeed(speedSet);
172
173    motor2.setSpeed(speedSet);
174    motor3.setSpeed(speedSet);
175    motor4.setSpeed(speedSet);
176
177    delay(5);
178  }
179}  
180
181void turnRight() {
182  motor1.run(FORWARD);
183
184  motor2.run(FORWARD);
185  motor3.run(BACKWARD);
186  motor4.run(BACKWARD);     
187
188  delay(500);
189  motor1.run(FORWARD);      
190  motor2.run(FORWARD);
191  motor3.run(FORWARD);
192
193  motor4.run(FORWARD);      
194} 
195 
196void turnLeft() {
197  motor1.run(BACKWARD);
198     
199  motor2.run(BACKWARD);  
200  motor3.run(FORWARD);
201  motor4.run(FORWARD);
202   
203  delay(500);
204  motor1.run(FORWARD);     
205  motor2.run(FORWARD);
206
207  motor3.run(FORWARD);
208  motor4.run(FORWARD);
209}  
210

//Surapaneni Sai Shnamukkha - Obstacle Avoidance Algorithm
#include
  <AFMotor.h>  //Motor Driver shield Management Library
#include <NewPing.h>  //Ultrasonic
  sensor Library
#include <Servo.h>   //Servo Motor Library

#define TRIG_PIN
  A0 
#define ECHO_PIN A1 
#define MAX_DISTANCE 200 
#define MAX_SPEED 200
  
#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) 
   {

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

Obstacle Avoidance_Car

arduino

1//Surapaneni Sai Shnamukkha - Obstacle Avoidance Algorithm
2#include  <AFMotor.h>  //Motor Driver shield Management Library
3#include <NewPing.h>  //Ultrasonic  sensor Library
4#include <Servo.h>   //Servo Motor Library
5
6#define TRIG_PIN  A0 
7#define ECHO_PIN A1 
8#define MAX_DISTANCE 200 
9#define MAX_SPEED 200  
10#define MAX_SPEED_OFFSET 20
11
12NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);  
13
14AF_DCMotor motor1(1, MOTOR12_1KHZ); 
15AF_DCMotor motor2(2, MOTOR12_1KHZ);
16AF_DCMotor  motor3(3, MOTOR34_1KHZ);
17AF_DCMotor motor4(4, MOTOR34_1KHZ);
18Servo myservo;   
19
20boolean goesForward=false;
21int distance = 100;
22int speedSet = 0;
23
24void  setup() {
25
26  myservo.attach(10);  
27  myservo.write(115); 
28  delay(2000);
29  distance = readPing();
30  delay(100);
31  distance = readPing();
32  delay(100);
33  distance = readPing();
34  delay(100);
35  distance = readPing();
36  delay(100);
37}
38
39void  loop() {
40 int distanceR = 0;
41 int distanceL =  0;
42 delay(40);
43 
44  if(distance<=15)
45 {
46  moveStop();
47  delay(100);
48  moveBackward();
49  delay(300);
50  moveStop();
51  delay(200);
52  distanceR = lookRight();
53  delay(200);
54  distanceL = lookLeft();
55  delay(200);
56
57  if(distanceR>=distanceL)
58  {
59    turnRight();
60    moveStop();
61  }else
62  {
63    turnLeft();
64    moveStop();
65  }
66 }else
67 {
68  moveForward();
69 }
70 distance =  readPing();
71}
72
73int lookRight()
74{
75    myservo.write(50); 
76    delay(500);
77    int distance = readPing();
78    delay(100);
79    myservo.write(115); 
80    return distance;
81}
82
83int lookLeft()
84{
85    myservo.write(170);  
86    delay(500);
87    int distance = readPing();
88    delay(100);
89    myservo.write(115);  
90    return distance;
91    delay(100);
92}
93
94int readPing() { 
95  delay(70);
96  int cm = sonar.ping_cm();
97  if(cm==0)
98  {
99    cm = 250;
100  }
101  return  cm;
102}
103
104void moveStop() {
105  motor1.run(RELEASE); 
106  motor2.run(RELEASE);
107  motor3.run(RELEASE);
108  motor4.run(RELEASE);
109  } 
110  
111void moveForward()  {
112
113 if(!goesForward)
114  {
115    goesForward=true;
116    motor1.run(FORWARD);      
117    motor2.run(FORWARD);
118    motor3.run(FORWARD); 
119    motor4.run(FORWARD);     
120   for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2) 
121   {
122    motor1.setSpeed(speedSet);
123    motor2.setSpeed(speedSet);
124    motor3.setSpeed(speedSet);
125    motor4.setSpeed(speedSet);
126    delay(5);
127   }
128  }
129}
130
131void  moveBackward() {
132    goesForward=false;
133    motor1.run(BACKWARD);      
134    motor2.run(BACKWARD);
135    motor3.run(BACKWARD);
136    motor4.run(BACKWARD);  
137  for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2) 
138  {
139    motor1.setSpeed(speedSet);
140    motor2.setSpeed(speedSet);
141    motor3.setSpeed(speedSet);
142    motor4.setSpeed(speedSet);
143    delay(5);
144  }
145}  
146
147void turnRight() {
148  motor1.run(FORWARD);
149  motor2.run(FORWARD);
150  motor3.run(BACKWARD);
151  motor4.run(BACKWARD);     
152  delay(500);
153  motor1.run(FORWARD);      
154  motor2.run(FORWARD);
155  motor3.run(FORWARD);
156  motor4.run(FORWARD);      
157} 
158 
159void turnLeft() {
160  motor1.run(BACKWARD);     
161  motor2.run(BACKWARD);  
162  motor3.run(FORWARD);
163  motor4.run(FORWARD);   
164  delay(500);
165  motor1.run(FORWARD);     
166  motor2.run(FORWARD);
167  motor3.run(FORWARD);
168  motor4.run(FORWARD);
169}  
170

//Surapaneni Sai Shnamukkha - Obstacle Avoidance Algorithm
#include  <AFMotor.h>  //Motor Driver shield Management Library
#include <NewPing.h>  //Ultrasonic  sensor Library
#include <Servo.h>   //Servo Motor Library

#define TRIG_PIN  A0 
#define ECHO_PIN A1 
#define MAX_DISTANCE 200 
#define MAX_SPEED 200  
#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) 
   {
    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) 
  {
    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);
}

Downloadable files

Circuit Diagram

Make circuit complete as shown in it

Circuit Diagram

Comments

Only logged in users can leave comments

saishanmukkha

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content