VPM Blackbook
VPM Blackbook
PROJECT REPORT ON
Prof. R. V. SHINDE
DEPARTMENT OF
INFORMATION TECHNOLOGY
ACADEMIC YEAR
2023-2024
MARATHA VIDYA PRASARAK SAMAJ’S
RAJARSHI SHAHU MAHARAJ
POLYTECHNIC
NASHIK-422013
CERTIFICATE
4. Om Kame 445912
5. Raj Ranka 445947
Institute
External Examiner Seal
i
SPONSORSHIP LETTER
ii
ACKNOWLEDGEMENT
With all respect and gratitude, I would like to thank all people who have helped me directly or indirectly
for the completion of this Project. I express my heartily gratitude towards Prof. R. V. Shinde for
guiding me to understand the work conceptually and also for her constant encouragement to complete
this project on “VEHICLE POLLUTION MONITORING USING IoT” My association with him as
a student has been extremely inspiring. I express my sincere thanks to him for kind help and guidance. I
would like to give my sincere thanks to Prof. A. P. Patil Project Coordinator & Prof. M. B. Patl Head
of Department of Information Technology Department for providing necessary help, providing facilities
and time to time valuable guidance. No words could be good enough to express my deep gratitude to our
honorable respected Principal Prof. Prashant Patil, and staff members of Information Technology
Department of Maratha Vidya Prasarak Samaj’s, Rajarshi Shahu Maharaj Polytechnic Nashik, for
providing all necessary facilities with their constant encouragement and support.
Finally, yet importantly, I would like to express my heartfelt thanks to my beloved parents for their
blessings, my friends and colleagues for their help and wishes for the successful completion of this
project.
iii
CONTENT
Certificate i.
Sponsorship Letter ii.
Acknowledgement iii.
Content iv.
List Of Figures vi.
List Of Tables viii.
Abstract ix.
1 Introduction 1
2 Problem Statement & Scope Of Project 2
2.1 Objective 2
2.2 Scope 3
3 Literature Survey 4
4 Software Requirements Specifications 5
4.1 Assumption And Dependencies 5
4.2 Functional Requirements 5
4.3 External Interface Requirements 5
4.4 Non-Functional Requirements 6
4.5 System Requirements 6
4.6 Analysis Models: SDLC Model To Be Applied 6
5 System Design 9
5.1 System Architecture 9
5.2 Mathematical Module 9
5.3 Data Flow Diagram(Dfd) 10
5.4 Uml Diagram 12
6 Project Plan 17
6.1 Cost Estimate 17
6.2 Risk Management 19
6.3 Risk Management W.R.T Np Hard Analysis 20
6.4 Project Schedule 22
iv
7 Project Implementation 25
8 Cocomo Model 27
9 Testing 32
9.1 Black Box Testing 32
9.2 White Box Testing 34
10 Result And Performance Analysis 39
11 Source Code 46
11.1 User Application Code 46
11.2 Admin Side Application Code 72
12 Feasibility Study 102
12.1 Feasibility Study 102
12.2 Analysis 103
13 Advantages And Limitations 106
14 Applications 108
Future Scope 110
Conclusions 112
References 113
Bibliography
v
LIST OF FIGURES
vi
10.5 User App Home Page – Challan Paid 41
10.6 Razor Pay Payment Gateway 42
10.7 Sign In Page 43
10.8 Admin Home Page 43
10.9 User Paid And Pending Challans 44
10.10 Area Module 45
10.11 Admin App Profile 45
vii
LIST OF TABLES
6.3.3.1 Monitoring 21
6.2.3.2 Management 21
viii
ABSTRACT
Pollution has a significant part in the degradation of our planet. Quick industrialization, rapid
urbanisation, rapid population expansion, a dramatic increase in automobiles on the road, and other
human activities have disrupted the natural environment's balance. It alters the climate's quality, and
season change is caused by build-up of the greenhouse gases in the aerosphere. Global warming, which
is produced by the release of greenhouse gases, is one of the most serious environmental issues
confronting the globe today. CO2, which is a main component of the circumstances, is causing the
globe's surface to warm. Observing and regulating these seasonal changes is a major problem in saving
our ecosystem. The transportation sector is a main source of air pollution in urban cities, particularly in
growing countries such as India. This project uses multiple sensors, including a gas sensor located at the
vehicle's exhaust, to measure pollution limits in real time. The information collected checks the standard
limits and is sent to the vehicle operator via the Global System for Mobile Communication module
(GSM) and the cloud using Internet of Things (IoT)
ix
Chapter No. 01
INTRODUCTION
Air pollution, predominantly caused by vehicular emissions, has emerged as a major environmental
and public health concern worldwide. Exposure to pollutants such as carbon monoxide (CO), nitrogen
oxides (NOx), particulate matter (PM), and volatile organic compounds (VOCs) has been linked to a
variety of health problems, including respiratory diseases, cardiovascular disorders, and even cancer.
Furthermore, vehicle emissions are significant contributors to global warming and climate change,
exacerbating the already critical ecological challenges facing our planet. Traditional methods of monitoring
vehicle emissions, such as periodic vehicle inspections and stationary monitoring stations, have limitations
in terms of coverage, accuracy, and timeliness. These conventional approaches often fail to provide real-
time data on emissions levels across different locations and time periods, making it difficult to implement
timely interventions and policy measures.
With the escalating concerns surrounding environmental pollution, especially vehicular emissions,
there is a growing need for effective monitoring systems. This project introduces a solution that leverages
the NodeMCU IoT platform in conjunction with an Android application to create a robust vehicle pollution
monitoring system. By integrating sensors onto the NodeMCU, real-time data on pollutants is collected
and transmitted wirelessly to the Android app. This approach not only facilitates accurate monitoring but
also provides a user-friendly interface for individuals and authorities to assess and address pollution levels.
The amalgamation of NodeMCU and the Android app represents a significant stride toward sustainable
and technology-driven environmental management.
An increase in automobile vehicle leads to an increase in air pollution since automobiles are the
main source of environmental pollution. The smoke emitted from the vehicle consists of gases like
nitrogen oxides (NOx ), carbon monoxide (CO), and hydrocarbon (HC). approximately one-half of the
nitrogen oxide gases, carbon monoxide and one-fourth of hydrocarbon gases in our environment are
emitted from automobile vehicles, which leads to global warming. Due to poor vehicle maintenance and
ignition defect. the gases emitted from the exhaust may increase. In order to reduce environmental
pollution and to increase vehicles life, we can use this system. when the rate of gases emitted from the
vehicle exceeds the threshold limit set by the government, our system will alert to the user through LCD.
Using IOT, the emission level is also displayed and stored in the database of a vehicle owner. When the
vehicle owner ignores it, the report will send to the transport office with entire details. The entire system is
controlled by Node MCU microcontroller.
1
Chapter No. 2
PROBLEM STATEMENT & SCOPE OF PROJECT
"In today's increasingly urbanized world, vehicle emissions pose a significant threat to air quality, public
health, and the environment. As cities continue to grow, the problem of vehicle pollution becomes more
acute. Therefore, there is a pressing need for an IoT-based vehicle pollution monitoring system that can
accurately and efficiently measure emissions from vehicles in real-time. This system should leverage IoT
technologies to provide real-time data collection, analysis, and reporting, enabling authorities and
individuals to make informed decisions and take actions to mitigate pollution levels and improve overall
air quality in urban areas."
1. Real-time Data Collection: The system will continuously gather emissions data from vehicles on
the roads.
2. Access to real-time data will empower authorities and individuals to make informed decisions
regarding pollution mitigation strategies.
3. Timely interventions can be implemented to address pollution hotspots and improve air quality in
urban areas.
4. By reducing vehicle emissions, the system aims to mitigate health risks associated with air
pollution.
5. Efforts to curb pollution contribute to preserving the environment and mitigating climate change
impacts.
2.1 Objectives
The objectives are as follows:
3 Real-Time Monitoring: Develop a system capable of continuously monitoring vehicle emissions in
real-time to provide up-to-date information on pollution levels.
4 Accurate Data Collection: Ensure the accuracy and reliability of data collected from vehicles,
utilizing IoT sensors and devices to capture emissions data effectively.
5 Data Analysis and Insights: Implement algorithms and analytics to analyze collected data,
identifying trends, patterns, and pollution hotspots to provide actionable insights.
6 Remote Accessibility: Enable remote access to the monitoring system, allowing authorities and
stakeholders to view pollution data and reports from anywhere via web or mobile interfaces.
7 Integration with Existing Infrastructure: Integrate the IoT monitoring system with existing
transportation and environmental monitoring infrastructure for seamless data exchange and
collaboration.
8 Alerting and Notification Mechanisms: Develop alerting mechanisms to notify relevant authorities
and individuals in real-time when pollution levels exceed predefined thresholds, enabling prompt
response and intervention.
9 User-Friendly Interface: Design a user-friendly interface for easy interaction with the monitoring
system, catering to the needs of both technical and non-technical users.
10 Scalability and Flexibility: Build a scalable and flexible architecture that can accommodate the
growing number of monitored vehicles and adapt to evolving environmental regulations and
technological advancements.
2
2.2 Scope
1. System Architecture and Design: Designing the overall architecture of the IoT-based monitoring
system, including hardware components (sensors, devices), software platforms, and communication
protocols.
2. Sensor Deployment and Integration: Identifying suitable sensors for measuring various pollutants
emitted by vehicles (e.g., carbon monoxide, nitrogen oxides) and deploying them strategically across
road networks. Integrating sensors with IoT devices for data collection and transmission.
3. Data Collection and Transmission: Developing mechanisms for collecting emissions data from
vehicles in real-time, ensuring reliable transmission to centralized servers or cloud platforms for
storage and analysis. Implementing communication protocols (e.g., Wi-Fi, cellular, LoRa) to
facilitate data transmission.
4. Data Analysis and Insights: Implementing algorithms and analytics to process collected data,
identify trends, patterns, and pollution hotspots, and generate actionable insights. Visualizing data
through dashboards and reports to facilitate interpretation and decision-making.
5. Alerting and Notification Mechanisms: Designing alerting mechanisms to notify relevant
authorities and stakeholders when pollution levels exceed predefined thresholds, enabling timely
intervention and response.
6. User Interface Development: Developing user-friendly interfaces for interacting with the
monitoring system, including web-based portals, mobile applications, and administrative consoles.
Ensuring accessibility and usability for various user groups, including government agencies,
environmental organizations, and the general public.
3
Chapter No 03
LITERATURE SURVEY
2 IOT Based Vehicle April, International Journal This paper RFID technology, as one of
Emission Monitoring 2022 of Advanced the enabling technologies of IoT (Internet
System and Pollution Research in Science, of Things), is employed to develop the
Detection Communication and information system. RFID reading can be
Technology interrogated along with the corresponding
(IJARSCT) tag ID through a wireless connection
among traffic lights and vehicles. This
will maintain the database and graph for
the data by monitoring the emissions data,
the engine health can be easily inspected
and Examine.
4
Chapter No. 4
SOFTWARE REQUIREMENTS SPECIFICATIONS
5
4.4 Non-Functional Requirements
4.4.1 Performance Requirements:
Performance requirements for proposed system are as follows:
1. Proper level and user information will provide proper and fast results.
2. Proper integration will generate proper results
6
Fig 4.6 waterfall model
7
Waterfall Model –Application
Every software developed is different and requires a suitable SDLC approach to be followed based on the
internal and external factors. Some situations where the use of Waterfall model is most appropriate are −
• Requirements are very well documented, clear and fixed. • Product definition is stable.
• Technology is understood and is not dynamic.
• There are no ambiguous requirements.
• Ample resources with required expertise are available to support the product.
• The project is short
8
Chapter No. 05
SYSTEM DESIGN
5.2.Mathematical Module
S = Input, Output, Deterministic Data, Let S is the system; S = I, O, F, DD, NDD,
Success, Failure
I = Input to the system
I = username, password, order menu, order acknowledge
O= Output of the system
O= order placed, order accepted, email sent
F= Function in System
F=adminLogin(), CustomerLogin()
DD = Deterministic data DD = Null
·NDD = Non Deterministic data NDD = I, O
Success – Order Placed Successfully
Failure - Failed to Placed Order
9
5.3 Data Flow Diagram(DFD)
5.3.1 DFD Level 0
A data flow diagram (DFD) is used to show a graphical representation of the flow of data through an
information system, modelling its process aspects. A DFD is also used as a preliminary step to create an
overview of the system, which can later be elaborated.
10
5.3.3 DFD Level 2
11
5.4 UML Diagram
5.4.1 Use case diagram
Use case diagram is used for describe the function requirements of the system by using the use cases and
the actors. In the Figure user and database are the actors into the system. Use cases involved into the
system.
12
5.4.2 Class diagram
The class diagram is the main building block of object-oriented modeling. It issued for general conceptual
modeling of the structure of the application, and for detailed modeling translating the mode ls into
programming code. Class diagram scan also be used for data modeling. The purpose of class diagram is to
model the static view of an application. Class diagrams are the only diagrams which can be directly
mapped with object- oriented languages and thus widely used at the time of construction
13
5.4.4 Activity diagram
The basic purposes of activity diagram are similar to other four diagrams. It captures the dynamic behavior
of the system. Other four diagrams are used to show the message flow from one object to another, but
activity diagram is used to show message flow from one activity to another
14
5.4.5 Sequence Diagram
The purpose of interaction diagrams is to visualize the interactive behavior of the system. Visualizing the
interaction is a difficult task. Hence, the solution is to use different types of models to capture the different
aspects of the interaction. The sequence diagram represents the flow of messages in the system and is also
termed as an event diagram. It helps in envisioning several dynamic scenarios.
15
5.4.7 Component diagram
In Unified Modeling Language, a component diagram depicts how components are wired together to form
larger components or software systems. They are used to illustrate the structure of arbitrarily complex
systems.
16
Chapter No. 6
PROJECT PLAN
17
Phases Time in Hrs
Analysis 20
Design 30
Coding 20
Testing 30
Documentation 20
Maintenance 40
18
6.2 Risk Management
RISK ANALYSIS: There are quite different types of risk analysis that can be used. Basically, risk
analysis is used to identify the high-risk elements of a project in software engineering. Also, it
provides ways of detailing the impact of risk mitigation strategies. Risk analysis has also been found
to be most important in the software design phase to evaluate criticality of the system, where risks are
analyzed and necessary counter measures are introduced. The main purpose of risk analysis is to
understand risks in better ways and to verify and correct attributes. A successful risk analysis includes
important elements like problem definition, problem formulation, data collection. Risk analysis is
useful in many situations:
When you're planning projects, to help you anticipate and neutralize possible problems.
When you're deciding whether or not to move forward with a project.
When you're improving safety, and managing potential risks in the workplace.
When you're preparing for events such as equipment or technology failure, theft, staff sickness,
or natural disasters.
When you're planning for changes in your environment, such as new competitors coming into
the market, or changes to government policy.
Personnel risks: Caused by a lack of Knowledge about technology and training to perform
functions. There is a possibility that errors are intentional, this is the result of the dubious conduct.
The main risks from personal issues are:
Unintentional; resulting in omission or negligence.
Cannot perform task because lack of ability.
Lack of time management.
Process Risks: The occurrence of internal process deficiencies like inadequate performance
indicators, inefficient controls, modeling failures and an inability to abide by the current laws.
Systems risks: Arising from inadequate, poorly structured or defective IT systems. Some examples:
Intermittent networks
Server crash
Physical damage to data storage components
System obsolescence
Improper maintenance
Power outage from internal causes
System slowdown
Security holes
19
6.3 RISK MANAGEMENT W.R.T NP HARD ANALYSIS:
1. In rural area most of the time Internet will not be available so our system may not work.
2. If reviews not available and false review are there then systems results will fail.
3. If provide wrong input then system will show wrong output or it may fail.
20
6.3.3 Monitoring, Management
Following are the details for each risk
Risk Id tak1
Probability Low
Impact High
Response Mitigate
Risk Id 2
Probability Low
Response Identified
21
6.4 Project Schedule:
6.4.1 Project Planning Chart
22
7. Modified To study the Original Adobe Reader
Architecture original architecture and Algorithm is Studied
modify the original and modified
architecture
23
is going well and each testing will be
Unit Testing and carried out in
every component is order to check the
Integration Testing working functioning of the
system
White box Testing
24
Chapter No. 07
PROJECT IMPLEMENTATION
Implementing a vehicle pollution monitoring project involves several key steps, from planning and design
to deployment and maintenance. Below is a detailed project implementation plan for monitoring vehicle
pollution:
Tasks:
Define project goals (e.g., reducing vehicle emissions, improving air quality).
Identify stakeholders and their requirements (e.g., government agencies, environmental organizations,
general public).
Conduct a feasibility study to assess technical, financial, and operational aspects.
Tasks:
Research existing pollution monitoring technologies (e.g., portable emissions measurement systems,
remote sensing devices).
Evaluate the suitability, accuracy, and cost-effectiveness of different technologies.
Select the most appropriate technology based on project requirements and budget.
Tasks:
Design the architecture of the monitoring system, including hardware and software components.
Develop or customize software for data collection, analysis, and reporting.
Integrate selected monitoring technologies into the system.
Conduct pilot testing to validate the system's functionality and performance.
Tasks:
Identify suitable locations for installing monitoring stations (e.g., busy roads, intersections, toll booths).
Procure necessary equipment and materials for installation.
Install and configure monitoring stations according to design specifications.
Conduct initial calibration and testing of the monitoring system.
25
Objective: Collect, analyze, and interpret vehicle pollution data.
Tasks:
Collect real-time or periodic data on vehicle emissions from monitoring stations.
Store collected data securely in a centralized database.
Analyze data to identify trends, patterns, and hotspots of pollution.
Generate reports and visualizations to communicate findings to stakeholders.
Tasks:
Prepare and distribute regular reports summarizing monitoring results and findings.
Organize stakeholder meetings, workshops, or webinars to discuss findings and solicit feedback.
Develop a public communication strategy to raise awareness about vehicle pollution and promote
behavioral change.
Tasks:
Establish a maintenance schedule for monitoring equipment and software.
Monitor system performance and troubleshoot any issues or malfunctions promptly.
Implement upgrades or enhancements to the system based on technological advancements or changing
requirements.
Tasks:
Conduct periodic evaluations to assess the impact of the monitoring project on reducing vehicle pollution.
Solicit feedback from stakeholders and the general public to identify strengths, weaknesses, and
opportunities for improvement.
Implement recommendations and adjustments to enhance the project's effectiveness and efficiency.
26
Chapter No. 08
COCOMO MODEL
COCOMO Model is a procedural cost estimate model for software projects and is often used
as a process of reliably predicting the various parameters associated with making a project such as
size, effort, cost, time, and quality. The costing of the project mainly depends on the Camera that we
use for developing this system. In our project we have used concept like AI, Machine Learning. The
total man work included for developing the software is about 15 hours per week and near about 20
weeks so the overall costing of this project is not so high.
1. Basic COCOMO Model
2. Intermediate COCOMO Model
3. Complete/Detailed COCOMO Model
Basic COCOMO:
Computes software development effort and cost as a function of program size expressed in
estimated DSIs.
There are three modes within Basic COCOMO:
1. Organic Mode:
Development projects typically are uncomplicated and involve small experienced teams. The
planned software is not considered innovative and requires a relatively small amount of DSIs
(typically under 50,000).
2. Semidetached Mode:
Development projects typically are more complicated than in Organic Mode and involve teams of
people with mixed levels of experience. The software requires no more than 300,000 DSIs. The
project has characteristics of both projects for Organic Mode and projects for Embedded Mode.
3. Embedded Mode:
Development projects must fit into a rigid set of requirements because the software is to be
embedded in a strongly joined complex of hardware, software, regulations and operating procedures.
Effort = a1 x (KLOC)a2PM
27
Tdev=b1 x(Effort)b2 Months
Where,
KLOC is the estimated size of the software product expressed in Kilo Lines of code
a1, a2, b1, b2 are constants for each category of software products
Effort is the total effort required to develop the software product, expressed in person
months (PM’s)
Intermediate COCOMO:
An extension of the Basic model that computes software development effort by adding a set of
"cost drivers," that will determine the effort and duration of the project, such as assessments of
personnel and hardware.
Detailed COCOMO:
An extension of the Intermediate model that adds effort multipliers for each phase of the project to
determine the cost drivers impact on each step.
Example: A distributed Management Information System (MIS) product for an organization having
offices at several places across the country can have the following sub-components:
Database part
Graphical User Interface (GUI) part
Communication part
For the three classes of software products, the formulas for estimating the effort based on the code
size are shown below:
Organic: Effort = 2.4(KLOC)1.05 PM
Semi-Detached: Effort = 3.0(KLOC)1.12 PM
Embedded: Effort = 3.6(KLOC)1.20 PM
PM: Person Months
28
Estimation of development time (Basic COCOMO Model):
For the three classes of software products, the formulas for estimating the development time based on
the effort are given below:
The effort estimation is expressed in units of person-months (PM). It is the area under the person-
month plot as shown in figure below. It should be carefully noted that an effort of 100 PM does not
imply that 100 persons should work for 1 month nor does it imply that 1 person should be employed
for 100 months, but it denotes the area under the person-month curve
For the three classes of software products, the formulas for estimating the effort based on the code
size are shown below:
For the three classes of software products, the formulas for estimating the development time based on
the effort are given below:
29
COST ESTIMATION
KLOC = 18.88
NodeMCU = 600
MQ135 = 400
30
VEHICLE POLLUTION MONITORING USING IoT
Sr.
Title Cost
No.
3. NodeMCU 1200
5. Group Members 5
150(per
6. Charges per hour person)
30x150 =4500(per
7.
Total work charge person)
9. Internet Hours 20
31
VEHICLE POLLUTION MONITORING USING IoT
Chapter No. 09
TESTING
9.1 Black Box Testing
Black Box Testing is a software testing method in which the functionalities of software applications
are tested without having knowledge of internal code structure, implementation details and internal
paths. Black Box Testing mainly focuses on input and output of software applications and it is entirely
based on software requirements and specifications. It is also known as Behavioral Testing.
The above Black-Box can be any software system you want to test. For Example, an operating system
like Windows, a website like Google, a database like Oracle or even your own custom application.
Under Black Box Testing, you can test these applications by just focusing on the inputs and outputs
without knowing their internal code implementation.
How to do BlackBox Testing
Here are the generic steps followed to carry out any type of Black Box Testing.
Functional testing – This black box testing type is related to the functional requirements of a
system; it is done by software testers.
Non-functional testing – This type of black box testing is not related to testing of specific
functionality, but non-functional requirements such as performance, scalability, usability.
Regression testing – Regression Testing is done after code fixes, upgrades or any other system
maintenance to check the new code has not affected the existing code.
32
VEHICLE POLLUTION MONITORING USING IoT
Equivalence Class Testing: It is used to minimize the number of possible test cases to an
optimum level while maintains reasonable test coverage.
Boundary Value Testing: Boundary value testing is focused on the values at boundaries. This
technique determines whether a certain range of values are acceptable by the system or not. It is
very useful in reducing the number of test cases. It is most suitable for the systems where an
input is within certain ranges.
Decision Table Testing: A decision table puts causes and their effects in a matrix. There is a
unique combination in each column.
33
VEHICLE POLLUTION MONITORING USING IoT
34
VEHICLE POLLUTION MONITORING USING IoT
4 test cases required such that all branches of all decisions are covered, i.e, all edges of flowchart are
covered
Condition Coverage: In this technique, all individual conditions must be covered as shown in
the following example:
1. READ X, Y
2. IF(X == 0 || Y == 0)
3. PRINT ‘0’
In this example, there are 2 conditions: X == 0 and Y == 0. Now, test these conditions get
TRUE and FALSE as their values. One possible example would be:
1. #TC1 – X = 0, Y = 55
2. #TC2 – X = 5, Y = 0
Multiple Condition Coverage: In this technique, all the possible combinations of the possible
outcomes of conditions are tested at least once. Let’s consider the following example:
1. READ X, Y
2. IF(X == 0 || Y == 0)
3. PRINT ‘0’
4. #TC1: X = 0, Y = 0
5. #TC2: X = 0, Y = 5
6. #TC3: X = 55, Y = 0
7. #TC4: X = 55, Y = 5
35
VEHICLE POLLUTION MONITORING USING IoT
36
VEHICLE POLLUTION MONITORING USING IoT
Cyclomatic Complexity: It is a measure of the logical complexity of the software and is used to define
the number of independent paths. For a graph G, V(G) is its cyclomatic complexity.
Calculating V(G):
5. V(G) = P + 1, where P is the number of predicate nodes in the flow graph
6. V(G) = E – N + 2, where E is the number of edges and N is the total number of nodes
7. V(G) = Number of non-overlapping regions in the graph
Example:
37
VEHICLE POLLUTION MONITORING USING IoT
■ 2 passes
■ m passes, where m < n
■ n-1 ans n+1 passes
2. Nested loops: For nested loops, all the loops are set to their minimum count and we start
from the innermost loop. Simple loop tests are conducted for the innermost loop and this
is worked outwards till all the loops have been tested.
3. Concatenated loops: Independent loops, one after another. Simple loop tests are applied
for each.
If they’re not independent, treat them like nesting.
Advantages:
1. White box testing is very thorough as the entire code and structures are tested.
2. It results in the optimization of code removing error and helps in removing extra lines of code.
3. It can start at an earlier stage as it doesn’t require any interface as in case of black box testing.
4. Easy to automate.
Disadvantages:
38
VEHICLE POLLUTION MONITORING USING IoT
Chapter No 10
RESULT AND PERFORMANCE ANALYSIS
User App:
39
VEHICLE POLLUTION MONITORING USING IoT
40
VEHICLE POLLUTION MONITORING USING IoT
Fig. 10.4. User App Home Page – Fig. 10.5. User App Home Page –
Challan Pending Challan Paid
41
VEHICLE POLLUTION MONITORING USING IoT
42
VEHICLE POLLUTION MONITORING USING IoT
Admin App:
43
VEHICLE POLLUTION MONITORING USING IoT
44
VEHICLE POLLUTION MONITORING USING IoT
45
VEHICLE POLLUTION MONITORING USING IoT
Chapter No. 11
SOURCE CODE
11.1 User Application Code:
46
VEHICLE POLLUTION MONITORING USING IoT
child: GetMaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(
fontFamily: regular,
filledButtonTheme: FilledButtonThemeData(
style: FilledButton.styleFrom(
backgroundColor: blueColor,
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(6)),
minimumSize: const Size(double.infinity, 50),
),
),
inputDecorationTheme: const InputDecorationTheme(
border: OutlineInputBorder(),),
),
home: SplashScreen(),
),
);
}
}
2. FireBase Options :-
import 'package:firebase_core/firebase_core.dart' show FirebaseOptions;
import 'package:flutter/foundation.dart'
show defaultTargetPlatform, kIsWeb, TargetPlatform;
/// Default [FirebaseOptions] for use with your Firebase apps.
///
/// Example:
/// dart
/// import 'firebase_options.dart';
/// // ...
/// await Firebase.initializeApp(
/// options: DefaultFirebaseOptions.currentPlatform,
/// );
47
VEHICLE POLLUTION MONITORING USING IoT
///
class DefaultFirebaseOptions {
static FirebaseOptions get currentPlatform {
if (kIsWeb) {
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for web - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
}
switch (defaultTargetPlatform) {
case TargetPlatform.android:
return android;
case TargetPlatform.iOS:
return ios;
case TargetPlatform.macOS:
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for macos - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
case TargetPlatform.windows:
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for windows - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
case TargetPlatform.linux:
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for linux - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
default:
throw UnsupportedError(
'DefaultFirebaseOptions are not supported for this platform.',
);
}
48
VEHICLE POLLUTION MONITORING USING IoT
}
static const FirebaseOptions android = FirebaseOptions(
apiKey: 'AIzaSyASUrcasjS6raxm4GDywW_zVBAj-TOFUFA',
appId: '1:210223083459:android:0a53cd7804a7adb4b91776',
messagingSenderId: '210223083459',
projectId: 'vehiclepollutionmonitori-8c43d',
databaseURL: 'https://vehiclepollutionmonitori-8c43d-default-rtdb.firebaseio.com',
storageBucket: 'vehiclepollutionmonitori-8c43d.appspot.com',
);
static const FirebaseOptions ios = FirebaseOptions(
apiKey: 'AIzaSyB6vlo1OX5g-ug6oAzJrzJbTAvcA7w4TMk',
appId: '1:210223083459:ios:2819c16c14a5094bb91776',
messagingSenderId: '210223083459',
projectId: 'vehiclepollutionmonitori-8c43d',
databaseURL: 'https://vehiclepollutionmonitori-8c43d-default-rtdb.firebaseio.com',
storageBucket: 'vehiclepollutionmonitori-8c43d.appspot.com',
iosBundleId: 'com.example.user',
);
}
3. Sign-In Screen :-
import 'package:user/consts/consts.dart';
// ignore: must_be_immutable
class SignInScreen extends StatelessWidget {
SignInScreen({super.key});
TextEditingController emailField = TextEditingController();
TextEditingController nameField = TextEditingController();
TextEditingController passField = TextEditingController();
final form_key = GlobalKey<FormState>();
@override
Widget build(BuildContext context) {
var controller = Provider.of<AuthController>(context, listen: false);
return Scaffold(
body: Container(
49
VEHICLE POLLUTION MONITORING USING IoT
padding: screenPadding,
width: context.width,
child: SingleChildScrollView(
child: Form(
key: form_key,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
SizedBox(
height: context.height * 0.13,
),
"Hello Again!".text.fontFamily(semibold).size(22).make(),
20.heightBox,
customTextField(
name: "Email",
hint: "Enter your email",
controller: emailField),
customTextField(
name: "Password",
hint: "Enter Password",
is_pass: true,
controller: passField),
20.heightBox,
Consumer<AuthController>(builder: (context, controller, xxx) {
return FilledButton(
onPressed: () {
if (form_key.currentState!.validate()) {
controller
.userSignIn(
email: emailField.text, pass: passField.text)
.then((value) {
if (value != null) {
Get.off(() => Home());
}
50
VEHICLE POLLUTION MONITORING USING IoT
});
}
},
child: controller.is_loading
? SizedBox(
width: 10,
height: 10,
child: CircularProgressIndicator(
color: Colors.white,
strokeWidth: 2,
),
)
: "Sign In".text.make(),
);
}),
20.heightBox,
Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
"Dont have an account?".text.make(),
10.widthBox,
"Sign Up".text.fontFamily(semibold).color(blueColor).make(),
],
).onTap(() {
Get.to(() => SignUpScreen());
})
],
),
),
),
),
);
}
}
51
VEHICLE POLLUTION MONITORING USING IoT
4. Sign-Up Screen:-
import 'package:user/consts/consts.dart';
// ignore: must_be_immutable
class SignUpScreen extends StatelessWidget {
SignUpScreen({super.key});
TextEditingController emailField = TextEditingController();
TextEditingController nameField = TextEditingController();
TextEditingController passField = TextEditingController();
final form_key = GlobalKey<FormState>();
@override
Widget build(BuildContext context) {
return Scaffold(
body: Container(
padding: screenPadding,
width: context.width,
child: SingleChildScrollView(
child: Form(
key: form_key,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
SizedBox(
height: context.height * 0.13,
),
"Create an account".text.fontFamily(semibold).size(22).make(),
20.heightBox,
customTextField(
name: "Name",
hint: "Enter your name",
controller: nameField),
customTextField(
name: "Email",
hint: "Enter your email",
controller: emailField),
52
VEHICLE POLLUTION MONITORING USING IoT
customTextField(
name: "Password",
hint: "Enter Password",
is_pass: true,
controller: passField),
20.heightBox,
Consumer<AuthController>(builder: (context, controller, xxx) {
return FilledButton(
onPressed: () async {
if (form_key.currentState!.validate()) {
controller
.userSignUp(context,
email: emailField.text, pass: passField.text)
.then(
(value) async {
await controller.storeAuthDetails(
name: nameField.text, email: emailField.text);
if (value != null) {
Get.offAll(() => UserRegistrationScreen());
}
},
);
}
},
child: controller.is_loading
? const SizedBox(
width: 10,
height: 10,
child: CircularProgressIndicator(
color: Colors.white,
strokeWidth: 2,
),
)
: "Sign Up".text.fontFamily(semibold).size(16).make(),
53
VEHICLE POLLUTION MONITORING USING IoT
);
})
],
),
),
),
),
);
}
}
5. Splash Screen :-
import 'package:firebase_auth/firebase_auth.dart';
import 'package:user/consts/consts.dart';
import 'package:user/consts/images.dart';
import 'package:user/views/auth_screens/sign_in_screen.dart';
class SplashScreen extends StatelessWidget {
const SplashScreen({super.key});
// ignore: non_constant_identifier_names
ChangeScreen(context) {
Future.delayed(const Duration(seconds: 1), () {
FirebaseAuth.instance.authStateChanges().listen((value) async {
if (value != null) {
await Provider.of<AuthController>(context, listen: false)
.NavigateUser();
} else {
Get.offAll(() => SignInScreen(),
transition: Transition.fadeIn,
duration: const Duration(milliseconds: 500));
}
});
});
}
@override
54
VEHICLE POLLUTION MONITORING USING IoT
6. History Screen :-
import 'package:flutter/material.dart';
class HistoryScreen extends StatelessWidget {
const HistoryScreen({super.key});
@override
Widget build(BuildContext context) {
return Scaffold();
}
}
55
VEHICLE POLLUTION MONITORING USING IoT
7. Home Screen :-
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:razorpay_flutter/razorpay_flutter.dart';
import 'package:user/consts/colors.dart';
import 'package:user/consts/list.dart';
import 'package:user/consts/marginsAndPaddings.dart';
import 'package:user/consts/typography.dart';
import 'package:user/controllers/home_controller.dart';
import 'package:velocity_x/velocity_x.dart';
class HomeScreen extends StatefulWidget {
const HomeScreen({super.key});
@override
State<HomeScreen> createState() => _HomeScreenState();
}
class _HomeScreenState extends State<HomeScreen> {
Razorpay _razorpay = Razorpay();
@override
void initState() {
// TODO: implement initState
super.initState();
_razorpay.on(Razorpay.EVENT_PAYMENT_SUCCESS, _handlePaymentSuccess);
_razorpay.on(Razorpay.EVENT_PAYMENT_ERROR, _handlePaymentError);
_razorpay.on(Razorpay.EVENT_EXTERNAL_WALLET, _handleExternalWallet);
}
@override
void dispose() {
// TODO: implement dispose
super.dispose();
_razorpay.clear();
}
void _handlePaymentSuccess(PaymentSuccessResponse response) async {
56
VEHICLE POLLUTION MONITORING USING IoT
57
VEHICLE POLLUTION MONITORING USING IoT
58
VEHICLE POLLUTION MONITORING USING IoT
}
var documentData =
snapshot.data!.data() as Map<String, dynamic>;
return Column(
crossAxisAlignment: CrossAxisAlignment.end,
children: [
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"${documentData['vehicle_number']}"
.text
.fontFamily(semibold)
.size(16)
.make(),
documentData['device_installed'] == true
? "${documentData['ppm']}"
.text
.fontFamily(semibold)
.color(
getColor(double.parse(documentData['ppm'])))
.make()
: "Device Not installed"
.text
.fontFamily(semibold)
.color(Colors.red)
.make()
],
),
20.heightBox,
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Column(
crossAxisAlignment: CrossAxisAlignment.start,
59
VEHICLE POLLUTION MONITORING USING IoT
children: [
"Model".text.make(),
"${documentData['vehicle_model']}"
.text
.fontFamily(semibold)
.make()
],
),
Container(
height: 30,
width: 1,
decoration: BoxDecoration(color: Colors.black),
),
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
"type".text.make(),
"${documentData['vehicle_type']}"
.text
.fontFamily(semibold)
.make()
],
),
Container(
height: 30,
width: 1,
decoration: BoxDecoration(color: Colors.black),
),
Column(
crossAxisAlignment: CrossAxisAlignment.end,
children: [
"Insurance".text.make(),
"${documentData['insurance_status']}"
.text
60
VEHICLE POLLUTION MONITORING USING IoT
.fontFamily(semibold)
.make()
],
),
],
),
],
)
.box
.roundedSM
.border(color: borderColor)
.padding(
const EdgeInsets.all(16),
)
.make();
},
),
20.heightBox,
"Challans".text.fontFamily(semibold).size(18).make(),
10.heightBox,
Consumer<HomeController>(builder: (context, controller, xxx) {
return Row(
children: List.generate(
Challans.length,
(index) => "${Challans[index]}"
.text
.color(controller.selectedChallans == index
? Colors.white
: blueColor)
.make()
.box
.border(color: blueColor)
.roundedSM
.color(controller.selectedChallans == index
61
VEHICLE POLLUTION MONITORING USING IoT
? blueColor
: Colors.white)
.padding(
EdgeInsets.symmetric(horizontal: 10, vertical: 6),
)
.margin(
EdgeInsets.only(right: 10),
)
.make()
.onTap(() {
controller.updateChallan = index;
}),
),
);
}),
20.heightBox,
Expanded(
child:
Consumer<HomeController>(builder: (context, controller, xx) {
return StreamBuilder<QuerySnapshot>(
stream: controller.selectedChallans == 0
? FirebaseFirestore.instance
.collection('Challans')
.where('uid',
isEqualTo: FirebaseAuth.instance.currentUser!.uid)
.where('paid_status', isEqualTo: 'pending')
.snapshots()
: FirebaseFirestore.instance
.collection('Challans')
.where('uid',
isEqualTo: FirebaseAuth.instance.currentUser!.uid)
.where('paid_status', isEqualTo: 'paid')
.snapshots(),
builder: (context, snapshot) {
62
VEHICLE POLLUTION MONITORING USING IoT
if (snapshot.hasError) {
return Text('Error: ${snapshot.error}');
}
if (snapshot.connectionState == ConnectionState.waiting) {
return Center(
child: SizedBox(
width: 10,
height: 10,
child: CircularProgressIndicator(
color: blueColor,
),
),
);
}
// Check if there are no pending documents
if (snapshot.data!.docs.isEmpty) {
return Center(
child: Text('No Challans found.'),
);
}
// Display the list of pending documents
return ListView.builder(
padding: EdgeInsets.all(0),
// itemCount: 10,
itemCount: snapshot.data!.docs.length,
itemBuilder: (context, index) {
var document = snapshot.data!.docs[index];
// Access the document data using document.data()
var data = document.data() as Map<String, dynamic>;
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
63
VEHICLE POLLUTION MONITORING USING IoT
children: [
"${data['vehicle_no']}"
.text
.fontFamily(semibold)
.size(16)
.make(),
"₹ ${data['fine']}"
.text
.color(data['paid_status'] == "paid"
? Colors.green
: Colors.red)
.fontFamily(semibold)
.size(16)
.make(),
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"PPM ".text.size(16).make(),
"${data['ppm']}".text.size(16).make(),
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Date ".text.size(16).make(),
"${data['date']}".text.size(16).make(),
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Due Date ".text.size(16).make(),
64
VEHICLE POLLUTION MONITORING USING IoT
"${data['due_date']}".text.size(16).make(),
],
),
data['paid_status'] != "paid"
? 20.heightBox
: SizedBox(),
data['paid_status'] != "paid"
? FilledButton(
onPressed: () {
controller.SelectedChallanId =
document.id;
openCheckOut(int.parse(data['fine']));
},
child: "Pay Challan"
.text
.fontFamily(semibold)
.size(14)
.make())
: SizedBox()
],
)
.box
.border(color: borderColor)
.padding(EdgeInsets.all(12))
.roundedSM
.margin(
EdgeInsets.only(
bottom: 20,
),
)
.make();
},
);
},
65
VEHICLE POLLUTION MONITORING USING IoT
);
}),
)
],
),
),
);
}
}
8. Home :-
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:user/consts/colors.dart';
import 'package:user/controllers/auth_controller.dart';
import 'package:user/controllers/home_controller.dart';
import 'package:user/views/home/home_screen.dart';
import 'package:user/views/profile/profile_screen.dart';
class Home extends StatelessWidget {
Home({super.key});
List<Widget> Screens = [HomeScreen(), ProfileScreen()];
@override
Widget build(BuildContext context) {
var controller = Provider.of<AuthController>(context, listen: false);
return Scaffold(
bottomNavigationBar:
Consumer<HomeController>(builder: (context, controller, xxx) {
return BottomNavigationBar(
onTap: (value) {
controller.updateScreen = value;
},
selectedItemColor: blueColor,
currentIndex: controller.selectedScreenIndex,
items: [
66
VEHICLE POLLUTION MONITORING USING IoT
9. Profile Screen :-
import 'package:firebase_auth/firebase_auth.dart';
import 'package:user/consts/consts.dart';
import 'package:user/views/auth_screens/splash_screen.dart';
class ProfileScreen extends StatelessWidget {
const ProfileScreen({super.key});
@override
Widget build(BuildContext context) {
return Scaffold(
body: Container(
width: double.infinity,
padding: EdgeInsets.only(top: 60, left: 20, right: 20),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
"Profile".text.fontFamily(semibold).size(22).make(),
20.heightBox,
Row(
children: [
CircleAvatar(
backgroundColor: borderColor,
radius: 35,
67
VEHICLE POLLUTION MONITORING USING IoT
),
20.widthBox,
"${FirebaseAuth.instance.currentUser!.displayName}"
.text
.fontFamily(semibold)
.size(18)
.make()
],
)
.box
.border(color: borderColor)
.roundedSM
.padding(EdgeInsets.all(12))
.make(),
20.heightBox,
ListTile(
onTap: () async {
await FirebaseAuth.instance.signOut();
Get.offAll(() => SplashScreen());
},
trailing: Icon(
Icons.arrow_forward_ios,
color: blueColor,
),
title: "Sign Out".text.make(),
).box.border(color: borderColor).roundedSM.make()
],
),
),
);
}
}
68
VEHICLE POLLUTION MONITORING USING IoT
69
VEHICLE POLLUTION MONITORING USING IoT
20.heightBox,
customTextField(
name: "Vehicle Number",
hint: "MH 15 GB 90008",
controller: controller.vehicleDetails.vehicleNumber,
),
customDropDownButton(
hint: "Select Vehicle Type",
onchange: (value) {
controller.vehicleDetails.selectedVehicleType = value;
},
label: "Select Vehicle Type",
list: VehicleTypes,
selectedValue:
controller.vehicleDetails.selectedVehicleType),
customDropDownButton(
hint: "Select your insurance status",
onchange: (value) {
controller.vehicleDetails.insurance_status = value;
},
label: "Select Insurance status",
list: insuranceStatus,
selectedValue: controller.vehicleDetails.insurance_status),
customTextField(
name: "Vehicle Color",
hint: "black/ red",
controller: controller.vehicleDetails.vehicleColor,
),
customTextField(
name: "Vehicle Brand",
hint: "mahindra/ mercedes",
controller: controller.vehicleDetails.vehicleBrand,
),
customTextField(
70
VEHICLE POLLUTION MONITORING USING IoT
71
VEHICLE POLLUTION MONITORING USING IoT
72
VEHICLE POLLUTION MONITORING USING IoT
borderRadius: BorderRadius.circular(6)),
minimumSize: const Size(double.infinity, 50),
),
),
inputDecorationTheme: const InputDecorationTheme(
border: OutlineInputBorder(),
),
),
home: SplashScreen(),
),
);
}
}
2. FireBase Options :
import 'package:firebase_core/firebase_core.dart' show FirebaseOptions;
import 'package:flutter/foundation.dart'
show defaultTargetPlatform, kIsWeb, TargetPlatform;
/// Default [FirebaseOptions] for use with your Firebase apps.
/// Example:
/// dart
/// import 'firebase_options.dart';
/// // ...
/// await Firebase.initializeApp(
/// options: DefaultFirebaseOptions.currentPlatform,
/// );
///
class DefaultFirebaseOptions {
static FirebaseOptions get currentPlatform {
if (kIsWeb) {
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for web - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
73
VEHICLE POLLUTION MONITORING USING IoT
}
switch (defaultTargetPlatform) {
case TargetPlatform.android:
return android;
case TargetPlatform.iOS:
return ios;
case TargetPlatform.macOS:
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for macos - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
case TargetPlatform.windows:
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for windows - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
case TargetPlatform.linux:
throw UnsupportedError(
'DefaultFirebaseOptions have not been configured for linux - '
'you can reconfigure this by running the FlutterFire CLI again.',
);
default:
throw UnsupportedError(
'DefaultFirebaseOptions are not supported for this platform.',
);
}
}
static const FirebaseOptions android = FirebaseOptions(
apiKey: 'AIzaSyASUrcasjS6raxm4GDywW_zVBAj-TOFUFA',
appId: '1:210223083459:android:ce17b6a6a415c511b91776',
messagingSenderId: '210223083459',
projectId: 'vehiclepollutionmonitori-8c43d',
storageBucket: 'vehiclepollutionmonitori-8c43d.appspot.com',
);
74
VEHICLE POLLUTION MONITORING USING IoT
3. Authentication Controller :-
import 'package:flutter/material.dart';
import 'package:firebase_auth/firebase_auth.dart';
class AuthController extends ChangeNotifier {
Future<UserCredential?> userSignIn({email, pass}) async {
UserCredential? user;
try {
user = await FirebaseAuth.instance
.signInWithEmailAndPassword(email: email, password: pass);
} on FirebaseAuthException catch (e) {
print(e);
}
return user;
}
}
4. Challan controller :-
import 'dart:convert';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:rsm/consts/consts.dart';
import 'package:http/http.dart' as http;
import 'package:rsm/consts/email_format.dart';
class ChallansController extends ChangeNotifier {
75
VEHICLE POLLUTION MONITORING USING IoT
int selectedChallans = 0;
String selectedVehicleUid = "";
set updateChallan(int value) {
selectedChallans = value;
notifyListeners();
}
Future<void> sendEmail({to, ppm, name, vehicleNumber}) async {
try {
final Uri url = Uri.parse('http://3.147.78.78:80/send-email');
76
VEHICLE POLLUTION MONITORING USING IoT
await challansCollection.add({
'ppm': ppm,
'date': getCurrentDateTimeString(),
'due_date': getDateAfterOneMonth(),
'fine': "500",
'paid_status': "pending",
'uid': uid,
'vehicle_name': vehicleName,
'vehicle_no': vehicleNo,
});
sendEmail(to: email, ppm: ppm, name: name, vehicleNumber: vehicleNo);
updateChallanStatus(docId);
print('Challan document added successfully.');
} catch (error) {
print('Error adding challan document: $error');
}
}
Future<void> updateChallanStatus(String vehicleId) async {
try {
// Get a reference to the Firestore instance
FirebaseFirestore firestore = FirebaseFirestore.instance;
// Reference to the "Vehicles" collection
CollectionReference vehiclesCollection = firestore.collection('Vehicles');
// Update the 'challan' field to true for the specified document ID
await vehiclesCollection.doc(vehicleId).update({'challan': true});
print('Challan status updated successfully.');
} catch (error) {
print('Error updating challan status: $error');
}
}}
77
VEHICLE POLLUTION MONITORING USING IoT
5. View Challan :-
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:rsm/consts/consts.dart';
import 'package:rsm/consts/list.dart';
import 'package:rsm/consts/margins_and_padding.dart';
import 'package:rsm/controllers/challans_controller.dart';
class ViewChallans extends StatelessWidget {
ViewChallans({super.key, this.vehicleData});
var vehicleData;
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
scrolledUnderElevation: 0,
centerTitle: false,
title: "${vehicleData['vehicle_number']}"
.text
.fontFamily(semibold)
.size(18)
.make(),
),
body: Container(
padding: screenPadding.copyWith(top: 20),
width: double.infinity,
child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: [
Column(
children: [
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Owner Name".text.fontFamily(semibold).make(),
"${vehicleData['username']}".text.fontFamily(semibold).make()
],
),
78
VEHICLE POLLUTION MONITORING USING IoT
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Vehicle Company".text.fontFamily(semibold).make(),
"${vehicleData['vehicle_brand']}"
.text
.fontFamily(semibold)
.make()
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"model".text.fontFamily(semibold).make(),
"${vehicleData['vehicle_model']}"
.text
.fontFamily(semibold)
.make()
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Insurance".text.fontFamily(semibold).make(),
"${vehicleData['insurance_status']}"
.text
.fontFamily(semibold)
.make()
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"PPM Value".text.fontFamily(semibold).make(),
79
VEHICLE POLLUTION MONITORING USING IoT
"${vehicleData['ppm']}".text.fontFamily(semibold).make()
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Device Status".text.fontFamily(semibold).make(),
vehicleData['device_installed'] == true
? "Installed"
.text
.fontFamily(semibold)
.color(Colors.green)
.make()
: "Not Installed"
.text
.color(Colors.red)
.fontFamily(semibold)
.make()
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Email".text.fontFamily(semibold).make(),
"${vehicleData['login_email']}"
.text
.fontFamily(semibold)
.make()
],
),
],
)
.box
.border(color: borderColor)
80
VEHICLE POLLUTION MONITORING USING IoT
.roundedSM
.padding(EdgeInsets.all(12))
.make(),
20.heightBox,
"Challans".text.fontFamily(semibold).size(18).make(),
10.heightBox,
Consumer<ChallansController>(builder: (context, controller, xxx) {
return Row(
children: List.generate(
Challans.length,
(index) => "${Challans[index]}"
.text
.color(controller.selectedChallans == index
? Colors.white
: blueColor)
.make()
.box
.border(color: blueColor)
.roundedSM
.color(controller.selectedChallans == index
? blueColor
: Colors.white)
.padding(
EdgeInsets.symmetric(horizontal: 10, vertical: 6),
)
.margin(
EdgeInsets.only(right: 10),
)
.make()
.onTap(() {
controller.updateChallan = index;
}),
),
);
81
VEHICLE POLLUTION MONITORING USING IoT
}),
20.heightBox,
Expanded(
child: Consumer<ChallansController>(
builder: (context, controller, xx) {
return StreamBuilder<QuerySnapshot>(
stream: controller.selectedChallans == 0
? FirebaseFirestore.instance
.collection('Challans')
.where('uid', isEqualTo: controller.selectedVehicleUid)
.where('paid_status', isEqualTo: 'pending')
.snapshots()
: FirebaseFirestore.instance
.collection('Challans')
.where('uid', isEqualTo: controller.selectedVehicleUid)
.where('paid_status', isEqualTo: 'paid')
.snapshots(),
builder: (context, snapshot) {
if (snapshot.hasError) {
return Text('Error: ${snapshot.error}');
}
if (snapshot.connectionState == ConnectionState.waiting) {
return SizedBox(
width: 10,
height: 10,
child: SizedBox(
width: 20,
height: 20,
child: Center(
child: CircularProgressIndicator(
color: blueColor,
),
),
),
82
VEHICLE POLLUTION MONITORING USING IoT
);
}
// Check if there are no pending documents
if (snapshot.data!.docs.isEmpty) {
return Center(
child: Text('No Challans found.'),
);
}
// Display the list of pending documents
return ListView.builder(
padding: EdgeInsets.all(0),
// itemCount: 10,
itemCount: snapshot.data!.docs.length,
itemBuilder: (context, index) {
var document = snapshot.data!.docs[index];
// Access the document data using document.data()
var data = document.data() as Map<String, dynamic>;
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"${data['vehicle_no']}"
.text
.fontFamily(semibold)
.size(16)
.make(),
"₹ ${data['fine']}"
.text
.color(data['paid_status'] == "paid"
? Colors.green
: Colors.red)
.fontFamily(semibold)
83
VEHICLE POLLUTION MONITORING USING IoT
.size(16)
.make(),
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"PPM ".text.size(16).make(),
"${data['ppm']}".text.size(16).make(),
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Date ".text.size(16).make(),
"${data['date']}".text.size(16).make(),
],
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
"Due Date ".text.size(16).make(),
"${data['due_date']}".text.size(16).make(),
],
),
],
)
.box
.border(color: borderColor)
.padding(EdgeInsets.all(12))
.roundedSM
.margin(
EdgeInsets.only(
bottom: 20,
84
VEHICLE POLLUTION MONITORING USING IoT
),
)
.make();
},
);
},
);
}),
),
]),
),
);
}
}
7. Area :-
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
import 'package:rsm/consts/consts.dart';
String getAirQualityFeedback(double sensorValue) {
// Define threshold values for different air quality levels
int goodThreshold = 200; // Example threshold for good air quality
int moderateThreshold = 400; // Example threshold for moderate air quality
int poorThreshold = 600; // Example threshold for poor air quality
85
VEHICLE POLLUTION MONITORING USING IoT
86
VEHICLE POLLUTION MONITORING USING IoT
87
VEHICLE POLLUTION MONITORING USING IoT
GoogleMap(
mapToolbarEnabled: false,
myLocationButtonEnabled: false,
markers: {
Marker(
markerId: MarkerId("moudle1"),
position: LatLng(lat, lon),
infoWindow: InfoWindow(
title: "$ppm ${getAirQualityFeedback(
double.parse(ppm),
)}",
),
)
},
circles: {
Circle(
circleId:
CircleId("your_unique_id"), // Unique identifier
center: LatLng(lat, lon), // Center coordinates
radius: 350, // Radius in meters
fillColor: getAirQualityColor(double.parse("600.0")),
// Fill color with opacity
strokeColor: Colors.transparent,
strokeWidth: 1
// Stroke width in pixels
)
},
initialCameraPosition:
CameraPosition(target: LatLng(lat, lon), zoom: 16),
),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Column(
88
VEHICLE POLLUTION MONITORING USING IoT
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
zone.text.fontFamily(semibold).size(16).make(),
getAirQualityFeedback(double.parse(ppm)).text.make()
],
),
"$ppm"
.text
.fontFamily(semibold)
.size(16)
.color(Colors.green)
.make()
],
)
.box
.white
.padding(EdgeInsets.all(12))
.roundedSM
.make()
.marginAll(12)
],
);
}),
);
}
}
8. Sign-in Authentication :-
import '../../consts/consts.dart';
class SignInScreen extends StatelessWidget {
SignInScreen({super.key});
final _key = GlobalKey<FormState>();
TextEditingController emailField = TextEditingController();
89
VEHICLE POLLUTION MONITORING USING IoT
90
VEHICLE POLLUTION MONITORING USING IoT
9. Sign-Up Authentication :-
import 'package:flutter/material.dart';
import 'package:rsm/consts/typography.dart';
import 'package:rsm/views/shared_widgets/custom_text_field.dart';
import 'package:velocity_x/velocity_x.dart';
class SignUpScreen extends StatelessWidget {
SignUpScreen({super.key});
final _formKey = GlobalKey<FormState>();
@override
Widget build(BuildContext context) {
var height = MediaQuery.of(context).size.height;
var width = MediaQuery.of(context).size.width;
return Scaffold(
91
VEHICLE POLLUTION MONITORING USING IoT
body: Container(
padding: const EdgeInsets.only(top: 60, left: 20, right: 20),
width: double.infinity,
child: Form(
key: _formKey,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
SizedBox(
height: height * 0.1,
),
"Create an account".text.fontFamily(semibold).size(22).make(),
10.heightBox,
customTextField(name: "Full Name", hint: "Enter your full name"),
customTextField(name: "Email", hint: "Enter Email"),
customTextField(
name: "Password", hint: "Enter your password", is_pass: true),
const SizedBox(
height: 20,
),
FilledButton(onPressed: () {}, child: const Text("Sign Up"))
],
),
),
),
);
}
}
92
VEHICLE POLLUTION MONITORING USING IoT
import 'package:rsm/consts/images.dart';
import 'package:rsm/consts/typography.dart';
import 'package:rsm/views/auth_screen/sign_in_screen.dart';
import 'package:velocity_x/velocity_x.dart';
class SplashScreen extends StatelessWidget {
const SplashScreen({super.key});
@override
Widget build(BuildContext context) {
Future.delayed(Duration(seconds: 1), () {
FirebaseAuth.instance.userChanges().listen(
(value) {
if (value == null) {
Get.off(
() => SignInScreen(),
transition: Transition.fadeIn,
duration: Duration(milliseconds: 500),
);
} else {
Get.offAll(() => Home());
}
},
);
});
return Scaffold(
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Image(
width: 250,
image: AssetImage(
ig_logo,
),
),
93
VEHICLE POLLUTION MONITORING USING IoT
20.heightBox,
"RSM\nPOLYTECHNIC"
.text
.size(18)
.align(TextAlign.center)
.fontFamily(semibold)
.make()
],
),
),
);
}
}
getColor(value) {
if (value > 100) {
return Colors.red;
} else if (value > 50) {
return Colors.orange;
} else {
return Colors.green;
}
}
94
VEHICLE POLLUTION MONITORING USING IoT
@override
Widget build(BuildContext context) {
var challanController =
Provider.of<ChallansController>(context, listen: false);
return Scaffold(
appBar: AppBar(
scrolledUnderElevation: 0,
centerTitle: false,
title: "Vehicles Information".text.fontFamily(semibold).make(),
),
body: Container(
width: double.infinity,
padding: const EdgeInsets.only(top: 10, left: 20, right: 20),
child: Column(
children: [
Row(
children: [
Expanded(
child: TextField(
controller: searchField,
decoration: const InputDecoration(
border: InputBorder.none,
isDense: true,
hintText: "Search Vehicles"),
),
),
Icon(
Icons.search,
color: borderColor,
)
],
)
.box
.roundedSM
95
VEHICLE POLLUTION MONITORING USING IoT
.border(color: borderColor)
.padding(
const EdgeInsets.symmetric(horizontal: 20),
)
.make(),
20.heightBox,
Expanded(
child: StreamBuilder<QuerySnapshot>(
stream: FirebaseFirestore.instance
.collection('Vehicles')
.where('vehicle_added', isEqualTo: true)
.snapshots(),
builder: (context, snapshot) {
if (snapshot.hasError) {
return Text('Error: ${snapshot.error}');
}
if (snapshot.connectionState == ConnectionState.waiting) {
return Center(
child: SizedBox(
width: 10,
height: 10,
child: CircularProgressIndicator()),
);
}
// Display the list of documents
return ListView.builder(
padding: const EdgeInsets.all(0),
itemCount: snapshot.data!.docs.length,
itemBuilder: (context, index) {
var document = snapshot.data!.docs[index];
String owner_name = document['username'];
// String contact = document['contact_no'];
String email = document['login_email'];
String insurance_status = document['insurance_status'];
96
VEHICLE POLLUTION MONITORING USING IoT
97
VEHICLE POLLUTION MONITORING USING IoT
],
),
20.heightBox,
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
"Owner".text.make(),
owner_name.text.fontFamily(semibold).make()
],
),
Container(
height: 30,
width: 1,
decoration: BoxDecoration(color: Colors.black),
),
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
"type".text.make(),
type.text.fontFamily(semibold).make()
],
),
Container(
height: 30,
width: 1,
decoration: BoxDecoration(color: Colors.black),
),
Column(
crossAxisAlignment: CrossAxisAlignment.end,
children: [
"Insurance".text.make(),
98
VEHICLE POLLUTION MONITORING USING IoT
insurance_status.text
.fontFamily(semibold)
.make()
],
),
],
),
],
)
.box
.roundedSM
.border(color: borderColor)
.padding(
const EdgeInsets.all(16),
)
.margin(EdgeInsets.only(bottom: 15))
.make()
.onTap(() {
challanController.selectedVehicleUid = document['uid'];
Get.to(
() => ViewChallans(vehicleData: document),
);
});
},
);
},
),
),
],
),
),
);
}
}
99
VEHICLE POLLUTION MONITORING USING IoT
100
VEHICLE POLLUTION MONITORING USING IoT
await FirebaseAuth.instance.signOut();
Get.offAll(() => SplashScreen());
},
trailing: Icon(
Icons.arrow_forward_ios,
color: blueColor,
),
title: "Sign Out".text.make(),
).box.border(color: borderColor).roundedSM.make()
],
),
),
);
}
}
101
VEHICLE POLLUTION MONITORING USING IoT
Chapter No. 12
FEASIBILITY STUDY
Project Overview:
IoT technology offers real-time monitoring and data collection capabilities, enabling efficient
tracking of vehicle emissions. The goal is to develop a scalable solution that can be deployed in
urban areas to monitor and mitigate air pollution from vehicles.
Market Analysis:
The market for pollution monitoring solutions is growing rapidly due to increasing
environmental concerns and stricter regulations. Competitors may include established
environmental monitoring companies and startups offering IoT-based solutions. Market trends
indicate a shift towards smart cities and sustainable development, creating opportunities for
innovative pollution monitoring technologies.
Technical Feasibility:
IoT sensors for pollution monitoring have advanced significantly, with high accuracy and
reliability. Integration with existing vehicle systems may require collaboration with automotive
manufacturers or aftermarket device installation.
Connectivity options like cellular networks or LPWAN technologies (e.g., LoRaWAN) can
facilitate data transmission. Potential challenges include sensor calibration, data interoperability,
and power management for IoT devices.
Cost Analysis:
Initial costs include sensor procurement, hardware development, and software engineering.
Ongoing operational costs may include data storage, maintenance, and network connectivity
fees. Potential revenue streams could come from selling data to governments, municipalities, or
private companies for environmental monitoring purposes.
Risk Assessment:
102
VEHICLE POLLUTION MONITORING USING IoT
Environmental Impact:
Implementation of IoT-based pollution monitoring can lead to significant reductions in harmful
emissions, contributing to improved air quality and public health. However, there may be
environmental concerns related to the manufacturing and disposal of IoT devices, which need to
be addressed through sustainable practices.
12.2 Analysis
1. Sensor Technology:
Feasibility: Advances in sensor technology enable the development of highly sensitive and
accurate pollution monitoring devices capable of detecting various pollutants emitted by
vehicles.
Feasibility: IoT platforms provide scalable solutions for real-time data collection from
distributed sensor networks installed in urban areas.
103
VEHICLE POLLUTION MONITORING USING IoT
Feasibility: Integration with onboard vehicle systems or retrofitting vehicles with IoT devices
allows for seamless data collection and transmission.
Challenges: Compatibility issues with different vehicle makes and models, as well as variations
in vehicle emissions control systems. Retrofitting existing vehicles with IoT devices may be
costly and require specialized expertise.
Feasibility: Data analytics techniques, including machine learning algorithms, enable the
processing and analysis of large volumes of pollution data to identify trends, patterns, and
pollution hotspots.
Challenges: Ensuring the accuracy and reliability of data analysis results, particularly in
dynamic urban environments with complex interactions between vehicles, infrastructure, and
weather conditions. Data privacy concerns may arise when processing and sharing sensitive
environmental data.
5. Power Management:
Feasibility: Low-power IoT devices and energy-efficient sensor technologies allow for
prolonged operation without frequent battery replacements.
Challenges: Balancing power consumption with data collection frequency and transmission
intervals to maximize device uptime while minimizing energy usage. Implementing efficient
power management strategies in remote or inaccessible deployment locations may be
challenging.
Feasibility: IoT-based solutions offer scalability to deploy and manage large-scale pollution
monitoring networks across urban areas.
104
VEHICLE POLLUTION MONITORING USING IoT
105
VEHICLE POLLUTION MONITORING USING IoT
Chapter No. 13
ADVANTAGES AND LIMITATIONS
Advantages: -
1. Real-Time Monitoring: IoT enables continuous and real-time monitoring of vehicle emissions,
providing instant insights into pollution levels in urban areas. This allows for prompt
interventions and mitigation measures to address pollution hotspots.
2. Data Accuracy and Granularity: IoT sensors provide accurate and granular data on various
pollutants emitted by vehicles, including nitrogen oxides (NOx), particulate matter (PM),
carbon monoxide (CO), and hydrocarbons. This detailed data enables better understanding and
management of air quality issues.
4. Scalability: IoT platforms allow for the deployment of scalable monitoring networks across
large geographical areas. Multiple sensors can be deployed in urban environments to cover
diverse locations and monitor pollution levels effectively.
5. Predictive Analytics: Data collected from IoT sensors can be analyzed using advanced
analytics techniques, such as machine learning algorithms. This enables the prediction of
pollution trends, identification of pollution sources, and optimization of pollution control
strategies.
6. Environmental Protection: By providing accurate and timely data on vehicle emissions, IoT-
based monitoring helps in enforcing emissions regulations and implementing targeted
interventions to reduce pollution levels.
7. Public Health Benefits: Improved air quality resulting from effective pollution monitoring
leads to numerous public health benefits. Reduced exposure to harmful pollutants lowers the
risk of respiratory diseases, cardiovascular problems, and other health issues associated with air
pollution.
8. Policy Support: IoT-based pollution monitoring aligns with government initiatives and
environmental policies aimed at reducing vehicle emissions and improving air quality. It
provides policymakers with actionable data to develop evidence-based regulations and
strategies for pollution control.
106
VEHICLE POLLUTION MONITORING USING IoT
10. Technological Innovation: Implementing IoT for vehicle pollution monitoring drives
technological innovation in environmental monitoring and sustainability. It encourages the
development of new sensor technologies, data analytics tools, and smart city solutions to
address complex urban challenges.
107
VEHICLE POLLUTION MONITORING USING IoT
Chapter No. 14
APPLICATIONS
2) Fleet Management: Companies with fleets of vehicles can use IoT sensors to monitor emissions
from each vehicle in real-time. This data can help in optimizing routes, identifying poorly
performing vehicles, and scheduling maintenance to reduce emissions.
3) Urban Air Quality Monitoring: By deploying IoT sensors at various locations throughout a
city, authorities can monitor the impact of vehicle emissions on air quality. This data can be
used to implement targeted interventions, such as traffic management measures or emission
control zones.
4) Emission Hotspot Detection: IoT sensors installed in strategic locations can detect emission
hotspots, such as congested intersections or areas with heavy traffic. Authorities can then take
proactive measures to alleviate congestion or reroute traffic to reduce emissions in these areas.
5) Vehicle Inspection and Maintenance Programs: IoT-enabled vehicle inspection systems can
automatically assess emissions during routine inspections. If a vehicle exceeds emission limits,
alerts can be sent to the owner, prompting them to schedule maintenance to rectify the issue.
6) Public Health Monitoring: High levels of vehicle emissions can have adverse effects on public
health, leading to respiratory problems and other health issues. IoT-based pollution monitoring
systems can provide data to public health agencies, enabling them to take appropriate actions to
protect public health.
7) Compliance Monitoring: Governments can use IoT sensors to monitor compliance with
emission standards. By collecting and analyzing emission data from vehicles, authorities can
identify non-compliant vehicles and enforce regulations more effectively.
8) Consumer Awareness: IoT-enabled pollution monitoring systems can provide consumers with
real-time information about the environmental impact of their vehicles. This information can
influence consumer behavior, encouraging them to choose cleaner and more fuel-efficient
vehicles.
108
VEHICLE POLLUTION MONITORING USING IoT
9) Policy Evaluation and Planning: Governments can use IoT data to evaluate the effectiveness
of existing pollution control policies and develop evidence-based strategies to further reduce
emissions from vehicles.
109
VEHICLE POLLUTION MONITORING USING IoT
FUTURE SCOPE
Future Scope:
Deploy advanced IoT sensors and devices with higher sensitivity and precision to capture detailed data
on vehicle emissions.
Integrate multi-modal sensing technologies (e.g., gas sensors, particulate matter sensors, noise sensors)
to monitor various pollutants and environmental conditions simultaneously.
Implement edge computing and fog computing solutions to process and analyze data locally, reducing
latency and improving real-time monitoring capabilities.
Future Scope:
Develop AI and machine learning algorithms to analyze complex IoT-generated datasets and identify
patterns, correlations, and anomalies in vehicle pollution.
Build predictive models to forecast future pollution levels based on historical data, weather conditions,
traffic patterns, and other relevant factors.
Implement anomaly detection and predictive maintenance algorithms to identify and address sensor
malfunctions or performance issues proactively.
Future Scope:
Collaborate with city planners, transportation authorities, and infrastructure developers to integrate
pollution monitoring sensors into smart traffic management systems, intelligent transportation systems
(ITS), and smart city initiatives.
Utilize IoT data to optimize traffic flow, reduce congestion, and mitigate pollution hotspots through
adaptive traffic control, route optimization, and demand-responsive transportation solutions.
Future Scope:
Develop user-friendly IoT-based mobile and web applications to provide real-time pollution data,
110
VEHICLE POLLUTION MONITORING USING IoT
Future Scope:
Work closely with policymakers, legislators, regulatory bodies, and environmental agencies to advocate
for stricter emission standards, cleaner fuels, sustainable transportation solutions, and infrastructure
development.
Leverage IoT-generated data, insights, and evidence-based recommendations to inform policy
decisions, evaluate the effectiveness of pollution control measures, and drive continuous improvement
in environmental regulations and enforcement.
Future Scope:
Encourage interdisciplinary research and innovation in sensor technology, IoT devices, data analytics,
AI, machine learning, and environmental science to advance the field of vehicle pollution monitoring.
Collaborate with academic institutions, research organizations, industry partners, and technology
providers to explore new methodologies, best practices, and technological advancements in IoT-based
monitoring, mitigation, and management of vehicle pollution.
111
VEHICLE POLLUTION MONITORING USING IoT
CONCLUSION
In conclusion, implementing a project for vehicle pollution monitoring using IoT technology
presents a compelling solution to address the pressing environmental and public health challenges
posed by transportation emissions. By deploying IoT sensors in vehicles and urban infrastructure, real-
time data on emissions can be collected, analyzed, and utilized to inform evidence-based policy
decisions, optimize traffic management strategies, and empower individuals to make more sustainable
transportation choices. The future scope for this project is promising, with opportunities for
advancements in sensor technologies, data analytics, and collaborative initiatives to create smarter and
more sustainable transportation systems. Ultimately, by leveraging IoT technology for vehicle pollution
monitoring, we can work towards reducing emissions, improving air quality, and creating healthier and
more livable cities for current and future generations.
112
VEHICLE POLLUTION MONITORING USING IoT
REFERENCES
[1] Souvik Manna, Suman Sankar Bhunia, Nandini Mukherjee, Vehicular Pollution Monitoring U
sing loT, IEEE International Conference on Recent Advances and Innovations in Engineering
(ICRAIE-2014),May 09-11, 2014, Jaipur, India.
[2] Ramagiri Rushikesh, Chandra Mohan Reddy Sivappagari, Development of IoT based Vehicular
Pollution Monitoring System, International Conference on Green Computing and Internet of
Things (ICGCIoT) 2015.
[3] A.Rajalakshmi, S.Karthick, Dr.S.Valarmathy, Vehicular Pollution and Status Monitoring Using
IOT, International Journal of Advanced Research in Science, Engineering and Technology, Vol.
2, Issue 4 , April 2015.
[4] Prof. Vishal V. Pande, Rupesh A. Kale, Rupali S. Shirke, Jigar V. Chitroda, Aakash P. Panchal,
Online Vehicle Pollutants Monitoring System using GSM, International Journal of Advanced
Research in Electrical, Electronics and Instrumentation Engineering (An ISO 3297: 2007
Certified Organization)Vol. 4, Issue 4, April 2015.
[5] S.SMRUTHIE, G.SUGANYA, S.GOWRI, A.SIVANESHKUMAR, Vehicular pollution
monitoring using IoT, International Journal of Digital Communication and Networks
(IJDCN)Volume 2, Issue 12, December 15.
[6] Gopinath, S., Basha, S. H., Prabha, G., & Rajasekaran, M. P. (2018). Internet of Things (IoT)
based Smart Environmental Pollution Monitoring and Management System for Smart City.
Procedia Computer Science, 133, 615-622.
[7] Gupta, G., Choudhury, S., Yadav, A. K., & Yadav, A. (2018). Real-Time Monitoring of Vehicle
Emissions Using Internet of Things. 2018 4th International Conference on Computing Sciences
(ICCS).
[8] Han, B., Liu, W., Zhan, X., & Zhao, Y. (2018). An Internet of Things Approach for Extracting
the Impact of Traffic Pollution on Road Networks. Sensors, 18(6), 1794.
[9] Khan, T. U., Naqvi, M. R., Iqbal, M., Siddique, F., & Rashid, M. (2020). An IoT-Based Real-
Time Vehicle Emission Monitoring System. Sensors, 20(4), 1097.
113
VEHICLE POLLUTION MONITORING USING IoT
BIBLIOGRAPHY
1. https://copyright.gov.in/UserRegistration/frmLoginPage.aspx
2. https://www.ijsrd.com/
3. https://www.irjmets.com/uploadedfiles/paper//issue_1_january_2023/33097/final/fin_irjmets16
74484921.pdf
4. https://www.ijert.org/vehicle-pollution-monitoring-system-using-iot
5. https://ijrpr.com/uploads/V4ISSUE5/IJRPR13327.pdf
6. https://www.ijrte.org/wp-content/uploads/papers/v9i1/A1899059120.pdf
114
SmartX Prokits, Vedant Plaza, Chumble Marg, Near Ved Mandir, New CBS,Nashik
- 422001 Mo No – 7276757409 , 9421390933
CERTIFICATE OF COMPLETION
PROJECT MEMBERS –
PROJECT DESCRIPTION -
Yours Sincerely,
Acknowledgement Slip
(Date: 13/12/2023)
Communication Address
Name Address Phone Number
MVPS RAJARSHI SHAHU
MVPS RAJARSHI SHAHU MAHARAJ POLYTECHNIC
MAHARAJ POLYTECHNIC GANGAPUR ROAD NASHIK
-422013
Financial Details
Payment ID Amount Bank Name Payment Mode Payment Date
332084 500 13/12/2023
* For future communication please mention this DIARY No.
INSTRUCTIONS
For the purpose of processing the application, following documents are mandatory to send by post along
with the acknowledgement slip(Office Copy).
1. 2 Copies of work
2. DD/IPO of Rs.(as applicable) per work favouring Registrar Copyright Office payable at New Delhi (Not
applicable for online payment)
4. If the work is being used on goods or capable of being used on the goods
5. If the application is being field through attorney, a specific power of attorney in original duly signed by
the applicant and accepted by the attorney
6. Search Certificate from Trade Mark Office(TM-60) (Only in case of Artistic work).
7. Applicant must take a print out of the application, sign it and send along with the other documents.
Kindly send the above documents within 30 Days from the date of online submission on the following
address given by herewith: .
***APPLICANT'S COPY***
THANK YOU
about:blank 1/2
4/14/24, 2:16 AM Copyright Office
Acknowledgement Slip
(Date:13/12/2023)
Communication Address
Name Address Phone Number
MVPS RAJARSHI SHAHU
MVPS RAJARSHI SHAHU MAHARAJ POLYTECHNIC
MAHARAJ POLYTECHNIC GANGAPUR ROAD NASHIK
-422013
Financial Details
Payment ID Amount Bank Name Payment Mode Payment Date
332084 500 13/12/2023
* For future communication please mention this DIARY No.
INSTRUCTIONS
For the purpose of processing the application, following documents are mandatory to send by post along
with this acknowledgement slip(Applicant's Copy).
1. 2 Copies of work
2. DD/IPO of Rs.(as applicable) per work favouring Registrar Copyright Office payable at New Delhi (Not
applicable for online payment)
4. If the work is being used on goods or capable of being used on the goods
5. If the application is being field through attorney, a specific power of attorney in original duly signed by
the applicant and accepted by the attorney
6. Search Certificate from Trade Mark Office(TM-60) (Only in case of Artistic work).
7. Applicant must take a print out of the application, sign it and send along with the other documents.
Kindly send the above documents within 30 Days from the date of online submission on the following
address given by herewith: .
***OFFICE COPY***
THANK YOU
about:blank 2/2
OUR PUBLICATION AND CERTIFICATION
IJSRD - International Journal for Scientific Research & Development| Vol. 11, Issue 12, 2024 | ISSN (online): 2321-0613
sensor part of the hardware LM35 as our temperature sensor analog signals like sound, light, temperature) to digital
and A/D converter for conversion of analog signals to digital signals like the computers. This process allows one from real-
signals. world to get the analog data in the human understandable
1) Node MCU (Microcontroller): language.
The main working of the node MCU that is the
microcontroller has the major role in this project covering all
the connections and integrations part on a motherboard.
Mainly this is the connecting block of the software part and
the hardware part of the project.
IV. CONCLUSION
This Project represents the design and development of
vehicular pollution monitoring system. The developed
system checks the pollution level emitted by the vehicles and
if it is above the threshold, a warning message will be sent to
the vehicular owner using the GSM module. These data are
finally stored in a cloud for future analysis. This idea differs
from the existing system that the vehicle owner gets an
awareness about the emission level without going for a
checking process. The main objective is we will be aware of
the pollution level from the vehicles. Hence a solution for
global warming.
A. Future scope:
In future as the number of vehicles will increase the pollution
will also increase. The air quality will become worse in future
so it is necessary to control the pollution as it can adversely
affect human health and can cause severe diseases like lung
cancer, astama, respiratory problems and many more. So
through our project the pollution will be in control and the
vehicles causing pollution will be detected.
REFERENCES
[1] Souvik Manna, Suman Sankar Bhunia, Nandini
Mukherjee, Vehicular Pollution Monitoring U sing loT,
IEEE International Conference on Recent Advances and
Innovations in Engineering (ICRAIE-2014),May 09-11,
2014, Jaipur, India.
[2] Ramagiri Rushikesh, Chandra Mohan Reddy
Sivappagari, Development of IoT based Vehicular