FIRE DETECTION USING RASPBERRY PI PICO W

NAME REGISTER NUMBER

SIJIN S G 961421106049
SUGANTH J 961421106052
ABISHEK A M 961421106004
SIVA D V 961421106050
ROSHAN R S 961421106046

NISANTH N S 961421106041

ARJUN P L 961421106013

Guided By

Mr. G. Sivaramalingam, M. Tech

Mrs. Priya J S, M. E, AP/ECE

Mar Ephraem College of Engineering and Technology, Marthandam, 629162
 BONAFIDE CERTIFICATE

Certified that this project report "FIRE DETECTION USING RASPBERRY PI

PICO W “ is the Bonafide work of “SIJIN S G (961421106049), SUGANTH J
(961421106052), ABISHEK A M (961421106004), SIVA D V
(961421106050), ROSHAN R S (961421106046),NISANTH N S
(961421106041),ARJUN P L(961421106013)" who carried out the project
work under my supervision.

INTERNAL GUIDE HEAD OF THE DEPARTMENT

EXTERNAL EXAMINER INTERNAL EXAMINER

ABSTRACT

In the era of IoT (Internet of Things), smart devices have become an integral
part of modern living. This project presents the design and implementation of
a Smart Clock utilizing the ESP8266 microcontroller, offering a blend of
traditional timekeeping functionality with advanced IoT capabilities. The core
of the Smart Clock is the ESP8266 microcontroller, renowned for its low cost,
versatility, and Wi-Fi connectivity. Through this platform, the clock seamlessly
connects to the internet, enabling a myriad of features beyond conventional
timekeeping. Key functionalities include real-time clock synchronization
through NTP (Network Time Protocol), allowing precise timekeeping
irrespective of geographical location. The clock's intuitive interface,
comprising LED displays or TFT screens, provides clear and customizable time
readouts.Moreover, leveraging its Wi-Fi connectivity, the Smart Clock
integrates with various online services, such as weather APIs, enabling
real-time weather updates and forecasts. Additionally, it can synchronize with
online calendars, displaying upcoming events or reminders.Furthermore, the
Smart Clock serves as a hub for home automation, capable of controlling IoT
devices through MQTT (Message Queuing Telemetry Transport) protocol.
Users can schedule tasks, such as turning lights on/off, adjusting thermostat
settings, or activating alarms, directly from the clock's interface or remotely
through a dedicated mobile application. Security features are paramount in
IoT devices, and the Smart Clock implements robust encryption protocols to
safeguard user data and device integrity. Access controls and authentication
mechanisms ensure secure communication and prevent unauthorized access.
The versatility and expandability of the ESP8266 platform allow for further
customization and integration of additional features based on user
preferences and requirements. Overall, the Smart Clock offers a seamless
blend of traditional timekeeping with the convenience and functionality of IoT,
enhancing user productivity and convenience in the digital age.
BLOCK DIAGRAM:
ESP8266 NodeMCU:

The Node Microcontroller Unit (Node MCU) is open source software

and hardware enlargement background that is constructed
everywhere a very inexpensive system on a chip named the ESP8266.
In our System we have used Node MCU to receive data from Arduino
and send that data over internet. The NodeMCU is a powerful
development board based on the ESP8266 Wi-Fi module, widely
known for its versatility and ease of use in Internet of Things (IoT)
projects. Featuring an onboard ESP8266 microcontroller unit (MCU),
the NodeMCU combines the functionality of a microcontroller with
integrated Wi-Fi connectivity, making it an ideal platform for building
connected devices and applications. With a range of GPIO pins, analog
inputs, and support for various communication protocols, including
Wi-Fi and serial communication, the NodeMCU offers flexibility for
interfacing with sensors, actuators, and other peripherals. Its
compatibility with the Arduino IDE and extensive community support
further simplifies development, allowing users to leverage a wealth of
libraries and resources. Whether used for home automation, remote
monitoring, or prototyping IoT solutions, the NodeMCU empowers
developers and enthusiasts to bring their ideas to life in the rapidly
evolving world of connected devices
RTC Module:

A Real-Time Clock (RTC) module is an essential component in electronic

devices requiring accurate timekeeping functionality. Unlike standard clocks
or microcontrollers with internal clocks, RTC modules are designed to
maintain precise time even when the device is powered off or disconnected
from a power source. Typically, RTC modules consist of an integrated circuit
(IC) and a small battery backup. The IC, such as the popular DS1307, DS3231,
or PCF8563, contains a highly accurate clock/calendar circuit with features
like seconds, minutes, hours, day, date, month, and year counters. These
counters are maintained by an internal oscillator, ensuring stable timekeeping
over extended periods. The battery backup, usually a small coin cell battery,
provides power to the RTC module when the main power source is
unavailable. This ensures that the RTC continues to operate and maintain
accurate time even during power outages or when the device is turned off.
RTC modules communicate with microcontrollers or other devices using
standard communication protocols such as I2C (Inter-Integrated Circuit) or
SPI (Serial Peripheral Interface), making them compatible with a wide range
of microcontrollers and development boards. This allows for seamless
integration into various projects, including smart clocks, data loggers, data
loggers, and industrial automation systems.In summary, RTC modules play a
crucial role in electronics projects requiring precise timekeeping, offering
reliability, accuracy, and the ability to maintain time even in the absence of
external power sources.
LED Display:

LED displays, short for Light Emitting Diode displays, are a popular choice for
visual output in electronic projects due to their low power consumption, high
brightness, and ease of use. These displays consist of an array of individual
LEDs arranged in a matrix or segmented format, capable of emitting light in
different colors such as red, green, blue, or a combination of these colors.
Segmented LED Displays displays consist of multiple segments arranged to
form alphanumeric characters, symbols, or digits. Each segment represents a
specific portion of a character or symbol. Common configurations include
7-segment, 14-segment, and 16-segment displays. Segmented displays are
widely used in applications where numerical or alphanumeric information
needs to be displayed, such as digital clocks, temperature indicators, or
scoreboards. Dot Matrix LED Displays are composed of a grid of individual
LEDs, where each LED represents a pixel in the display. By selectively turning
on or off specific LEDs, dot matrix displays can generate text, graphics, or
animations. Dot matrix displays offer more flexibility in displaying information
compared to segmented displays and are often used in applications requiring
dynamic content, such as scrolling text messages, graphical interfaces, or
simple animations. LED displays are typically controlled by microcontrollers
or driver ICs using serial communication protocols like SPI (Serial Peripheral
Interface) or I2C (Inter-Integrated Circuit). This allows for easy interfacing
with various microcontroller platforms, making LED displays suitable for a
wide range of projects. In summary, LED displays are versatile visual output
devices commonly used in electronics projects to display text, numbers,
symbols, graphics, and animations. With their low power consumption, high
brightness, and flexible control options, LED displays are an excellent choice
for applications requiring visual feedback or information display.
LCM1602IIC:

The LCM1602IIC is a popular LCD (Liquid Crystal Display) module with an

integrated I2C (Inter-Integrated Circuit) interface, designed for easy
integration into microcontroller projects. Here's an explanation of its key
components and features: **LCD Display**: The module features a 16x2
character LCD display, capable of showing two lines of text with up to 16
characters per line. Each character position consists of a 5x8 dot matrix,
allowing the display of alphanumeric characters, symbols, and custom
graphics.**Backlight**: The LCM1602IIC module typically includes an LED
backlight to illuminate the display for better readability in various lighting
conditions. The backlight can be controlled independently, allowing users to
adjust its brightness or turn it on/off as needed.**I2C Interface**: One of the
distinguishing features of the LCM1602IIC module is its built-in I2C interface.
This interface simplifies the communication between the module and
microcontroller by reducing the number of required pins. With I2C, only two
wires (SDA and SCL) are needed to communicate with the module, making it
ideal for projects with limited GPIO pins or for applications requiring multiple
modules to be connected to the same bus. **Integrated I2C Backpack**: The
module often comes with an integrated I2C backpack, which consists of an I2C
serial interface module (commonly based on PCF8574 or similar IC)
connected to the LCD display. The backpack handles the communication
between the microcontroller and the LCD display, translating commands and
data into signals that the display can understand. This simplifies the wiring
and programming required to interface with the LCD display.The I2C backpack
typically allows for address configuration, enabling multiple LCM1602IIC
modules to be connected to the same I2C bus without conflicts. By changing
the address jumpers or solder pads on the backpack, each module can be
assigned a unique address, allowing them to be individually addressed and
controlled by the microcontroller.
PROGRAM :

##include <ESP8266WiFi.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h> // Library for I2C
LCD

// Replace these values with your WiFi

credentials
const char* ssid = "your_network_ssid";
const char* password =
"your_network_password";

// Set the RTC address if using an RTC module

#define RTC_I2C_ADDRESS 0x68

// Initialize the LCD

LiquidCrystal_I2C lcd(0x27, 16, 2); // Change the
address (0x27) if necessary

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

// Initialize the LCD display

lcd.init();
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print("Smart Clock");

// Connect to WiFi
connectToWiFi();
}

void loop() {
// Get current time from RTC
// Example:
// int hours = readRTC(0x02); // Read hours
register from RTC
// int minutes = readRTC(0x01); // Read
minutes register from RTC

// Display time on LCD

 // Example:
// lcd.setCursor(0, 1);
// lcd.print("Time: ");
// lcd.print(hours);
// lcd.print(":");
// lcd.print(minutes);

// Other functionalities like weather updates,

alarms, etc. can be added here
delay(1000); // Update every second
}

void connectToWiFi() {
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
}

Serial.println("");
Serial.println("WiFi connected");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}

// Function to read from RTC module

// int readRTC(byte reg) {
// Wire.beginTransmission(RTC_I2C_ADDRESS);
// Wire.write(reg);
// Wire.endTransmission();
// Wire.requestFrom(RTC_I2C_ADDRESS, 1);
// if (Wire.available()) {
// return Wire.read();
// }
// return -1; // Error
}
PROGRAM EXPLANATION:

This code provides a basic framework for a smart clock using an ESP8266. It
initializes the LCD display, connects to WiFi, and then enters the main loop
where you can add functionalities like reading time from an RTC module,
displaying it on the LCD, updating weather information, setting alarms, etc.

Remember to replace `"your_network_ssid"` and `"your_network_password"`

with your actual WiFi credentials.

Additionally, if you're using an RTC module, you'll need to uncomment the

`readRTC` function and modify it to suit your RTC module's communication
protocol.

Feel free to expand upon this code to add more features and customize it
according to your requirements