GOVERNMENT POLYTECHNIC NAINITAL

CERTIFICATE

This is to certify that the major project entitled “Courier and Surveillance Robot" as successfully
completed by Students of Sixth semester Diploma in Mechanical Engineering.

1) Vinod Kumar
2) Akshit Dhaila
3) Amit Padaliya
4) Tushar Kumar
5) Vinod Dalakoti
6) Dinesh Singh Bisht
7) Deepak Mourya
8) Prakash Negi

In partial fulfillment of the requirements for the award of the Diploma in Mechanical Engineering and
submitted to the Department of Mechanical Engineering of Government Polytechnic, Nainital work
carried out during a period for the academic year 2023-24 as per curriculum.

Project Guide

Mrs. Ruchita Joshi Mrs. Ruchita Joshi

HOD - Mech. Eng. HOD - Mech. Eng.

Government Polytechnic, Nainital

External Examiner Signature

 ACKNOWLEDGEMENT

We would like to extend our deepest gratitude to everyone who contributed to the
successful completion of our Courier and Surveillance Robot project. First and foremost, we
are grateful to our advisor, Mrs. Ruchita Joshi, for her invaluable guidance, support, and
encouragement throughout this project. Her expertise and insights were instrumental in
shaping the direction and outcomes of our work.

We are also thankful to Harshit Budhlakoti his unwavering support and patience, which kept
us motivated during challenging times. His encouragement provided the necessary drive to
persevere.

Special thanks go to the Department of Mechanical Engineering for providing the necessary
resources and facilities to conduct this project. The access to advanced tools and
technologies significantly contributed to the project's success. We would also like to
acknowledge the contributions of our colleagues and classmates, whose constructive
feedback and collaboration enriched the project.

Lastly, we extend our appreciation to all the authors and researchers whose works have
served as references and inspiration throughout the development of this project.

Thank you all for your support and contribution.

 ABSTRACT

This project presents the development of a multifunctional robot designed for courier and
surveillance purposes, aimed at enhancing efficiency and security within college campuses.
The robot integrates advanced technologies in robotics, navigation, and real-time
monitoring to perform dual functions seamlessly.

For courier tasks, the robot is equipped with a secure compartment for transporting
documents and packages autonomously, utilizing pathfinding algorithms to navigate
complex campus environments. In its surveillance role, the robot is fitted with high-
definition cameras and sensors to monitor activities, detect anomalies, and provide live
video feeds to security personnel.

The project leverages a combination of hardware components and software programming

to ensure robust performance, reliability, and user-friendly operation.

Extensive testing within the college premises has demonstrated the robot's capability to
handle dynamic obstacles, variable terrain, and diverse environmental conditions.

This innovative solution promises to contribute significantly to the operational efficiency

and safety of college campuses, potentially extending to broader applications in other
institutional and commercial settings.
 CONTENTS

❖ Purpose
❖ Objective
❖ Hardware Components
❖ Software Components
❖ Market Research
❖ Progress chart
❖ Manufacturing Process
❖ Robot Circuit Diagram
❖ Project Code
❖ Conclusion
❖ References
 Purpose
The primary purpose of this project is to create a versatile and efficient robotic solution that addresses the
dual needs of courier services and surveillance within a college campus. By leveraging advanced robotics
and automation technologies, this project aims to streamline the process of transporting documents and
packages and enhance campus security through continuous monitoring.

This dual-function robot is designed to operate autonomously, reducing the reliance on human effort and
minimizing the potential for human error, thus ensuring a more efficient, secure, and responsive campus
environment.

Problems the Robot Will Solve:

• Inefficiency in Manual Courier Services:

• Problem: Manual courier services on campus can be time-consuming and inefficient, often
requiring staff to physically carry documents and packages across various buildings and
departments. This process can lead to delays, misplacements, and increased workload for
administrative personnel.
• Solution: The courier function of the robot automates the delivery process, ensuring timely and
accurate transportation of items. The robot can navigate complex campus layouts, avoiding
obstacles and delivering packages directly to specified locations.

• Limited Surveillance Coverage:

• Problem: Traditional surveillance systems may have blind spots and are typically fixed in one
location, which limits their coverage area. Security personnel may also face challenges in
monitoring large areas effectively and responding promptly to incidents.
• Solution: The surveillance function of the robot provides mobile monitoring, expanding the
coverage area beyond static cameras. Equipped with high-definition cameras and sensors, the
robot can patrol the campus, detect anomalies, and provide real-time video feeds to security
personnel.

• High Operational Costs:

• Problem: Employing a large number of staff for courier services and security monitoring can be
costly for educational institutions. This includes salaries, benefits, and other associated expenses.
• Solution: The robot reduces the need for a large workforce by automating routine tasks. This can
lead to significant cost savings in the long run, allowing the institution to allocate resources more
efficiently.

• Human Error and Fatigue:

• Problem: Human operators are susceptible to errors and fatigue, which can result in misplaced
packages, missed deliveries, and lapses in surveillance coverage.
• Solution: The robot operates with high precision and consistency, eliminating the risk of human
error. It can work continuously without fatigue, ensuring reliable performance in both courier and
surveillance tasks.
 Objectives

• Design and Development:

• To design and build a robust and reliable robot capable of navigating diverse campus environments
autonomously.
• To integrate secure compartments within the robot for the safe transport of documents and
packages.

• Navigation and Pathfinding:

• To develop and implement advanced pathfinding algorithms enabling the robot to navigate
complex and dynamic campus layouts efficiently.
• To ensure the robot can detect and avoid obstacles, adapting to changes in the environment in real-
time.

• Surveillance Capability:

• To equip the robot with high-definition cameras and sensors for effective surveillance and real-time
monitoring.
• To enable live video streaming and anomaly detection, providing timely alerts to security
personnel.

• User-Friendly Operation:

• To develop an intuitive user interface for easy operation and control of the robot by campus staff
and security personnel.
• To ensure seamless integration of the robot’s functions with existing campus infrastructure.

• Testing and Validation:

• To conduct extensive testing of the robot in various scenarios within the college campus to ensure
reliability and performance.
• To evaluate the robot’s effectiveness in both courier and surveillance roles, making necessary
adjustments based on feedback and observed performance.

• Future Applications:

• To explore the potential for extending the robot’s applications beyond the college campus,
including other institutional and commercial settings.
• To identify and document opportunities for further enhancements and scalability of the robot’s
functions.

By achieving these objectives, the project aims to demonstrate the practical benefits and feasibility of
integrating multifunctional robotic solutions into everyday operational and security processes.
 Hardware Components

❖ ESP32
❖ Jumper Wires
❖ Li-ion Battery Cells (3.7V, 2000mAh)
❖ Battery Management System (BMS) 16V 40A
❖ Fire Sensor
❖ Ultrasonic Sensor
❖ Step-Down Buck Converter (300W)
❖ Step-Up Boost Converter (150W)
❖ ESP32-CAM
❖ 12V Gear Motor
❖ 10x4 mm Tyres for Robot
❖ MS Square Bar
❖ PVC Pipe
❖ Cardboard
❖ Heat Shrink Tubing (2mm)
❖ Heatsink
❖ Motor Driver (12V L298)
ESP32

Description:
The ESP32 is a powerful microcontroller with integrated Wi-Fi and Bluetooth capabilities,
making it ideal for IoT and home automation projects. It features dual-core processors, a
rich set of peripherals including GPIO, ADC, DAC, UART, SPI, and I2C, and a robust power
management system. The ESP32 supports a variety of development environments such as
Arduino IDE and PlatformIO, enabling flexible and efficient programming.

Applications:
Central control unit for IoT devices
Wireless communication and control
Real-time monitoring and automation
Jumper Wires

Description:
Jumper wires are insulated wires with pin connectors at each end, designed for making
temporary connections between components on a breadboard or other prototyping setups.
They are essential for establishing and modifying connections during the development and
testing phases of electronic projects.

Applications:
Connect various electronic components such as sensors, ESP32, and motor drivers.

Facilitate easy modifications and debugging during development.

Ensure reliable electrical connections between modules.

Li-ion Battery Cells (3.7V, 2000mAh)

Description:
These are rechargeable lithium-ion battery cells with a nominal voltage of 3.7V and a
capacity of 2000mAh. Known for their high energy density, long cycle life, and stable
voltage, these batteries are commonly used in portable electronics and robotics.

Applications:
Provide the necessary power for the robot's electronic components and motors.

Ensure long operating times due to high energy density.

Supply stable voltage and current to the system.

Battery Management System (BMS) 16V 40A

Description:
A Battery Management System (BMS) is a critical component that ensures the safety and
efficiency of rechargeable battery packs. It protects the battery from overcharging, over-
discharging, overcurrent, and short circuits, while also balancing the charge across cells.

Applications:
Protect the Li-ion batteries from overcurrent, overvoltage, and undervoltage conditions.

Ensure safe charging and discharging of the batteries.

Monitor battery health and extend battery lifespan.

Fire Sensor

Description:
A fire sensor detects the presence of fire or flames, typically using infrared or ultraviolet
light detection methods. It is designed to provide early warning of a fire, enabling prompt
action to prevent damage and ensure safety.

Applications:
Detect fire hazards during the robot's surveillance tasks.

Alert security personnel in case of fire detection.

Enhance the safety features of the surveillance system.

Ultrasonic Sensor

Description:
An ultrasonic sensor measures distance by emitting ultrasonic sound waves and measuring
the time it takes for the echo to return. It is widely used for object detection and ranging in
robotics and automation projects.

Applications:
Detect obstacles in the robot's path to avoid collisions.

Aid in navigation and path planning.

Enhance the robot's ability to operate autonomously.

Step-Down Buck Converter (300W)

Description:
A step-down buck converter is a DC-DC converter that reduces a higher input voltage to a
lower output voltage with high efficiency. It is commonly used to power lower voltage
components from a higher voltage source.

Applications:
Convert the battery voltage to the required lower voltages for various electronic
components.

Ensure stable and efficient power supply to the system.

Protect sensitive components from voltage spikes.

Step-Up Boost Converter (150W)

Description:
A step-up boost converter is a DC-DC converter that increases a lower input voltage to a
higher output voltage. It is used in situations where the input voltage needs to be boosted
to meet the requirements of certain components.

Applications:
Boost the battery voltage to the required higher voltages for components like motors.

Provide consistent voltage levels for high-power components.

Enhance the overall power management of the robot.

ESP32-CAM

Description:
The ESP32-CAM is a compact module that combines the ESP32 SoC with a camera, enabling
image and video capture. It supports various camera resolutions and features an integrated
Wi-Fi module for wireless communication.

Applications:
Provide the robot with vision capabilities for surveillance.

Capture and stream live video feeds for real-time monitoring.

Assist in image processing tasks and environment recognition.

12V Gear Motor

Description:
A 12V gear motor includes a motor and an integrated gearbox that provides high torque and
low-speed rotation. It is ideal for applications requiring precise control of speed and
movement.

Applications:
Power the movement of the robot, driving the wheels.

Enable navigation and mobility across various terrains.

Provide sufficient torque for carrying loads and overcoming obstacles.

10x4 mm Tyres for Robot

Description:
These are small rubber tires designed for use on robot wheels. They provide traction and
stability, ensuring smooth and controlled movement over different surfaces.

Applications:
Ensure smooth and stable movement of the robot.

Provide traction on various surfaces.

Enhance the robot's mobility and handling.

MS Square

Description:
Mild steel square and iron squares are structural elements used in construction. They
provide strength and support, making them ideal for building the frame of a robot.

Applications:
Provide a sturdy structural framework for the robot.

Ensure durability and support for all components.

Form the main chassis of the robot.

PVC Pipe

Description:
Polyvinyl chloride (PVC) pipes are versatile materials used for various construction and
insulation purposes. They are lightweight, durable, and easy to work with.

Applications:
Construct parts of the robot's body or housing.

Protect and route wiring and cables.

Create custom mounts and supports.

Cardboard

Description:
Cardboard is a thick, stiff paper material used for packaging and prototyping. It is easy to cut
and shape, making it useful for creating temporary structures.

Applications:
Construct prototype parts of the robot.

Create temporary housing for components.

Use for initial design and layout planning.

Heat Shrink Tubing (2mm)

Description:
Heat shrink tubing is a plastic tube that shrinks when heated, providing insulation and
protection for electrical connections. It is available in various sizes and shrinks tightly
around wires and connectors.

Applications:
Insulate exposed wires and connectors.

Provide strain relief and protection for electrical connections.

Enhance the safety and durability of the wiring.

Heatsink

Description:
A heatsink is a device that dissipates heat from electronic components to prevent
overheating. It typically consists of a metal base with fins to increase surface area for heat
dissipation.

Applications:
Cool the ESP32, motor driver, or other heat-generating components.

Prevent overheating and ensure stable operation.

Extend the lifespan of electronic components.

Motor Driver (12V L298)

Description:
The L298 is a dual H-bridge motor driver that can control the speed and direction of two DC
motors independently. It allows for precise control of motor functions through PWM (Pulse
Width Modulation).

Applications:
Interface between the ESP32 and the gear motors.

Control the speed and direction of the robot's movement.

Enable smooth and precise navigation.

Charger 12V 3A

Description:
A 12V 3A charger is an external power supply unit designed to charge 12V batteries. It
provides a steady and controlled current of 3 amps, ensuring efficient and safe charging of
the battery pack. These chargers typically come with safety features such as overcurrent
protection, overvoltage protection, and short circuit protection.

Applications:
Recharges the robot's battery pack.

Ensures the battery is maintained at optimal charge levels for extended operational periods.

Protects the battery from overcharging and ensures safe operation through integrated
safety features.
 Software Components

❖ Blynk IoT
❖ Arduino IDE
Blynk IoT

Description:
Blink IoT Platform is a cloud-based platform that simplifies the development, deployment,
and management of IoT solutions. It offers features such as device management, data
visualization, and remote monitoring.

Applications:
Facilitates remote monitoring and control of the robot's operations, allowing users to access
real-time data, receive alerts, and perform diagnostics from anywhere with an internet
connection.

Enables data aggregation, analysis, and visualization for insights into robot performance,
usage patterns, and environmental conditions.

Provides scalability, security, and reliability for IoT deployments, ensuring seamless
integration and operation of multiple devices and sensors in diverse environments.
Arduino IDE

Description:
Arduino IDE is an open-source software development environment used for programming
Arduino and compatible microcontroller boards. It features a simple, user-friendly interface
for writing, compiling, and uploading code to microcontrollers.

Applications:
Allows developers to write, debug, and upload firmware code for the robot's
microcontroller, facilitating customization, optimization, and testing of robot functionalities.

Provides access to a vast library of pre-built functions and code examples for rapid
development and prototyping of IoT applications.

Supports collaboration, community sharing, and continuous improvement through an active

ecosystem of developers, forums, and online resources.
Market Research
Progress chart
Manufacturing Process

Planning:

• Before starting the manufacturing process, thorough planning is essential to define the project
scope, requirements, and objectives. This phase involves:

o Identifying the purpose and intended use of the robot, whether for courier services,
surveillance, or other applications.

o Defining the specifications and functionality required, such as mobility, sensor capabilities,
communication methods, and payload capacity.

o Creating a detailed project timeline, including milestones, tasks, and deadlines for each
phase of development.

o Assessing resource requirements, including materials, components, tools, and personnel,

and establishing a budget.

o Conducting research on existing solutions, technologies, and best practices to inform the
design and development process.
Battery Assembly:

• The manufacturing process begins with the assembly of the power source for the
robot. Multiple Li-ion battery cells, typically 3.7V each, are soldered together in series
to create a higher voltage pack. In this case, the cells are soldered to form a 16V
10000mAh battery pack.

• The soldering process requires careful attention to ensure proper connections and
minimize the risk of short circuits or overheating.
Frame Construction:

• With the power supply system in place, the next step is to construct the frame of the
robot. This involves assembling structural elements using materials such as aluminum
and iron MS square bars.

• The frame is designed to provide rigidity, support, and mounting points for attaching
other components such as motors, wheels, and electronics.

• The assembly process may involve cutting, drilling, welding, or fastening of

components to create a sturdy and durable frame structure.
Motor and Wheel Installation:

• Once the frame is constructed, the motors are mounted onto the frame using appropriate brackets
or mounts. These motors typically drive the wheels or propulsion system of the robot.

• The wheels, often equipped with tires for better traction and grip, are then attached to the motor
shafts or hubs using screws or other fasteners.

• Proper alignment and spacing of the motors and wheels are essential to ensure smooth and
efficient movement of the robot.

Voltage Regulation:

• Once the battery pack is assembled, a step-down buck converter is used to regulate the voltage
output to the desired level. Since the motors and other components of the robot typically operate
at 12V, the buck converter is configured to reduce the voltage from 16V to 12V while maintaining a
high amperage level.

• This step is crucial to ensure that all components receive the appropriate voltage levels for optimal
performance and to prevent damage due to overvoltage.

Electronics Integration:

• With the mechanical components in place, attention turns to integrating the electronic systems
into the robot. This includes connecting the motors, sensors, microcontroller, and other electronic
modules.

• The ESP32 microcontroller board, acting as the brain of the robot, is securely mounted within the
frame and connected to the motor drivers, sensors, and other peripheral devices.

• Careful attention is paid to wiring and cable management to prevent tangling, interference, or
damage to the electronic components.
Testing and Troubleshooting:

• Once the robot is fully assembled, a series of tests are conducted to ensure all components are
functioning correctly. This includes testing motor movement, sensor readings, communication with
the microcontroller, and overall system functionality.

• During testing, issues or malfunctions may arise, requiring troubleshooting and debugging.
Common issues include wiring errors, faulty components, or software bugs.

• Iterative testing and refinement are performed to address any issues and optimize the performance
and reliability of the robot.

Experience and Learning:

• Throughout the manufacturing process, valuable experience and insights are gained, particularly in
troubleshooting and problem-solving.

• Challenges such as component failures, wiring issues, or software glitches are opportunities for
learning and improvement.

• Each setback or failure provides an opportunity to refine techniques, enhance skills, and develop a
deeper understanding of the design and manufacturing process.

Finalization and Deployment:

• After successful testing and troubleshooting, the robot is finalized and prepared for deployment.
This may involve adding finishing touches such as protective enclosures, labeling, or aesthetic
enhancements.

• The robot is then ready for deployment in its intended application, whether it be for courier
services, surveillance, or other tasks.

Cost Estimation:
Basic Circuit Diagram ( Without Sensors )

Camera Basic Circuit Diagram

Esp32 Code

#define BLYNK_TEMPLATE_ID "TMPL3_yUIiLKa"

#define BLYNK_TEMPLATE_NAME "Major Project"
#define BLYNK_AUTH_TOKEN "Z1WWcoq14D6E89-GDmI6ETXtycy_f4zM"

#include <WiFi.h>
#include <BlynkSimpleEsp32.h>

// You should get Auth Token in the Blynk App.

// Go to the Project Settings (nut icon).
char auth[] = "Z1WWcoq14D6E89-GDmI6ETXtycy_f4zM";

// Your WiFi credentials.

// Set password to "" for open networks.
char ssid[] = "robot";
char pass[] = "robot123";

// Pins for controlling devices

#define PIN_1 26
#define PIN_2 25
#define PIN_3 33
#define PIN_4 32

// Ultrasonic Sensor Pins

#define TrigPin 5
#define EchoPin 18

// Fire Sensor Pin

#define FirePin 19

void setup() {
// Debug console
Serial.begin(9600);

Blynk.begin(auth, ssid, pass);

// Setup pins for controlling devices

pinMode(PIN_1, OUTPUT);
pinMode(PIN_2, OUTPUT);
pinMode(PIN_3, OUTPUT);
pinMode(PIN_4, OUTPUT);

// Set pins to high initially

digitalWrite(PIN_1, HIGH);
digitalWrite(PIN_2, HIGH);
digitalWrite(PIN_3, HIGH);
digitalWrite(PIN_4, HIGH);

// Setup pins for sensors

pinMode(TrigPin, OUTPUT);
pinMode(EchoPin, INPUT);
pinMode(FirePin, INPUT);
}
void loop() {
Blynk.run();

// Check for obstacles and fire

checkObstacle();
checkFire();
}

// Function to check for obstacles using the ultrasonic sensor

void checkObstacle() {
long duration;
int distance;

// Send a pulse to trigger the ultrasonic sensor

digitalWrite(TrigPin, LOW);
delayMicroseconds(2);
digitalWrite(TrigPin, HIGH);
delayMicroseconds(10);
digitalWrite(TrigPin, LOW);

// Read the pulse duration from the echo pin

duration = pulseIn(EchoPin, HIGH);

// Calculate the distance in cm

distance = duration * 0.034 / 2;

// If distance is less than 100 cm, stop the device

if (distance < 100) {
stopDevice();
}
}

// Function to check for fire using the fire sensor

void checkFire() {
int fireDetected = digitalRead(FirePin);

// If fire is detected (LOW signal), stop the device

if (fireDetected == LOW) {
stopDevice();
}
}

// Function to stop the device

void stopDevice() {
digitalWrite(PIN_1, LOW);
digitalWrite(PIN_2, LOW);
digitalWrite(PIN_3, LOW);
digitalWrite(PIN_4, LOW);
}

// Widget for controlling PIN_1 and PIN_2 together (forward)

BLYNK_WRITE(V0) {
int pinValue = param.asInt();
digitalWrite(PIN_1, pinValue);
digitalWrite(PIN_2, pinValue);
}
// Widget for controlling PIN_3 and PIN_4 together (backward)
BLYNK_WRITE(V1) {
int pinValue = param.asInt();
digitalWrite(PIN_3, pinValue);
digitalWrite(PIN_4, pinValue);
}

// Widget for controlling PIN_2 (individual) (left)

BLYNK_WRITE(V2) {
int pinValue = param.asInt();
digitalWrite(PIN_2, pinValue);
}

// Widget for controlling PIN_1 (individual) (right)

BLYNK_WRITE(V3) {
int pinValue = param.asInt();
digitalWrite(PIN_1, pinValue);
}
Camera Code

#include "esp_camera.h"
#include <WiFi.h>
#include "WebServer.h"

// Wi-Fi settings
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

// Camera pins configuration

#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27
#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22

// Server initialization
WebServer server(80);

void startCameraServer() {
server.on("/", HTTP_GET, []() {
server.send(200, "text/html", "<h1>Welcome to ESP32-CAM</h1><p><a href='/stream'>Start Video
Stream</a></p>");
});

server.on("/stream", HTTP_GET, []() {

camera_fb_t *fb = NULL;
fb = esp_camera_fb_get();
if (!fb) {
server.send(500, "text/plain", "Camera capture failed");
return;
}

server.sendHeader("Access-Control-Allow-Origin", "*");
server.sendHeader("Content-Type", "multipart/x-mixed-replace; boundary=frame");
server.send(200);

while (true) {
fb = esp_camera_fb_get();
if (!fb) {
break;
}
 server.sendContent("--frame\r\n");
server.sendContent("Content-Type: image/jpeg\r\n");
server.sendContent("Content-Length: " + String(fb->len) + "\r\n\r\n");
server.sendContent((const char*)fb->buf, fb->len);
server.sendContent("\r\n");

esp_camera_fb_return(fb);

if (server.client().connected() == false) {
break;
}
}
});

server.begin();
}

void setup() {
Serial.begin(115200);

camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;

if (psramFound()) {
config.frame_size = FRAMESIZE_UXGA; // UXGA for high resolution
config.jpeg_quality = 10; // Lower value means higher quality
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}

// Initialize the camera

if (esp_camera_init(&config) != ESP_OK) {
Serial.println("Camera init failed");
return;
 }

// Connect to Wi-Fi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("Wi-Fi connected.");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());

// Start the camera server

startCameraServer();
}

void loop() {
server.handleClient(); // Handle HTTP requests
}
 Conclusion

The Courier and Surveillance Robot project has been an enriching and transformative
journey for our team. Starting from the initial planning stages, where we meticulously
outlined the project's scope and objectives, to the hands-on assembly and coding phases,
each step has contributed significantly to our learning and skill development. The successful
integration of various hardware components such as the Li-ion battery pack, step-down
buck converter, and sensors with the ESP32 microcontroller has not only demonstrated our
technical abilities but also highlighted the importance of teamwork and perseverance.
Throughout the project, we encountered numerous challenges, including the damage of
multiple ESP32 boards and complex wiring issues. These setbacks, however, served as
valuable learning experiences, allowing us to develop problem-solving strategies and refine
our technical skills. The iterative testing and debugging phases were crucial in ensuring the
reliability and efficiency of the robot, ultimately leading to a robust and functional
prototype capable of performing courier and surveillance tasks.

The project has also underscored the importance of collaboration and support from team
members and external contributors. The successful completion of this robot is a testament
to the hard work, dedication, and innovative spirit of everyone involved. This experience has
not only achieved its initial goals but also paved the way for future advancements in
robotics and IoT applications, inspiring us to explore new possibilities and push the
boundaries of technology.
 References

OpenAI:
For providing the foundational knowledge and resources used throughout the project.

Robocraze, Flyrobu, Amazon, and Makerbazaar:

For supplying the essential electronic components that were integral to the robot's
functionality.

Harshit Budhlakoti:
Harshit played a pivotal role in the project's success, offering invaluable assistance in coding
and sensor integration. His expertise in programming and his deep understanding of sensor
systems were critical in overcoming technical challenges. Beyond his technical
contributions, Harshit provided unwavering support and encouragement, especially during
the more challenging phases of the project. His positive attitude and willingness to help
were a source of motivation for the entire team.

Arduino IDE:
For providing the user-friendly development environment that facilitated the programming
of the ESP32 microcontroller.

Blink IoT Platform:

For enabling the remote monitoring and control capabilities that enhanced the robot's
functionality.

Local Suppliers in Nainital:

For providing the materials such as MS square bar, PVC pipes, and cardboard used in
constructing the robot’s frame, contributing to the mechanical robustness of the design.