Code Your Own Obstacle-Avoiding Robot Car: A Beginner's Guide

Embark on an exciting journey into the world of robotics and coding by building your very own obstacle-avoiding robot car! This project is perfect for beginners eager to learn about Arduino programming and create a fun, interactive device. We’ll break down the code step-by-step, making it easy for you to understand and implement. Let’s dive into the fascinating realm of Coding Robot Cars.

Understanding the Code Structure for Your Robot Car Project

The foundation of our robot car lies in Arduino code, structured into two primary functions: setup() and loop(). The setup() function is executed once at the beginning. It’s where we initialize settings like defining pin modes and starting serial communication for debugging. The loop() function, as the name suggests, runs continuously, forming the core logic of our robot car’s behavior.

#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);
  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() {
  // ... (loop code explained below) ...
}

This initial code block sets up the necessary pins for controlling the robot’s motors and the ultrasonic sensor. #define statements assign names to pin numbers, making the code more readable. For instance, LEFT_A1 is assigned to pin 4, which we’ll use to control one side of the robot’s motors.

Components and Connections for Coding a Robot Car

To bring this code to life, you’ll need a few key components:

Arduino Board: The brain of your robot, processing the code and controlling the components.
Motor Driver: To control the car’s motors, as Arduino pins alone cannot provide enough power.
DC Motors and Wheels: To make your robot car move.
Ultrasonic Sensor (HC-SR04): This sensor acts as the “eyes” of your robot, detecting obstacles by emitting sound waves and measuring their return time.
Jumper Wires: To connect all the components to the Arduino board.

The code defines specific pins for motor control (LEFT_A1, LEFT_B1, RIGHT_A2, RIGHT_B2) and the ultrasonic sensor (IR_TRIG, IR_ECHO). Connecting these components correctly to your Arduino according to these pin definitions is crucial for the robot to function as intended.

Alt text: Wiring diagram showing the connections between Arduino, motor driver, DC motors, and ultrasonic sensor for a robot car project.

Decoding the Movement Functions in Robot Car Code

The code includes several functions that dictate the robot car’s movements: forward(), backward(), left(), right(), stop(), and forwardi(). Let’s examine each one:

forward(): This function instructs the robot to move forward by setting the appropriate pins HIGH and LOW to activate the motors in the forward direction.
```
void forward(){
  digitalWrite(LEFT_A1, HIGH);
  digitalWrite(LEFT_B1, LOW);
  digitalWrite(RIGHT_A2, HIGH);
  digitalWrite(RIGHT_B2, LOW);
}
```
backward(): Similarly, backward() makes the robot move in reverse by reversing the motor directions.
```
void backward(){
  digitalWrite(LEFT_A1, LOW);
  digitalWrite(LEFT_B1, HIGH);
  digitalWrite(RIGHT_A2, LOW);
  digitalWrite(RIGHT_B2, HIGH);
  delay(1000);
}
```
Notice the delay(1000); in the backward() function. This makes the robot move backward for 1 second.

left() and right(): These functions control turning by making one side of the motors move forward while the other side moves backward, or stops, resulting in a turn.

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

The delay(500); in left() and right() determines the duration of the turn.

stop(): This function brings the robot to a halt by deactivating all motors.

void stop(){
  digitalWrite(LEFT_A1, LOW);
  digitalWrite(LEFT_B1, LOW);
  digitalWrite(RIGHT_A2, LOW);
  digitalWrite(RIGHT_B2, LOW);
  delay(3000);
}

The delay(3000); in stop() makes the robot stop for 3 seconds.

forwardi(): This function is similar to forward(), but it includes a delay, causing the robot to move forward for a specific duration.
```
void forwardi (){
  digitalWrite(LEFT_A1, HIGH);
  digitalWrite(LEFT_B1, LOW);
  digitalWrite(RIGHT_A2, HIGH);
  digitalWrite(RIGHT_B2, LOW);
  delay (2000);
}
```
The delay(2000); in forwardi() makes the robot move forward for 2 seconds.

Understanding these movement functions is key to grasping how the robot car navigates its environment.

Alt text: Animated GIF showing a small robot car moving forward, illustrating the action of the forward() function in the Arduino code.

Obstacle Detection Logic: Coding the “Brain” of Your Robot Car

The loop() function contains the core logic for obstacle avoidance. It uses the ultrasonic sensor to measure the distance to objects in front of the robot.

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;
  Serial.print("nDistance : ");
  Serial.println(distance);

  int sum = 0;
  while(distance < 20) {
    Serial.println("stop");
    stop();
    sum++ ;
    Serial.println(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;
    Serial.print("nDistance : ");
    Serial.println(distance);
    if(distance >= 20){
      Serial.println("forward");
      forward();}
    if(distance >= 20) {
      break;
    }
    if(sum > 9) {
      Serial.println("backward");
      backward ();
      Serial.println("left");
      left ();
      Serial.println("forwardi");
      forwardi ();
      Serial.println("right");
      right ();
      Serial.println("forwardi");
      forwardi ();
      Serial.println("forwardi");
      forwardi ();
      Serial.println("right");
      right ();
      Serial.println("forwardi");
      forwardi ();
      Serial.println("left");
      left ();
      Serial.println("forward");
      forward();
      sum = 0;
    }
  }
  if(distance >= 20){
    Serial.println("forward");
    forward();}
}

Let’s break down this crucial part:

Distance Measurement: The code first triggers the ultrasonic sensor to send out a sound wave (digitalWrite(IR_TRIG, HIGH); digitalWrite(IR_TRIG, LOW);) and then measures the duration of the echo (duration = pulseIn(IR_ECHO, HIGH);). This duration is used to calculate the distance to the nearest object.
Obstacle Detection and Response: The while(distance < 20) loop checks if an obstacle is within 20 centimeters. If an obstacle is detected:
- The robot stop()s.
- A counter sum increments.
- If sum exceeds 9 (meaning the robot has encountered obstacles multiple times in a row), it initiates a sequence of movements to navigate away from the obstacle: backward(), left(), forwardi(), right(), and so on. This series of movements is designed to get the robot out of a corner or away from a persistent obstacle.
- If the distance becomes greater than or equal to 20cm after stopping or maneuvering, the robot resumes moving forward().
Continuous Loop: The loop() function ensures that this distance measurement and obstacle avoidance process repeats continuously, allowing the robot car to navigate autonomously.

By understanding this logic, you can modify and expand upon the code to create more complex robot behaviors.

Conclusion: Your First Steps in Coding Robot Cars

This code provides a fundamental framework for coding an obstacle-avoiding robot car. It demonstrates basic movement control and sensor integration, offering a fantastic starting point for your robotics journey. Experiment with the code, adjust the distances, delays, and movement sequences to customize your robot’s behavior. With further exploration and learning, you can enhance your robot car with more sophisticated features and algorithms. Happy coding and building!