ABSTRACT

In recent years, household devices have become more intelligent and automated, reshaping the way people
manage their homes. Home automation systems provide convenience, reduce manual labor, and create more
free time, allowing people to focus on other tasks. One significant innovation in this space is domestic
robots, such as automated vacuum cleaners. While the market for domestic robots is still relatively new, it is
expected to grow significantly as technology advances and adoption increases. The aim of this project is to
design and develop an automatic vacuum cleaner that operates autonomously and simplifies household
chores, particularly cleaning.
This vacuum cleaner will feature both automatic and manual modes, providing flexibility in its operation.
Key features will include a scheduling function that allows the vacuum to clean at specific times, and an
automatic dirt disposal system that empties the dirt container without human intervention. These features,
combined with the vacuum's efficiency, time-saving capabilities, and flexibility, make it a valuable addition
to any household. The vacuum cleaner will be equipped with a DC motor, motor shield, servo motor, and
ultrasonic sensors, enabling it to autonomously vacuum a floor while navigating around obstacles. The
ultrasonic sensors will detect obstacles in real-time and adjust the vacuum’s path for thorough and efficient
cleaning.
Keywords: Robotics, Ultrasonic Sensor, Vacuum Cleaner, DC Motor, Home Automation

1
 CHAPTER 1

1.1. INTRODUCTION

Technology has revolutionized modern life in countless ways, with automation increasingly becoming an
integral part of everyday living. The rise of smart homes—where devices are interconnected, automated, and
controlled remotely—has fundamentally changed the way people interact with their environments. Among
the innovations leading this shift are robotic vacuum cleaners, which automate one of the most common
household tasks: floor cleaning.

1.2. BACKGROUND
Traditional vacuum cleaners require significant manual effort, from pushing and pulling across different
floor types to moving around furniture and navigating tight spaces. This can be especially challenging in
larger homes or homes with a lot of clutter. In contrast, robotic vacuum cleaners offer a fully automated
solution, minimizing the need for human involvement. They operate autonomously, navigating rooms,
avoiding obstacles, and ensuring that the entire floor area is cleaned efficiently. Their ability to work
independently makes them a valuable tool for maintaining cleanliness with minimal effort.

Despite their increasing popularity, robotic vacuum cleaners are still a relatively new market, and there is
plenty of room for growth and innovation. As automation becomes more prevalent, we are seeing
advancements in sensor technology, path-planning algorithms, and smart home integration, all of which
contribute to the enhanced functionality of these devices. The ongoing evolution of domestic robots holds
the potential to greatly improve everyday life, particularly for those with busy schedules or physical
limitations.

1.3. OBJECTIVE
The primary objective of this project is to design and develop a smart, autonomous vacuum cleaner that can
clean various floor types efficiently and without human supervision. Specifically, this project aims to
achieve the following goals:

1. Autonomous Navigation: The vacuum cleaner will be able to move around rooms without colliding
with furniture, walls, or other obstacles. It will use sensor data to detect objects and obstacles in real-
time and make appropriate decisions to avoid them.

2
 2. Efficient Cleaning: The vacuum cleaner will use intelligent path-planning algorithms to ensure
maximum coverage of the available floor space, minimizing cleaning time while maximizing
efficiency. This will allow it to clean the entire floor without missing any areas.

3. Obstacle Detection and Avoidance: The vacuum cleaner will be equipped with sensors, such as
ultrasonic sensors, to detect obstacles in its path. This will prevent it from bumping into furniture or
falling down stairs.

4. Adaptability to Different Floor Types: The vacuum cleaner will automatically adjust its suction
power and movement depending on the type of floor it is cleaning, whether it is carpet, tile, or
hardwood. This adaptability will ensure effective cleaning on all surfaces.

5. User-Friendly Interface: A simple interface, such as a control panel or mobile app, will allow users
to start, pause, and schedule cleaning sessions easily. The user interface will make the vacuum
cleaner easy to control and monitor, even when the user is not at home.

Overall, the project aims to develop an efficient, reliable, and cost-effective smart vacuum cleaner that meets
the needs of modern households and contributes to the growing trend of home automation.

1.4. SCOPE
The scope of this project is focused on the design, development, and testing of a fully functional prototype
of a smart vacuum cleaner. The report will cover both the hardware and software aspects of the project,
including the selection of components, system integration, and the algorithms that enable autonomous
operation. Specifically, the project will address the following areas:

1. Hardware Design: This includes the selection and integration of key components such as
sensors (infrared, ultrasonic, or proximity), motors for movement, suction components for
cleaning, a microcontroller for processing data, and a power supply. The chassis of the vacuum
cleaner will also be designed or selected to accommodate these components.
2. Software Development: The project will involve the development of control software using C++
on the Arduino platform. This software will handle sensor data processing, motor control,
obstacle detection, and path-planning algorithms. It will ensure that the vacuum cleaner operates
smoothly and efficiently.
3. Testing and Validation: The smart vacuum cleaner will be tested in various real-world
environments, including rooms with different floor types (carpet, tile, hardwood) and varying
obstacle layouts (furniture, walls, etc.). The testing phase will assess the device's ability to detect
and avoid obstacles, cover the entire floor area, and adapt to different surfaces.

3
 User Interface: Although the project is focused primarily on the autonomous capabilities of the
vacuum cleaner, a simple user interface may be developed to allow users to control or monitor the
vacuum cleaner remotely, either through buttons on the device or via a mob

CHAPTER 2

2.1. MATERIAL REQUIREMENTS

As we have used very generic components to build the hardware section of the vacuum cleaner robot, you
should be able to find all of those in your local hobby store. Here is the complete list of required material
along with the image of all the components.

2.2. HARDWARE REQUIREMENTS

- Gear motor with wheel https://amzn.to/2UDR7m6

- 12v AC to DC Power supply https://amzn.to/3jIfiYo

- Arduino Uno https://amzn.to/48zHrds

- Arduino motor shield https://amzn.to/2XP5Lbx

- Servo motor https://amzn.to/3jaNP3o

- Ultrasonic sensor https://amzn.to/46h2PTb

- 6v motor https://amzn.to/3goKmfs

- Lithium-ion battery cell https://amzn.to/48Ed6KN

2.3. HARDWARE DESCRIPTION

1. Arduino Motor Shield: The Arduino Motor Shield, specifically the L293D model, is used to control
various types of motors, such as DC motors, stepper motors, and servo motors, which are commonly
employed in robotic projects. The L293D motor driver allows the microcontroller to control the
motors efficiently by acting as an intermediary between the Arduino and the motors. This is
necessary because motors require higher power and current than what the Arduino itself can provide.
The motor shield provides the capability to drive two DC motors independently, or one stepper
motor, while also supporting speed and direction control. This is essential for the movement and

4
 operation of the smart vacuum cleaner, enabling precise control over the direction and speed of the
robot’s wheels.

Fig 2.1

2. Arduino UNO: The Arduino UNO is the brain of the vacuum cleaner. It is one of the most popular
microcontroller boards, based on the ATmega328P, known for its simplicity and versatility in a wide
range of projects. It features 14 digital input/output pins, 6 analog inputs, and a USB interface for easy
programming and connection to a computer. The Arduino UNO controls the motors, reads data from
sensors like the ultrasonic sensor, and executes the logic necessary for the vacuum cleaner to operate
autonomously.

Fig2.2

3. Ultrasonic Sensor (HC-SR04): The ultrasonic sensor HC-SR04 is a key component for obstacle
detection in the vacuum cleaner. It measures the distance to objects by emitting ultrasonic waves and
detecting the time it takes for the sound waves to return after bouncing off obstacles. The sensor has
four pins: Trigger, Echo, VCC, and Ground. The Arduino sends a signal through the Trigger pin,
which prompts the sensor to emit an ultrasonic wave. The wave hits an object, reflects back, and the
sensor records the time it takes for the wave to return via the Echo pin. The distance to the obstacle is
calculated using the time delay between the emission and reception of the sound wave. This sensor
helps the vacuum cleaner navigate around obstacles and ensures it does not collide with furniture or
walls.

Fig 2.3

5
 4. Battery (18650 Li-ion 1200mAh): The 18650 Li-ion battery is used to power the vacuum cleaner.
This rechargeable battery is commonly used in high-current applications such as cameras, laptops,
and other electronic devices. In the case of the smart vacuum cleaner, the 1200mAh capacity ensures
that the cleaner can operate for a reasonable period without requiring frequent recharging. The 18650
battery is known for its longevity, capable of undergoing many charge/discharge cycles, and it is safe
and environmentally friendly. The power from this battery is used to drive both the motors and the
onboard electronics of the vacuum cleaner.

Fig 2.4

5. DC Power Supply (12V AC to DC Converter): The DC power supply converts the AC power from
a mains outlet into a 12V DC supply, which is necessary to run certain components of the vacuum
cleaner, like the DC motors and other electronics that require a stable and consistent DC voltage. The
power supply ensures that the vacuum cleaner operates efficiently without voltage fluctuations,
which could damage the motors or the Arduino.

Fig 2.5

6
 6. Servo Motor: A servo motor is a high-precision motor used for tasks that require accurate control of
position, velocity, and acceleration. In the smart vacuum cleaner, a servo motor might be used for
controlling specific movements like the angle of the vacuum head or for other precision tasks.

Fig 2.6

CHAPTER 3

WORKING PRINCIPLE

The smart vacuum cleaner operates autonomously by using a combination of sensors and motors,
coordinated through the Arduino microcontroller. The core of its functionality lies in its ability to navigate a
room while avoiding obstacles and cleaning the floor efficiently.

3.1. Scanning the Environment

The vacuum cleaner is equipped with ultrasonic and infrared sensors to continuously scan its surroundings.
These sensors detect obstacles like furniture or walls and inform the Arduino, which processes this data in
real-time. When an obstacle is detected, the microcontroller adjusts the cleaner's path by controlling the
motors to avoid the obstacle and continue cleaning.

3.2. Movement Control

The movement of the vacuum cleaner is powered by two DC motors, which are controlled via the Arduino
motor shield. These motors drive the wheels, allowing the vacuum to move forward, backward, or turn. The
Arduino microcontroller sends signals to the motor driver, adjusting the speed and direction of the motors
based on sensor input to ensure efficient navigation.

3.3. Dust Collection

In addition to movement, the vacuum cleaner has a suction motor responsible for collecting dust and debris.
As the vacuum moves, the suction motor creates a vacuum effect, pulling in dirt from the floor. The dirt is
then deposited into a dirt container inside the vacuum. Some designs may include an automatic dirt disposal
mechanism that periodically empties the dirt container without requiring user intervention.

3.4. Obstacle Detection and Path Correction

7
When an obstacle is detected, such as a piece of furniture or a wall, the ultrasonic sensor measures the
distance to the object. The Arduino processes this information and determines whether the vacuum should
stop, turn, or reverse to avoid a collision. This ensures that the vacuum cleaner can navigate complex
environments without getting stuck or causing damage to itself or the objects around it.

3.5. Efficient Cleaning Path

The vacuum cleaner follows a pre-programmed cleaning pattern, which may be optimized for maximum
floor coverage. The cleaning algorithm, combined with real-time obstacle detection, allows the vacuum to
clean large areas without missing spots. Some advanced designs might include the ability to return to
previously uncleaned areas or follow a zigzag or spiral pattern for thorough coverage.

CHAPTER 4

SOFTWARE REQUIREMENTS (ELABORATED)

4.1. Arduino Integrated Development Environment (IDE)

The Arduino Integrated Development Environment (IDE) is the primary software tool used to program
and control Arduino microcontroller boards. It provides a user-friendly interface that simplifies embedded
system development by allowing users to write, edit, and upload code to their Arduino boards. The IDE’s
simplicity, coupled with its open-source nature, has made it an essential tool for a wide audience, including
hobbyists, students, and professionals in the fields of electronics and robotics. Its ease of use has
democratized the process of developing embedded systems, which were once the domain of only highly
skilled engineers.

The Arduino IDE supports a wide range of microcontroller boards and is compatible with Windows, macOS,
and Linux, making it highly accessible. The software uses a simplified version of the C/C++ programming
language, called sketches, which are compiled and uploaded to the Arduino board for execution. The
Arduino IDE abstracts much of the complexity involved in low-level programming, allowing users to focus
on creating their projects without needing to understand the intricacies of microcontroller architecture.

4.2. Key Features of the Arduino IDE

 Cross-Platform Compatibility: The Arduino IDE runs on multiple operating systems (Windows,
macOS, Linux), making it widely accessible for different users.

 Simplified Coding Environment: The IDE uses a simple version of the C/C++ programming
language, making it approachable for beginners while still powerful enough for advanced users.
8
  Open Source: The IDE and its libraries are open source, encouraging a large community of
developers to create and share libraries, making it easier to interface with a wide variety of hardware
components.

 Built-in Libraries: The Arduino IDE includes a vast library of prewritten code, simplifying the
process of working with different hardware such as motors, sensors, and displays.

 Serial Monitor: The IDE includes a serial monitor tool that allows users to communicate with the
Arduino board and receive real-time data during program execution, useful for debugging and
monitoring sensor data.

4.3. Background of the Arduino IDE

The Arduino platform was created in 2005 at the Interaction Design Institute Ivrea in Italy by a team of
educators and engineers. Their goal was to develop a low-cost, easy-to-use platform for students, artists, and
designers to begin working with microcontrollers and electronics without needing extensive technical
knowledge or expensive tools. Before the introduction of Arduino, programming microcontrollers required
expertise in embedded systems and specialized programming tools, making them inaccessible to many.

With the introduction of the Arduino IDE, the complexity involved in microcontroller programming was
significantly reduced. The Arduino board and its corresponding IDE were designed to be intuitive, allowing
users to upload code (or "sketches") directly to the board via USB. This design simplified the process of
working with microcontrollers, enabling even non-technical users to create interactive projects, control
hardware, and explore robotics.

https://support.arduino.cc/hc/en-us/articles/360019833020-Download-and-install-Arduino-IDE

9
 Fig 4.1

CHAPTER 5

METHODOLOGY

5.1. BLOCK DIAGRAM :

10
 Fig 5.1

In this project, an automated vacuum cleaner is designed. It consists of a RC car to which a vacuum
cleaner is attached. Ultrasonic sensor is attached to the front of the car which is used to measure the
distance if any obstacle is detected. If suppose there is an obstacle, the car changes its course as per the
code. Vacuum cleaner consists of CPU Fan which runs by a battery. At the front of cleaner, a pipe is
attached to suck the dust from the floor. The cleaner has space to collect the dust. Once it gets filled, it
should be removed and cleaned manually. Vacuum cleaner will be carried on the RC car and the
direction of the wheels depend on the code uploaded to the Arduino in the current hectic schedule,
cleaning houses and surrounding environment is more arduous. At present, there are vacuum cleaners
which require humans to handle it. Thus, there is a dire need to implement vacuum cleaner which works
without human intervention. An efficient method to clean the desired area has been implemented
through this project. By using this vacuum cleaner, hazardous places can be cleaned which thereby
reduce risks to mankind. This is achieved by implementing an autonomous system. Here, RC car which
is embedded with a vacuum cleaner is used. This system has an ultrasonic sensor attached to it, That
helps in avoiding large obstacles such as tables, chairs, walls etc. By measuring the distance via this
sensor, the car takes the direction where the distance between obstacle and car is more, hence avoiding
the collision with the obstacles. The vacuum cleaner is designed with a CPU fan and a pipe is attached
to the mouth of the bottle The entire system is run by batteries Current vacuum cleaners, although
efficient, are rather bulky and therefore require large manpower for proper functioning. The former
vacuum cleaners use to generate suction and gathered dust with a rotating brush, the latter worked with a
belt driven by hand- cranked fan making it awkward to operate.

CHAPTER 6

CIRCUIT DIAGRAM OF ARDUINO BASED VACUUM CLEANER

11
 Fig 6.1

We have three ultrasonic sensors that detect obstacles. So, we need to connect all grounds of ultrasonic
sensors and connected them to common ground. Also, we connect all the three Vcc of the sensor and
connect that to the common VCC pin. Next, we connect the trigger and echo pins to the PWM pins of
the Arduino. We also connect the VCC of the IR module to 5V and ground to the ground pin of
Arduino, the output pin of the IR sensor module goes to the digital pin D2 of the Arduino. For the motor
driver, we connect the two enable pins to 5v and also the driver voltage pin to 5V because we are using
5volt motors. In a previous article, we have made an Arduino Motor Driver Shield, you can check that
out to learn more about L293D Motor Driver IC and its operations. The Arduino, Ultrasonic modules,
motor driver, and motors work on 5 Volt, the higher voltage will kill it and we are using the 7.4-volt
battery, to convert that into 5 Volt, the LM7805 voltage regulator is used. Connect the vacuum cleaner
directly to the main circuit.

CHAPTER 7

12
 ARDUINO PROGRAM
Creating a basic program for a smart vacuum cleaner with Arduino will involve using some sensors and
actuators, such as ultrasonic sensors for obstacle detection, motor drivers to control the wheels, and
optionally, a fan motor for suction. Here’s a simple program that can help you get started with the basic
functionality of avoiding obstacles.

#include <Servo.h> // Include the Servo library for the ESC

// Create a Servo object for the ESC

Servo esc;

// Define ultrasonic sensor pins

const int trigPinLeft = 2;
const int echoPinLeft = 3;
const int trigPinFront = 4;
const int echoPinFront = 5;
const int trigPinRight = 6;
const int echoPinRight = 7;

// Define IR sensor pin

const int irPin = 8;

// Define motor control pins

const int motorLeftForward = 9;
const int motorLeftBackward = 10;
const int motorRightForward = 11;
const int motorRightBackward = 12;

// ESC control pin

const int escPin = 13;

// Analog input for ESC control

const int analogInputPin = A0;

13
// Variables for ultrasonic distance
long durationLeft, durationFront, durationRight;
int distanceLeft, distanceFront, distanceRight;
int obstacleDetected = 0;

void setup() {
// Setup motor pins as outputs
pinMode(motorLeftForward, OUTPUT);
pinMode(motorLeftBackward, OUTPUT);
pinMode(motorRightForward, OUTPUT);
pinMode(motorRightBackward, OUTPUT);

// Setup ultrasonic sensor pins

pinMode(trigPinLeft, OUTPUT);
pinMode(echoPinLeft, INPUT);
pinMode(trigPinFront, OUTPUT);
pinMode(echoPinFront, INPUT);
pinMode(trigPinRight, OUTPUT);
pinMode(echoPinRight, INPUT);

// Setup IR sensor pin

pinMode(irPin, INPUT);

// Setup ESC control

esc.attach(escPin);
esc.writeMicroseconds(1000); // Initialize ESC
delay(2000); // Give ESC some time to initialize

Serial.begin(9600); // Start Serial communication for debugging

}

14
// Function to get distance from ultrasonic sensor
int getDistance(int trigPin, int echoPin) {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
long duration = pulseIn(echoPin, HIGH);
int distance = duration * 0.034 / 2; // Convert to cm
return distance;
}

// Function to control movement

void moveForward() {
digitalWrite(motorLeftForward, HIGH);
digitalWrite(motorLeftBackward, LOW);
digitalWrite(motorRightForward, HIGH);
digitalWrite(motorRightBackward, LOW);
}

void moveBackward() {
digitalWrite(motorLeftForward, LOW);
digitalWrite(motorLeftBackward, HIGH);
digitalWrite(motorRightForward, LOW);
digitalWrite(motorRightBackward, HIGH);
}

void turnLeft() {
digitalWrite(motorLeftForward, LOW);
digitalWrite(motorLeftBackward, LOW);
digitalWrite(motorRightForward, HIGH);
digitalWrite(motorRightBackward, LOW);

15
}

void turnRight() {
digitalWrite(motorLeftForward, HIGH);
digitalWrite(motorLeftBackward, LOW);
digitalWrite(motorRightForward, LOW);
digitalWrite(motorRightBackward, LOW);
}

void stopMoving() {
digitalWrite(motorLeftForward, LOW);
digitalWrite(motorLeftBackward, LOW);
digitalWrite(motorRightForward, LOW);
digitalWrite(motorRightBackward, LOW);
}

// Function to control ESC speed

void controlESC() {
int val = analogRead(analogInputPin);
val = map(val, 0, 1023, 1000, 2000); // Map analog value to ESC control range
esc.writeMicroseconds(val);
}

void loop() {
// Read distances from ultrasonic sensors
distanceLeft = getDistance(trigPinLeft, echoPinLeft);
distanceFront = getDistance(trigPinFront, echoPinFront);
distanceRight = getDistance(trigPinRight, echoPinRight);

// Display distances for debugging

Serial.print("Left Distance: ");
Serial.println(distanceLeft);

16
 Serial.print("Front Distance: ");
Serial.println(distanceFront);
Serial.print("Right Distance: ");
Serial.println(distanceRight);

// Read infrared sensor

int irStatus = digitalRead(irPin);

// Control ESC speed based on analog input

controlESC();

// Decision making based on sensor readings

if (irStatus == HIGH) {
// Obstacle detected by IR sensor; move backward and set flag
moveBackward();
delay(1000);
obstacleDetected = 1;
}

// Move forward if no obstacles detected

if ((obstacleDetected == 0) && (irStatus == LOW) &&
((distanceLeft > 15 && distanceFront > 15 && distanceRight > 15) ||
(distanceLeft <= 15 && distanceFront > 15 && distanceRight <= 15))) {
moveForward();
}

// Turn left if an obstacle is detected in front or left

if ((obstacleDetected == 1 && irStatus == LOW) ||
(irStatus == LOW && distanceLeft <= 15 && distanceFront <= 15 && distanceRight > 15) ||
(irStatus == LOW && distanceLeft <= 15 && distanceFront > 15 && distanceRight > 15)) {
turnLeft();
delay(100);

17
 obstacleDetected = 0;
}

// Turn right if an obstacle is detected in front or right

if ((irStatus == LOW && distanceLeft > 15 && distanceFront <= 15 && distanceRight <= 15) ||
(irStatus == LOW && distanceLeft > 15 && distanceFront > 15 && distanceRight <= 15) ||
(irStatus == LOW && distanceLeft > 15 && distanceFront <= 15 && distanceRight > 15)) {
turnRight();
delay(100);
}
}

Program output

Fig 7.1

CHAPTER 8
18
 PROJECT OVERVIEW

Fig 8.1

The developed robot is a fully functional device that autonomously navigates based on a predefined
logic to efficiently clean dry dust particles. Since the robot is wireless, it can cover a large area without
being tethered to a power source, offering flexibility and ease of movement. Its autonomous operation
reduces the need for human intervention, minimizing manual labor and making household cleaning
more convenient.
In its current state, the robot is designed primarily for cleaning floors, and its performance has been
optimized for this task. However, there is significant potential for future upgrades. For example, the
robot could be enhanced to detect and move towards dust clusters, resulting in more targeted and
efficient cleaning. Other improvements could include adding self-charging capabilities, automatic dust
disposal mechanisms, and scheduling features that allow users to set specific cleaning times.
While the autonomous vacuum cleaner is not yet ready for commercial release, this was not the primary
objective of the project. The results achieved so far are very promising. The robot's shape, for instance,
is well-suited for cleaning along walls, around furniture legs, and in corners, where traditional vacuum
cleaners often struggle. The ultrasonic sensor effectively identifies obstacles, helping the robot navigate
complex environments. The combination of the robot's design, ultrasonic sensing, and navigation
algorithms works cohesively to enable it to clean unstructured, unknown environments efficiently.

19
 CHAPTER 9
CONCLUSION

The smart vacuum cleaner project demonstrates how an Arduino-based system can autonomously navigate
and clean a space using simple sensors and control mechanisms. By integrating ultrasonic sensors for
obstacle detection, an infrared sensor for obstacle recognition, and motor control through an ESC (Electronic
Speed Controller), the vacuum cleaner can effectively avoid obstacles, maneuver through various paths, and
perform basic cleaning functions.

Through this project, key skills in robotics, sensor integration, and Arduino programming were developed.
The project’s modular code and component design also allow for future improvements, such as enhanced
path planning, more sophisticated obstacle recognition, and wireless connectivity for remote control or
monitoring.

Key features of the project include:

1. Obstacle Detection and Avoidance: Using ultrasonic sensors, the vacuum cleaner can measure the
distance to nearby objects and avoid obstacles by changing its direction.

2. Motor Control: The vacuum's movement is controlled by motors, which are powered through an
ESC (Electronic Speed Controller) that adjusts the motor speed based on sensor readings.

3. Basic Navigation: The robot can move forward, backward, and turn left or right depending on the
proximity of obstacles, enabling it to clean various areas effectively.

4. Speed Control: The ESC system allows for smooth motor control, ensuring the vacuum operates
efficiently and without sudden jerks, which could be detrimental in a real-world cleaning
environment.

Overall, this project serves as a foundational example of how embedded systems can be used in robotics to
perform practical, everyday tasks. It provides a stepping stone for developing more advanced autonomous
cleaning robots or applying similar principles in other robotic applications.

20
 CHAPTER 10

REFERENCE

This chapter lists all the sources cited throughout the project report, including books, journal articles,
websites, and any other resources used in the research and development of the medical health assistance
system.

https://www.instructables.com

https://github.com

https://www.allaboutcircuits.com

https://circuitdigest.com

https://www.electronicshub.org

https://www.hackster.io

https://www.youtube.com

21
 Chapter 11
Costing

22