Arduino Programming for Robot Car: A Practical Obstacle Avoidance Guide

Embarking on the journey of robotics? Building a robot car is an exciting project, and Arduino provides the perfect platform to bring your creations to life. This guide delves into the essentials of Arduino Programming For Robot Cars, specifically focusing on implementing obstacle avoidance using an ultrasonic sensor. We’ll break down a functional Arduino code example, explaining each part to empower you to build your own intelligent robot car.

Understanding the Basics of Robot Car Programming with Arduino

At the heart of many DIY robotics projects, Arduino stands out for its ease of use and versatility. For a robot car, Arduino acts as the brain, controlling motors, sensors, and decision-making processes. To get started with arduino programming for robot car, you’ll typically need these components:

• Arduino Board: The microcontroller that executes your program.
• Motor Driver: An interface to control the car’s motors, as Arduino pins alone can’t directly power them.
• DC Motors with Wheels: The driving force of your robot car.
• Ultrasonic Sensor: To perceive the environment and detect obstacles by measuring distance.
• Power Supply: Batteries to energize the entire system.

The fundamental principle involves programming the Arduino to read data from the ultrasonic sensor, process this information to detect obstacles, and then control the motors to navigate the car around them. This core logic is what we’ll explore in the code example below.

Step-by-Step Arduino Code Explanation for Obstacle Avoidance

Let’s examine the Arduino code designed for robot car obstacle avoidance. This code snippet provides a basic yet effective approach to making your robot car navigate autonomously.

#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() {
  Serial.begin(9600); // Initialize serial communication for debugging
  pinMode(LEFT_A1, OUTPUT);
  pinMode(RIGHT_A2, OUTPUT);
  pinMode(LEFT_B1, OUTPUT);
  pinMode(RIGHT_B2, OUTPUT);
  pinMode(IR_TRIG, OUTPUT); // Set trigger pin as output
  pinMode(IR_ECHO, INPUT);  // Set echo pin as input
}

void loop() {
  float duration, distance;

  // Trigger the ultrasonic sensor
  digitalWrite(IR_TRIG, HIGH);
  delay(10); // Keep trigger high for 10ms
  digitalWrite(IR_TRIG, LOW);

  // Measure the duration of the echo pulse
  duration = pulseIn(IR_ECHO, HIGH);

  // Calculate distance in centimeters (speed of sound: 340 m/s)
  distance = ((float)(340 * duration) / 10000) / 2;

  Serial.print("nDistance : ");
  Serial.println(distance);

  int sum = 0;
  while(distance < 20) { // If obstacle is closer than 20cm
    Serial.println("stop");
    stop(); // Stop the car
    sum++ ;
    Serial.println(sum);

    // Re-measure distance
    float duration, distance;
    digitalWrite(IR_TRIG, HIGH);
    delay(10);
    digitalWrite(IR_TRIG, LOW);
    duration = pulseIn(IR_ECHO, HIGH);
    distance = ((float)(340 * duration) / 10000) / 2;
    Serial.print("nDistance : ");
    Serial.println(distance);

    if(distance >= 20){
      Serial.println("forward");
      forward(); // Move forward if obstacle is cleared
    }
    if(distance >= 20) {
      break; // Exit the while loop if obstacle is cleared
    }
    if(sum > 9) { // If obstacle persists after multiple stops, perform avoidance maneuver
      Serial.println("backward");
      backward (); // Move backward
      Serial.println("left");
      left ();     // Turn left
      Serial.println("forwardi");
      forwardi (); // Move forward for a short duration
      Serial.println("right");
      right ();    // Turn right
      Serial.println("forwardi");
      forwardi (); // Move forward again briefly
      Serial.println("forwardi");
      forwardi (); // Another short forward movement
      Serial.println("right");
      right ();    // Turn right again
      Serial.println("forwardi");
      forwardi (); // Short forward movement
      Serial.println("left");
      left ();     // Turn left
      Serial.println("forward");
      forward();   // Resume forward movement
      sum = 0;      // Reset the sum counter
    }
  }

  if(distance >= 20){
    Serial.println("forward");
    forward(); // Move forward if no obstacle detected
  }
}

void forward(){
  digitalWrite(LEFT_A1, HIGH);
  digitalWrite(LEFT_B1, LOW);
  digitalWrite(RIGHT_A2, HIGH);
  digitalWrite(RIGHT_B2, LOW);
}

void forwardi (){ // Forward with a delay
  digitalWrite(LEFT_A1, HIGH);
  digitalWrite(LEFT_B1, LOW);
  digitalWrite(RIGHT_A2, HIGH);
  digitalWrite(RIGHT_B2, LOW);
  delay (2000); // Move forward for 2 seconds
}

void backward(){
  digitalWrite(LEFT_A1, LOW);
  digitalWrite(LEFT_B1, HIGH);
  digitalWrite(RIGHT_A2, LOW);
  digitalWrite(RIGHT_B2, HIGH);
  delay(1000); // Move backward for 1 second
}

void left(){
  digitalWrite(LEFT_A1, LOW);
  digitalWrite(LEFT_B1, HIGH);
  digitalWrite(RIGHT_A2, HIGH);
  digitalWrite(RIGHT_B2, LOW);
  delay(500); // Turn left for 0.5 seconds
}

void right(){
  digitalWrite(LEFT_A1, HIGH);
  digitalWrite(LEFT_B1, LOW);
  digitalWrite(RIGHT_A2, LOW);
  digitalWrite(RIGHT_B2, HIGH);
  delay(500); // Turn right for 0.5 seconds
}

void stop(){
  digitalWrite(LEFT_A1, LOW);
  digitalWrite(LEFT_B1, LOW);
  digitalWrite(RIGHT_A2, LOW);
  digitalWrite(RIGHT_B2, LOW);
  delay(3000); // Stop for 3 seconds
}

Code Breakdown:

• Includes and Definitions:

  • #include <SoftwareSerial.h>: While included, this library isn’t actually used in this code. It’s likely a remnant from other code and can be removed.
  • #define ...: These lines assign meaningful names to Arduino pins connected to the motor driver (LEFT_A1, LEFT_B1, RIGHT_A2, RIGHT_B2) and ultrasonic sensor (IR_TRIG, IR_ECHO). This makes the code more readable.

• setup() Function:

  • Serial.begin(9600);: Initializes serial communication, allowing you to send data from your Arduino to the serial monitor on your computer for debugging.
  • pinMode(...): Configures the defined pins as either OUTPUT (for controlling motors and triggering the sensor) or INPUT (for reading sensor echo).

• loop() Function: This function runs continuously, forming the main control cycle of the robot car.

  • Distance Measurement:
    • digitalWrite(IR_TRIG, HIGH); delay(10); digitalWrite(IR_TRIG, LOW);: This sequence triggers the ultrasonic sensor to send out a sound wave.
    • duration = pulseIn(IR_ECHO, HIGH);: Measures the time it takes for the sound wave to return (echo).
    • distance = ((float)(340 * duration) / 10000) / 2;: Calculates the distance to the obstacle based on the speed of sound and the measured duration. The result is in centimeters.
  • Obstacle Detection and Response:
    • while(distance < 20): This loop executes as long as an obstacle is detected within 20cm.
    • stop();: Calls the stop() function to halt the robot car.
    • The code remeasures distance within the while loop.
    • If the obstacle persists (sum > 9 after multiple checks), a series of maneuvers (backward(), left(), forwardi(), right(), etc.) are executed to attempt to navigate around the obstacle. This sequence is a simple pre-programmed avoidance pattern.
  • Forward Movement:
    • if(distance >= 20){ forward(); }: If no obstacle is detected (distance is 20cm or more), the robot car moves forward.

• Movement Functions (forward(), backward(), left(), right(), stop(), forwardi()):

  • These functions control the motors by setting the digital pins HIGH or LOW in specific combinations. The logic here is dependent on your motor driver and how your motors are wired.
  • delay() functions are used to control the duration of each movement. forwardi() is a forward movement with a longer delay.

Enhancing Your Robot Car Project with Arduino Programming

This code provides a solid foundation for arduino programming for robot car projects focused on obstacle avoidance. However, there’s always room for improvement and expansion. Consider these enhancements:

• PID Control for Motors: Implement Proportional-Integral-Derivative (PID) control for smoother and more precise motor control, especially for turns and straight-line driving.
• Advanced Obstacle Avoidance Algorithms: Instead of a fixed maneuver sequence, explore more intelligent algorithms like mapping the environment or path planning to navigate complex obstacle courses.
• Sensor Fusion: Integrate additional sensors like line followers or encoders to create more sophisticated behaviors and improve accuracy.
• Refined Movement Logic: Experiment with different movement durations and patterns to optimize obstacle avoidance performance.

By understanding this basic code and exploring these enhancements, you can significantly advance your arduino programming for robot car skills and build increasingly intelligent and capable robots. Continue experimenting and exploring the vast resources available for Arduino robotics to take your projects to the next level!