Scribd
Upload
25 views16 pages

Arduino Obstacle Avoidance Robot Code

Uploaded by

sunilkrdas549
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
25 views16 pages

Arduino Obstacle Avoidance Robot Code

Uploaded by

sunilkrdas549
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

void loop() {

float duration, distance;


digitalWrite(IR_TRIG, HIGH);
delay(10);
digitalWrite(IR_TRIG, LOW);

duration = pulseIn(IR_ECHO, HIGH);


distance = ((float)(340 * duration) / 10000) / 2;
[Link]("\nDIstance : ");
[Link](distance);

if(distance < 20) { //sense obstacle (20cm)


[Link]("stop");
stop(); //stop(3sec)
}else{ // no obstacle
[Link]("forward");
forward();
}
}
void forward(){
digitalWrite(LEFT_A1, HIGH);
digitalWrite(LEFT_B1, LOW);
digitalWrite(RIGHT_A2, HIGH);
digitalWrite(RIGHT_B2, LOW);
}
void backward(){
digitalWrite(LEFT_A1, LOW);
digitalWrite(LEFT_B1, HIGH);
digitalWrite(RIGHT_A2, LOW);
digitalWrite(RIGHT_B2, HIGH);
delay(500);
}
void left(){
digitalWrite(LEFT_A1, LOW);
digitalWrite(LEFT_B1, HIGH);
digitalWrite(RIGHT_A2, HIGH);
digitalWrite(RIGHT_B2, LOW);
delay(1000);
}
void right(){
digitalWrite(LEFT_A1, HIGH);
digitalWrite(LEFT_B1, LOW);
digitalWrite(RIGHT_A2, LOW);
digitalWrite(RIGHT_B2, HIGH);
delay(1000);
}
void stop(){
digitalWrite(LEFT_A1, LOW);
digitalWrite(LEFT_B1, LOW);
digitalWrite(RIGHT_A2, LOW);
digitalWrite(RIGHT_B2, LOW);
delay(3000);
}

#include <SoftwareSerial.h>

#define LEFT_A1 4

#define LEFT_B1 5

#define RIGHT_A2 6

#define RIGHT_B2 7

#define IR_TRIG 9

#define IR_ECHO 8

void setup() {

[Link](9600);

pinMode(LEFT_A1, OUTPUT);

pinMode(RIGHT_A2, OUTPUT);

pinMode(LEFT_B1, OUTPUT);

pinMode(RIGHT_B2, OUTPUT);
pinMode(IR_TRIG, OUTPUT);

pinMode(IR_ECHO, INPUT);

void loop() {

float duration, distance;

digitalWrite(IR_TRIG, HIGH);

delay(10);

digitalWrite(IR_TRIG, LOW);

duration = pulseIn(IR_ECHO, HIGH);

distance = ((float)(340 * duration) / 10000) / 2;

[Link]("\nDistance : ");

[Link](distance);

int sum = 0;

if(distance < 20) {

[Link]("stop");

stop();

sum++ ;

while (sum > 10) {

[Link]("backward");

backward ();
[Link]("left");

left ();

[Link]("forwardi");

forwardi ();

[Link]("right");

right ();

[Link]("forwardi");

forwardi ();

[Link]("forwardi");

forwardi ();

[Link]("right");

right ();

[Link]("forwardi");

forwardi ();

[Link]("left");

left ();

[Link]("forward");

forward();

}else {

[Link]("forward");

forward();

void forward(){

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, HIGH);
digitalWrite(RIGHT_B2, LOW);

void forwardi (){

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, HIGH);

digitalWrite(RIGHT_B2, LOW);

delay (4000);

void backward(){

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, HIGH);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, HIGH);

delay(1000);

void left(){

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, HIGH);

digitalWrite(RIGHT_A2, HIGH);

digitalWrite(RIGHT_B2, LOW);

delay(1000);

void right(){

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, HIGH);

delay(1000);
}

void stop(){

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, LOW);

delay(3000);

#include <SoftwareSerial.h>

#define LEFT_A1 4

#define LEFT_B1 5

#define RIGHT_A2 6

#define RIGHT_B2 7

#define IR_TRIG 9

#define IR_ECHO 8

int currState = 0;

int nextState = 1;

unsigned long int forwardStartTime;

unsigned long int stopStartTime;

unsigned long int backStartTime;


unsigned long int leftStartTime;

unsigned long int totalForwardTime = 0;

void setup() {

[Link](9600);

pinMode(LEFT_A1, OUTPUT);

pinMode(RIGHT_A2, OUTPUT);

pinMode(LEFT_B1, OUTPUT);

pinMode(RIGHT_B2, OUTPUT);

pinMode(IR_TRIG, OUTPUT);

pinMode(IR_ECHO, INPUT);

void loop() {

float duration, distance;

digitalWrite(IR_TRIG, HIGH);

delay(10);

digitalWrite(IR_TRIG, LOW);

duration = pulseIn(IR_ECHO, HIGH);

distance = ((float)(340 * duration) / 10000) / 2;


distance = 10;

[Link]("\nDistance : ");

[Link](distance);

/*

STATE=0 1. Drive 10m ahead

STATE=1 2. If the ultrasonic sensor detects obstacle 30cm front, the robot stops.

STATE=0 3. If the obstacle is removed, it continues to move

if the obstacle is not removed for 1 minute, it moves but changes path.

STATE=2 The changed path is following: Move backward by 30 cm.

STATE=3 Drive with semi-circle of D=2m to to the left to avoid obstacle.

STATE4 After finishing the 10m straight to front, it ends.

*/

/* State Trnsitions

0 --> 0 keep moving forward

0 --> 1 obstacle detected 30cm

0 --> 4 10 meters achieved

1 --> 0 obstacle removed

1 --> 1 Waiting

1 --> 2 1 minute elapse Change path

2 --> 2 Still moving backward

2 --> 3 backward or 30 cm achieved

3 --> 3 turning to the left

3 --> 0 2m achieved
4 --> 4 Stop

*/

int prevState = currState;

currState = nextState;

if (currState == 0) {

if (distance <= 30) {

nextState = 1;

} else if (prevState != currState) { // just started

forward();

forwardStartTime = millis();

} else { // keep going forward

unsigned long int timeNow = millis();

totalForwardTime = totalForwardTime + timeNow - forwardStartTime;

forwardStartTime = timeNow;

[Link]("forwardStartTime:");

[Link](forwardStartTime);

if (totalForwardTime >= 10000) { //10 meters achieved

nextState = 4;

} else if (currState == 1) {

if (distance > 30) { // obstacle removed

nextState = 0;

} else if (prevState != currState) { // just stoped

stop();

stopStartTime = millis();
} else if (millis() - stopStartTime > 60000) { //60 * 1000ms = 1 minute elapse Change path

nextState = 2;

} else if (currState == 2) {

if (prevState != currState) { // start moving backward

backward();

backStartTime = millis();

} else if (millis() - backStartTime > 3000) { //back 30 cm achieved

nextState = 3;

} else if (currState == 3) {

if (prevState != currState) { // start turning left

left();

leftStartTime = millis();

} else if (millis() - leftStartTime > 20000) { //left 2m achieved

nextState = 0;

} else if (currState == 4) { // Stop

if (prevState != currState) { // start turning left

stop();

while (true) {

void forward() {

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);
digitalWrite(RIGHT_A2, HIGH);

digitalWrite(RIGHT_B2, LOW);

void backward() {

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, HIGH);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, HIGH);

void left() {

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, HIGH);

digitalWrite(RIGHT_A2, HIGH);

digitalWrite(RIGHT_B2, LOW);

void right() {

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, HIGH);

void stop() {

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, LOW);

#include <SoftwareSerial.h>
#define LEFT_A1 4

#define LEFT_B1 5

#define RIGHT_A2 6

#define RIGHT_B2 7

#define IR_TRIG 9

#define IR_ECHO 8

void setup() {

[Link](9600);

pinMode(LEFT_A1, OUTPUT);

pinMode(RIGHT_A2, OUTPUT);

pinMode(LEFT_B1, OUTPUT);

pinMode(RIGHT_B2, OUTPUT);

pinMode(IR_TRIG, OUTPUT);

pinMode(IR_ECHO, INPUT);

void loop() {

float duration, distance;

digitalWrite(IR_TRIG, HIGH);

delay(10);
digitalWrite(IR_TRIG, LOW);

duration = pulseIn(IR_ECHO, HIGH);

distance = ((float)(340 * duration) / 10000) / 2;

[Link]("\nDistance : ");

[Link](distance);

int sum = 0;

while(distance < 20) {

[Link]("stop");

stop();

sum++ ;

[Link](sum);

float duration, distance;

digitalWrite(IR_TRIG, HIGH);

delay(10);

digitalWrite(IR_TRIG, LOW);

duration = pulseIn(IR_ECHO, HIGH);

distance = ((float)(340 * duration) / 10000) / 2;

[Link]("\nDistance : ");

[Link](distance);

if(distance >= 20){

[Link]("forward");
forward();}

if(distance >= 20) {

break;

if(sum > 9) {

[Link]("backward");

backward ();

[Link]("left");

left ();

[Link]("forwardi");

forwardi ();

[Link]("right");

right ();

[Link]("forwardi");

forwardi ();

[Link]("forwardi");

forwardi ();

[Link]("right");

right ();

[Link]("forwardi");

forwardi ();

[Link]("left");

left ();

[Link]("forward");

forward();

sum = 0;

}
}

if(distance >= 20){

[Link]("forward");

forward();}

void forward(){

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, HIGH);

digitalWrite(RIGHT_B2, LOW);

void forwardi (){

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, HIGH);

digitalWrite(RIGHT_B2, LOW);

delay (2000);

void backward(){

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, HIGH);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, HIGH);

delay(1000);
}

void left(){

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, HIGH);

digitalWrite(RIGHT_A2, HIGH);

digitalWrite(RIGHT_B2, LOW);

delay(500);

void right(){

digitalWrite(LEFT_A1, HIGH);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, HIGH);

delay(500);

void stop(){

digitalWrite(LEFT_A1, LOW);

digitalWrite(LEFT_B1, LOW);

digitalWrite(RIGHT_A2, LOW);

digitalWrite(RIGHT_B2, LOW);

delay(3000);

Common questions

Powered by AI

To enhance sensor management and responsiveness, the code could incorporate non-blocking techniques, replacing 'pulseIn' with interrupt-driven readings. This allows the program to continue other processes while waiting for sensor signals, potentially integrating a state machine to more seamlessly manage asynchronous events and improve real-time obstacle detection .

The program manipulates digital I/O pins to control the direction of the motors, thus altering the robot's movement. For forward movement, specific pins are set HIGH and others LOW, creating a polarity that drives the motors in the desired direction. Different pin combinations result in left and right turns, backwards movement, and stopping, effectively using digital signals to control the motors' direction .

The program transitions to an obstacle avoidance maneuver when the ultrasonic sensor detects an obstacle within 30 cm. This triggers a state change from moving forward (State 0) to stopping (State 1). If the obstacle persists for more than a minute, the robot changes path (State 2), which involves moving backward and then executing a turn to bypass the obstacle .

Improvements could include implementing a priority queue for state transitions, allowing more complex decision trees based on sensor input rather than fixed transitions. Incorporating feedback mechanisms and learning algorithms could enhance adaptability to new scenarios, allowing the robot to dynamically adjust state sequences in real-time based on historical data or environmental changes .

A potential infinite loop is present in the code that handles State 4, where the robot must stop permanently. The use of 'while(true)' without a breaking condition results in an infinite loop, as the robot will continuously execute the stop command and no longer respond to any other commands or changes in state .

The loop in the robot control program continuously checks for obstacles within 20cm using an ultrasonic sensor. If an obstacle is detected, the loop executes commands to stop the robot. If no obstacle is detected, the robot continues moving forward. It also increments a counter used in part of the obstacle avoidance strategy .

The 'pulseIn' function effectively measures the time it takes for ultrasound waves to return, allowing the calculation of distances by dividing travel time. However, its limitations include blocking program execution while waiting for input and potential inaccuracies under certain environmental conditions, like ambient noise or fast-moving targets, limiting real-time responsiveness .

The program achieves precise backward movement by transitioning to State 2 when an obstacle persists beyond one minute. It starts moving backward and measures time using 'millis()'. Once the calculated time corresponds to moving back 30 cm, about 3000 milliseconds, the robot transitions to turn maneuvers, precisely controlling the backward distance .

The program uses a state machine approach to manage the robot's movement. State 0 indicates normal forward motion. If an obstacle is detected within 30 cm, it moves to State 1, stopping the robot. If the obstacle is removed, it returns to State 0. If not removed within a minute, it transitions to State 2, moving backward 30 cm. Then, it transitions to State 3, executing a left semi-circle turn. Once 2 meters are achieved, it reverts to moving forward in State 0. State 4 marks the end of the 10-meter journey .

Delay functions are used to control the duration for which the robot performs specific movements, such as turning or stopping. They ensure that actions complete before transitioning to the next operation. However, excessive reliance on delay may cause inefficiencies, as it can block other critical functions like sensor readings, potentially reducing responsiveness to dynamic environments .

You might also like