1.

Introduction
Fires can occur unexpectedly and spread rapidly, causing significant loss of life and property. Traditional
fire detection systems, such as smoke detectors and sprinkler systems, are useful but often limited by
range, mobility, and response time.

A Fire Detector Robot offers a mobile and intelligent

solution by detecting fires, alerting responders, and, in some designs, attempting to extinguish the fire.
This robot is especially useful in environments that are hazardous or difficult for humans to access.

2. Objective
The main goals of the Fire Detector Robot are:

• Early Detection: Identify fire as soon as it starts using flame and temperature sensors.
• Autonomous Navigation: Move through an area without human control to locate the fire.
• Fire Alert System: Trigger an alarm or send a message when a fire is detected.
• Extinguishing Mechanism (optional): Use a water sprayer or extinguisher to suppress small fires.
• Safety Monitoring: Reduce risk to humans by exploring dangerous environments.

3. Components Used and Their Functions

1. 4WD Car Base (Four-Wheel Drive Chassis)

• Function: Acts as the mechanical foundation of the robot.

• Description: A 4WD chassis consists of four DC motors with attached wheels mounted on a
frame. This setup provides better stability and traction, allowing the robot to move smoothly
across different surfaces.
• Advantages:
o High maneuverability
o Suitable for uneven terrains
o Enhanced load-carrying capacity

2. Motor Driver (e.g., L298N Dual H-Bridge Motor Driver)

• Function: Controls the direction and speed of the DC motors.

• Description: The motor driver acts as an interface between the microcontroller (like Arduino)
and the motors. It allows low-power signals from the Arduino to control high-power motors.
• Features:
o Dual-channel (can drive 2 motors independently)
o Can control speed using PWM (Pulse Width Modulation)
o Can drive motors in both forward and reverse directions
3. Arduino Uno (Microcontroller Board)

• Function: Serves as the brain of the robot.

• Description: The Arduino Uno is an open-source microcontroller board based on the
ATmega328P. It reads data from sensors and sends commands to other components like motors
and the water pump.
• Specifications:
o 14 digital input/output pins
o 6 analog inputs
o 16 MHz clock speed
o USB connection for programming

4. FET Module (MOSFET Control Module)

• Function: Switches high-power devices (like water pumps) using low-voltage control signals.
• Description: A Field Effect Transistor (FET) module is used when the Arduino’s pins can’t supply
enough current to drive components like pumps or lights. The FET acts like an electronic switch.
• Benefits:
o Safe high-current switching
o Efficient and fast response
o Often includes optocouplers for isolation

5. 6W Water Pump

• Function: Used to extinguish fire by spraying water.

• Description: A compact 6-watt DC water pump draws water from a reservoir and ejects it
through a nozzle toward the fire when activated.
• Features:
o Operates on 5V–12V DC
o Compact and portable
o Controlled via FET or relay module

6. 3 Flame Sensors (IR-based Flame Detection)

• Function: Detects presence of fire based on infrared light emitted by flames.

• Description: Infrared flame sensors are used in an array (three in total) to cover multiple
directions (360-degree monitoring). Each sensor provides digital or analog output based on
flame proximity.
• Capabilities:
o Flame detection distance up to 80 cm (depends on flame size)
o Wide detection angle (~60 degrees per sensor)
o Can be used to guide the robot toward the fire source
7. Servo Motor

• Function: Used for precise angular movements.

• Description: A servo motor can be used to rotate a water nozzle or a camera/sensor mount
toward the direction of fire detection.
• Specifications:
o Rotational range: typically 0° to 180°
o Controlled via PWM signal from Arduino
• Use Case:
o Aim the water sprayer toward detected flame

8. Light Follower Sensor (Light-Dependent Resistor Module - LDR)

• Function: Detects ambient light levels to follow light sources or detect fire’s brightness.
• Description: This module uses LDRs to sense light intensity. It can be used to enhance flame
detection or help the robot align with the brightest (possibly hottest) source.
• Uses:
o Additional navigation or orientation toward fire
o Fire confirmation through brightness level

4. Working Principle
The Fire Detector Robot operates on the principle of autonomous navigation and sensor-based
fire detection. As the robot moves around on its 4WD chassis, it continuously monitors its
surroundings using an array of six flame sensors placed at different angles, allowing it to detect
the direction and presence of fire. Simultaneously, a temperature sensor and light follower
sensor help confirm the existence of a fire by detecting heat and increased light intensity. When
a flame is detected, the microcontroller (Arduino Uno) processes the input signals and
commands the robot to stop. Using the servo motor, it rotates a mounted water nozzle toward
the fire source, guided by the most active flame sensor. The Arduino then activates the 6W
water pump through the FET module to spray water at the fire. An alarm or buzzer can also be
triggered to notify nearby personnel. The motor driver controls the motion of the robot
throughout the process, ensuring smooth and accurate movement. This system allows the robot
to autonomously detect and respond to fire in a safe, efficient manner without human
intervention.
CAD/CAM SYSTEMATIC VIEW
Top View:

Isomatric view:
Right view Left view

Back view Front view

ELECTRICAL COMPONENTS:

Component Quantity Description

Arduino Uno 1 Microcontroller for controlling
system
L298N Motor Driver 1 Dual H-bridge for motor control

Flame Sensor Module 1–2 Detects infrared from fire

Buzzer 1 Audio alert
Servo Motor 1 For fire extinguisher nozzle
Fan Module 1 Fire extinguishing
Battery Pack (12V) 1 Power source
Wires, Switches, PCB — Supporting electronics
DC Motors 2 For driving wheels

Power Supply:

The robot is powered by a lithium battery, which provides a lightweight and efficient energy source.
Lithium batteries are rechargeable and have a high energy density, making them suitable for mobile
robotic applications. The battery used typically supplies between 7.4V to 11.1V, depending on the
component requirements. This power is distributed to the motors, Arduino, water pump, and other
modules via appropriate regulators and drivers.

Motor and Mobility System:

The base of the robot consists of a 4WD (four-wheel drive) platform equipped with four 6V DC motors.
These motors provide adequate torque for smooth movement and can navigate various terrains. The
motors are driven by a motor driver module (such as an L298N), which receives control signals from the
Arduino. This setup allows the robot to move forward, backward, and turn toward detected fire sources.

Arduino Control Unit:

The Arduino Uno acts as the main controller of the robot. It gathers input from the flame sensor(s) and
sends output signals to control other components such as motors, servo, buzzer, and water pump. The
Arduino is programmed using C/C++ through the Arduino IDE and serves as the decision-making brain of
the system.
 Flame Detection Sensor:

The robot is equipped with one or more flame sensors, which detect infrared light emitted by a fire.
These sensors have both analog and digital outputs. The digital output triggers when flame intensity
crosses a set threshold, while the analog output can be used to determine distance or direction. The
detection range of a typical flame sensor is around 80 to 100 cm. These sensors are mounted at the
front to scan for fire in the robot's path.

FET Module and High-Current Control

A FET (Field Effect Transistor) module is used in the system to control high-current devices like the water
pump. Since the Arduino cannot handle large current loads directly, the FET acts as an electronic switch
that allows the Arduino to turn the pump on or off using a digital signal. This setup protects the
controller and ensures efficient operation.

Water Pump System:

The water pump is responsible for extinguishing the fire once it has been detected. It operates on 6V to
8V DC and draws power through the FET module. The pump is connected to a small water reservoir
mounted on the robot chassis and sprays water toward the fire when activated by the Arduino.

Servo Motor for Nozzle Direction:

A servo motor is attached to the nozzle or water sprayer to control its direction. The Arduino sends
PWM signals to the servo, allowing it to rotate within a range (typically 0–180 degrees). This enables the
robot to target the flame more precisely after determining its direction using sensor input.

Step-by-Step Operation:

1. Startup: The robot powers on, and the Arduino initializes all sensors and modules.
2. Sensor Monitoring: The flame sensor continuously checks for fire.
3. Detection: If a fire is detected, the Arduino triggers the buzzer and water pump.
4. Targeting: The servo motor adjusts the spray direction toward the flame.
5. Extinguishing: The water pump is activated via the FET module to spray water.
6. Loop: The system returns to monitoring after attempting to extinguish the fire.
ARDINO:

Arduino is an open-source electronics platform designed to simplify the process of

working with microcontrollers. It allows users to interact with sensors and control actuators in real-
world applications. The platform includes both hardware (a physical programmable board) and software
(Arduino IDE), making it ideal for creating automated systems. Arduino is widely used in educational,
industrial, and DIY projects due to its simplicity, flexibility, and low cost.

Common Arduino Boards:

There are various models of Arduino boards, each suited to different

applications. The most commonly used board is the Arduino Uno, which is ideal for beginners. Other
variants include Arduino Mega (for more I/O pins), Nano (compact version), and Due (more advanced
features). These boards are all based on different microcontrollers but follow a similar structure and
programming approach.

Arduino Uno Features

The Arduino Uno uses the ATmega328P microcontroller, operating at 5V

with a clock speed of 16 MHz. It features 14 digital input/output pins (6 of which provide PWM output),
6 analog inputs, a USB connection, a power jack, a reset button, and an ICSP header. The board has 32KB
of flash memory for storing code and can be powered either through a USB cable or an external
battery/power adapter (7–12V recommended). This makes the Uno versatile and reliable for most
embedded system projects.

Programming Environment

Arduino is programmed using the Arduino IDE, which supports a simplified version of the C/C++
language. Each Arduino program (called a sketch) contains two main functions: setup() and loop(). The
setup() function runs once to initialize inputs and outputs, while the loop() function runs repeatedly,
making the board respond to real-time inputs like sensor values or user commands. This structure
makes it easy to understand and implement both basic and advanced logic.

One of Arduino's biggest advantages is its open-source nature,

allowing anyone to access, modify, and distribute its hardware and software designs. It is also supported
by a large global community that contributes tutorials, code samples, and troubleshooting help. Arduino
boards are affordable, easy to use, and compatible with a wide variety of sensors, modules, and
electronic components, making them perfect for prototyping and learning.
ARDUINO CODE

#include <Servo.h>

// Motor driver pins

const int IN1 = 2;
const int IN2 = 3;
const int IN3 = 4;
const int IN4 = 7;
int Speed = 180;
int ena = 5;
int enb = 6;

// Fire sensors and pump

const int sense_F = A2; // Fire sensor front
const int sense_L = A3; // Fire sensor left
const int sense_R = A4; // Fire sensor right
const int sense_thresh = A5; // Fire intensity threshold
const int pump = 13; // Pump control

Servo myServo;

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

// Motor setup
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
pinMode(ena, OUTPUT);
pinMode(enb, OUTPUT);

analogWrite(ena, Speed);
analogWrite(enb, Speed);

// Sensor and pump setup

pinMode(sense_F, INPUT);
pinMode(sense_L, INPUT);
pinMode(sense_R, INPUT);
pinMode(sense_thresh, INPUT);
pinMode(pump, OUTPUT);

// Servo setup
myServo.attach(9);
 myServo.write(90); // Center position

Serial.println("Firefighter Robot Ready!");

}

void loop() {
firefighterMode();
}

// Firefighter logic
void firefighterMode() {
digitalWrite(pump, LOW);
myServo.write(90); // Center servo

int intensity = analogRead(sense_thresh);

if (intensity < 20) {

stopCar();
digitalWrite(pump, HIGH);

// Sweep servo to spray

for (int pos = 0; pos <= 180; pos++) {
myServo.write(pos);
delay(15);
}
for (int pos = 180; pos >= 0; pos--) {
myServo.write(pos);
delay(15);
}

digitalWrite(pump, LOW);
} else if (digitalRead(sense_F) == LOW) {
backwardCar();
} else if (digitalRead(sense_L) == LOW) {
turnLeft();
} else if (digitalRead(sense_R) == LOW) {
turnRight();
} else {
stopCar();
}
}

// Motor control functions

void forwardCar() {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
}

void backwardCar() {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
}

void turnLeft() {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
}

void turnRight() {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
}

void stopCar() {
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
}
FLOWCHART:
Working Range:
The fire detector robot has an effective working range of approximately 1 to 1.5
meters for fire detection and extinguishing. This range is determined by the sensitivity of the flame
sensors, which can detect infrared radiation emitted by fire within this distance. The water pump and
servo motor are designed to spray water in a wide arc, covering up to 180 degrees, allowing the robot to
extinguish flames within close proximity effectively. The robot’s movement range depends on the motor
battery capacity and surface conditions, allowing it to operate for up to 30 minutes on a full charge
while patrolling and detecting fire sources within its sensor range.

Total cost:

Abdul Sammad

Battery Power and Battery Time:

The fire detector robot operates using a Lithium-ion battery
with a typical rating of 7.4V and 2200mAh. This battery is capable of powering the entire system,
including the 6V DC motors, Arduino UNO board, flame sensors, servo motor, and the water pump.
Under normal operating conditions, the battery provides a working time of approximately 25 to 40
minutes, depending on the load and frequency of water pump activation. Efficient power distribution
and low power consumption of the components allow the robot to function effectively during its patrol
and fire extinguishing tasks within this timeframe.

Power Types and Power Used in the Project:

The fire detector robot can be powered using various
sources such as Lithium-ion batteries, Nickel Metal Hydride (NiMH) batteries, or a direct DC power
supply (in lab testing conditions). However, in this project, a rechargeable Lithium-ion battery (7.4V,
2200mAh) is used due to its high energy density, light weight, and ability to supply stable voltage. This
battery is suitable for portable robotic applications as it efficiently powers all components including the
Arduino UNO board, 6V DC motors, flame sensors, servo motor, and water pump. The choice of lithium-
ion battery ensures uninterrupted operation and reliable performance throughout the robot’s active
duty cycle.

Conclusion:
The fire detector robot project demonstrates an effective integration of electronics, embedded systems,
and mechanical components to develop a compact and autonomous fire-fighting system. By using flame
sensors to detect fire and a combination of motors, a water pump, and a servo motor to extinguish it,
the robot provides a practical solution for fire hazard mitigation in small-scale indoor environments. The
system is controlled by an Arduino UNO, which reads sensor data, operates actuators, and executes
decision-making algorithms through a well-defined code structure.

The robot is powered by a rechargeable lithium-ion battery that delivers adequate runtime and
performance. With a detection range of about 1 to 1.5 meters and an operational time of up to 40
minutes, it is capable of responding promptly to fire threats within its working area. The successful
design and implementation of this project highlight the feasibility of using low-cost electronics and
open-source programming for developing real-world automated safety systems. Future improvements
may include integrating wireless communication for remote alerts and using multiple sensors for
increased accuracy.