SKILL LAB 2024-2025

Robotic Car Project Using Arduino Uno

Table of Contents

1. Introduction

2. Materials Required

3. System Design and Block Diagram

4. Circuit Diagram

5. Working Principle

6. Arduino Code

7. Implementation Steps

8. Testing and Troubleshooting

9. Conclusion

10. References

VEMANA IT / MECH.ENGG 1
SKILL LAB 2024-2025

1. Introduction:

The world of robotics is rapidly evolving, and automation has become a significant part of daily life. From
manufacturing industries to home automation, robotics has found its way into various applications. One of
the fundamental aspects of learning robotics is building simple autonomous vehicles that can perform basic
tasks such as obstacle avoidance and path following. This project aims to create a robotic car using an
Arduino Uno microcontroller that responds to environmental stimuli, specifically obstacles, by moving
backward to avoid collisions. This simple robotic car can serve as an educational tool for beginners in
electronics, programming, and robotics, helping them understand the fundamentals of sensor integration,
motor control, and decision-making logic.

The project is centered around an Arduino Uno, a widely used and versatile microcontroller board based on
the ATmega328P, it is well-suited for DIY projects and prototyping due to its simplicity and compatibility
with a wide variety of sensors, actuators, and modules. This project also employs an ultrasonic distance
sensor (such as the HC-SR04), a critical component in obstacle detection. The sensor allows the car to "see"
obstacles in its path by emitting ultrasonic waves and calculating the time it takes for the waves to bounce
back after hitting an object. By processing this information, the Arduino can make decisions about the car's
movement, such as reversing when an obstacle is too close.

Another essential component in the system is the motor driver IC (such as the 1.298N), which allows the
Arduino to control the motors that drive the car. Since the Arduino itself cannot supply enough current to
power motors, the motor driver acts as an intermediary. receiving low-power signals from the Arduino and
using external power sources to drive the motors. This enables the car to move forward, backward, or stop
based on the sensor input. Jumper wires are used to connect the components, providing a flexible and simple
way to wire the various parts of the system.

One of the key features of this project is its simplicity and accessibility. The components used are readily
available and inexpensive, making it an ideal project for beginners or students looking to delve into the
world of robotics and embedded systems. The project introduces learners to several important concepts such
as sensor data acquisition, motor control, and feedback loops. Furthermore, it provides hands-on experience
with coding, as the Arduino must be programmed to handle the sensor inputs and control the motors
accordingly. The code used in this project is straightforward and written in C++, the primary language used
in the Arduino programming environment System. The distance sensor used in this project, the ultrasonic

VEMANA IT / MECH.ENGG 2
SKILL LAB 2024-2025

sensor, sends out ultrasonic waves and measures the time it takes for them to return after bouncing off an
object. This allows the sensor to calculate the distance between the car and the object. When the car gets too
close to an object, it automatically moves backward until it reaches a safe distance. This type of feedback
mechanism is fundamental in robotics and automation, where systems must continuously respond to changes
in their environment.

The project can be expanded upon or modified in several ways. For example, additional sensors such as
infrared or touch sensors can be integrated to enhance the car's ability to detect obstacles or follow specific
paths. More advanced control algorithms can be implemented to make the car's movements smoother and
more efficient. Furthermore, wireless control using Bluetooth or Wi-Fi modules can be introduced, allowing
users to manually control the car or receive data about its surroundings remotely.

From a practical perspective, this project provides a hands-on introduction to several important engineering
and programming concepts. For students and hobbyists, building a robotic car introduces them to the basics
of autonomous navigation, which is a vital component of modem robotics. The project demonstrates how
sensors can be used to gather information about the environment, how that information can be processed in
real-time, and how decisions can be made based on processed data. It also touches on important aspects of
electrical engineering, such as motor control and power management, as the car requires a motor driver to
function correctly and a reliable power supply to drive both the motors and the Arduino.

In conclusion, this project offers a well-rounded introduction to the world of robotics and embedded
systems. By building an Arduino-based robotic car, learners gain valuable.

VEMANA IT / MECH.ENGG 3
SKILL LAB 2024-2025

2. Materials Required

The following components are used in the project:

1. Arduino Uno (Arduino ide)

2. IC Controller (Motor Driver, such as L298N)

3. Ultrasonic Distance Sensor (HC-SR04)

4. Jumper Wire

5. Motors

6. Batteries and Battery Holder

7. Chassis of the car

8. Arduino uno

1. Arduino uno

The Arduino Uno is a widely used microcontroller board based on the ATmega328P chip. It is part of the
Arduino family, which is known for its ease of use in electronic projects and prototyping. The hoard is
equipped with 14 digital input/output pins, 6 analog inputs, a 16. MHz ceramic resonator, a SB connection, a
power jack, an ICSP header, and a reset button. It operates at 5V and can be powered via a USB cable or an
external power supply (typically 7 to 12V).

VEMANA IT / MECH.ENGG 4
SKILL LAB 2024-2025

What makes the Arduino Uno popular is its open-source platform, which is accompanied by a robust
integrated development environment (IDE) where users can write and upload code using C++-based
Arduino programming language. The Arduino community also provides extensive tutorials and libraries,
simplifying development for novices and experts alike. In this robotic car project, the Arduino Uno acts as
the central controller, processing input from the ultrasonic sensor and sending commands to the motor driver
to control the car's movement. Its versatility and accessibility make it an ideal choice for robotics and
embedded system applications.

2. IC Controller {Motor Driver, such as L298N)

The IC Controller or motor driver (e.g., L298N) is a critical component in projects involving motors, as it
allows the microcontroller (in this case, Arduino Uno) to control the direction and speed of the motors. The
L298N is a dual H-bridge motor driver that enables independent control of two DC motors. It allows the
motors to be driven in both directions (forward and backward) and provides the necessary power to them, as
microcontrollers are not capable of directly supplying the current needed to operate motors.

The L298N has multiple input and output pins. It takes low-power signals from the Arduino and translates
them into high-power signals for the motors. It has two enabled pins that control the speed of the motors and
four input pins that determine the direction of the motors. Additionally, the motor driver can be powered by
an external power supply, and it typically comes with a heat sink to dissipate the heat generated during
operation. In this robotic car project, the motor driver controls the left and right motors to move the car
forward, backward, or stop based on the commands from the Arduino.

VEMANA IT / MECH.ENGG 5
SKILL LAB 2024-2025

3. Ultrasonic Distance Sensor [HC-SR04]

The ultrasonic distance sensor, such as the HC-SR04, is an essential part of this robotic car. project for
obstacle detection. The sensor works by emitting ultrasonic sound waves from a transmitter and measuring
the time it takes for the waves to bounce back from an object and return to the receiver.

This time interval is used to calculate the distance between the sensor and the object, making the HC-SR04
ideal for proximity sensing and object detection applications.

The HC-SR04 sensor has four pins: VCC (for power), Trig (trigger input), Echo (output), and GND
(ground). When the Arduino sends a signal to the Trig pin, the sensor sends out a series of ultrasonic pulses.
The Echo pin then reads the return signal, and the Arduino calculates the time it took for the echo to return,
which is converted into distance.

4. Jumper Wires

Jumper wires are essential components used in prototyping and electronic projects to establish
connections between various components without soldering. They are typically. made from insulated
wire with metal pins at each end, allowing them to be easily inserted into breadboards or connected
to header pins on microcontroller boards like the Arduino Uno. Jumper wires come in three types:
male-to-male, male-to-female, and female-to-female, depending on the connections required in a
circuit.

In the context of this robotic car project, jumper wires are used to connect the Arduino Uno to the
ultrasonic sensor, motor driver, and other components.

VEMANA IT / MECH.ENGG 6
SKILL LAB 2024-2025

5. Motors

Motors are the driving force behind the movement of the robotic car, converting electrical energy into
mechanical motion. In most robotic car projects, DC motors are commonly used due to their
simplicity, efficiency, and ease of control. A DC motor operates on direct current and consists of a
rotor (or armature), stator, and brushes that enable rotation when electrical current flows through the
motor. In this project, two DC motors are typically mounted on the chassis to control the movement
of the car's wheels, allowing for forward and backward motion.

The motors are controlled by the motor driver, which regulates the voltage and direction of the
current supplied to the motors based on commands from the Arduino.

6. Batteries and Battery Holder

Batteries serve as the power source for the entire robotic car system, providing the necessary
electrical energy to the motors, sensors, and Arduino Uno. In most cases, a combination of AA or Li
ion batteries is used, depending on the power requirements of the motors and electronic components.
The Arduino board itself can operate on voltages between 7V and 12V, while the motors typically
require a higher current than what the Arduino can supply directly, hence the need for external
batteries.

VEMANA IT / MECH.ENGG 7
SKILL LAB 2024-2025

7. Chassis for the Car

The chassis of the robotic car provides the structural framework that holds all the components together,
including the motors, wheels, battery pack, Arduino board, and sensors. Typically made from durable
materials such as plastic or metal, the chassis must be sturdy enough to support the weight of all the
components while maintaining stability during movement. A well-designed chassis ensures that the
motors and wheels are properly aligned, allowing the car to move efficiently without veering off
course.

3.System Design and Block Diagram

Wire connection

VEMANA IT / MECH.ENGG 8
SKILL LAB 2024-2025

Circuit diagram

Car design

The system design of the Arduino-based robotic car project is focused on creating an autonomous
vehicle capable of obstacle detection and avoidance using basic electronic components. The design
integrates several elements such as the Arduino Uno, ultrasonic distance sensor, motor driver, motors,
and power supply, all working together to achieve the desired functionality.

The project follows a modular design approach, where each component has a specific role in the
system, and all modules work together to create a cohesive, autonomous vehicle. The core function
of the system is to detect objects or obstacles in the car's path using an ultrasonic distance sensor.
Based on the sensor's readings, the system processes data using the Arduino microcontroller and
makes real-time decisions regarding the car's movement. If an obstacle is detected within a
predefined distance, the car will reverse to maintain a safe distance from the object, and once the
path is clear, the car resumes forward movement.

VEMANA IT / MECH.ENGG 9
SKILL LAB 2024-2025

Block Diagram Explanation

In the block diagram of the system, the components interact in a logical sequence:

Ultrasonic Sensor: Positioned at the front of the car, the ultrasonic sensor constantly monitors for
obstacles. The sensor sends data (distance readings) to the Arduino.

Arduino: The Arduino receives the distance data from the sensor and processes it. Based on
predefined conditions (e.g., if the distance is less than 20 cm), the Arduino decides whether to
continue moving forward or to reverse the car. The Arduino sends control signals to the motor driver
based on these decisions.

Motor Driver: The motor driver receives control signals from the Arduino. These signals determine
whether the motors should move the car forward, backward, or stop. The motor driver powers the
motors using an external battery source.

Motors: The motors rotate the wheels of the car, allowing it to move in the desired direction. Their
movement is controlled by the motor driver, which receives commands from the Arduino.
Power Supply: A battery pack powers the motor driver, which in turn powers the motors. The
Arduino is powered separately via a battery or USB connection.

Circuit Diagram:

The circuit involves connecting the ultrasonic sensor to the Arduino for input, and connecting the
motor driver to the Arduino and motors for output. The diagram shows how each component is
wired together.

VEMANA IT / MECH.ENGG 10
SKILL LAB 2024-2025

Working Principle

The working principle of the Arduino-based robotic car revolves around the coordination of multiple
electronic components to create an autonomous system capable of obstacle detection and avoidance.
The robotic car responds to its surroundings by using an ultrasonic distance sensor to detect obstacles
and a motor driver to control the car's movement based on the sensor's input. This system is a
fundamental example of embedded systems and robotics, where microcontrollers, sensors, and
actuators work together to accomplish a task.

1. Central Control by Arduino Uno

At the heart of the system is the Arduino Uno microcontroller. The Arduino acts as the brain. of the
robotic car, coordinating the actions of various components. It processes inputs from the ultrasonic
sensor and sends corresponding outputs to the motor driver, which in turn controls the motors. The
Arduino is programmed with a set of instructions (written in the Arduino IDE) that define how the
car behaves when encountering obstacles.

The working principle begins when the Arduino is powered on. The program uploaded to the
Arduino includes the following logical flow: Continuously monitor the environment for obstacles
using the ultrasonic sensor.

If an obstacle is detected within a predefined range (e.g., 20 cm), instruct the car to reverse, once the
path is clear, instruct the car to resume forward motion.

2. Obstacle Detection Using the Ultrasonic Sensor

The ultrasonic distance sensor (such as the HC-SR04) is a crucial component in the car's. ability to
detect obstacles. The sensor operates by emitting ultrasonic waves from a transmitter. These waves
travel through the air until they hit an object, at which point they bounce back toward the sensor's
receiver. The sensor calculates the distance to the object based on the time it takes for the sound
waves to travel to the object and back.

Triggering and Echo Mechanism: The Arduino sends a signal to the sensor's Trig pin, which
triggers the sensor to emit a series of ultrasonic pulses. When the pulses hit an object, they are
reflected back to the sensor's Echo pin.

VEMANA IT / MECH.ENGG 11
SKILL LAB 2024-2025

Action Based on Distance: The Arduino processes this distance data and compares it to a
predefined threshold (e.g., 20 cm). If the detected distance is below the threshold, it triggers the
car to stop moving forward and begin moving backward.

3. Motor Control via the Motor Driver

Since the Arduino cannot supply enough current to drive the motors directly, a motor driver (such
as the L298N) is used as an intermediary between the Arduino and the motors.

The motor driver receives control signals from the Arduino and uses an external power source (battery
pack) to power the motors,

H-Bridge Operation: The L298N motor driver uses an H-bridge configuration to control the
direction of the motors. An H-bridge allows the current to flow in both directions. through the
motor, enabling it to move forward or backward depending on the input signals from the Arduino.
By varying the control signals, the Arduino can instruct the motor driver to either rotate the motors
forward (moving the car forward) or reverse the motors (moving the car backward).

1-Speed Control: In addition to controlling direction, the motor driver can also control the speed
of the motors using Pulse Width Modulation (PWM). By adjusting the duty cycle of PWM signals,
the Arduino can regulate how fast the motors spin, allowing for smoother movement and better
control over the car's motion.

Movement and Obstacle Avoidance

Once the system is powered, the car moves forward until an obstacle is detected by the ultrasonic
sensor. When an object comes within the preset distance threshold, the following steps occur.

Detection: The ultrasonic sensor detects the obstacle and sends the distance data to the Arduino .

VEMANA IT / MECH.ENGG 12
SKILL LAB 2024-2025

Decision Making:

The Arduino processes the data and determines whether the car needs to reverse. If the object is
within the unsafe range (e.g., 20 cm), the Arduino instructs the motor driver to reverse the car.

Motor Reversal:

The motor driver reverses the direction of the motors, causing the car to move backward.

Safe Distance:

Once the car is at a safe distance (as determined by the sensor), the Arduino instructs the motor
driver to stop the reversal and resume forward motion. This cycle repeats as the car navigates its
environment, continuously avoiding obstacles.

Power Supply and Integration:

The entire system is powered by a battery pack, which provides the necessary voltage and current
to run both the Arduino and the motors. The Arduino can be powered by a 9V. battery or through a
USB connection, while the motors receive power through the motor driver, which is connected to an
external battery pack capable of supplying sufficient current for motor operation.

Arduino Code

//esp32 board version must be 2.0.11

//otherwise the code will not compile

#include "BluetoothSerial.h" #include

<Arduino.h> BluetoothSerial serialBT;

//Bluetooth signal Store in this variable

char btSignal;

VEMANA IT / MECH.ENGG 13
SKILL LAB 2024-2025

//initial Speed int

Speed = 100;

//declare channel for pwm Output

#define R 0

#define L 1

//PWM Pin for Controlling the speed int enA

= 4;

int enB = 21;

//motor controlling pin int IN1 = 2;

int IN2 = 13; int

IN3 = 4; int IN4

= 5;

void setup0
{ Serial.begin(115200
);

//Bluetooth Name serialBT.begin("Car");

//output pin declare pinMode(enA,

OUTPUT); pinMode(enB, OUTPUT);

// Setup PWM channels

// ledcSetup(R, 10000, 8); // Channel O for Motor A, 1 kHz frequency, 8-bit resolution

// ledcAttachPin(enA, R);

// ledcSetup(L, 10000, 8); // Channel 1 for Motor B, 1 kHz frequency, 8-bit resolution

// ledcAttachPin(enB, L);

pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);

VEMANA IT / MECH.ENGG 14
SKILL LAB 2024-2025

//Initial State of Car digitaIWrite(IN1,

LOW); digitaIWrite(IN2, LOW);
digitaIWrite(IN3, LOW);

digitaIWrite(IN4, LOW); }

void loop0 {

while (serialBT.available0) { btSignal

= serialBT.read0;

// Print the received signal

Serial.println(btSignal);

if (btSignal == 'L') Speed= 100; if

(btSignal == 'M') Speed= 150; if
(btSignal == 'H') Speed= 200; if
(btSignal == '3') Speed= 130;

if (btSignal == '4') Speed= 140;

if (btSignal == '5') Speed= 150;

if (btSignal == '6') Speed= 180;

if (btSignal == '7') Speed= 200;

if (btSignal == '8') Speed= 220;

if (btSignal == '9') Speed= 240;

if (btSignal == 'V') Speed = 255;

VEMANA IT / MECH.ENGG 15
SKILL LAB 2024-2025

II Perform actions and print them B if

(btSignal == 'B') { Serial.println("Moving

Backward");

backwardO; }

else if (btSignal == 'F')

{ Serial.println("Moving Forward"); forwardO;
}

else if (btSignal == 'L')

{ Serial.println("Turning Left"); leftO;
}

else if (btSignal == 'R')

{ Serial.println("Turning Right");
rightO;
}

else if (btSignal == 'S')

{ Serial.println("Stopping");

stop0;

} } }

// Function for backward motion void

backward0 {Serial.println("Motors
running in backward direction");
ledcWrite(R, Speed);

ledcWrite(L, Speed);

digitaIWrite(IN1, LOW);
digitaIWrite(IN2, HIGH);
digitaIWrite(IN3, LOW);
digitaIWrite(IN4, HIGH);

}
// Function for forward motion void
forward0 {

VEMANA IT / MECH.ENGG 16
SKILL LAB 2024-2025

Serial.println("Motors running in forward direction");

ledcWrite(R,Speed);

ledcWrite(L, Speed);

digitaIWrite(IN1, HIGH);
digitaIWrite(IN2, LOW);
digitaIWrite(IN3, HIGH);
digitaIWrite(IN4, LOW);}

// Function for left turn void left0 {

Serial.println("Motors running for left turn"); ledcWrite(R,

Speed);

ledcWrite(L, Speed);

// Function for right turn void

right0 {

Serial.println("Motors running for right turn"); ledcWrite(R,

Speed);

ledcWrite(L, Speed);

digitaIWrite(IN1, LOW);
digitaIWrite(IN2, HIGH);
digitaIWrite(IN3, HIGH);
digitaIWrite(IN4, LOW);

digitaIWrite(IN1, HIGH);
digitaIWrite(IN2, LOW);
digitaIWrite(IN3, LOW);
digitaIWrite(IN4, HIGH);

// Function to stop the car void

stop0 {

Serial.println("Motors stopped");

VEMANA IT / MECH.ENGG 17
SKILL LAB 2024-2025

ledcWrite(R, O); // Set PWM to O to stop the motors

ledcWrite(L, O);

igitaIWrite(IN1, LOW);
digitaIWrite(IN2, LOW);
digitaIWrite(IN3, LOW);
digitaIWrite(IN4, LOW);

1. Implementation Steps

2. Assemble the chassis and attach the motors.

3. Connect the ultrasonic sensor to the Arduino pins.

4. Connect the motor driver to the Arduino and motors,

5. Power the Arduino and motor driver using batteries.

6. Upload the Arduino code (Arduino ide).

7. Testing and Troubleshooting

Testing and troubleshooting are critical steps to ensure the proper functioning of the Arduino-
based robotic car. The process involves verifying individual components and system-wide
integration.

Testing:

Ultrasonic Sensor: Test the sensor by uploading a basic Arduino code to check its distance readings.
Ensure the sensor is accurately detecting objects within the defined range.

Motor and Motor Driver: Run a simple test to verify that the motors respond to control signals.
Ensure they move forward, backward, and stop as per the Arduino instructions.

Power Supply: Confirm that the hattery provides sufficient voltage and current for the Arduino,
motor driver, and motors without causing dips in power or shutdowns.

Troubleshooting:

Incorrect Sensor Readings: Check the connections between the ultrasonic sensor and Arduino. Ensure
the sensor's trigger and echo pins are correctly connected.

VEMANA IT / MECH.ENGG 18
SKILL LAB 2024-2025

Motor Not Responding: Verify that the motor driver is connected properly to both the Arduino and
the power supply. Check for loose jumper wires.

Power Issues: Ensure the batteries are charged and that the ground connections are properly wired to
avoid short circuits or power loss.

By methodically testing each component and fixing connection or code issues, the system. can be made
reliable for obstacle detection and movement.

Conclusion:
The Arduino-based robotic car project represents a foundational step into the world of embedded
systems, automation, and robotics. Through the integration of essential electronic components such
as the Arduino Uno, motor driver, ultrasonic sensor, DC motors, and a reliable power supply, this
project demonstrates the principles of real-time data processing, decision-making, and mechanical
control. The goal of the robotic car is to navigate autonomously by detecting obstacles in its
environment and taking appropriate action, such reversing or stopping to avoid collisions. This
project not only teaches the basics of circuit design and coding but also opens the door to more
advanced applications in robotics and autonomous systems.

Learning Outcomes and Practical Applications:

One of the key takeaways from this project is the understanding of how microcontrollers like the
Arduino work in conjunction with sensors and actuators. The Arduino Uno acts as the brain of the
system, processing input from the ultrasonic sensor and translating it into control signals for the
motor driver, which in turn drives the motors. This process of real- time data processing and action
based on sensor input is the foundation of autonomous systems, whether in simple robotic cars or
more complex machines like drones or industrial robots.

This project also introduces essential concepts such as pulse-width modulation (PWM) for speed
control, H-bridge circuitry for motor direction control, and basic programming logic for decision-
making based on sensor input. Moreover, the robotic car demonstrates the importance of modular
design, where each component (sensor, motor, motor driver, and power supply) operates
independently but is integrated into a larger system. This modularity not only makes the system
easier to troubleshoot and maintain but also allows for future upgrades and enhancements.

VEMANA IT / MECH.ENGG 19
SKILL LAB 2024-2025

Challenges and Solutions:

While building this project, several challenges may arise, primarily in the areas of wiring,
component selection, and coding. Ensuring proper connections between the Arduino, motor driver,
sensors, and power supply is essential for reliable operation.

Another challenge is related to power management. Motors require significantly more power than
sensors and the microcontroller, so ensuring that the battery can provide current without voltage
drops is essential for smooth operation. Using the appropriate power source and voltage regulator
can solve many power-related issues.

Coding errors can also lead to unpredictable behaviour in the robotic car. Testing small segments of
code separately before integrating them into the main program helps to ensure that each function
behaves as expected. The Arduino IDE offers a user-friendly platform to test and debug the code
incrementally, making troubleshooting easier.

Future Enhancements

The project as it stands is a basic implementation of obstacle avoidance in a robotic car. However, it
offers vast potential for future enhancements. For instance, more sophisticated sensors like infrared or
lidar could be added to improve obstacle detection accuracy.

Integration of GPS or Bluetooth modules would allow for remote control or autonomous navigation
along predefined routes.

In summary, the Arduino-based robotic car project is an excellent starting point for anyone interested
in learning about robotics, embedded systems, and automation. The knowledge. and skills gained
from this project lay a strong foundation for further exploration into the fields of robotics and
artificial intelligence, and the project itself can be expanded in countless ways to meet the challenges
of more complex applications.

VEMANA IT / MECH.ENGG 20
SKILL LAB 2024-2025

VEMANA IT / MECH.ENGG 21
SKILL LAB 2024-2025

DISCUSSION ON ROBOTIC ARM WITH STUDENTS AND FACULTY.

VEMANA IT / MECH.ENGG 22