Kiosks System

FLOOD DETECTION SYSTEM
A Project Report
Submitted in partial fulfillment of the requirement for the award of Degree of Bachelor
of Technology in Computer Science & Engineering
Submitted to
DR. A.P.J. ABDUL KALAM TECHNICAL UNIVERSITY,

LUCKNOW (U.P)
PROJECT REPORT
Submitted By
Rahul (1904730100038) Pintu (1904730100034)

Sateesh (1904730100046) Vivek (1904730100038)
Project Guide
Prof Mr.Tushar Giri
DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING
G.C.R.G MEMORIAL TRUST GROUP OF INSTITUTIONS, LUCKNOW
Session 2022-23
I
CERTIFICATE
This is to certify that the work embodied in this Project title “Flood
Detection System Using Iot” has been satisfactorily completed by Rahul
Kumar Sahani, Sateesh Kumar Chaudhary, Pintu Kumar and Vivek Prasad,
students of 4th year. It is a bonafide piece of work, carried out under my
supervision and guidance in the Department Of Computer Science &
Engineering ,G.C.R.G Memorial Trust Group Of Institutions , Lucknow for
partial fulfillment of the Bachelor of Technology during the academic year
2019-23.
Under the Supervision of
Prof Mr. Tushar Giri
Approved By
Dr. Shivi Chaturvedi
Head of the Department
II
DECLARATION
We, Rahul Kumar Sahani, Sateesh Kumar Chaudhary, Pintu Kumar and Vivek
Prasad, students of Bachelor of Technology, Department Of Computer Science &
Engineering,
G.C.R.G Memorial Trust Group Institutions , Lucknow hereby declare that the work
presented in this Project is outcome of our own work, is bonafide, correct to the best of
my/our knowledge and this work has been carried out taking care of Engineering
Ethics. The work presented does not infringe any patented work and has not been
submitted to any University for the award of any degree or any professional diploma.
Rahul Kumar Sahani Pintu Kumar

1904730100038 1904730100034
Enrollment No. 1904730100050518 Enrollment No.1904730100050514
Sateesh Kumar Chaudhary Vivek Prasad

1904730100046 1904730100062
Enrollment No. 190473010050526 EnrollmentNo.1904730100050542
Date: 31-05-2023
III
ACKNOWLEDGEMENT
Reasons can be given & they can be many but nothing can replace the efforts of
numerous people behind the work, put in by the creator, giving us constant support all
the way. On the very outset I would like to thank Dr. Abhishek Kumar, Dy. Director,
GCRG, Lucknow for providing me the glorious opportunity to work on this project. I
express my hearty gratitude to Dr. Shivi Chaturvedi, Head of Department Computer
Science & Engineering Her invaluable guidance, advice & time out of extremely busy
schedule made this works an enthusiastic experience. I wish to express my most
sincere gratitude for her whole hearted cooperation.
I am grateful, beyond my sense of gratitude, to Dr. Suman Sharma, Project

Coordinator, Department of Computer Science & Engineering, for her kind
cooperation throughout the planning & preparation of this project. Working on this
project was quite a wonderful experience & that too an unforgettable one. Without his
unhindered support, sustained interest, unlimited patience, sound counsel &
tremendous knowledge in the field of electronics, this work would have not been
possible.
Nothing can be taken away from my project guide Prof. Mr. Tushar Giri.
Computer Science & Engineering, who has been instrumental in guiding us through
the various aspects of designing of our project & implementing the idea of the project
“Flood Detection System Using Iot”.
IV
TABLE OF CONTENTS
TOPIC NAME PAGE NUMBER

Certificate
II
Declaration
III
Acknowledgement IV
Table of Content V-VI
List of figures VII
Abstract 1
Chapter 1: Introduction............................................................................2-5
1.1 Introduction of Flood detection system
1.2 Introduction of Ultrasonic Sensor
Chapter 2: Literature Review..................................................................6-7

2.1 Principle
2.2 Methodology
Chapter 3: Application and Usage..........................................................8-9
Chapter 4: Architecture of Project.........................................................10
Chapter 5: Experimental Setup..............................................................11-23.
5.1 Hardware Components
5.1.1 Jumper Wires
5.1.2 Breadboard
5.1.3 Ultrasonic Sensor
5.1.4 I2C Module
5.1.5 LED Bulb
5.1.6 LCD display
5.1.7 Node MCU
5.1.8 Buzzer
5.1.9 Laptop
5.2 Software Components
5.2.1 Arduino IDE
5.2.2 Required Libraries
V
5.3 Working
5.3.1 Connecting Of Ultrasonic Sensor
5.3.2 Connecting of I2C module
5.3.3 Connecting of LCD Display
5.3.4 Connecting Of LED
Chapter 6 : Node MCU Tools...................................................................24-38
6.1 Installing necessary libraries
6.2 Coding the microcontroller for flood detection
6.3 Initializing Wi-Fi connection
6.4 Configuring sensor pins and alarms
6.5 Reading sensor data
6.6 Checking water level thresholds
6.7 Sending notifications and alarms
6.8 Uploading the code to the microcontroller
Chapter 7: Diagram.................................................................................39-41
7.1 Flowchart
7.2 Hardware Connection Chart
Chapter 8: Software Installation and Code..................................................42-46
Chapter 9: Discussion and Result..............................................................47-50
9.1 Testing the System
9.2 Output
Chapter 10: Conclusion and References........................................................50-53
VI
LIST OF FIGURES
1 Model Of Flood Detection System.......................................................3

2. Ultrasonic Sensor................................................................................4
3 Architecture of Project.........................................................................10
4 Jumper Wire.........................................................................................11
5 BreadBoard..........................................................................................12
6 Ultrasonic Sensor.................................................................................13
7 I2C Module..........................................................................................14
8 LED Bulb.............................................................................................. 15
9 LCD Display......................................................................................... 15
10 Node MCU.......................................................................................... 16
11 Buzzer................................................................................................. 16
12 Laptop................................................................................................. 17
13 Arduino IDE........................................................................................ 18
14 Connecting Of Ultrasonic Sensor........................................................20
15 Connecting Of I2C Module.................................................................21
16 Connecting Of LCD Display...............................................................22
17 Connecting Of LED Bulb....................................................................23
18 Libraries.............................................................................................. 26
19 Flowchart............................................................................................ 39
VII
ABSTRACT
The Flood Detection System in IoT project aims to develop an efficient and reliable
solution for detecting and monitoring flood events using Internet of Things (IoT)
technology. Floods pose a significant threat to lives and property, necessitating the
implementation of advanced monitoring systems to enable early detection and timely
response. Leveraging the power of IoT, this project combines various sensors, wireless
communication, and data analytics to create a comprehensive flood detection system.
The proposed system consists of multiple sensors strategically placed in flood-prone

areas, such as near rivers, streams, or low-lying regions. These sensors are equipped with
capabilities to measure water level, temperature, and other relevant environmental
parameters. They are wirelessly connected to a central control unit, which serves as a
data hub for collecting and processing the sensor readings.
.
The Flood Detection System in IoT project offers several benefits over traditional flood
monitoring methods. By leveraging IoT technology, the system provides real-time data,
enabling rapid response and evacuation measures. It enhances the accuracy and
reliability of flood detection, minimizing false alarms and maximizing the efficiency of
emergency services. Furthermore, the system can be integrated with existing disaster
management systems, enabling seamless coordination between different stakeholders.
In conclusion, the Flood Detection System in IoT project presents an innovative

approach to flood detection and monitoring. By harnessing the power of IoT technology,
this system has the potential to significantly enhance the resilience of communities to
floods, mitigate damages, and save lives.
-1
CHAPTER 1. INTRODUCTION
1.1 Introduction of Flood Detection System.

The Flood Detection System in IoT project represents an innovative and efficient
solution aimed at mitigating the risks and damages associated with flooding events.
Leveraging the power of Internet of Things (IoT) technology, this project combines
interconnected sensors, data analytics, and real-time communication to provide early
detection, accurate monitoring, and timely alerts related to flood conditions. By
harnessing the capabilities of IoT, the project aims to enhance the resilience of
communities, infrastructure, and ecosystems in flood-prone areas.
Floods pose significant threats to life, property, and the environment, making effective
flood detection and response systems crucial for disaster management. Traditional
approaches often rely on manual observations or isolated sensor systems, which can be
limited in scope and effectiveness. However, the integration of IoT into flood detection
systems has introduced a new paradigm that offers advanced capabilities and improved
outcomes.
The Flood Detection System in IoT project involves deploying a network of

interconnected sensors strategically throughout areas susceptible to flooding, such as
riverside regions, low-lying areas, and urban zones prone to flash floods. These sensors
are equipped with a range of environmental monitoring capabilities, including water
level sensors, rainfall sensors, weather sensors, and even video surveillance cameras.
The sensors continuously collect real-time data, enabling a comprehensive understanding
of flood conditions in the monitored areas.
The project's success lies in the intelligent processing and analysis of the data collected
by the IoT sensors. By employing sophisticated algorithms and machine learning
techniques, the system can interpret the incoming sensor data streams in real-time. This
analysis involves detecting patterns, identifying anomalies, and predicting flood events
based on historical data and meteorological forecasts. By correlating data from multiple
sensors, the system provides accurate flood predictions, warning signals, and detailed
flood extent mapping.
-2
Fig.1 : Model of flood Detection system
Seamless integration with existing emergency management infrastructure is another key

aspect of the Flood Detection System in IoT project. Flood alerts and warnings can be
automatically disseminated to emergency personnel, local authorities, and residents
through various communication channels, such as mobile applications, SMS
notifications, and sirens. This enables swift and informed decision-making, ensuring
proactive measures can be implemented promptly, such as evacuations, deployment of
emergency services, and activation of flood control mechanisms.
The project offers several notable benefits. Firstly, the early detection and prediction of
floods enable authorities and individuals to initiate preventive measures, thereby
minimizing potential damages and safeguarding lives. Secondly, the scalability and
flexibility of IoT technology allow for sensor deployment in remote or inaccessible
areas, expanding the monitoring coverage and improving flood management.
Additionally, the availability of accurate and real-time data enhances emergency
response coordination, enabling efficient allocation of resources and informed decision-
making during critical situations.
In conclusion, the Flood Detection System in IoT project represents a transformative

solution for effective flood detection and management. By leveraging IoT technology,
interconnected sensors, and advanced data analytics, the project aims to enhance flood
resilience, protect infrastructure, and improve disaster response. With the continuous
-3
advancements in IoT and data analytics, this project showcases the potential for creating
smarter and more efficient flood detection systems that contribute to the safety and
well- being of communities worldwide.
Data collected from the sensors is transmitted in real-time to the central control unit
using wireless communication protocols such as Wi-Fi or LoRaWAN. The control unit
employs advanced data analytics techniques to analyze the incoming data, detect flood
events, and generate alerts or warnings. Additionally, the system can generate graphical
representations of water levels over time, enabling authorities to visualize flood patterns
and make informed decisions.
The Flood Detection System in IoT project offers several benefits over traditional
flood monitoring methods. By leveraging IoT technology, the system provides real-time
data, enabling rapid response and evacuation measures. It enhances the accuracy and
reliability of flood detection, minimizing false alarms and maximizing the efficiency of
emergency services. Furthermore, the system can be integrated with existing disaster
management systems, enabling seamless coordination between different stakeholders.
How to program an Arduino ?
The Arduino tool window consists of the toolbar with the buttons like verify, upload,
new, open, save, serial monitor. It also consists of a text editor to write the code, a
message area which displays the feedback like showing the errors, the text console
which displays the output and a series of menus like the File, Edit, Tools menu. Thus the
code is uploaded by the boot loader onto the microcontroller.
1.2 Introduction Of Ultrasonic Sensor
-4
As the name indicates, ultrasonic sensors measure distance by using ultrasonic waves.
The sensor head emits an ultrasonic wave and receives the wave reflected
back from the target. Ultrasonic Sensors measure the distance to the target
by measuring the time between the emission and reception.
An optical sensor has a transmitter and receiver, whereas an ultrasonic sensor uses a
single ultrasonic element for both emission and reception. In a reflective model
ultrasonic sensor, a single oscillator emits and receives ultrasonic waves alternately. This
enables miniaturization of the sensor head.
Distance calculation
The distance can be calculated with the following formula:
Distance L= ½ TXC
Where L is the distance, T is the time between the emission and reception, and C is the
sonic speed. (The value is multiplied by ½ because T is the time for go-and-return
distance.) Features
The following list shows typical characteristics enabled by the detectionsystem.

[Transparent object detectable]
Since ultrasonic waves can reflect off a glass or liquid surface and return to the sensor
head, even transparent targets can be detected.
[Resistant to mist and dirt]
Detection is not affected by accumulation of
dustor dirt. [Complex shaped objects
detectable]
Presence detection is stable even for targets such as mesh trays or springs.
-5
CHAPTER 2. LITERRATURE REVIEW
2.1 Principle:
The principle behind a flood detection system in an IoT project is to monitor and detect
abnormal water levels in an area or a specific location. By leveraging sensors, data
collection, and communication technologies, the system can provide real-time
information about flood conditions, enabling timely alerts and appropriate response
measures. The primary principle revolves around the detection of water level changes
and transmitting that data for analysis and decision-making.
2.2 Methodology:
1. Sensor Placement: Identify suitable locations for installing water level sensors. These
sensors can be placed in areas prone to flooding, such as near rivers, lakes, or
drainage systems. Depending on the project's scope, sensors can also be installed in
critical infrastructure areas like basements, underground parking lots, or low-lying
regions susceptible to flooding.
2. Sensor Selection: Choose appropriate sensors capable of measuring water levels

accurately. Different sensor types can be used, such as ultrasonic sensors,
pressure sensors, or float switches. Consider factors such as accuracy, reliability,
power consumption, and environmental conditions while selecting the sensors.
3. Data Collection: Connect the water level sensors to IoT devices or microcontrollers
equipped with wireless communication capabilities. These devices collect data from the
sensors at regular intervals. Ensure that the sensors are properly calibrated to provide
accurate measurements.
4. Data Transmission: Establish a communication network to transmit the collected

sensor data to a central server or cloud platform. This can be achieved using
wireless technologies like Wi-Fi, Bluetooth, or cellular networks. MQTT or other
lightweight protocols can be employed to efficiently transfer data over the
network.
5. Data Analysis: Develop an analysis framework to process the incoming sensor data.
Apply algorithms to detect sudden changes or abnormal patterns in the water level
measurements. Threshold-based approaches or machine learning techniques can be
utilized for identifying flood conditions based on historical data or predefined thresholds.
6. Alert Generation: Implement a mechanism to generate alerts or notifications when

flood conditions are detected. Alerts can be sent through various communication
channels like SMS, email, push notifications, or even automated voice calls. The alerts
should reach the relevant stakeholders, including residents, emergency services, and
authorities responsible for managing flood-related events.
-6
7. Response and Mitigation: Provide guidance or recommendations for appropriate
actions based on the severity of the flood situation. This may include evacuation
plans, activation of flood prevention systems, or mobilization of emergency response
teams. Integrating the flood detection system with other IoT devices or infrastructure,
such as automatic floodgates or drainage pumps, can further enhance the mitigation
efforts.
8. Data Visualization and Reporting: Develop a user interface or dashboard to visualize

the real-time and historical flood data. This allows users to monitor the water levels,
view flood alerts, and analyze patterns over time. Additionally, generate reports and
analytics that aid in understanding flood patterns, assessing the effectiveness of
mitigation measures, and facilitating future planning.
9. Maintenance and Scalability: Regularly maintain and calibrate the sensors to ensure
accurate measurements. Additionally, consider the scalability of the system to
accommodate larger areas or multiple locations. Robustness, data security, and the
ability to handle a growing number of sensors should be addressed when designing the
flood detection system.
-7
CHAPTER 3. APPLICATION AND USAGE
1. Early Warning Systems: A flood detection system in an IoT project can be deployed
in areas prone to flash floods, river overflow, or coastal flooding. It provides early
warnings to residents, authorities, and emergency services, allowing them to take
necessary precautions and initiate evacuation procedures in a timely manner.
2. Urban Planning and Infrastructure Management: Flood detection systems can be

integrated into urban planning initiatives to assess flood risks and make informed
decisions regarding infrastructure development. By analyzing historical flood data, urban
planners can identify flood-prone areas and design appropriate drainage systems, flood
barriers, or stormwater management facilities.
3. Environmental Monitoring: Flood detection systems can contribute to environmental

monitoring efforts by collecting real-time data on water levels, rainfall intensity, and
flood patterns. This information aids in assessing the impact of climate change, studying
hydrological systems, and understanding the ecological effects of flooding on flora and
fauna.
4. Insurance and Risk Assessment: Insurance companies can leverage flood detection
systems to assess flood risks and determine insurance premiums. By analyzing historical
flood data, they can accurately evaluate the likelihood of flood-related damages and
provide appropriate coverage to homeowners, businesses, and agricultural sectors.
5. Smart Agriculture: In agricultural settings, flood detection systems can help farmers
monitor water levels in fields, irrigation systems, and reservoirs. By integrating weather
data and soil moisture measurements, the system can optimize irrigation practices,
prevent waterlogging, and reduce crop losses due to excessive flooding or inadequate
drainage.
6. Critical Infrastructure Protection: Flood detection systems play a vital role in

protecting critical infrastructure such as power plants, hospitals, transportation networks,
and communication facilities. By providing real-time flood alerts, these systems enable
operators to take immediate actions to safeguard infrastructure, mitigate damage, and
ensure uninterrupted services.
7. Disaster Management and Emergency Response: During natural disasters like floods,
flood detection systems aid emergency response teams in coordinating rescue operations,
deploying resources, and prioritizing affected areas. Real-time flood data helps them
identify the most vulnerable regions and allocate resources effectively for rescue and
relief efforts.
8. Water Resource Management: Flood detection systems assist in managing water

resources efficiently. By monitoring water levels in rivers, lakes, and reservoirs,
authorities can make informed decisions about water releases, dam operations, and flood
control measures. This ensures the optimum utilization of water resources while
minimizing flood risks downstream.
-8
9. Community Awareness and Education: Flood detection systems can be used as
educational tools to raise community awareness about flood risks, safety measures, and
emergency preparedness. By providing easily accessible flood information and
educational materials, these systems empower individuals to understand the potential
hazards and take necessary precautions.
Overall, the application and usage of flood detection systems in IoT projects have
significant implications for public safety, urban planning, environmental management,
infrastructure protection, and emergency response. By leveraging real-time data and
intelligent analytics, these systems contribute to mitigating the impact of floods, saving
lives, and reducing economic losses associated with flooding events.
Usage and Benefits:
1. Real-time Monitoring: Flood detection systems provide continuous monitoring of

water levels, enabling timely detection of rising water and potential flood events.
2. Early Warning Systems: By leveraging IoT connectivity, flood detection systems can
send alerts to relevant stakeholders, such as local authorities, emergency responders,
facility managers, or homeowners, allowing them to respond quickly and effectively.
3. Data-Driven Insights: Flood detection systems generate valuable data about water
levels, rainfall patterns, and flood events. This data can be analyzed to gain insights
into flood-prone areas, identify trends, and develop effective flood management
strategies.
4. Integration with Existing Systems: Flood detection systems can be integrated with
existing infrastructure, such as weather monitoring stations, water management systems,
or smart city platforms, enhancing the overall efficiency of flood response and
prevention.
5. Cost and Risk Reduction: By providing early warnings and enabling proactive
measures, flood detection systems help reduce the economic and human costs associated
with floods. They also minimize the risk of damage to critical infrastructure and loss
of property.
-9
CHAPTER 4. ARCHITECTURE OF PROJECT
Fig 4 Architecture of Project
- 10
CHAPTER 5. EXPERIMENTAL SETUP
5.1 Hardware Requirements.
The hardware requirements for a flood detection system in an IoT project can vary
depending on the specific needs and scope of the project. However, here are some
common hardware components that you may consider:
5.1.1 Jumper wires.
A jump wire (also known as jumper, jumper wire, DuPont wire) is an electrical wire, or
group of them in a cable, with a connector or pin at each end (or sometimes without
them - simply "tinned"), which is normally used to interconnect the components of a
breadboard or other prototype or test circuit, internally or with other equipment or
components, without soldering
5.1.2 Breadboard.
A breadboard, or protoboard, is a construction base for prototyping of electronics.

Originally the word referred to a literal bread board, a polished piece of wood used
when slicing bread. In the 1970s the solderless breadboard (a.k.a. plugboard, a
terminal array board) became available and nowadays the term "breadboard" is
commonly used to refer to these.
Because the solderless breadboard does not require soldering, it is reusable. This makes
it easy to use for creating temporary prototypes and experimenting with circuit design.
For this reason, solderless breadboards are also popular with students and in
technological education. Older breadboard types did not have this property.
- 11
A stripboard (Veroboard) and similar prototyping printed circuit boards, which are used
to build semi-permanent soldered prototypes or one-offs, cannot easily be reused. A
variety of electronic systems may be prototyped by using breadboards, from small
analog and digital circuits to complete central processing units (CPUs)
5.1.3 Ultrasonic Sensor
An ultrasonic sensor is an electronic device that measures the distance of a target

object by emitting ultrasonic sound waves, and converts the reflected sound into an
electrical signal. Ultrasonic waves travel faster than the speed of audible sound (i.e. the
sound that humans can hear). Ultrasonic sensors have two main components: the
transmitter (which emits the sound using piezoelectric crystals) and the receiver (which
encounters the sound after it has travelled to and from the target).
In order to calculate the distance between the sensor and the object, the sensor
measures the time it takes between the emission of the sound by the transmitter to its
contact with the receiver. The formula for this calculation is D= % Tx C (where D is
the distance, T is the time, and C is the speed of sound - 343 meters/second). For
example, if a scientist set up an ultrasonic sensor aimed at a box and it took 0.025
seconds for the sound to bounce back, the distance between the ultrasonic sensor and
the box would be:
or about 4.2875
meters. D=0.5 x 0.025
x 343
- 12
5.1.4 I2C Module
An I2C (Inter-Integrated Circuit) module, also known as an I2C interface or I2C

controller, is an electronic component that facilitates communication between devices
using the I2C protocol. I2C is a widely used serial communication protocol that allows
multiple devices to communicate with each other using a shared bus.
The I2C module acts as a master or a slave device on the I2C bus, depending on its
configuration. As a master, it initiates communication with other devices on the bus,
while as a slave, it responds to requests or commands from the master device.
The I2C module typically consists of two main components: a hardware module and
associated software libraries. The hardware module includes circuitry that handles the
electrical signaling and timing required for I2C communication. It typically provides
features like clock generation, data transmission, and reception, as well as addressing
and arbitration mechanisms.
The software libraries or APIs (Application Programming Interfaces) provide an

abstraction layer that allows programmers to interact with the I2C module through high-
level function calls. These libraries simplify the process of sending and receiving data
over the I2C bus, handling low-level details like start and stop conditions, addressing,
and data formatting.
I2C modules are commonly used in various applications where multiple devices need to
communicate with each other using a simple, two-wire interface. Some typical
applications include:
1. Sensor modules: I2C is often used to interface with sensors such as temperature
sensors, humidity sensors, accelerometers, gyroscopes, and magnetometers. The I2C
module can be used to read data from these sensors and control their settings.
- 13
2. Display modules: Many OLED and LCD displays can be controlled via I2C. The I2C
module allows sending commands and data to control the display and update its content.
3. Real-time clocks (RTCs): I2C modules are commonly used to interface with RTC
modules, which provide accurate timekeeping functionality. The I2C module enables
reading and setting the time and date information.
4. EEPROM and memory modules: I2C is used to communicate with non-volatile

memory devices like EEPROM (Electrically Erasable Programmable Read-Only
Memory) and other memory modules. The I2C module allows reading and writing data
to these memory devices.
5. Integrated circuits: Many integrated circuits, such as motor controllers, analog-to-

digital converters (ADCs), digital-to-analog converters (DACs), and I/O expanders, use
I2C as a communication interface. The I2C module facilitates communication with these
ICs and enables control and data exchange.
I2C modules provide a convenient and standardized way to communicate between

devices, making it easier to integrate various components into a system. They simplify
the implementation of I2C communication, allowing developers to focus on higher-level
functionalities and applications rather than dealing with the low-level intricacies of the
protocol.
- 14
5.1.5 LED BULB
An LED bulb is a type of light bulb that uses light-emitting diodes (LEDs) as the
primary light source. LEDs are semiconductor devices that emit light when an electric
current passes through them. LED bulbs have gained popularity in recent years due to
their energy efficiency, long lifespan, and versatility.
5.1.6 LCD DISPLAY
An LCD (Liquid Crystal Display) is a type of flat-panel display technology commonly

used in electronic devices, such as televisions, computer monitors, smartphones, and
digital watches. LCD displays provide a thin, lightweight, and energy-efficient
alternative to traditional cathode ray tube (CRT) displays.
- 15
5.1.7 NODE MCU
Node MCU is an open-source firmware and development board based on the

ESP8266 Wi-Fi module. It combines the capabilities of the ESP8266 microcontroller
with built-in Wi-Fi connectivity, making it a popular choice for Internet of Things
(IoT) projects and rapid prototyping.
5.1.8 BUZZER
A buzzer is an electronic component that produces audible sound signals when an

electric current passes through it. It is commonly used in various applications,
including alarms, notifications, timers, and interactive devices. Buzzer functionality is
based on the principle of electromagnetic or piezoelectric vibration.
- 16
5.1.9 LAPTOP
A laptop, also known as a notebook computer, is a portable personal computer

designed for mobile use. It combines the essential components of a desktop computer,
including a display, keyboard, touchpad or trackpad, and speakers, into a single
compact unit.
Laptops are self-contained and can operate on battery power, allowing users to work,
study, or engage in various activities while on the go.
5.2 SOFTWARE COMPONENTS
The hardware requirements for a flood detection system in an IoT project can
vary depending on the specific needs and scope of the project. However, here are
some common hardware components that you may consider:
5.2.1 Arduino IDE
The Arduino integrated development environment (IDE) is a cross-platform application

(for Microsoft Windows, macOS, and Linux) that is written in the Java programming
language. It originated from the IDE for the languages Processing and Hiring. It
includes a code editor with features such as text cutting and pasting, searching and
replacing text, automatic indenting, brace matching, and syntax highlighting, and
provides simple one- click mechanisms to compile and upload programs to an Arduino
board. It also contains a message area, a text console, a toolbar with buttons for
common functions and a hierarchy of operation menus. The source code for the IDE is
released under the GNU General Public License, version
The Arduino IDE supports the languages C and C++ using special rules of code
structuring. The Arduino IDE supplies a software library from the Wiring project, which
provides many common input and output procedures. User-written code only requires
two basic functions, for starting the sketch and the main program loop, that are compiled
and linked with a program stub maint) into an executable cyclic executive program
with the GNU toolchain, also included with the IDE distribution.
- 17
The Arduino IDE employs the program avrdude to convert the executable code into a
text file in hexadecimal encoding that is loaded into the Arduino board by a loader
program in the board's
firmware.
From version 1.8.12, Arduino IDE windows compiler supports only Windows 7 or
newer OS. On Windows Vista or older one gets "Unrecognized Win32 application" error
when trying to verify/upload program. To run IDE on older machines, users can either
use version 1.8.11, or copy "arduino-builder" executable from version 11 to their current
install folder as it's independent from IDE.
- 18
5.2.2 Required Libraries
Required Libraries: Libraries are collections of pre-written code that provide additional
functionality to Arduino projects. These libraries contain ready-to-use functions and
code snippets that can be easily incorporated into your own Arduino sketches. Libraries
extend the capabilities of Arduino by offering support for specific hardware components,
communication protocols, sensors, actuators, and more. They save time and effort by
providing pre-built code for common tasks, allowing you to focus on the specific
functionality of your project.
To install libraries in the Arduino IDE, follow these steps:
a. Open the Arduino IDE.

b. Go to "Sketch" -> "Include Library" -> "Manage Libraries".
c. The Library Manager will open, displaying a list of available libraries.
d. Search for the library you want to install by entering its name in the search box.
e. Select the library from the search results and click on the "Install" button.
f. The IDE will download and install the library.
Once installed, you can include the library in your Arduino sketch by going to "Sketch" -
> "Include Library" and selecting the library from the list. This makes the
library's functions and features accessible in your code.
There is a vast collection of Arduino libraries available, both official libraries developed
by the Arduino team and third-party libraries contributed by the Arduino community.
Some common libraries include the "Wire" library for I2C communication, the "Servo"
library for controlling servos, and the "Adafruit GFX" library for working with displays.
Using libraries allows you to leverage existing code and functionality, making it easier
to develop complex projects with Arduino. You can find libraries on the Arduino
Library Manager, as well as on various online repositories and the official Arduino
website.
- 19
5.3 WORKING
A flood detection system using IoT involves the integration of various sensors and
devices to monitor water levels, detect potential flooding, and notify relevant parties.
Here's a general outline of how such a system could work:
By combining IoT devices, sensors, and communication technologies, a flood detection

system can provide real-time monitoring and early warning capabilities, enabling timely
response and mitigating potential damage caused by floods.
5.3.1 Connecting of Ultrasonic Sensor
An Ultrasonic Sensor consists of three wires. One for Vcc, second for Ground and the
third for pulse signal. The ultrasonic sensor is mounted on the servo motor and both
of them further connected to the Arduino board. The ultrasonic sensor uses the
reflection principle for its working. When connected to the Arduino, the Arduino
provides the pulse signal to the ultrasonic sensor which then sends the ultrasonic
wave in forward direction. Hence whenever there is any obstacle detected or present
in front, it reflects the waves which are received by the ultrasonic sensor.
If detected, the signal is sent to the Arduino and hence to the PC/laptop to the processing
software that shows the presence of the obstacle on the rotating RADAR screen with
distance and the angle at which it has been detected.
- 20
5.3.2 Connecting Of I2C Module
To connect an I2C module with a NodeMCU board, you'll need to follow these steps:
1. Gather the necessary hardware:

- NodeMCU board (e.g., ESP8266-based development board)
- I2C module (e.g., a sensor or display with I2C interface)
- Jumper wires
- Breadboard (optional)
2. Identify the I2C pins on your NodeMCU board. The NodeMCU board has dedicated
pins for I2C communication:
- SDA (Serial Data): Connect this pin to the SDA pin of the I2C module.
- SCL (Serial Clock): Connect this pin to the SCL pin of the I2C module.
- VCC (Power): Connect the VCC pin of the I2C module to the 3.3V or 5V pin of
the NodeMCU board.
- GND (Ground): Connect the GND pin of the I2C module to the GND pin of
the NodeMCU board.
3. Make the physical connections:

- Use jumper wires to connect the SDA pin of the I2C module to the SDA pin of
the NodeMCU board.
- Connect the SCL pin of the I2C module to the SCL pin of the NodeMCU board.
- Connect the VCC and GND pins accordingly.
4. Write the code:

- Open the Arduino IDE or your preferred development environment.
- Include the Wire library by adding `#include <Wire.h>` at the beginning of your
sketch.
- Initialize the I2C communication by calling `Wire.begin()` in the `setup()` function.
- Use the appropriate library or commands to interact with your specific I2C module.
This will vary depending on the module you are using. Consult the module's
documentation or library for specific instructions.
- 21
5.3.3 Connecting Of LCD Display
Attach the Pins of the I2C module with the 16×2 LCD. Connect the VIN or 3.3-volts
pin of the NodeMCU with the VCC pin of the I2C module and the GND pin of the
NodeMCU with the GND pin of the I2C module. Join the SDA pin of the I2C module
with the digital-2 pin of the NodeMCU for node MCU.
5.3.4 Connecting Of LED Bulb
Take an LED and place it on the breadboard. Join the positive leg of the LED with the
digital-5 pin of the nodemcu. Connect the GND pin of the nodemcu with the negative
leg of the LED via a 220-ohm resistor. Use a USB cable to power the nodemcu.
LEDs are diodes which are elecronic devices that only allow current to go through them
in one direction. This means that LEDs (and other diodes) have positive (+) and negative
(-) sides to them. For an LED to work it needs to be connected to a voltage source with
the correct side. The voltage supply side of the diode is the positive (+) side, this is
called the anode. The negative side is called the cathode.
- 22
- 23
CHAPTER 6. NODE MCU TOOLS
To set up the NodeMCU, an open-source firmware and development board based on the
ESP8266 microcontroller, follow these steps:
1. Connect the NodeMCU to your computer: Use a USB cable to connect the NodeMCU
board to your computer. Make sure the board is properly powered.
2. Install the Arduino IDE: Download and install the Arduino IDE (Integrated
Development Environment) from the official Arduino website
(https://www.arduino.cc/en/software). Choose the version compatible with your
operating system.
3. Install the ESP8266 Board Package: Open the Arduino IDE and go to "File" -
> "Preferences". In the "Additional Boards Manager URLs" field, enter the
following URL:
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Click "OK" to close the preferences window.
4. Install the ESP8266 Boards: Go to "Tools" -> "Board" -> "Boards Manager". In the
Boards Manager, type "esp8266" in the search box. Select the "esp8266 by ESP8266
Community" option and click "Install". This will download and install the necessary
board files.
5. Select the NodeMCU board: After the installation is complete, go to "Tools" -

> "Board" and select the appropriate NodeMCU board variant. For example, choose
"NodeMCU 1.0 (ESP-12E Module)" or the specific variant you have.
6. Select the correct port: Go to "Tools" -> "Port" and select the port to which the
NodeMCU is connected. The port might be named "COMX" (Windows) or
"/dev/ttyUSBX" (Linux) or "/dev/cu.SLAB_USBtoUART" (Mac). If you are unsure, you
can check the available ports before and after connecting the NodeMCU to identify the
correct one.
7. Verify the setup: To ensure that the NodeMCU is set up correctly, open the Arduino
IDE and go to "File" -> "Examples" -> "ESP8266" -> "Blink". This will open a sample
sketch. Click on the "Verify" button (checkmark icon) to compile the sketch. Make sure
there are no compilation errors.
8. Upload the sketch: Once the sketch is successfully compiled, click on the "Upload"
button (right-arrow icon) to upload the sketch to the NodeMCU board. You should see
the upload progress in the bottom console window. After uploading, the onboard LED on
the NodeMCU should start blinking.
- 24
At this point, your NodeMCU is set up and ready for further development. You can
now start building your flood detection system by writing your own code or using libraries
specific to your project requirements. Make sure to refer to the NodeMCU
documentation and the respective sensor documentation for further guidance on utilizing
the specific functionalities and features.
6.1 INSTALLING NECESSARY LIBRARIES
To install the necessary libraries for a flood detection system in an IoT project, you need to
identify the specific libraries required based on your hardware, programming language, and
sensor devices. However, I can provide you with a general set of libraries commonly used in
IoT projects that might be relevant for a flood detection system. Here are the steps:
1. Identify the programming language: Determine the programming language you are using
for your IoT project. Common languages for IoT development include Python, C/C++,
JavaScript, and Java.
2. Identify the hardware platform: Determine the specific hardware platform you are using for
your IoT project, such as Arduino, Raspberry Pi, or a specific microcontroller. This will help
in finding libraries compatible with your hardware.
3. Identify the sensor devices: Determine the sensor devices you are using to detect floods.
Common sensors for flood detection include water level sensors, moisture sensors, or
pressure sensors.
4. Research relevant libraries: Once you have identified the programming language,
hardware platform, and sensor devices, research libraries that are compatible with your
choices. Some popular libraries for IoT projects include:
- For Arduino: Arduino IDE comes with built-in libraries for various sensors. Additionally,
you can search for specific libraries based on your sensor's model or requirements.
- For Raspberry Pi: Libraries like RPi.GPIO, Adafruit CircuitPython, or WiringPi can be
used to interact with GPIO pins and sensors.
- For Python: Libraries like pySerial, requests, or MQTT can be used for
communication, depending on your project requirements.
- For JavaScript: Libraries like Johnny-Five, MQTT.js, or Cylon.js can be used for
IoT development with JavaScript.
5. Install the libraries: Once you have identified the relevant libraries, you can install them
based on the programming language and the specific installation methods for each library. This
can vary depending on the language and the package manager used.
- For Python, you can use pip, the Python package manager, to install libraries. For
example, you can use the command `pip install library_name` to install a library.
- For Arduino, you can use the Arduino Library Manager within the Arduino IDE to search
and install libraries.
- For other languages, refer to the respective package managers or installation methods
specific to those languages.
- 25
It's important to note that the specific libraries and installation process may vary depending on
your project requirements and the hardware and software components you are using.
6.2 COADINF THE MICROCONTROLLER FOR FLOOD DETECTION
[11:48 AM, 5/29/2023] Sateesh Gcrg: To code the microcontroller for flood detection
using the NodeMCU or ESP8266, you will need to write the firmware using the Arduino
IDE or any other suitable development environment. Here's a general outline of the steps
you can follow:
1. Open the Arduino IDE: Launch the Arduino IDE on your computer.
2. Set up the sketch: Create a new sketch by going to "File" -> "New".
3. Include the necessary libraries: Depending on the specific sensors and modules you
are using for flood detection, include the relevant libraries at the beginning of your
sketch. Refer to the documentation of your sensors for instructions on library inclusion
and usage.
- 26
4. Define pins and variables: Declare the pins to which your flood detection sensors
are connected. Assign appropriate variable types for storing sensor readings or any
other necessary variables.
5. Set up the setup() function: In the `setup()` function, initialize the serial
communication for debugging or monitoring purposes. Set the pinMode for your sensor
pins as either INPUT or OUTPUT.
6. Implement the loop() function: In the `loop()` function, continuously monitor the
sensor readings and take appropriate actions based on the flood detection logic.
For example, you might compare the sensor readings with predefined threshold
values to determine if a flood condition exists.
7. Trigger actions based on flood detection: If a flood condition is detected, you can
perform actions like activating an alarm, sending notifications, or controlling other
devices connected to the microcontroller.
8. Upload the code: Connect the NodeMCU to your computer using a USB cable. Select
the correct board and port in the Arduino IDE as explained in the previous response.
Then, click on the "Upload" button to compile and upload the code to the NodeMCU.
9. Monitor the serial output: Open the Serial Monitor in the Arduino IDE to view debug
messages or any other output you have programmed in your code. This can help in
troubleshooting and understanding the behavior of the flood detection system.
10. Test the flood detection system: Deploy the NodeMCU with the flood detection
sensors in the desired environment and test its functionality by simulating flood
conditions or using real-world scenarios.
Remember to consult the documentation and examples provided by the sensor

manufacturers and library authors to understand how to interface with the specific
sensors and utilize their functionalities effectively.
Please note that the above steps provide a general outline, and the actual implementation
may vary depending on the specific sensors, modules, and requirements of your flood
detection system.
[11:49 AM, 5/29/2023] Sateesh Gcrg: To initialize the Wi-Fi connection on the
NodeMCU or ESP8266 for your flood detection system, you can use the built-in Wi-Fi
library and follow these steps:
1. Include the Wi-Fi library: At the beginning of your sketch, include the Wi-Fi library
by adding the following line:
cpp
#include <ESP8266WiFi.h>
- 27
2. Define network credentials: Declare variables to store your Wi-Fi network credentials
such as SSID (network name) and password. For example:
cpp
const char* ssid = "YourWiFiSSID";
const char* password = "YourWiFiPassword";
communication as well as the Wi-Fi connection. Use the `WiFi.begin()` function to
connect to the specified network. For example:
cpp
void setup() {
Serial.begin(9600);
// Connect to Wi-Fi network

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {

delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");
}
4. Add necessary functionality: After establishing a Wi-Fi connection, you can add
additional functionality to your flood detection system. This may include reading sensor
data, processing flood detection algorithms, and triggering appropriate actions.
5. Set up the loop() function: In the `loop()` function, you can perform periodic tasks or
continuously monitor the flood detection system. Make sure to include a delay to avoid
excessive looping and to prevent unnecessary network traffic. For example:
cpp
void loop() {
// Perform flood detection tasks
// ...
delay(1000); // Delay for 1 second

}
6. Upload the code: Connect the NodeMCU to your computer via USB, select the correct
board and port in the Arduino IDE, and click on the "Upload" button to compile and
upload the code to the NodeMCU.
Once uploaded, the NodeMCU will attempt to connect to the specified Wi-Fi network
using the provided credentials. You can monitor the serial output to check the status
of the Wi-Fi connection and any relevant debug information.
- 28
Note: Make sure you have the correct SSID and password for your Wi-Fi network.
Additionally, consider implementing error handling and reconnection mechanisms in
case the Wi-Fi connection is lost or encounters issues.
This is a basic example to initialize the Wi-Fi connection on the NodeMCU or

ESP8266. Depending on your specific requirements, you may need to include
additional functionality, such as handling Wi-Fi disconnections, reconnecting to the
network, or implementing secure communication protocols.
6.3 INITIALIZING THE WI-FI CONNECTION
To initialize the Wi-Fi connection on the NodeMCU or ESP8266 for your flood
detection system, you can use the built-in Wi-Fi library and follow these steps:
1. Include the Wi-Fi library: At the beginning of your sketch, include the Wi-Fi library
by adding the following line:
cpp
2. Define network credentials: Declare variables to store your Wi-Fi network credentials
such as SSID (network name) and password. For example:
cpp
const char* ssid = "YourWiFiSSID";
const char* password = "YourWiFiPassword";
communication as well as the Wi-Fi connection. Use the `WiFi.begin()` function to
connect to the specified network. For example:
cpp
void setup() {
Serial.begin(9600);


delay(1000);
}
}
4. Add necessary functionality: After establishing a Wi-Fi connection, you can add
additional functionality to your flood detection system. This may include reading sensor
data, processing flood detection algorithms, and triggering appropriate actions.
- 29
5. Set up the loop() function: In the `loop()` function, you can perform periodic tasks or
continuously monitor the flood detection system. Make sure to include a delay to avoid
excessive looping and to prevent unnecessary network traffic. For example:
cpp
void loop() {
// Perform flood detection tasks
// ...

}
6. Upload the code: Connect the NodeMCU to your computer via USB, select the correct
board and port in the Arduino IDE, and click on the "Upload" button to compile and
upload the code to the NodeMCU.
Once uploaded, the NodeMCU will attempt to connect to the specified Wi-Fi network
using the provided credentials. You can monitor the serial output to check the status
of the Wi-Fi connection and any relevant debug information.
Note: Make sure you have the correct SSID and password for your Wi-Fi network.
Additionally, consider implementing error handling and reconnection mechanisms in
case the Wi-Fi connection is lost or encounters issues.
This is a basic example to initialize the Wi-Fi connection on the NodeMCU or

ESP8266. Depending on your specific requirements, you may need to include
additional functionality, such as handling Wi-Fi disconnections, reconnecting to the
network, or implementing secure communication protocols.
6.4 CONFIGURING SENSOR PINS AND ALARM
To configure sensor pins and alarms in your flood detection system using the NodeMCU
or ESP8266, follow these steps:
1. Identify the sensor pins: Determine the pins on the NodeMCU or ESP8266 board to
which your flood detection sensors are connected. For example, if you have a water level
sensor connected to pin D1, a moisture sensor connected to pin D2, and an alarm output
connected to pin D3, note down these pin assignments.
2. Set pin modes: In the `setup()` function, configure the sensor pins as either INPUT
or OUTPUT using the `pinMode()` function. For example:
cpp
void setup() {
pinMode(D1, INPUT); // Water level sensor
pin pinMode(D2, INPUT); // Moisture sensor
pin pinMode(D3, OUTPUT); // Alarm output
pin
// Additional setup code

}
- 30
3. Read sensor values: In the `loop()` function or wherever appropriate, read the sensor
values using the `digitalRead()` or ànalogRead()` functions depending on your sensor type.
Store the readings in variables for further processing. For example:
cpp
void loop() {
int waterLevel = digitalRead(D1); // Read water level
sensor int moisture = analogRead(A0); // Read moisture
sensor
// Additional code for flood detection and processing

}
4. Implement flood detection logic: Utilize the sensor readings to implement your flood
detection logic. Compare the readings with threshold values or apply appropriate algorithms
based on your specific requirements. Determine the conditions that indicate a flood and take
corresponding actions. For example, if the water level is above a certain threshold and the
moisture level is high, trigger the alarm output. Modify the code according to your desired
logic.
5. Activate the alarm output: To activate the alarm or perform any desired action, control
the state of the alarm output pin using the `digitalWrite()` function. For example, to
activate the alarm, set the alarm output pin to HIGH; to deactivate it, set it to LOW. For
instance:
cpp
void loop() {
// Read sensor values
int waterLevel = digitalRead(D1);
int moisture = analogRead(A0);
// Flood detection logic

if (waterLevel == HIGH && moisture > 500) {
digitalWrite(D3, HIGH); // Activate alarm
output
} else {
digitalWrite(D3, LOW); // Deactivate alarm output
}

}
6. Upload the code: Connect the NodeMCU to your computer, select the correct board and
port in the Arduino IDE, and click on the "Upload" button to compile and upload the code to
the NodeMCU.
Ensure that you adjust the pin assignments, sensor types, threshold values, and flood detection
logic according to your specific sensors and requirements. Additionally, consider
implementing debouncing techniques or applying sensor calibration if necessary.
By following these steps, you can configure the sensor pins and alarms in your flood detection
system using the NodeMCU or ESP8266.
[11:53 AM, 5/29/2023] Sateesh Gcrg: To read sensor data in your flood detection system using
the NodeMCU or ESP8266, follow these steps:
- 31
1. Identify the sensors: Determine the type and model of the sensors you are using in your
flood detection system. Common sensors for flood detection include water level sensors,
moisture sensors, or pressure sensors.
- 32
2. Include the necessary libraries: Depending on the specific sensors you are using, include
the relevant libraries at the beginning of your sketch. These libraries provide functions to
communicate with and read data from the sensors. Refer to the documentation of your
sensors for instructions on library inclusion and usage.
3. Set up the setup() function: In the `setup()` function, initialize the serial communication
for debugging or monitoring purposes. Additionally, set up any necessary configurations or
initializations for the sensors.
4. Read sensor data: In the `loop()` function or at appropriate intervals, read the sensor data
using the functions provided by the sensor libraries. The specific functions and methods will
depend on the sensor type and library you are using. Typically, you will use functions like
ànalogRead()` or `digitalRead()` for simple sensors, or specific methods provided by the
sensor libraries for more complex sensors.
For example, if you are using an analog moisture sensor connected to pin A0, you can read
the sensor value using ànalogRead(A0)`:
cpp
void loop() {
// Read moisture sensor data
int moistureValue = analogRead(A0);
// Perform further processing or actions based on the sensor data

}
5. Process and utilize sensor data: Once you have read the sensor data, you can process it
according to your flood detection logic or any other requirements of your project. This
may involve comparing the sensor readings with threshold values, performing
calculations, or triggering appropriate actions based on the data.
For example, if the moisture sensor reading exceeds a certain threshold, you might consider
it as an indication of a flood condition and trigger an alarm or send a notification:
cpp
void loop() {
// Check if moisture level exceeds

threshold if (moistureValue > 500) {
// Trigger flood condition
// Perform actions like activating an alarm, sending a notification, etc.
}

}
6. Upload the code: Connect the NodeMCU to your computer, select the correct board and
port in the Arduino IDE, and click on the "Upload" button to compile and upload the code to
the NodeMCU.
Ensure that you adjust the pin assignments, sensor types, threshold values, and flood detection
logic according to your specific sensors and requirements.
- 33
6.5 READING SENSOR DATA
To read sensor data in your flood detection system using the NodeMCU or ESP8266,
follow these steps:
1. Identify the sensors: Determine the type and model of the sensors you are using in
your flood detection system. Common sensors for flood detection include water level
sensors, moisture sensors, or pressure sensors.
2. Include the necessary libraries: Depending on the specific sensors you are using,
include the relevant libraries at the beginning of your sketch. These libraries provide
functions to communicate with and read data from the sensors. Refer to the
documentation of your sensors for instructions on library inclusion and usage.
communication for debugging or monitoring purposes. Additionally, set up any
necessary configurations or initializations for the sensors.
4. Read sensor data: In the `loop()` function or at appropriate intervals, read the sensor
data using the functions provided by the sensor libraries. The specific functions and
methods will depend on the sensor type and library you are using. Typically, you will
use functions like ànalogRead()` or `digitalRead()` for simple sensors, or specific
methods provided by the sensor libraries for more complex sensors.
For example, if you are using an analog moisture sensor connected to pin A0, you can
read the sensor value using ànalogRead(A0)`:
cpp
void loop() {
// Perform further processing or actions based on the sensor data

}
5. Process and utilize sensor data: Once you have read the sensor data, you can process it
according to your flood detection logic or any other requirements of your project. This
may involve comparing the sensor readings with threshold values, performing
calculations, or triggering appropriate actions based on the data.
For example, if the moisture sensor reading exceeds a certain threshold, you might
consider it as an indication of a flood condition and trigger an alarm or send a
notification:
- 34
cpp
void loop() {
// Check if moisture level exceeds threshold

if (moistureValue > 500) {
// Trigger flood condition
// Perform actions like activating an alarm, sending a notification, etc.
}

}
6. Upload the code: Connect the NodeMCU to your computer, select the correct board
and port in the Arduino IDE, and click on the "Upload" button to compile and upload
the code to the NodeMCU.
Ensure that you adjust the pin assignments, sensor types, threshold values, and flood
detection logic according to your specific sensors and requirements.
By following these steps, you can read sensor data in your flood detection system
using the NodeMCU or ESP8266.
6.6 CHECKING WATER LEVEL THRESHOLD
To check water level thresholds in your flood detection system using the NodeMCU or
ESP8266, you can follow these steps:
1. Determine the water level sensor: Identify the specific water level sensor you are
using in your flood detection system. Different water level sensors may have varying
methods of providing readings, such as analog voltage output or digital signal output.
2. Read the water level sensor data: Use the appropriate method or function provided by
the sensor library to read the water level sensor data. This could involve utilizing analog-
to-digital conversion (ADC) for analog sensors or digitalRead() for digital sensors. Refer
to the documentation or examples provided with your water level sensor for guidance.
For example, if you are using an analog water level sensor connected to pin A0, you
can read the sensor value using analogRead(A0):
cpp
void loop() {
// Read water level sensor data
int waterLevel = analogRead(A0);
// Perform further processing or actions based on the sensor
data delay(1000); // Delay for 1 second
- 35
}
3. Define water level thresholds: Determine the specific water level thresholds that
indicate a flood condition in your system. This will depend on your application and
the characteristics of the environment you are monitoring. For example, you might
define a threshold where a water level reading above a certain value indicates a flood
condition.
4. Compare sensor data with thresholds: Compare the water level sensor readings with
the defined thresholds to determine if a flood condition exists. Use conditional
statements to check if the sensor data exceeds the threshold values.
For example, if the water level exceeds a specific threshold, you can trigger
flood- related actions:
cpp
void loop() {
// Read water level sensor data
int waterLevel = analogRead(A0);
// Check if water level exceeds threshold

if (waterLevel > 800) {
// Perform flood-related actions
// For example, activate an alarm, send notifications, etc.
}

}
5. Upload the code: Connect the NodeMCU to your computer, select the correct board
and port in the Arduino IDE, and click on the "Upload" button to compile and upload
the code to the NodeMCU.
Ensure that you adjust the pin assignments, sensor types, threshold values, and flood
detection logic according to your specific sensors and requirements.
By following these steps, you can check water level thresholds in your flood detection
system using the NodeMCU or ESP8266.
6.7 SENDING NOTIFICATIONS AND ALARMS
To send notifications and alarms in your IoT flood detection system, you can integrate a
communication module, such as GSM/GPRS, Wi-Fi, or a cloud-based service, to enable
the transmission of notifications and alerts. Here's a general outline of the process:
1. Choose a communication method: Select the appropriate communication method

based on your project requirements. For example, you can use a GSM module if you
want to send SMS alerts, or utilize Wi-Fi connectivity to send notifications via email or
push notifications to a mobile app. Alternatively, you can leverage cloud-based services
like MQTT or webhooks to communicate with external platforms or services.
- 36
2. Set up the communication module: Install and configure the communication module
or service according to the specifications provided by the manufacturer or service
provider. This may involve connecting the module to the appropriate pins on your
microcontroller or setting up the necessary credentials for cloud-based services.
3. Implement notification logic: Write code to trigger notifications and alarms when a
flood condition is detected. This logic can be incorporated into your existing code that
checks water level thresholds or is executed when other relevant sensor data indicates a
flood condition.
4. Send notifications: Depending on your chosen communication method, use the

appropriate library, API, or service to send the notifications. For example, if you are
using a GSM module, you may utilize a library like `GSM.h` to send an SMS. If you
are using Wi-Fi, you might use an email library or utilize an API for push
notifications.
Here's an example using the GSM module and the `GSM.h` library to send an SMS
notification:
cpp
#include <GSM.h>
GSM gsmAccess;
GSM_SMS sms;
void sendSMSNotification(const char* phoneNumber, const char* message) {

sms.beginSMS(phoneNumber);
sms.print(message);
sms.endSMS();
}
void loop() {
// Code for flood detection and checking thresholds
if (floodDetected) {
sendSMSNotification("+123456789", "Flood detected! Take immediate action!");
}
delay(1000);
}
5. Test and refine: Deploy your flood detection system and test the notification
functionality. Make sure to test various scenarios, including both flood and non-
flood conditions, to ensure the notifications are sent correctly. Monitor the system's
behavior and refine the code as needed.
6. Enhance with additional features: Depending on your project requirements, you can
further enhance the notification system by integrating additional functionalities. For
- 37
example, you can implement multiple notification methods, such as sending emails,
- 38
triggering alarms or buzzers, or even integrating with cloud platforms like IFTTT to
enable customized notifications or actions.
Remember to handle any potential errors or exceptions that may occur during the
notification process. Implement error handling mechanisms to retry sending notifications
in case of failures or implement feedback mechanisms to ensure successful delivery.
It's important to consider the cost, reliability, and availability of the chosen
communication method. For example, GSM-based solutions require a cellular network
and an active SIM card, while Wi-Fi-based solutions rely on a stable internet connection.
Evaluate these factors and choose the method that best suits your project's needs.
Additionally, be mindful of any regulations or legal requirements related to sending

notifications, especially when using SMS services. Comply with applicable laws and
regulations regarding message content, recipient consent, and data privacy.
Adapt the code and implementation to your specific microcontroller, communication

module, and chosen notification methods to create an effective flood detection system
with notification capabilities in your IoT project.
6.8 UPLOADING THE CODE TO MICROCONTROLLER
To upload the code to the microcontroller in your IoT flood detection system, you can
follow these steps:
1. Connect the microcontroller: Ensure that your microcontroller (e.g., NodeMCU or

ESP8266) is properly connected to your computer using a USB cable.
2. Open the Arduino IDE: Launch the Arduino IDE (Integrated Development
Environment) on your computer. If you don't have it installed, you can download it from
the official Arduino website (https://www.arduino.cc/en/software).
3. Select the board: From the "Tools" menu, select the appropriate board that matches
your microcontroller. For example, if you are using a NodeMCU, select "NodeMCU 1.0
(ESP-12E Module)" or a similar option.
4. Select the port: In the same "Tools" menu, select the port to which your
microcontroller is connected. The port should be detected automatically, but if not,
choose the correct port from the list.
5. Copy and paste the code: Copy the code you have written for your flood
detection system in the Arduino IDE. Create a new sketch or open an existing one
and paste the code into the editor.
6. Verify the code: Click on the "Verify" button (checkmark icon) in the Arduino IDE
to compile the code. This step ensures that there are no syntax errors or compilation
issues.
7. Upload the code: Once the code is successfully compiled, click on the "Upload"
button (right arrow icon) to upload the code to your microcontroller. The Arduino IDE
will compile the code again and transfer it to the microcontroller. You can monitor the
- 39
upload progress in the status bar at the bottom of the IDE.
- 40
8. Monitor the serial output (optional): If you have included serial communication in
your code for debugging or monitoring purposes, you can open the serial monitor in the
Arduino IDE by clicking on the "Serial Monitor" button (magnifying glass icon) or
pressing Ctrl+Shift+M. The serial monitor allows you to view any output or debug
information sent by your microcontroller.
9. Test your flood detection system: After the code is successfully uploaded to the
microcontroller, disconnect it from your computer and power it using the appropriate
power source for your project. Test the flood detection system and verify that it functions
as intended.
Ensure that you have selected the correct board, port, and programming language (e.g.,
C/C++) in the Arduino IDE to match your microcontroller and code. If there are any
compilation or upload errors, double-check your connections and code for any potential
issues.
By following these steps, you can upload the code to the microcontroller in your
IoT flood detection system using the Arduino IDE.
- 41
CHAPTER 7. DIAGRAM
7.1 Flowchart
- 42
Here's a simple flowchart of a flood detection system using IoT:
1. Start
2. Initialize the system and set up the IoT devices and sensors.
3. Read sensor data from the water level sensor.
4. Check if the water level exceeds a predefined threshold.
5. If the water level is below the threshold, continue monitoring.
6. If the water level exceeds the threshold, trigger an alert.
7. Activate the alarm system to notify people about the flood.
8. Send a notification to the designated authorities or emergency services.
9. Check if the system has detected previous alerts within a specified time frame.
10. If previous alerts have been detected, update the system's status to "Flood Ongoing."
11. If no previous alerts are detected, update the system's status to "New Flood Alert."
12. Record the flood event in a log or database for future reference.
13. Wait for the water level to decrease.
14. Read sensor data periodically to monitor the water level.
15. If the water level drops below the threshold, update the system's status to
"No Flood."
16. Deactivate the alarm system and notify the authorities that the flood has subsided.
17. End
- 43
7.2 HARDWARE CONNECTION CHART
Here is a sample hardware connection chart for a flood detection system in an

IoT project using a NodeMCU or ESP8266 microcontroller:
Hardware connection Chart

Sensor Microcontroller
Water Level Sensor Analog Pin A0
Alarm/Buzzer Digital Pin D4
| Wi-Fi Module (ESP8266) UART Pins
Please note that this is a simplified example and may vary based on the specific
components and requirements of your flood detection system. You should refer to the
documentation and pinout diagrams of your microcontroller, sensor, and other modules
for the precise connections.
In the above example:

- The water level sensor is connected to analog pin A0 on the microcontroller. Make
sure to choose the appropriate pin based on the specific water level sensor you are
using.
- The alarm or buzzer is connected to digital pin D4 on the microcontroller. You can
select a different pin if needed, but ensure that it supports digital output.
- The Wi-Fi module (e.g., ESP8266) is connected to the UART pins of the
microcontroller for communication. In this example, RX (Receive) pin is connected to
D7 and TX (Transmit) pin is connected to D8. Confirm the correct pin numbers based
on your microcontroller's pin configuration.
Always double-check the pin compatibility, voltage levels, and any other requirements
specified in the documentation of your microcontroller and sensors before making the
connections. It's also essential to handle power supply connections appropriately and
ensure that the components are powered according to their specifications.
Make sure to refer to the pinout diagrams and documentation of your specific
microcontroller, sensors, and modules to determine the accurate hardware connections
for your flood detection system in your IoT project.
- 44
CHAPTER 8. SOFTWARE INSTALLATION AND CODE
To set up the software environment and write code for a flood detection system in an IoT
project, you will need to follow these steps:
1. Install Arduino IDE: Download and install the Arduino IDE from the official Arduino
website (https://www.arduino.cc/en/software) based on your operating system.
2. Install necessary libraries: Depending on the specific components and sensors you are
using in your flood detection system, you may need to install additional libraries. To
install a library in Arduino IDE, go to "Sketch" -> "Include Library" -> "Manage
Libraries." Search for the desired library and click the "Install" button.
3. Connect the microcontroller: Connect your NodeMCU or ESP8266 microcontroller to

your computer using a USB cable.
4. Select board and port: Open the Arduino IDE and go to "Tools" -> "Board" and
select the appropriate board for your microcontroller (e.g., NodeMCU or ESP8266).
Then, go to "Tools" -> "Port" and select the port to which your microcontroller is
connected.
5. Write the code: Start a new sketch in the Arduino IDE and write the code for
your flood detection system. The code will include initializing the Wi-Fi
connection, configuring sensor pins, reading sensor data, checking water level
thresholds, and triggering notifications or alarms.
Here's a simple example code structure to get you started:
cpp
// Include necessary libraries
#include <WiFiClient.h>
// Include other required libraries based on your components (e.g., water level
sensor, notification methods)
// Define Wi-Fi credentials

const char* ssid = "YourWiFiNetworkName";
const char* password = "YourWiFiNetworkPassword";
// Define other necessary variables and constants
void setup() {
// Initialize serial communication
Serial.begin(115200);
// Connect to Wi-
Fi connectWiFi();
// Set up sensor pins, notifications, alarms, etc.

setupSensors();
}
void loop() {
- 45
// Read sensor data
- 46
readSensorData();
// Check water level thresholds

checkWaterLevelThresholds();
// Trigger notifications or alarms if flood condition detected
// Other necessary operations and delays

}
void connectWiFi() {
delay(1000);
}
}
// Implement other necessary functions for sensor setup, data reading, threshold
checking, and notifications
Note: The code provided is a basic structure, and you need to fill in the specific
details based on your components, sensor libraries, and notification methods.
6. Verify and upload the code: Click on the "Verify" button (checkmark icon) to compile
the code and check for any errors. Once the code is successfully verified, click on the
"Upload" button (right arrow icon) to upload the code to your microcontroller. The
Arduino IDE will compile the code again and transfer it to the microcontroller.
7. Monitor the output (optional): If you have included serial communication in your code
for debugging purposes, you can open the serial monitor in the Arduino IDE by
clicking on the "Serial Monitor" button (magnifying glass icon) or pressing
Ctrl+Shift+M. The serial monitor allows you to view any output or debug information
sent by your microcontroller.
By following these steps, you can install the necessary software environment, write code,
and upload it to your microcontroller for a flood detection system in your IoT project.
Make sure to adapt the code based on your specific
- 47
10.1 CODE OF FLOOD DETECTION SYSTEM USING IOT.
//Include the library files

#include <LiquidCrystal_I2C.h>
#define BLYNK_PRINT Serial
#include <BlynkSimpleEsp8266.h>
//Initialize the LCD display

LiquidCrystal_I2C lcd(0x27, 16,
2);
char auth[] = "vTLG8NNP4q2XCNk7fL2xjpVKO6vFAyOI";//Enter your Auth token

char ssid[] = "vivo T1 5G";//Enter your WIFI name
char pass[] = "rahul@123";//Enter your WIFI password
BlynkTimer timer;
// Define the component

pins #define trig D7
#define echo D8
#define LED1
D0 #define
LED2 D3
#define LED3
D4 #define
LED4 D5
#define LED5
D6 #define relay
3
// #define buzzer D2
//Enter your tank max

value(CM) int MaxLevel = 15;
int Level1 = (MaxLevel * 75) /

100; int Level2 = (MaxLevel * 65)
/ 100; int Level3 = (MaxLevel *
50) / 100; int Level4 = (MaxLevel
* 40) / 100; int Level5 =
(MaxLevel * 30) / 100;
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
pinMode(trig, OUTPUT);
pinMode(echo, INPUT);
pinMode(LED1, OUTPUT);
- 48
pinMode(relay, OUTPUT);
digitalWrite(relay, HIGH);
- 49
// pinMode(buzzer,OUTPUT)
Blynk.begin(auth, ssid, pass, "blynk.cloud", 80);
lcd.setCursor(4, 1);
lcd.print("Water level");
lcd.print("Monitoring");
delay(4000);
lcd.clear();
//Call the functions

timer.setInterval(100L, ultrasonic);
}
//Get the ultrasonic sensor

values void ultrasonic() {
digitalWrite(trig, LOW);
delayMicroseconds(4);
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
long t = pulseIn(echo,
HIGH); int distance = t / 29 /
2;
int blynkDistance = (distance - MaxLevel) * -

1; if (distance <= MaxLevel) {
Blynk.virtualWrite(V0, blynkDistance);
} else {
Blynk.virtualWrite(V0, 0);
}
lcd.print("WLevel:");
if (Level1 <= distance) {

lcd.print("Very Low");
digitalWrite(LED1, HIGH);
digitalWrite(LED2, LOW);
} else if (Level2 <= distance && Level1 > distance)
{ lcd.setCursor(8, 0);
lcd.print("Low");
lcd.print(" ");
- 50
lcd.print("Medium");
lcd.print(" ");
lcd.print("High");
lcd.print(" ");
} else if (Level5 >= distance)
lcd.print("Full");
lcd.print(" ");
}
}
//Get the button value

BLYNK_WRITE(V1) {
bool Relay = param.asInt();
if (Relay == 1) {
digitalWrite(relay, LOW);
lcd.print("Motor is ON ");
} else {
digitalWrite(relay, HIGH);
lcd.print("Motor is
OFF");
}
}
void loop() {
Blynk.run();//Run the Blynk
library timer.run();//Run the Blynk
timer
}
- 51
CHAPTER 9. DISCUSSION AND RESULTS
The flood detection system in an IoT project is designed to monitor water levels and
detect potential flood conditions. It utilizes sensors to measure the water level, thresholds
to determine flood conditions, and notifications or alarms to alert users about potential
risks.
The system continuously reads sensor data and compares it with predefined thresholds. If
the water level exceeds the specified threshold, indicating a flood condition, the system
triggers notifications or alarms to notify the users. This can be done through various
methods, such as sending SMS alerts, email notifications, push notifications to a mobile
app, or activating physical alarms or buzzers.
The result of the flood detection system depends on the accuracy and reliability of the
sensors, the effectiveness of the threshold settings, and the responsiveness of the
notification mechanisms. By properly configuring and calibrating the sensors, setting
appropriate thresholds, and ensuring reliable communication and notification methods,
the system can effectively detect and alert users about flood conditions.
During the implementation and testing phase, it is essential to validate the system's
performance in various scenarios, including different water levels, environmental
conditions, and potential false positives or false negatives. Robust testing helps ensure
the system's reliability and accuracy in detecting actual flood conditions while
minimizing false alarms or missed detections.
Additionally, it is crucial to consider factors like power supply, data logging, remote
monitoring, and integration with cloud platforms for enhanced functionality and
scalability. The flood detection system can be further improved by incorporating features
like data visualization, historical data analysis, and remote control of devices.
Regular maintenance and monitoring of the flood detection system are necessary to
ensure its continued operation and reliability. This includes checking sensor
functionality, updating thresholds if needed, and monitoring the performance of the
notification mechanisms.
Overall, a well-designed and properly implemented flood detection system in an IoT

project can provide timely alerts and help mitigate potential damage caused by flooding,
enabling users to take necessary actions and ensure the safety of their property and
surroundings.
- 52
9.1 TESTING THE SYSTEM
Testing the flood detection system in your IoT project is crucial to ensure its
functionality and reliability. Here are some steps you can follow to test the system:
1. Simulate water levels: Create a controlled environment to simulate different water

levels. You can use a water container or basin and adjust the water level manually
to simulate various scenarios, from normal to flood conditions.
2. Power up the system: Connect the microcontroller and the sensors to their power
sources as per your project's setup.
3. Verify sensor readings: Monitor the sensor readings through the serial monitor or any
other means of output you have implemented in your code. Ensure that the sensor
readings correspond to the water levels accurately.
4. Test threshold detection: Set the threshold values in your code appropriately to trigger
flood detection. Gradually raise the water level and observe if the system correctly
detects the flood condition and triggers the desired notifications or alarms.
5. Evaluate notification mechanisms: Verify that the notifications or alarms are being
sent as expected. If you are using SMS alerts, check if the messages are being delivered
to the intended recipients. If you are utilizing email notifications or push notifications,
ensure that the messages are being received by the designated email addresses or mobile
devices.
6. Test response time: Measure the response time of the system from the moment
the flood condition is detected to the time the notifications or alarms are triggered.
The response time should be as quick as possible to ensure timely alerts.
7. Test false positives and false negatives: Introduce scenarios that may cause false
positives or false negatives. For example, you can create situations where the
sensor readings are affected by external factors such as noise, reflections, or
disturbances. Observe if the system responds appropriately to minimize false alarms
and maintains accuracy.
8. Monitor system stability: Run the system continuously for an extended period
and observe its stability. Ensure that the system remains operational and performs
reliably without any unexpected behavior or crashes.
9. Fine-tune and iterate: Based on the test results, make necessary adjustments to the
system, such as modifying threshold values, optimizing sensor calibration, or refining
the notification mechanisms. Repeat the testing process to verify the effectiveness of the
adjustments.
- 53
10. Consider real-world conditions: If possible, test the system in real-world conditions
that closely resemble the intended deployment environment. Factors such as humidity,
temperature, and other environmental conditions can influence the system's performance.
Evaluate how the system behaves under these conditions.
By conducting thorough testing, you can identify any potential issues, improve the
system's accuracy, and ensure that it operates reliably during flood events. Regular
maintenance and periodic testing are recommended to keep the system in optimal
condition and address any emerging issues promptly
- 54
9.2 OUTPUT
The output of a flood detection system in an IoT project depends on the specific
implementation and the chosen notification methods. Here are some examples of
possible outputs:
1. Visual notifications: If you have integrated a display or indicator lights in

your system, the output could be a visual signal that indicates the flood condition.
For example, an LED may turn on or change color to signify the presence of
flooding.
2. Audible alarms: The system can output an audible alarm or buzzer to alert
people nearby about the flood condition. The alarm can be activated when the
water level exceeds a predefined threshold.
3. SMS alerts: If you have integrated SMS functionality, the system can send text
messages to designated phone numbers, notifying them about the flood condition. The
message can include relevant details such as the location and severity of the flood.
4. Email notifications: The system can send email notifications to specific email
addresses, providing information about the flood condition. The email can include details
like the water level, location, and any necessary instructions or actions to be taken.
5. Push notifications: If you have developed a mobile application or integrated with a

third-party messaging service, the system can send push notifications to mobile devices.
Users who have the application installed will receive instant notifications about the flood
condition.
6. Web-based alerts: The system can display alerts or notifications on a web-based

dashboard or user interface. Users can access this interface through a web browser on
their computers or mobile devices to stay informed about the flood condition.
7. Data logging and analysis: The system can log the sensor readings, water levels,
and flood events over time. This data can be stored locally or in a cloud platform for
further analysis, allowing users to monitor historical trends and patterns.
The specific output options will depend on the components, sensors, and notification
methods you have incorporated into your flood detection system. You can choose one
or multiple output methods based on the requirements and preferences of your project.
Remember that the effectiveness of the output relies on the proper configuration, reliable
communication, and user accessibility to receive and act upon the notifications or
alarms. Regular testing, maintenance, and user feedback can help optimize the system's
output to ensure timely and accurate flood alerts.
- 55
- 56
CHAPTER 10. CONCLUSIONS AND REFERENCES
10.1 Conclusions
The flood detection system in an IoT project is a valuable tool for monitoring and
mitigating flood risks. It provides early detection of rising water levels, real-time
monitoring, and timely alerts to users. By leveraging IoT technologies, such as sensors,
data analytics, and remote connectivity, the system offers numerous advantages for flood
management and response.
In conclusion, here are some key points regarding the flood detection system in an IoT
project:
1. Early warning: The system enables early detection of flood conditions, allowing
individuals and authorities to take proactive measures and minimize the impact
of flooding.
2. Real-time monitoring: Continuous monitoring of water levels provides real-time data,

enabling prompt decision-making and effective flood response.
3. Remote accessibility: Users can access the system's data and receive notifications
remotely through connected devices, enhancing convenience and enabling rapid
response regardless of location.
4. Accuracy and reliability: The system utilizes sensors and data analytics algorithms to
provide accurate and reliable measurements, reducing false alarms and missed flood
events.
5. Customizability and scalability: The system can be tailored to specific requirements

and easily scaled to cover larger areas or multiple locations, making it adaptable to
various applications.
6. Integration capabilities: The system can be seamlessly integrated with other systems
and platforms, enhancing its functionality and enabling a more comprehensive approach
to flood management.
7. Data-driven insights: The system generates valuable data that can be analyzed to gain
insights into flood patterns, assess risks, and inform decision-making processes for long-
term flood management strategies.
By implementing a well-designed flood detection system in an IoT project, stakeholders

can effectively monitor and manage flood risks, mitigate potential damage, and ensure
the safety of people and property. The system's early detection, real-time monitoring,
and remote accessibility contribute to improved flood preparedness, rapid response, and
effective mitigation measures.
Regular maintenance, testing, and continuous improvement are essential to optimize the
system's performance and ensure its reliability over time. With advancements in IoT
technologies and ongoing development in flood detection systems, we can expect further
- 57
10.2 REFERENCES
1].Early Flood Monitoring System using loT Applications S Vara Kumari, O Sailaja, NV
S Rama Krishna, ChThrinisha
[2]. Flood Monitoring and Detection System using Wireless Sensor Network, Edward N.
Udol, Etcbong B. Isong2
[3] Sms based flood monitoring and early warning system, Sheikh Azid, Bibhya
Sharma, Krishna Raghuwaiya,Abinendra Chand, Sumeet Prasad. A Jacquier
[4] Development of low cost community based real time flood monitoring and early
warning system by Abimbola Atijosan, Ayodeji Olalekan Sulan, Rahmon Ariyo Badru,
Tanfeek Alaga
[5].1OT based real time flood monitoring and alert management system by Jagadeesh
Babu Mallisetty and Chandrasekhar V
[6].Automatic monitoring & Reporting of water quality by using WSN Technology and
different routing methods.A.C.Khetrel, Prof S.G.Hate2
[7] https://lastminuteengineers.com/water-level-sensor-arduino-tutorial
[8].https://store.arduino.cc/usa/arduino-uno-rev3
[9] https://www.maxbotix.com/articles/how-ultrasonic-sensors-work.htm [10]

https://www.elprocus.com/a-memoir-on-water-flow-sensor
[11] https://en.wikipedia.org/wiki/Internet of t things
[12] https://www.adafruit.com/product/386
[13] https://en.wikipedia.org/wiki/ESP8266
[14] https://thingspeak.com/
- 58

Kiosks System

Uploaded by

Document Informationclick to expand document informationfor aktu students projects file proper way

Document Informationclick to expand document information

Copyright:

Available Formats

Kiosks System

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Kiosks System

Uploaded by

Copyright:

Available Formats

FLOOD DETECTION SYSTEM

DR. A.P.J. ABDUL KALAM TECHNICAL UNIVERSITY,

Rahul (1904730100038) Pintu (1904730100034)

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

G.C.R.G MEMORIAL TRUST GROUP OF INSTITUTIONS, LUCKNOW

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

Detection System Using Iot” has been satisfactorily completed by Rahul

students of 4th year. It is a bonafide piece of work, carried out under my

supervision and guidance in the Department Of Computer Science &

Engineering ,G.C.R.G Memorial Trust Group Of Institutions , Lucknow for

partial fulfillment of the Bachelor of Technology during the academic year

Under the Supervision of

Prof Mr. Tushar Giri

Dr. Shivi Chaturvedi

Head of the Department

G.C.R.G MEMORIAL TRUST GROUP OF INSTITUTIONS, LUCKNOW

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

Rahul Kumar Sahani Pintu Kumar

Sateesh Kumar Chaudhary Vivek Prasad

I am grateful, beyond my sense of gratitude, to Dr. Suman Sharma, Project

TOPIC NAME PAGE NUMBER

Chapter 2: Literature Review..................................................................6-7

6.3 Initializing Wi-Fi connection

6.4 Configuring sensor pins and alarms

6.5 Reading sensor data

6.6 Checking water level thresholds

6.7 Sending notifications and alarms

6.8 Uploading the code to the microcontroller

1 Model Of Flood Detection System.......................................................3

The proposed system consists of multiple sensors strategically placed in flood-prone

In conclusion, the Flood Detection System in IoT project presents an innovative

1.1 Introduction of Flood Detection System.

The Flood Detection System in IoT project involves deploying a network of

Seamless integration with existing emergency management infrastructure is another key

In conclusion, the Flood Detection System in IoT project represents a transformative

How to program an Arduino ?

1.2 Introduction Of Ultrasonic Sensor

by measuring the time between the emission and reception.

The distance can be calculated with the following formula:

The following list shows typical characteristics enabled by the detectionsystem.

[Resistant to mist and dirt]

Detection is not affected by accumulation of

dustor dirt. [Complex shaped objects

2. Sensor Selection: Choose appropriate sensors capable of measuring water levels

4. Data Transmission: Establish a communication network to transmit the collected

6. Alert Generation: Implement a mechanism to generate alerts or notifications when

8. Data Visualization and Reporting: Develop a user interface or dashboard to visualize

2. Urban Planning and Infrastructure Management: Flood detection systems can be

3. Environmental Monitoring: Flood detection systems can contribute to environmental

6. Critical Infrastructure Protection: Flood detection systems play a vital role in

8. Water Resource Management: Flood detection systems assist in managing water

Usage and Benefits:

1. Real-time Monitoring: Flood detection systems provide continuous monitoring of

Fig 4 Architecture of Project

5.1 Hardware Requirements.

5.1.1 Jumper wires.

A breadboard, or protoboard, is a construction base for prototyping of electronics.