Smart Self-Driving Car with Obstacle

Avoidance, Bluetooth Remote Control, and

Voice Command Integration

Submitted By
Ronit Kumar Dey - D222316126
Sanjib Naiya - D232401764
Nasirul Ali Khan - D212200628
Imran Saikh - D232401762
Jit Saha - D232401755

Under the supervision of “Suman Poddar”

Academic Year: 2023-2024

REPORT SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE

DIPLOMA IN COMPUTER SCIENCE & TECHNOLOGY UNDER WEST BENGAL STATE
COUNCIL OF TECHNICAL & VOCATIONAL EDUCATION AND SKILL DEVELOPMENT

DEPARTMENT OF COMPUTER SCIENCE & TECHNOLOGY

APC RAY PLOLYTECHNIC
188, Raja Subodh Chandra Mallick Rd, Jadavpur, Kolkata
- 700032

CERTIFICATE OF RECOMMENDATION
0
We hereby recommend that the project report prepared under our
supervision by
Ronit Kumar Dey,
Sanjib Naiya,
Nasirul Ali Khan,
Imran Saikh,
Jit Saha,

Entitled “Smart Self-Driving Car with Obstacle Avoidance,

Bluetooth Remote Control, and Voice Command Integration”
be accepted in partial fulfillment of the requirements for the
DIPLOMA IN “COMPUTER SCIENCE &
TECHNOLOGY”.

________________________________________ ______________________
Head, Computer Sc. & Technology Department, Project Guide
APC Ray Polytechnic, Jadavpur, Kolkata

1
 CERTIFICATE OF APPROVAL*
(Diploma in COMPUTER SCIENCE & TECHNOLOGY)

This project report is hereby approved as a creditable study of an

engineering subject carried out and presented in a manner satisfactory to
warrant its acceptance as a pre-requisite to the diploma for which it has
been submitted. It is to be understood that by this approval, the
undersigned do not necessarily endorse or approve any statement made,
opinion expressed and conclusion drawn therein but approve the project
report only for the purpose for which it has been submitted.

COMMITTEE ON FINAL 1. ----------------------------------------

EXAMINATION FOR
EVALUATION OF 2. -----------------------------------------
PROJECT REPORT
3. -----------------------------------------

4. -----------------------------------------

5. -----------------------------------------

* Only in case report is approved.

ABSTRACT

This project presents the design and development of a Smart Self-

Driving Car that integrates three major control systems: Obstacle
2
Avoidance, Bluetooth-based Remote Control, and Voice
Command Integration. The primary objective of this project is to
create a compact, cost-effective, and intelligent robotic vehicle
capable of autonomous navigation while maintaining remote
operability and user interaction through voice.

The Obstacle Avoidance system utilizes an ultrasonic sensor to

detect nearby obstacles and automatically adjusts the car's movement
to avoid collisions. The system continuously monitors the
surroundings in real-time, making it suitable for dynamic and
unpredictable environments. The Bluetooth Remote Control feature
allows the user to control the car manually using a smartphone or
compatible device, offering flexible control for various use cases.
Furthermore, the Voice Command Integration adds a hands-free
interaction layer, enabling users to issue movement commands using
simple voice inputs via a microphone and voice recognition module
or mobile app.

The hardware implementation is based on an Arduino Uno

microcontroller, with integration of DC motors, servo motors, and
various sensors. The software is developed using the Arduino IDE,
combining sensor data handling, motor control logic, and
communication protocols. This project demonstrates the potential of
embedded systems and IoT in developing intelligent robotic platforms
that can assist in education, home automation, and prototyping for
more advanced autonomous systems.

Overall, the Smart Self-Driving Car is a multifunctional robotic

system that showcases the convergence of automation, remote
connectivity, and user-friendly interfaces, aiming to bridge the gap
between theoretical knowledge and practical application in the field of
embedded systems and robotics.

ACKNOWLEDGEMENT

3
We would like to express our sincere gratitude to all those who
contributed to the successful completion of this project titled “Smart
Self-Driving Car with Obstacle Avoidance, Bluetooth Remote
Control, and Voice Command Integration.”

First and foremost, we extend our heartfelt thanks to our respected

project guide, Suman Poddar, for their constant support, expert
guidance, and valuable feedback throughout the development of this
project. Their insights and encouragement have played a vital role in
shaping the outcome.

We are also thankful to the faculty and staff of the Department of

Computer Science and Technology, Acharya Prafulla Chandra
Roy Polytechnic, for providing the necessary resources, lab facilities,
and a learning environment that enabled me to work effectively on
this project.

A special note of appreciation goes to our friends and classmates

who offered their time, assistance, and motivation during various
phases of the project.

Lastly, we express our deepest gratitude to our family for their

unwavering support, understanding, and encouragement, which kept
us focused and determined throughout this endeavour.

This project has been a great learning experience and has helped us
enhance our technical, analytical, and problem-solving skills. we are
truly thankful for the opportunity to apply theoretical knowledge in a
practical, hands-on project.

Table of contents

4
 1. CERTIFICATE OF RECOMMENDATION…………..1

2. CERTIFICATE OF APPROVAL…………………………2

3. ABSTRACT……………………………………………………..3

4. ACKNOWLEDGEMENT…………………………………..4

5. INTRODUCTION……………………………………………...6-7

6. Definition……………………………………………………….8

a. The process of this robot car…………………..8

7. DESCRIPTION………………………………………………...9-17

a. Hardware Requirements…………………………..9-15

b. Software Requirements……………………………16-17

8. program for this project……………………………..18-25

9. Code explanation………………………………………….26-31

10. SUMMARY AND CONCLUSIONS…………………….32-34

a. Summary of Work Carried Out…………………32

b. Conclusions……………………………………………..33

c. Scope for Future Work……………………………34

INTRODUCTION

In recent years, the field of robotics and automation has experienced

significant advancements, particularly in the area of autonomous
5
vehicles. The growing demand for intelligent, efficient, and user-
friendly systems has inspired the development of smart robotic
platforms that can mimic human control and decision-making. One
such innovation is the Smart Self-Driving Car equipped with
Obstacle Avoidance, Bluetooth Remote Control, and Voice
Command Integration. This project is a step towards building an
affordable, versatile robotic vehicle capable of performing
autonomous navigation while also allowing manual and voice-based
control.

The problem posed in this project is the limitation of traditional

remote-controlled cars that lack real-time obstacle detection and
flexibility in control methods. These limitations hinder their use in
practical applications such as smart mobility systems, indoor
automation, and educational purposes. The need for a multifunctional,
user-interactive robotic platform has become essential in bridging the
gap between theoretical robotics and real-world implementation.

This project aims to design and implement a robotic car that can
operate in three distinct modes:

 Autonomous Navigation using an ultrasonic sensor for real-

time obstacle avoidance,
 Manual Bluetooth Control via a mobile app or paired device,
and
 Voice Command Operation for hands-free interaction using a
voice recognition system.

The scope of the project extends to demonstrating how embedded

systems, sensor integration, and communication protocols can work
together to build an intelligent robotic solution. The system is built
using an Arduino Uno microcontroller, ultrasonic sensor, Bluetooth
module (HC-05), voice recognition tools, and motor driver circuits to
control the vehicle's movement based on sensory input and user
commands.

The significant contributions of this project include:

6
  A real-time obstacle avoidance algorithm using ultrasonic
feedback,
 Wireless manual control through Bluetooth for flexible
operation,
 Voice command processing for natural interaction with the
system,
 Integration of all modules into a single compact robotic
platform,
 Demonstration of embedded system design principles and IoT
concepts.

This project not only showcases technical skills in hardware and

software development but also reflects the growing importance of
intelligent human-machine interaction, which is fundamental to the
future of smart robotics.

Project Title: Smart Self-Driving Car with Obstacle Avoidance,

Bluetooth Remote Control, and Voice Command Integration

Definition:

7
This project presents a prototype of a smart self-driving car designed
to navigate autonomously while integrating multiple control features.
The system is equipped with obstacle avoidance capabilities using
ultrasonic sensors to detect and bypass obstacles in real time,
ensuring safe movement. It also supports Bluetooth-based remote
control, allowing users to manually operate the car through a mobile
application. Additionally, the car features voice control functionality,
enabling hands-free command execution using predefined voice
inputs. The combination of autonomous navigation, remote
operation, and voice interaction demonstrates the use of embedded
systems and IoT technologies to enhance mobility and automation.

The process of this robot car

We can control this robot car using three methods. That is,

1.Obstacle avoidance
In this case, the robot car moves along using the obstacle avoiding. The
ultrasonic sensor is mainly used for this purpose.

2.Bluetooth control
In this case, we can control the robot through an app on the smartphone. The
Bluetooth module is used for this.

3.Voice control
In this case, we can control this robot using several predefined voice
commands. This also requires a Bluetooth module and mobile app.

DESCRIPTION

 Hardware Requirements
The required components are given below.
8
  Arduino UNO board x 1
 L293D motor driver x 1
 Ultrasonic sensor x 1
 Bluetooth module x 1
 Servo motor x 1
 Gear motor x 4
 Robot wheel x 4
 Li-ion battery holder x 1
 Li-ion battery x 3
 Jumper wires
 Transparent fibreboard

Step1
L293D motor driver shield
The L293D Motor Driver Shield is a popular Arduino-
compatible module used to control the speed and
direction of DC motors and stepper motors. In this
project, it plays a crucial role in controlling the
movement of the self-driving car.
The shield is based on the L293D IC, a dual H-bridge
motor driver that allows bidirectional control of two DC
motors or unidirectional control of four. It can supply up to 600 mA current per
channel and supports motor voltage up to 36V, making it ideal for small
robotics projects.

Ultrasonic Sensor (HC-SR04):

The HC-SR04 Ultrasonic Sensor is a key component in this
project, enabling the obstacle avoidance feature of the
self-driving car. It works by emitting ultrasonic sound
waves and measuring the time taken for the echo to

9
return after bouncing off an object. Using this time, the distance to the object
is calculated.

Key Features:
 Sensing Range: 2 cm to 400 cm (with accuracy up to 3 mm)
 Working Voltage: 5V DC
 Trigger and Echo Pins for signal transmission and reception
 Non-contact distance measurement, making it ideal for autonomous
navigation

Working Principle in the Project:

 The Arduino sends a pulse through the Trigger pin
 The sensor emits an ultrasonic wave (at 40 kHz)
 When the wave hits an obstacle, it reflects back to the Echo pin
 The time delay is measured and converted into distance
 If the object is within a predefined range, the car stops or changes
direction to avoid collision

Bluetooth Module (HC-05):

The HC-05 Bluetooth Module is used in this project to
enable wireless remote control of the self-driving car
through a smartphone or Bluetooth-enabled device. It
allows for seamless serial communication between the
Arduino and the user's mobile application, enabling
commands to be sent and received in real time.

10
Key Features:
 Operating Voltage: 3.3V–5V
 Communication: Serial (UART) with TX and RX pins
 Range: Up to 10 meters
 Bluetooth Protocol: Bluetooth 2.0+EDR (Enhanced Data Rate)
 Master/Slave mode configurable

Working in the Project:

 The module is connected to the Arduino via TX (Transmit) and RX
(Receive) pins.
 A mobile app (such as a custom or generic Bluetooth controller) sends
commands like forward, backward, left, right, or stop.
 The Arduino receives these commands via the HC-05 module and
controls the motor driver shield accordingly.

Servo Motor (SG90):

The SG90 Servo Motor is used in this project to rotate
the ultrasonic sensor for better obstacle detection and
enhanced navigation. Unlike DC motors, a servo motor
provides precise angular movement, which is ideal for
scanning the surroundings.

Key Features:
 Operating Voltage: 4.8V to 6V
 Control Signal: PWM (Pulse Width Modulation)
 Rotation Range: 0° to 180°
 Torque: Around 1.8 kg·cm (suitable for lightweight applications)

Working in the Project:

11
  The servo motor is mounted with the ultrasonic sensor, allowing it to
rotate left and right to scan for obstacles in a wider area.
 Controlled by the Arduino using a single PWM signal pin.
 The Arduino rotates the sensor to different angles (e.g., 0°, 90°, 180°),
reads the distance at each point, and makes decisions based on the
obstacle positions.

3x Li-ion Battery and Holder:

To power the self-driving car, the project uses a 3-cell Li-ion
battery setup (typically 18650 rechargeable batteries) along
with a battery holder. This setup provides a reliable and
portable power source for the motors, sensors, Arduino, and
other electronic components.

Key Features:
 Battery Type: 3 × 18650 Li-ion rechargeable batteries
 Typical Voltage: 3.7V per cell × 3 = 11.1V total
 Battery Holder: Securely holds the three batteries in
series and provides output terminals
 High Energy Density: Suitable for powering motors and
control circuits for extended periods

4× Gear Motors:
The project uses four DC gear motors to drive the wheels
of the self-driving car, enabling smooth and stable
movement. These motors are small but powerful,
providing enough torque to move the car and respond to
directional commands from the control system.

12
Key Features:
 Operating Voltage: Typically, 6V–12V
 RPM: 100–300 RPM (varies based on model and voltage)
 High Torque Output: Due to built-in gear reduction system
 Low Speed, High Power: Ideal for robotics applications
 Compact Size: Easy to mount directly on chassis wheels

Robot Wheels:
The robot wheels are essential mechanical
components that enable the movement of
the car. In this project, four rubberized
wheels are attached to the gear motors to
provide traction and stability.

Jumper Wires:
Jumper wires are used for making electrical
connections between components on the
Arduino, motor driver shield, sensors, and
modules without soldering.
Types: Male-to-male, male-to-female, female-
to-female

Transparent Fibreboard (Acrylic or PVC

Chassis):
The transparent fibreboard acts as the base platform or
chassis for mounting all components of the robot car.

Arduino Uno Board:

The Arduino Uno is highly suitable for robotics projects due to its simplicity,
flexibility, and strong community support. It enables the integration of various

13
components and allows the development of complex features like autonomous
navigation, Bluetooth control, and voice control with ease.
The Arduino Uno is the main microcontroller board used in this self-driving car
project. It serves as the brain of the system, controlling all sensors, motors,
and communication modules based on the programmed logic.

Key Features:
 Microcontroller: ATmega328P
 Operating Voltage: 5V
 Input Voltage (recommended): 7–12V
 Digital I/O Pins: 14 (6 PWM outputs)
 Analog Input Pins: 6
 Flash Memory: 32 KB (for storing code)
 USB Interface: For programming and serial
communication

Step 2
Assemble the base structure of the Robot. Shown on the images…

Step 3

14
Then, connect the motors to the motor driver shield. To do this, use the circuit
diagram below.

 Software Requirements

1. Arduino IDE
 Purpose: Writing, compiling, and uploading code to the Arduino Uno
microcontroller.
 Features Needed:
o Support for C/C++ programming.
o Serial Monitor to debug sensor outputs.
 Download: https://www.arduino.cc/en/software

2. Bluetooth Controller App (Mobile App)

 Purpose: To control the car manually via Bluetooth.
 Examples:

15
 o Arduino Bluetooth Controller (Android)
o BT Terminal or Bluetooth Electronics
 Requirement: Must support HC-05/HC-06 Bluetooth module
communication using simple characters (e.g., F for forward, L for left,
etc.)

3. Voice Recognition System / App

 Option A: Android App
o Use apps like Voice Control for Arduino, MIT App Inventor-based
custom app, or Google Voice + Bluetooth Interface.
o These apps recognize voice commands and send corresponding
characters via Bluetooth.

 Option B: Voice Recognition Module

o If using hardware like Voice Recognition Module V3, install the
Voice Recognition V3 Library in Arduino IDE.

4. Driver Software for Arduino USB Communication

 Purpose: Required to allow your computer to communicate with the
Arduino board.
 Common Drivers:
o CH340 USB Driver (for Chinese clone Arduino boards)
o FTDI Drivers (for some genuine Arduino boards)

5. Libraries for Arduino IDE

Include the following in the Arduino IDE to support hardware components:

16
 Servo.h – for servo motor control.
 AFMotor.h – for Adafruit Motor Shield (if used).
 SoftwareSerial.h – for communication with Bluetooth module.
 NewPing.h (optional) – for efficient ultrasonic distance measurement.

The program for this project.

17
Step 4
So, let’s create the program for this project. This program includes all three
functions. We can run these separately. It is as follows.
 AF motor library — Download

#include <Servo.h>
#include <AFMotor.h>
#define Echo A0
#define Trig A1
#define motor 10
#define Speed 110
#define spoint 103
char value;
int distance;
int Left;
int Right;
int L = 0;
int R = 0;
int L1 = 0;
int R1 = 0;
Servo servo;
AF_DCMotor M1(1);
AF_DCMotor M2(2);
AF_DCMotor M3(3);
AF_DCMotor M4(4);
void setup()
{
Serial.begin(9600);
pinMode(Trig, OUTPUT);
pinMode(Echo, INPUT);
servo.attach(motor);
M1.setSpeed(Speed);
M2.setSpeed(Speed);
18
 M3.setSpeed(Speed);
M4.setSpeed(Speed);
}
void loop()
{
Obstacle();
//Bluetoothcontrol();
// voicecontrol();
}
void Bluetoothcontrol()
{
if (Serial.available() > 0)
{
value = Serial.read();
Serial.println(value);
}

if (value == 'F')
{
forward();
delay(100);
Stop();
}
else if (value == 'B')
{
backward();
delay(100);
Stop();
}
else if (value == 'L')
{
right();
delay(100);
19
 Stop();
}
else if (value == 'R')
{
left();
delay(100);
Stop();
}
}

void Obstacle() //for automatic Obstacle avoiding

{
distance = ultrasonic();
if (distance <= 25)
{
Stop();
backward();
delay(75);
Stop();
L = leftsee();
servo.write(spoint);
delay(800);
R = rightsee();
servo.write(spoint);
if (L < R)
{
left();
delay(500);
Stop();
delay(200);
}
else if (L > R)
20
 {
right();
delay(500);
Stop();
delay(200);
}
}
else { forward(); }
}
void voicecontrol() //for voicecontrol
{
if (Serial.available() > 0)
{
value = Serial.read();
Serial.println(value);
if (value == '^')
{
distance = ultrasonic();
if (distance <= 25)
{
Stop();
backward();
delay(100);
Stop();
}
else
{
forward();
delay(500);
Stop();
}
}
else if (value == '-')
21
 {
backward();
delay(500);
Stop();
}
else if (value == '<')
{
L = leftsee();
servo.write(spoint);
if (L >= 10 )
{
right();
delay(700);
Stop();
}
else if (L < 10)
{
Stop();
}
}
else if (value == '>')
{
R = rightsee();
servo.write(spoint);
if (R >= 10 )
{
left();
delay(700);
Stop();
}
else if (R < 10)
{ Stop(); }
}
22
 else if (value == '*')
{ Stop(); }
}
}

// Ultrasonic sensor distance reading function

int ultrasonic()
{
digitalWrite(Trig, LOW);
delayMicroseconds(4);
digitalWrite(Trig, HIGH);
delayMicroseconds(10);
digitalWrite(Trig, LOW);
long t = pulseIn(Echo, HIGH);
long cm = t / 29 / 2; //time convert distance
return cm;
}
void forward()
{
M1.run(FORWARD);
M2.run(FORWARD);
M3.run(FORWARD);
M4.run(FORWARD);
}
void backward()
{
M1.run(BACKWARD);
M2.run(BACKWARD);
M3.run(BACKWARD);
23
 M4.run(BACKWARD);
}
void right()
{
M1.run(BACKWARD);
M2.run(BACKWARD);
M3.run(FORWARD);
M4.run(FORWARD);
}
void left()
{
M1.run(FORWARD);
M2.run(FORWARD);
M3.run(BACKWARD);
M4.run(BACKWARD);
}

void Stop()
{
M1.run(RELEASE);
M2.run(RELEASE);
M3.run(RELEASE);
M4.run(RELEASE);
}
int rightsee()
{
servo.write(20);
delay(800);
int distance = ultrasonic();
return distance;
}

int leftsee()
24
 {
servo.write(180);
delay(800);
int distance = ultrasonic();
return distance;
}

Code explanation

Firstly, libraries are included.

#include <Servo.h>
#include <AFMotor.h>

Secondly, ultrasonic sensor pins, servo motor pins, motor speed, and
servo motor starting point are defined.

#define Echo A0
#define Trig A1
#define motor 10
#define Speed 110
#define spoint 103

Thirdly, some variables have been created to help the program.

char value;
int distance;
int Left;
int Right;
int L = 0;

25
int R = 0;
int L1 = 0;
int R1 = 0;

Then, objects are created for the Servo Library and the AFMotor
Library.

Servo servo;
AF_DCMotor M1(1);
AF_DCMotor M2(2);
AF_DCMotor M3(3);
AF_DCMotor M4(4);

In the setup function, Ultrasonic pins are set to INPUT and OUTPUT.
Also, the gear motor speeds have been included.

void setup() {
Serial.begin(9600);
pinMode(Trig, OUTPUT);
pinMode(Echo, INPUT);
servo.attach(motor);
M1.setSpeed(Speed);
M2.setSpeed(Speed);
M3.setSpeed(Speed);
M4.setSpeed(Speed);
}
In the loop function, the three main functions are included. we can
run these functions one by one. These are described below.
void loop() {
26
 //Obstacle();
//Bluetoothcontrol();
//voicecontrol();
}

This function includes the Bluetooth control code. The code lines are
described one by one in the code.
void Bluetoothcontrol()
{
if (Serial.available() > 0)
{
value = Serial.read();
Serial.println(value);
}

if (value == 'F')
{
forward();
delay(100);
Stop();
}
else if (value == 'B')
{
backward();
delay(100);
Stop();
}
else if (value == 'L')
{
right();
27
 delay(100);
Stop();
}
else if (value == 'R')
{
left();
delay(100);
Stop(); } }
This function includes the obstacle-avoiding code. The code lines are
described one by one in the code.
void Obstacle() //for automatic Obstacle avoiding
{
distance = ultrasonic();
if (distance <= 25)
{
Stop();
backward();
delay(75);
Stop();
L = leftsee();
servo.write(spoint);
delay(800);
R = rightsee();
servo.write(spoint);
if (L < R)
{
left();
delay(500);
Stop();
delay(200);
}
else if (L > R)
{
28
 right();
delay(500);
Stop();
delay(200);
}
}
else { forward(); }
}
This function includes the voice control code. The code lines are
described one by one in the code.
void voicecontrol() //for voicecontrol
{
if (Serial.available() > 0)
{
value = Serial.read();
Serial.println(value);
if (value == '^')
{
distance = ultrasonic();
if (distance <= 25)
{
Stop();
backward();
delay(100);
Stop();
}
else
{
forward();
delay(500);
Stop();
}
}
29
 else if (value == '-')
{
backward();
delay(500);
Stop();
}
else if (value == '<')
{
L = leftsee();
servo.write(spoint);
if (L >= 10 )
{
right();
delay(700);
Stop();
}
else if (L < 10)
{
Stop();
}
}
else if (value == '>')
{
R = rightsee();
servo.write(spoint);
if (R >= 10 )
{
left();
delay(700);
Stop();
}
else if (R < 10)
{ Stop(); }
30
 }
else if (value == '*')
{ Stop(); }
}
}

SUMMARY AND CONCLUSIONS

Summary of Work Carried Out:

This project focused on the design and implementation of a Smart

Self-Driving Car capable of autonomous obstacle avoidance,
Bluetooth-based manual control, and voice command operation.
The system was built using an Arduino Uno microcontroller,
integrated with ultrasonic sensors, DC motors, Bluetooth module
(HC-05), and voice control mechanisms.

The car was programmed using the Arduino IDE, combining sensor
data interpretation, motor actuation logic, and wireless
communication protocols. The Bluetooth feature allowed manual
control through an Android app, while the voice module added a layer
of hands-free, natural interaction. The self-driving logic enabled the
car to detect obstacles and navigate without user intervention,
demonstrating real-time decision-making and autonomous behavior.

31
 Conclusions:

1. The self-driving functionality successfully detected and avoided

obstacles using ultrasonic sensors, validating the effectiveness
of the autonomous navigation logic.

2. The Bluetooth remote control feature enabled smooth manual

operation of the car using simple commands from a mobile
application.

3. Voice command integration allowed basic control through

spoken inputs, increasing user accessibility and demonstrating
multi-modal interaction capabilities.

4. The Arduino Uno proved to be a reliable and flexible platform

for integrating hardware components and executing the control
logic efficiently.

32
5. The project highlights the practical application of embedded
systems, sensor fusion, and wireless communication in building
intelligent robotic platforms.

Scope for Future Work:

 Advanced Path Planning: Implement algorithms such as A* or

Dijkstra for more intelligent route decisions and maze-solving
abilities.

 Natural Language Processing: Enhance the voice command

system to support natural language understanding and multi-
language input.

 IoT Integration: Connect the car to a cloud platform for remote

monitoring, data logging, and control via the internet.

 AI and Computer Vision: Add a camera and use computer

vision (OpenCV) to detect lanes, signs, or objects for more
advanced autonomous navigation.

 Energy Optimization: Integrate battery monitoring and solar

power options to extend usage time and promote sustainability.
33
34