cognifront - User contributions [en]

Experiment 1: Introduction to Arduino and Digital I/O Control

2026-10-19T03:21:40Z

CogWikiEditor: /* Circuit Connections */

== Experiment 1: Introduction to Arduino and Digital I/O Control ==

=== Objective ===
To understand digital input/output operations by interfacing LEDs and push buttons with Arduino.

=== Task ===
# Connect LEDs and push buttons to Arduino.
# Write a program to turn LEDs ON/OFF based on button press.
# Observe the response on the Serial Monitor.

<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your Arduino from the computer while making or removing component connections.
</span>

=== Circuit Diagram ===
[[File:Eecit-kit-01-circuit.png|center|thumb|400px|Circuit Diagram]]

=== Board Connections ===
[[File:Eecit-kit-01-board-connection.png|center|thumb|400px|Board Connections]]

=== Circuit Connections (Simple)===

{| class="wikitable" style="text-align:center;"
! Push Button !! Arduino Pin
|-
| Push Button 1 || 5
|-
| Push Button GND || GND
|-
| Push Button VCC || 5V
|}

{| class="wikitable" style="text-align:center;"
! LED Bar !! Arduino Pin
|-
| LED 1 || 7
|-
|LED GND || GND
|}
* '''Serial Communication:''' 9600 baud rate

=== Circuit Connections (Advanced)===

{| class="wikitable" style="text-align:center;"
! Push Button !! Arduino Pin
|-
| Push Button 1 || 5
|-
| Push Button 2 || 4
|-
| Push Button 3 || 2
|-
| Push Button 4 || 3
|-
| Push Button GND || GND
|-
| Push Button VCC || 5V
|}

{| class="wikitable" style="text-align:center;"
! LED Bar !! Arduino Pin
|-
| LED 1 || 7
|-
| LED 2 || 8
|-
| LED 3 || 9
|-
| LED 4 || 10
|-
|LED GND || GND
|}
* '''Serial Communication:''' 9600 baud rate

=== Arduino Code (Simple)===
<pre>
// © 2025, Cognifront. Member of The IoT Kits Family.
// Experiment 1: Introduction to Arduino and Digital I/O Control
// Define push button input pins
int push1Pin = 5;

// Variables to store button states
int push1Value;

// Define LED output pins
int ledPin1 = 7;

void setup() {
// Start serial communication at 9600 baud for debugging
Serial.begin(9600);

// Set push button pins as inputs
pinMode(push1Pin, INPUT);
// Set LED pins as outputs
pinMode(ledPin1, OUTPUT);
Serial.println("System Initialized: Monitoring Push Buttons and LEDs...");
}

void loop() {
// Read the state of each push button (HIGH = pressed, LOW = not pressed)
push1Value = digitalRead(push1Pin);

// Determine LED states and print to Serial Monitor
if(push1Value == HIGH) {
digitalWrite(ledPin1, HIGH);
Serial.println("Button1 PRESSED → LED1 ON");
}

else {
// If no button is pressed, turn OFF all LEDs
digitalWrite(ledPin1, LOW);
Serial.println("No button pressed → All LEDs OFF");
}
// Print raw pushbutton states for debugging
Serial.print("Buttons: ");
Serial.print(push1Value);
delay(500); // Small delay for better readability in Serial Monitor
}
</pre>

=== Arduino Code (Advanced)===
<pre>
// © 2025, Cognifront. Member of The IoT Kits Family.

// Experiment 1: Introduction to Arduino and Digital I/O Control

// Define push button input pins
int push1Pin = 5;
int push2Pin = 4;
int push3Pin = 2;
int push4Pin = 3;

// Variables to store button states
int push1Value;
int push2Value;
int push3Value;
int push4Value;

// Define LED output pins
int ledPin1 = 7;
int ledPin2 = 8;
int ledPin3 = 9;
int ledPin4 = 10;

void setup() {
// Start serial communication at 9600 baud for debugging
Serial.begin(9600);

// Set push button pins as inputs
pinMode(push1Pin, INPUT);
pinMode(push2Pin, INPUT);
pinMode(push3Pin, INPUT);
pinMode(push4Pin, INPUT);

// Set LED pins as outputs
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);

Serial.println("System Initialized: Monitoring Push Buttons and LEDs...");
}

void loop() {
// Read the state of each push button (HIGH = pressed, LOW = not pressed)
push1Value = digitalRead(push1Pin);
push2Value = digitalRead(push2Pin);
push3Value = digitalRead(push3Pin);
push4Value = digitalRead(push4Pin);

// Determine LED states and print to Serial Monitor
if(push1Value == HIGH) {
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
Serial.println("Button1 PRESSED → LED1 ON");
}
else if(push2Value == HIGH) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
Serial.println("Button2 PRESSED → LED2 ON");
}
else if(push3Value == HIGH) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, HIGH);
digitalWrite(ledPin4, LOW);
Serial.println("Button3 PRESSED → LED3 ON");
}
else if(push4Value == HIGH) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, HIGH);
Serial.println("Button4 PRESSED → LED4 ON");
}
else {
// If no button is pressed, turn OFF all LEDs
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
Serial.println("No button pressed → All LEDs OFF");
}

// Print raw pushbutton states for debugging
Serial.print("Buttons: ");
Serial.print(push1Value);
Serial.print(" ");
Serial.print(push2Value);
Serial.print(" ");
Serial.print(push3Value);
Serial.print(" ");
Serial.println(push4Value);

delay(500); // Small delay for better readability in Serial Monitor
}
</pre>

=== Observation ===
* Pressing any button will turn ON the corresponding LED.
* Only one LED lights up at a time because of the ''else-if'' structure.
* Serial Monitor can be used to confirm button press readings.

=== Conclusion ===
This experiment demonstrates basic digital input and output control using Arduino.

=== Real Life Examples ===
Automated Assembly Line Control: Digital I/O is used to operate actuators, solenoids, and indicator lamps. For example, pressing a start button activates a conveyor motor, demonstrating machine automation control in manufacturing lines.

Experiment 1: Introduction to Arduino and Digital I/O Control

2026-10-19T03:20:40Z

CogWikiEditor: /* Arduino Code */

== Experiment 1: Introduction to Arduino and Digital I/O Control ==

=== Objective ===
To understand digital input/output operations by interfacing LEDs and push buttons with Arduino.

=== Task ===
# Connect LEDs and push buttons to Arduino.
# Write a program to turn LEDs ON/OFF based on button press.
# Observe the response on the Serial Monitor.

<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your Arduino from the computer while making or removing component connections.
</span>

=== Circuit Diagram ===
[[File:Eecit-kit-01-circuit.png|center|thumb|400px|Circuit Diagram]]

=== Board Connections ===
[[File:Eecit-kit-01-board-connection.png|center|thumb|400px|Board Connections]]

=== Circuit Connections ===

{| class="wikitable" style="text-align:center;"
! Push Button !! Arduino Pin
|-
| Push Button 1 || 5
|-
| Push Button 2 || 4
|-
| Push Button 3 || 2
|-
| Push Button 4 || 3
|-
| Push Button GND || GND
|-
| Push Button VCC || 5V
|}

{| class="wikitable" style="text-align:center;"
! LED Bar !! Arduino Pin
|-
| LED 1 || 7
|-
| LED 2 || 8
|-
| LED 3 || 9
|-
| LED 4 || 10
|-
|LED GND || GND
|}
* '''Serial Communication:''' 9600 baud rate

=== Arduino Code (Simple)===
<pre>
// © 2025, Cognifront. Member of The IoT Kits Family.
// Experiment 1: Introduction to Arduino and Digital I/O Control
// Define push button input pins
int push1Pin = 5;

// Variables to store button states
int push1Value;

// Define LED output pins
int ledPin1 = 7;

void setup() {
// Start serial communication at 9600 baud for debugging
Serial.begin(9600);

// Set push button pins as inputs
pinMode(push1Pin, INPUT);
// Set LED pins as outputs
pinMode(ledPin1, OUTPUT);
Serial.println("System Initialized: Monitoring Push Buttons and LEDs...");
}

void loop() {
// Read the state of each push button (HIGH = pressed, LOW = not pressed)
push1Value = digitalRead(push1Pin);

// Determine LED states and print to Serial Monitor
if(push1Value == HIGH) {
digitalWrite(ledPin1, HIGH);
Serial.println("Button1 PRESSED → LED1 ON");
}

else {
// If no button is pressed, turn OFF all LEDs
digitalWrite(ledPin1, LOW);
Serial.println("No button pressed → All LEDs OFF");
}
// Print raw pushbutton states for debugging
Serial.print("Buttons: ");
Serial.print(push1Value);
delay(500); // Small delay for better readability in Serial Monitor
}
</pre>

=== Arduino Code (Advanced)===
<pre>
// © 2025, Cognifront. Member of The IoT Kits Family.

// Experiment 1: Introduction to Arduino and Digital I/O Control

// Define push button input pins
int push1Pin = 5;
int push2Pin = 4;
int push3Pin = 2;
int push4Pin = 3;

// Variables to store button states
int push1Value;
int push2Value;
int push3Value;
int push4Value;

// Define LED output pins
int ledPin1 = 7;
int ledPin2 = 8;
int ledPin3 = 9;
int ledPin4 = 10;

void setup() {
// Start serial communication at 9600 baud for debugging
Serial.begin(9600);

// Set push button pins as inputs
pinMode(push1Pin, INPUT);
pinMode(push2Pin, INPUT);
pinMode(push3Pin, INPUT);
pinMode(push4Pin, INPUT);

// Set LED pins as outputs
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);

Serial.println("System Initialized: Monitoring Push Buttons and LEDs...");
}

void loop() {
// Read the state of each push button (HIGH = pressed, LOW = not pressed)
push1Value = digitalRead(push1Pin);
push2Value = digitalRead(push2Pin);
push3Value = digitalRead(push3Pin);
push4Value = digitalRead(push4Pin);

// Determine LED states and print to Serial Monitor
if(push1Value == HIGH) {
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
Serial.println("Button1 PRESSED → LED1 ON");
}
else if(push2Value == HIGH) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
Serial.println("Button2 PRESSED → LED2 ON");
}
else if(push3Value == HIGH) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, HIGH);
digitalWrite(ledPin4, LOW);
Serial.println("Button3 PRESSED → LED3 ON");
}
else if(push4Value == HIGH) {
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, HIGH);
Serial.println("Button4 PRESSED → LED4 ON");
}
else {
// If no button is pressed, turn OFF all LEDs
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
Serial.println("No button pressed → All LEDs OFF");
}

// Print raw pushbutton states for debugging
Serial.print("Buttons: ");
Serial.print(push1Value);
Serial.print(" ");
Serial.print(push2Value);
Serial.print(" ");
Serial.print(push3Value);
Serial.print(" ");
Serial.println(push4Value);

delay(500); // Small delay for better readability in Serial Monitor
}
</pre>

=== Observation ===
* Pressing any button will turn ON the corresponding LED.
* Only one LED lights up at a time because of the ''else-if'' structure.
* Serial Monitor can be used to confirm button press readings.

=== Conclusion ===
This experiment demonstrates basic digital input and output control using Arduino.

=== Real Life Examples ===
Automated Assembly Line Control: Digital I/O is used to operate actuators, solenoids, and indicator lamps. For example, pressing a start button activates a conveyor motor, demonstrating machine automation control in manufacturing lines.

MDM331AID/Experiment 8

2026-10-08T10:17:37Z

CogWikiEditor: /* ESP32 Code */

= Experiment: Transmit sensor data between an IoT device and a server =

== Aim ==
To develop an IoT application that uses the communication protocol to transmit sensor data between an IoT device and a server

== Objectives ==
* To understand the concept of IoT-based sensor data communication.
* To interface an DHT11 temperature sensor with an ESP32 development board.
* To read temperature data from the DHT11 sensor using the ESP32.
* To connect the ESP32 to a Wi-Fi network and transmit sensor data to a cloud server.
* To store and log the transmitted sensor data in CSV format.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer with Arduino IDE
| 1
|-
| 7
| Cloud IoT platform / server (Cognifront IoT Cloud)
| 1 account per user/student
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT enables sensor data to be transmitted to a remote server or cloud platform for storage and monitoring.

An IoT-based sensor data transmission system generally consists of:
* '''Sensor:''' Measures physical parameters and provides the measured data to the IoT device. In this experiment, the DHT11 is used to measure temperature and humidity.
* '''IoT device / Controller:''' Reads the sensor data, processes it and provides network connectivity. In this experiment, the ESP32 acts as the IoT device.
* '''Communication network:''' Provides connectivity between the IoT device and the server or cloud platform. The ESP32 uses Wi-Fi for communication.
* '''Cloud server:''' Receives and stores the sensor data transmitted by the ESP32. The cloud platform used in this experiment provides facilities for storing the sensor data.
* '''Data storage:''' The collected sensor data can be stored on the server and exported in CSV format for further use.

'''DHT11''' is a digital temperature and humidity sensor that measures temperature and relative humidity. Unlike an analog temperature sensor such as the LM35, the DHT11 provides digital sensor data through its data pin. The sensor contains temperature and humidity sensing elements along with internal signal-processing circuitry.

The ESP32 communicates with the DHT11 through its digital data pin. It reads the temperature and humidity values from the sensor and processes the received data. The ESP32 then connects to a Wi-Fi network and transmits the sensor data to the cloud server using the configured cloud communication mechanism.

The cloud server receives the temperature and humidity readings and stores them as data records. In this experiment, the sensor readings are collected at regular intervals and stored on the server. The stored data can be exported as a '''CSV (Comma-Separated Values)''' file, allowing the collected sensor data to be saved in a standard tabular format.

The overall data flow of the system is:

<pre>
DHT11 Temperature & Humidity Sensor
↓
ESP32
↓
Wi-Fi
↓
Cloud Server
↓
Data Storage / CSV
</pre>

This type of IoT-based data logging system can be used for applications such as environmental monitoring, indoor temperature and humidity monitoring, weather monitoring and other systems where sensor measurements need to be collected remotely and stored for later use.

== Actions: ==
# Write ESP32 code to read temperature data from the DHT11 sensor and send it to a cloud server using Wi-Fi.
# Display this reading on a web-based dashboard in real-time.
# Download readings data in CSV format.

== Setting Up Cloud ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 15px; text-align: center;">

<div>
[[File:cloud-01.png|frameless|300px|alt=Step 1]]
<br /><b>Step 1</b><br />Visit [https://www.cognifront.com www.cognifront.com] and scroll down to the footer section.
</div>

<div>
[[File:cloud-02.png|frameless|300px|alt=Step 2]]
<br /><b>Step 2</b><br />Click on the <b>IoT Cloud</b> option.
</div>

<div>
[[File:cloud-03.png|frameless|300px|alt=Step 3]]
<br /><b>Step 3</b><br />Click on <i>Login</i> or <i>Sign Up / Registration</i> to access your account.
</div>

<div>
[[File:cloud-04.png|frameless|300px|alt=Step 4]]
<br /><b>Step 4</b><br />After logging in, navigate to the <b>Dashboard</b> section.
</div>

<div>
[[File:cloud-05.png|frameless|300px|alt=Step 5]]
<br /><b>Step 5</b><br />Click on <b>Create New App</b> to start a new cloud application.
</div>

<div>
[[File:cloud-06.png|frameless|300px|alt=Step 6]]
<br /><b>Step 6</b><br />Enter your app name — for example, <b>Data Logger</b>.
</div>

<div>
[[File:cloud-07.png|frameless|300px|alt=Step 7]]
<br /><b>Step 7</b><br />Your dashboard will update and display the newly created app.
</div>

<div>
[[File:cloud-08.png|frameless|300px|alt=Step 8]]
<br /><b>Step 8</b><br />Each app shows buttons for <i>Edit</i>, <i>Delete</i>, <i>Launch</i>, and <i>API Key</i>.
</div>

<div>
[[File:cloud-09.png|frameless|300px|alt=Step 9]]
<br /><b>Step 9</b><br />Click <b>Edit App</b> to open your app and create variables.
</div>

<div>
[[File:cloud-10.png|frameless|300px|alt=Step 10]]
<br /><b>Step 10</b><br />Click on <b>Create Variable</b> to define a new data variable.
</div>

<div>
[[File:cloud-11.png|frameless|300px|alt=Step 11]]
<br /><b>Step 11</b><br />Enter a variable name and select its type (defines input/output behavior).
</div>

<div>
[[File:cloud-12.png|frameless|300px|alt=Step 12]]
<br /><b>Step 12</b><br />For example: Name – <b>LM35</b>, Type – <b>Continuous</b>.
</div>

<div>
[[File:cloud-13.png|frameless|300px|alt=Step 13]]
<br /><b>Step 13</b><br />Return to the home page and click <b>View App</b> to launch your application.
Congratulations! Your cloud app is now ready.
</div>

<div>
[[File:cloud-14.png|frameless|400px|alt=Step 14]]
<br /><b>Step 14</b><br />Open the program folder — you will find two files:
<i>eecit-exp-06-data-logger.ino</i> (main program) and <i>cogcloudesp.h</i> (library header file).
Open the <b>.ino</b> file in Arduino IDE.
</div>

<div>
[[File:cloud-15.png|frameless|400px|alt=Step 15]]
<br /><b>Step 15</b><br />Ensure the <b>cogcloudesp.h</b> header file is included properly in your project.
</div>

<div>
[[File:cloud-16.png|frameless|300px|alt=Step 16]]
<br /><b>Step 16</b><br />Update your code with your Wi-Fi SSID, password, and API key.
A stable internet connection is required.
</div>

<div>
[[File:cloud-17.png|frameless|300px|alt=Step 17]]
<br /><b>Step 17</b><br />Change the variable name in your code to match the one you created in the cloud app.
</div>

<div>
[[File:code-esp32-upload-settings.png|frameless|300px|alt=Step 18]]
<br /><b>Step 18</b><br />Connect your ESP32 to your computer and upload the code.
</div>

<div>
[[File:cloud-19.png|frameless|300px|alt=Step 19]]
<br /><b>Step 19</b><br />Open or launch your cloud app to visualize real-time sensor data from the <b>LM35</b>.
</div>

<div>
[[File:cloud-20.png|frameless|300px|alt=Step 20]]
<br /><b>Step 20</b><br />In the app settings, click the <b>Download .CSV</b> button to export data.
</div>

<div>
[[File:cloud-21.png|frameless|300px|alt=Step 21]]
<br /><b>Step 21</b><br />Set the desired time range for data export, or leave it blank to download all records.
</div>

<div>
[[File:cloud-22.png|frameless|300px|alt=Step 22]]
<br /><b>Step 22</b><br />Open the downloaded <b>.CSV</b> file in Microsoft Excel to view the logged data.
</div>

</div>

== Circuit & Board Connections ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; text-align: center; align-items: start;">

<div>
[[File:eecit-esp32-06.png|frameless|400px|alt=Circuit Diagram]]
<br /><b>Circuit Diagram</b><br />
The complete connection diagram of ESP32-based setup.
</div>

<div>
[[File:eecit-kit-esp32-06.png|frameless|400px|alt=Board Connections]]
<br /><b>Board Connections</b><br />
Actual board wiring layout showing sensor and module connections.
</div>

</div>

== Pin Connections ==

The following connections are based on the ESP32 and DHT11 configuration used in the program.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| GND
| GND
| Ground connection
|-
| VCC
| VIN (5V supply)
| Power supply
|-
| DATA / VOUT
| GPIO4
| Analog temperature output
|}

The USB cable connects the ESP32 to the computer. The computer runs the Arduino IDE and uploads your code to ESP32.
<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your ESP32 from the computer while making or removing component connections.
</span>

== ESP32 Code ==
<pre>
// © 2026, Cognifront. Member of The IoT Kits Family.
// DHT11 Temperature Data Logging Using ESP32 and Cognifront Cloud

#include "cogcloudesp.h"
#include <DHT.h>

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);

String ssid = "********"; // Wi-Fi / hotspot name
String pass = "********"; // Wi-Fi / hotspot password

String apikey = "YOUR_API_KEY_HERE"; // API key from Cognifront Cloud

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

dht.begin();

// Initialize Cognifront Cloud
cogInitCloud(ssid, pass, apikey);

Serial.println("DHT11 Temperature Monitoring Started");
}

void loop()
{
// Handle cloud communication
cogAppLoop();

// Read temperature in Celsius
float temperature = dht.readTemperature();

// Check for sensor reading failure
if (isnan(temperature))
{
Serial.println("Failed to read temperature from DHT11");
delay(2000);
return;
}

// Display temperature on Serial Monitor
Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");

// Send temperature to Cognifront Cloud
cogStoreCloudVariable("DHT11", String(temperature, 2));

delay(2000);
}

</pre>

<div style="text-align: center; margin-top: 25px;">
[[:Media:eecit-exp-06-data-logger.zip|<span style="background-color:#007BFF;color:white;padding:10px 20px;border-radius:8px;text-decoration:none;font-weight:bold;">⬇ Click Here to Download Code File</span>]]
<br />
<span style="font-size: 90%;">(Contains ESP32 source code)</span>
<br />
[[File:Code-esp32-upload-settings.png|frameless|400px|alt=Board Connections]]
<br />
Connect your ESP32 to your computer and upload the code make sure right port selected.
</div>

== Observation ==
* The ESP32 successfully reads temperature data from the DHT11 sensor.
* Data is properly being logged in CSV file, and file is downloaded successfully.

== Conclusion ==
This experiment demonstrates how to log real-time sensor data from ESP32 to a computer using cloud communication.



== Real Life Example ==
Condition Monitoring in Machines and Data Logging: Sensors collect data such as vibration, temperature, or pressure from mechanical systems, which is logged and analysed for predictive maintenance and fault diagnosis. Also this data can be fed for training a machine learning model.

MDM331AID/Experiment 14

2026-10-08T03:50:49Z

CogWikiEditor: /* Working Principle */

= Experiment: Smart Threshold Alerts for Data Minimization using Privacy-by-Design =

== Aim ==

To design and implement a Privacy-by-Design IoT system using a vibration sensor and ESP32 that detects excessive vibration using a predefined threshold and generates an alert only when the threshold condition is reached, thereby minimizing unnecessary sensor data transmission.

== Objectives ==

# To understand Privacy-by-Design in an IoT system.
# To understand the concept of data minimization.
# To interface a vibration sensor with ESP32.
# To detect vibration activity using the sensor.
# To define a threshold for excessive vibration.
# To generate an EXCESSIVE VIBRATION alert when the threshold is crossed.
# To process vibration data locally on the ESP32.
# To avoid continuously transmitting raw vibration readings.
# To expose only the required alert information.
# To demonstrate data minimization through a simple web-based monitoring system.

== Components Required ==

{| class="wikitable"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| Reads the vibration sensor and hosts the web server
|-
| 2
| Vibration Sensor Module
| 1
| Detects vibration activity
|-
| 3
| Breadboard
| 1
| Circuit connections
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Smartphone
| 1
| Accesses the ESP32 web page
|-
| 6
| USB Cable
| 1
| Programming and powering ESP32
|-
| 7
| Computer with Arduino IDE
| 1
| Programming the ESP32
|}

== Theory ==

=== Internet of Things ===

The Internet of Things, or IoT, is a system in which physical devices use sensors and communication technologies to collect and exchange information.

In a conventional IoT system, sensor readings may be continuously transmitted even when the application does not require all of the readings.

For example, a vibration monitoring system may continuously generate sensor readings.

If the purpose of the application is only to detect excessive vibration, the application does not necessarily need every individual sensor reading.

The ESP32 can instead process the vibration activity locally and generate an alert only when the required condition occurs.

=== Privacy-by-Design ===

Privacy-by-Design means that privacy considerations are incorporated into the design of a system from the beginning.

One important approach related to Privacy-by-Design is data minimization.

Data minimization means collecting, processing, transmitting, and storing only the information that is necessary for the intended purpose.

In this experiment, the purpose is to detect excessive vibration.

Therefore, the system does not need to continuously expose every raw vibration reading.

The ESP32 processes the vibration activity locally and generates an alert only when the predefined threshold condition is reached.

=== Smart Threshold Alert ===

A threshold is a predefined value used to determine when a particular condition has occurred.

The ESP32 monitors the vibration sensor and keeps track of vibration activity.

When the number of detected vibration events reaches the selected threshold within the monitoring period, the ESP32 considers the vibration level excessive.

The operation is:

<pre>
Vibration Sensor
|
v
ESP32
|
v
Monitor vibration activity
|
v
Check threshold
|
+----------------------+
| |
v v
Normal vibration Excessive vibration
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The threshold can be adjusted according to the sensor and the required application.

=== Data Minimization ===

In a conventional system, raw vibration readings may be continuously sent to another device or server.

In the proposed system:

<pre>
Vibration Sensor
|
v
Local processing on ESP32
|
v
Count vibration activity
|
v
Check threshold
|
+----------------------+
| |
v v
Below threshold Threshold reached
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The raw vibration activity is processed locally for decision making.

Unnecessary continuous sensor data is therefore not exposed outside the device.

== Sensor Connection ==

The vibration sensor module normally provides VCC, GND, and a digital output pin.

{| class="wikitable"
! Vibration Sensor Pin
! ESP32
! Description
|-
| VCC
| 3.3V
| Sensor power supply
|-
| DO or OUT
| GPIO 27
| Digital vibration signal
|-
| GND
| GND
| Common ground
|}

'''Note:''' The exact pin names may vary between vibration sensor modules. Verify the labels on the actual sensor before making the connections.

== Connection Diagram ==

<pre>
Vibration Sensor
+-------------+
| |
3.3V ---| VCC |
| |
GPIO 27 <---| DO / OUT |
| |
GND ----| GND |
+-------------+
|
|
ESP32
|
|
Wi-Fi Access Point
|
|
Smartphone Browser
|
|
192.168.1.4
</pre>

== Working Principle ==

The ESP32 works as a Wi-Fi Access Point and hosts a simple web server.

The smartphone connects directly to the Wi-Fi network created by the ESP32.

The student then opens:

<pre>
http://192.168.1.4
</pre>

The ESP32 monitors the vibration sensor.

Each detected vibration event increases the vibration count during the monitoring period.

When the vibration count reaches the predefined threshold, the ESP32 generates an EXCESSIVE VIBRATION alert.

The web page displays the current status.

The web page automatically refreshes every 5 seconds so that the latest status can be observed.

The raw vibration activity is processed locally on the ESP32.
<pre>
#include <WiFi.h>
#include <WebServer.h>

const int VIBRATION_PIN=27;
const char* ap_ssid="ESP32-Vibration-Monitor";
const char* ap_password="12345678";

WebServer server(80);

const int VIBRATION_THRESHOLD=100;
const unsigned long MONITOR_PERIOD=10000;

int vibrationCount=0;
bool excessiveVibration=false;
unsigned long periodStart=0;
int lastSensorState=LOW;

void updateVibration()
{
int sensorState=digitalRead(VIBRATION_PIN);

if(sensorState==HIGH && lastSensorState==LOW)
{
vibrationCount++;
}

lastSensorState=sensorState;

if(millis()-periodStart>=MONITOR_PERIOD)
{
if(vibrationCount>=VIBRATION_THRESHOLD)
{
excessiveVibration=true;
Serial.println("EXCESSIVE VIBRATION");
Serial.println("Alert generated.");
}
else
{
excessiveVibration=false;
Serial.println("NORMAL");
Serial.println("Vibration level is within the normal range.");
}

Serial.print("Vibration events: ");
Serial.println(vibrationCount);

Serial.println("--------------------");

vibrationCount=0;
periodStart=millis();
}
}

void handleRoot()
{
updateVibration();

String page="";

char lt=60;
char gt=62;

page+=lt;
page+="html";
page+=gt;

page+=lt;
page+="head";
page+=gt;

page+=lt;
page+="meta name='viewport' content='width=device-width, initial-scale=1'";
page+=gt;

page+=lt;
page+="meta http-equiv='refresh' content='5'";
page+=gt;

page+=lt;
page+="title";
page+=gt;
page+="Vibration Monitor";
page+=lt;
page+="/title";
page+=gt;

page+=lt;
page+="/head";
page+=gt;

page+=lt;
page+="body";
page+=gt;

page+=lt;
page+="h1";
page+=gt;
page+="Smart Vibration Monitor";
page+=lt;
page+="/h1";
page+=gt;

if(excessiveVibration)
{
page+=lt;
page+="h2";
page+=gt;
page+="EXCESSIVE VIBRATION";
page+=lt;
page+="/h2";
page+=gt;

page+=lt;
page+="p";
page+=gt;
page+="Threshold crossed. Alert generated.";
page+=lt;
page+="/p";
page+=gt;
}
else
{
page+=lt;
page+="h2";
page+=gt;
page+="NORMAL";
page+=lt;
page+="/h2";
page+=gt;

page+=lt;
page+="p";
page+=gt;
page+="Vibration level is within the normal range.";
page+=lt;
page+="/p";
page+=gt;
}

page+=lt;
page+="p";
page+=gt;
page+="Page refreshes every 5 seconds.";
page+=lt;
page+="/p";
page+=gt;

page+=lt;
page+="/body";
page+=gt;

page+=lt;
page+="/html";
page+=gt;

server.send(200,"text/html",page);
}

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

pinMode(VIBRATION_PIN,INPUT);

periodStart=millis();

WiFi.softAPConfig(
IPAddress(192,168,1,4),
IPAddress(192,168,1,1),
IPAddress(255,255,255,0)
);

WiFi.softAP(ap_ssid,ap_password);

Serial.println("ESP32 Access Point started");
Serial.print("IP Address: ");
Serial.println(WiFi.softAPIP());

server.on("/",handleRoot);
server.begin();

Serial.println("Web server started");
Serial.println("--------------------");
}

void loop()
{
updateVibration();
server.handleClient();
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code or Function
! Explanation
|-
| WiFi.h
| Provides ESP32 Wi-Fi functionality.
|-
| WebServer.h
| Provides web server functionality.
|-
| VIBRATION_PIN
| Defines GPIO 27 as the vibration sensor input.
|-
| WiFi.softAP
| Creates a Wi-Fi Access Point using the ESP32.
|-
| WiFi.softAPConfig
| Sets the Access Point IP address to 192.168.1.4.
|-
| WebServer server(80)
| Creates an HTTP web server on port 80.
|-
| VIBRATION_THRESHOLD
| Defines the number of vibration events required to generate an alert.
|-
| MONITOR_PERIOD
| Defines the time interval over which vibration events are counted.
|-
| vibrationCount
| Stores the number of detected vibration events.
|-
| excessiveVibration
| Stores whether the excessive-vibration condition has been detected.
|-
| digitalRead
| Reads the digital output of the vibration sensor.
|-
| updateVibration
| Detects vibration events and checks the threshold.
|-
| handleRoot
| Generates the web page displayed on the smartphone.
|-
| server.send
| Sends the web page to the browser.
|-
| server.handleClient
| Processes browser requests.
|}

=== Access Point ===

The ESP32 creates its own Wi-Fi network.

The network name is:

<pre>
ESP32-Vibration-Monitor
</pre>

The IP address is:

<pre>
192.168.1.4
</pre>

The smartphone can therefore access the web page using:

<pre>
http://192.168.1.4
</pre>

=== Vibration Detection ===

The ESP32 reads the digital output of the vibration sensor:

<pre>
int sensorState = digitalRead(VIBRATION_PIN);
</pre>

When a vibration event causes the sensor output to change from LOW to HIGH, the vibration count is increased.

<pre>
if (sensorState == HIGH && lastSensorState == LOW)
{
vibrationCount++;
}
</pre>

This allows the ESP32 to count vibration events locally.

=== Threshold Detection ===

The program uses a vibration threshold:

<pre>
const int VIBRATION_THRESHOLD = 5;
</pre>

The monitoring period is:

<pre>
const unsigned long MONITOR_PERIOD = 10000;
</pre>

This means that the ESP32 counts vibration events during a 10 second period.

If the number of detected events is 5 or more, the system generates the excessive vibration alert.

The threshold can be changed depending on the sensor and demonstration requirements.

== Calibration of Vibration Threshold ==

The threshold should be tested before performing the main experiment.

# Upload the program to the ESP32.
# Open the Arduino IDE Serial Monitor.
# Keep the vibration sensor stationary.
# Observe the system under normal conditions.
# Tap or shake the vibration sensor several times.
# Observe how the sensor responds.
# Select a suitable vibration threshold.
# Change the VIBRATION_THRESHOLD value if required.
# Upload the program again.
# Verify that normal vibration does not unnecessarily generate an alert.
# Verify that repeated vibration generates the alert.

For a simple classroom demonstration, the threshold can be kept low so that students can easily trigger the alert by tapping or shaking the sensor.

== Procedure ==

# Connect the vibration sensor to the ESP32.
# Connect VCC to 3.3V.
# Connect GND to GND.
# Connect the digital output of the vibration sensor to GPIO 27.
# Connect the ESP32 to the computer.
# Open Arduino IDE.
# Select the appropriate ESP32 board.
# Select the appropriate COM port.
# Upload the program.
# Open the Serial Monitor.
# Verify that the ESP32 Access Point has started.
# Connect the smartphone to ESP32-Vibration-Monitor.
# Open the smartphone browser.
# Enter http://192.168.1.4.
# Observe the NORMAL status.
# Keep the vibration sensor stationary.
# Tap or shake the sensor repeatedly.
# Generate several vibration events within the monitoring period.
# Observe the EXCESSIVE VIBRATION alert.
# Wait for the next monitoring period and observe the status.
# Verify that the web page refreshes automatically every 5 seconds.
# Perform the data minimization demonstration.

== Observations and Output ==

=== Normal Condition ===

When the vibration sensor is stationary or experiences only minor vibration:

<pre>
Sensor Condition : Normal
System Status : NORMAL
Alert : None
</pre>

The system does not generate an alert.

=== Excessive Vibration Condition ===

When repeated vibration events cross the predefined threshold:

<pre>
Sensor Condition : Excessive vibration
System Status : ALERT
Alert : EXCESSIVE VIBRATION
</pre>

The ESP32 generates the alert locally.

=== Smartphone Output ===

Normal condition:

<pre>
SMART VIBRATION MONITOR

NORMAL

Vibration level is within
the normal range.

Page refreshes every 5 seconds.
</pre>

Excessive vibration condition:

<pre>
SMART VIBRATION MONITOR

EXCESSIVE VIBRATION

Threshold crossed.
Alert generated.

Page refreshes every 5 seconds.
</pre>

== Demonstration of Data Minimization ==

The main purpose of this experiment is to demonstrate that unnecessary raw sensor information does not need to be continuously transmitted.

=== Conventional System ===

In a conventional IoT system, every sensor event or sensor reading could be transmitted to a server.

For example:

<pre>
Vibration event detected
Vibration event detected
Vibration event detected
Vibration event detected
Vibration event detected
</pre>

The server would receive a continuous stream of sensor information.

=== Privacy-by-Design System ===

In the proposed system, the ESP32 processes the vibration activity locally.

The ESP32 counts the vibration events and compares the count with the threshold.

The process is:

<pre>
Vibration activity
|
v
Local processing
|
v
Count events
|
v
Check threshold
|
+---------------------+
| |
v v
Below threshold Threshold reached
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The raw vibration activity is not required outside the ESP32 for the basic application.

Only the required alert needs to be exposed.

== Data Inspection Demonstration ==

The data inspection demonstration is used to compare the amount of information exposed by two system designs.

The demonstration is educational and is intended to show the effect of data minimization.

=== Conventional Design ===

A conventional system may continuously expose individual vibration events:

<pre>
Vibration event
Vibration event
Vibration event
Vibration event
Vibration event
</pre>

An observer can therefore obtain detailed information about the vibration activity.

=== Privacy-by-Design Design ===

The Privacy-by-Design system processes the vibration activity locally.

When the vibration count is below the threshold:

<pre>
No alert
</pre>

When the threshold is reached:

<pre>
EXCESSIVE VIBRATION
</pre>

The application therefore exposes only the information required for the intended purpose.

=== Demonstration Steps ===

# Connect the smartphone to the ESP32 Access Point.
# Open the ESP32 web page.
# Observe the NORMAL condition.
# Tap or shake the vibration sensor repeatedly.
# Generate enough vibration events to cross the threshold.
# Observe the EXCESSIVE VIBRATION alert.
# Inspect the application data using an appropriate network inspection or server logging method.
# Observe that the application does not need to continuously expose every vibration event.
# Explain that the ESP32 processes the vibration activity locally before generating the alert.

'''Note:''' This demonstration is about data minimization. It does not claim that HTTP communication is encrypted or completely secure.

== Conventional System vs Privacy-by-Design System ==

{| class="wikitable"
! Feature
! Conventional System
! Privacy-by-Design System
|-
| Sensor processing
| May be performed at server
| Performed locally on ESP32
|-
| Vibration events
| May be continuously transmitted
| Processed locally
|-
| Normal activity
| May be transmitted
| No unnecessary transmission
|-
| Threshold detection
| May be performed at server
| Performed on ESP32
|-
| Alert
| May contain detailed sensor information
| Only required alert is exposed
|-
| Data volume
| Higher
| Lower
|-
| Data exposure
| Higher
| Minimized
|}

== Why This is Privacy-by-Design ==

The experiment demonstrates Privacy-by-Design through the following design decisions:

# '''Local Processing:''' Vibration activity is processed on the ESP32.
# '''Data Minimization:''' Individual vibration events do not need to be continuously transmitted.
# '''Purpose Limitation:''' The system only needs to detect excessive vibration.
# '''Smart Thresholding:''' An alert is generated only when the vibration threshold is crossed.
# '''Reduced Data Exposure:''' Unnecessary sensor information is not exposed.
# '''Privacy by Default:''' The system is designed to minimize data exposure from the beginning.

The main principle demonstrated is:

<pre>
Do not transmit unnecessary information
when the application does not require it.
</pre>

== Automatic Page Refresh ==

The web page automatically refreshes every 5 seconds.

This is implemented using the page refresh setting in the generated web page.

The refresh interval allows the student to observe the latest vibration status without manually refreshing the browser.

The refresh interval is:

<pre>
5 seconds
</pre>

Therefore, after generating vibration activity, the student can wait for the next page refresh to observe the updated alert status.

== Advantages ==

# Reduces unnecessary sensor data transmission.
# Processes vibration information locally.
# Reduces the amount of sensor information exposed outside the device.
# Allows fast local decision making.
# Demonstrates data minimization clearly.
# Does not require an external cloud server.
# Can be demonstrated easily using a smartphone.
# Vibration can be generated manually by tapping or shaking the sensor.
# The web page automatically refreshes every 5 seconds.
# Can be extended to industrial machine monitoring applications.

== Limitations ==

# The vibration sensor module provides a simple indication of vibration and may not provide precise vibration measurements.
# The sensor may respond differently depending on the strength and duration of vibration.
# The threshold must be calibrated for the actual sensor and application.
# Environmental vibration may cause unwanted detections.
# The HTTP communication used in this experiment is not encrypted.
# This experiment demonstrates data minimization and not complete IoT security.
# A real industrial vibration monitoring system would normally use a more precise vibration sensor and appropriate signal processing.

== Result ==

The smart threshold alert system was successfully implemented using a vibration sensor and ESP32.

The ESP32 locally monitored vibration activity and counted vibration events during a predefined monitoring period.

When the number of vibration events reached the selected threshold, the system generated an EXCESSIVE VIBRATION alert.

The alert was displayed on a smartphone through the ESP32 web server using:

<pre>
http://192.168.1.4
</pre>

The web page automatically refreshed every 5 seconds.

The experiment demonstrated that raw vibration activity does not need to be continuously exposed when the application only requires an excessive-vibration alert.

Thus, the experiment demonstrated data minimization through local processing and smart threshold alerts as a practical Privacy-by-Design approach.

== Viva Questions ==

'''Q1. What is Privacy-by-Design?'''

'''Ans:''' Privacy-by-Design means incorporating privacy considerations into the design of a system from the beginning.

'''Q2. What is data minimization?'''

'''Ans:''' Data minimization means collecting, processing, transmitting, and storing only the data required for the intended purpose.

'''Q3. Why is a vibration sensor used in this experiment?'''

'''Ans:''' A vibration sensor is used because vibration can be generated manually by tapping or shaking the sensor, making the alert easy to demonstrate.

'''Q4. What does excessive vibration represent in this experiment?'''

'''Ans:''' Excessive vibration represents a condition in which the number of vibration events has crossed the predefined threshold.

'''Q5. Why is the raw vibration activity not continuously transmitted?'''

'''Ans:''' The application only needs to know whether excessive vibration has occurred. Therefore, continuously transmitting every vibration event is unnecessary.

'''Q6. Where is the vibration threshold checked?'''

'''Ans:''' The threshold is checked locally on the ESP32.

'''Q7. What happens when the threshold is not crossed?'''

'''Ans:''' No excessive-vibration alert is generated.

'''Q8. What happens when the threshold is crossed?'''

'''Ans:''' The ESP32 detects excessive vibration and generates the EXCESSIVE VIBRATION alert.

'''Q9. What is the purpose of the data inspection demonstration?'''

'''Ans:''' It demonstrates how data minimization reduces the amount of unnecessary sensor information exposed outside the device.

'''Q10. What information is required when the threshold is crossed?'''

'''Ans:''' The required information is the EXCESSIVE VIBRATION alert.

'''Q11. Why does the web page refresh every 5 seconds?'''

'''Ans:''' The page refreshes every 5 seconds so that the smartphone can display the latest system status automatically.

'''Q12. Is the system completely secure?'''

'''Ans:''' No. The main purpose is to demonstrate data minimization and Privacy-by-Design. The HTTP communication used here is not encrypted.

'''Q13. Does data minimization mean that no data is transmitted?'''

'''Ans:''' No. It means that only the data necessary for the intended purpose should be transmitted or exposed.

'''Q14. Why is local processing useful?'''

'''Ans:''' Local processing allows the ESP32 to make decisions using sensor data without unnecessarily exposing the raw sensor activity.

'''Q15. What is a smart threshold alert?'''

'''Ans:''' A smart threshold alert is generated when sensor activity crosses a predefined threshold representing a meaningful condition.

'''Q16. What is the main principle demonstrated by this experiment?'''

'''Ans:''' The main principle is data minimization. Sensor activity is processed locally and only the required alert is exposed.

MDM331AID/Experiment 14

2026-10-08T03:49:55Z

CogWikiEditor: /* Program */

= Experiment: Smart Threshold Alerts for Data Minimization using Privacy-by-Design =

== Aim ==

To design and implement a Privacy-by-Design IoT system using a vibration sensor and ESP32 that detects excessive vibration using a predefined threshold and generates an alert only when the threshold condition is reached, thereby minimizing unnecessary sensor data transmission.

== Objectives ==

# To understand Privacy-by-Design in an IoT system.
# To understand the concept of data minimization.
# To interface a vibration sensor with ESP32.
# To detect vibration activity using the sensor.
# To define a threshold for excessive vibration.
# To generate an EXCESSIVE VIBRATION alert when the threshold is crossed.
# To process vibration data locally on the ESP32.
# To avoid continuously transmitting raw vibration readings.
# To expose only the required alert information.
# To demonstrate data minimization through a simple web-based monitoring system.

== Components Required ==

{| class="wikitable"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| Reads the vibration sensor and hosts the web server
|-
| 2
| Vibration Sensor Module
| 1
| Detects vibration activity
|-
| 3
| Breadboard
| 1
| Circuit connections
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Smartphone
| 1
| Accesses the ESP32 web page
|-
| 6
| USB Cable
| 1
| Programming and powering ESP32
|-
| 7
| Computer with Arduino IDE
| 1
| Programming the ESP32
|}

== Theory ==

=== Internet of Things ===

The Internet of Things, or IoT, is a system in which physical devices use sensors and communication technologies to collect and exchange information.

In a conventional IoT system, sensor readings may be continuously transmitted even when the application does not require all of the readings.

For example, a vibration monitoring system may continuously generate sensor readings.

If the purpose of the application is only to detect excessive vibration, the application does not necessarily need every individual sensor reading.

The ESP32 can instead process the vibration activity locally and generate an alert only when the required condition occurs.

=== Privacy-by-Design ===

Privacy-by-Design means that privacy considerations are incorporated into the design of a system from the beginning.

One important approach related to Privacy-by-Design is data minimization.

Data minimization means collecting, processing, transmitting, and storing only the information that is necessary for the intended purpose.

In this experiment, the purpose is to detect excessive vibration.

Therefore, the system does not need to continuously expose every raw vibration reading.

The ESP32 processes the vibration activity locally and generates an alert only when the predefined threshold condition is reached.

=== Smart Threshold Alert ===

A threshold is a predefined value used to determine when a particular condition has occurred.

The ESP32 monitors the vibration sensor and keeps track of vibration activity.

When the number of detected vibration events reaches the selected threshold within the monitoring period, the ESP32 considers the vibration level excessive.

The operation is:

<pre>
Vibration Sensor
|
v
ESP32
|
v
Monitor vibration activity
|
v
Check threshold
|
+----------------------+
| |
v v
Normal vibration Excessive vibration
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The threshold can be adjusted according to the sensor and the required application.

=== Data Minimization ===

In a conventional system, raw vibration readings may be continuously sent to another device or server.

In the proposed system:

<pre>
Vibration Sensor
|
v
Local processing on ESP32
|
v
Count vibration activity
|
v
Check threshold
|
+----------------------+
| |
v v
Below threshold Threshold reached
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The raw vibration activity is processed locally for decision making.

Unnecessary continuous sensor data is therefore not exposed outside the device.

== Sensor Connection ==

The vibration sensor module normally provides VCC, GND, and a digital output pin.

{| class="wikitable"
! Vibration Sensor Pin
! ESP32
! Description
|-
| VCC
| 3.3V
| Sensor power supply
|-
| DO or OUT
| GPIO 27
| Digital vibration signal
|-
| GND
| GND
| Common ground
|}

'''Note:''' The exact pin names may vary between vibration sensor modules. Verify the labels on the actual sensor before making the connections.

== Connection Diagram ==

<pre>
Vibration Sensor
+-------------+
| |
3.3V ---| VCC |
| |
GPIO 27 <---| DO / OUT |
| |
GND ----| GND |
+-------------+
|
|
ESP32
|
|
Wi-Fi Access Point
|
|
Smartphone Browser
|
|
192.168.1.4
</pre>

== Working Principle ==

The ESP32 works as a Wi-Fi Access Point and hosts a simple web server.

The smartphone connects directly to the Wi-Fi network created by the ESP32.

The student then opens:

<pre>
http://192.168.1.4
</pre>

The ESP32 monitors the vibration sensor.

Each detected vibration event increases the vibration count during the monitoring period.

When the vibration count reaches the predefined threshold, the ESP32 generates an EXCESSIVE VIBRATION alert.

The web page displays the current status.

The web page automatically refreshes every 5 seconds so that the latest status can be observed.

The raw vibration activity is processed locally on the ESP32.

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

const int VIBRATION_PIN=27;
const char* ap_ssid="ESP32-Vibration-Monitor";
const char* ap_password="12345678";

WebServer server(80);

const int VIBRATION_THRESHOLD=100;
const unsigned long MONITOR_PERIOD=10000;

int vibrationCount=0;
bool excessiveVibration=false;
unsigned long periodStart=0;
int lastSensorState=LOW;

void updateVibration()
{
int sensorState=digitalRead(VIBRATION_PIN);

if(sensorState==HIGH && lastSensorState==LOW)
{
vibrationCount++;
}

lastSensorState=sensorState;

if(millis()-periodStart>=MONITOR_PERIOD)
{
if(vibrationCount>=VIBRATION_THRESHOLD)
{
excessiveVibration=true;
Serial.println("EXCESSIVE VIBRATION");
Serial.println("Alert generated.");
}
else
{
excessiveVibration=false;
Serial.println("NORMAL");
Serial.println("Vibration level is within the normal range.");
}

Serial.print("Vibration events: ");
Serial.println(vibrationCount);

Serial.println("--------------------");

vibrationCount=0;
periodStart=millis();
}
}

void handleRoot()
{
updateVibration();

String page="";

char lt=60;
char gt=62;

page+=lt;
page+="html";
page+=gt;

page+=lt;
page+="head";
page+=gt;

page+=lt;
page+="meta name='viewport' content='width=device-width, initial-scale=1'";
page+=gt;

page+=lt;
page+="meta http-equiv='refresh' content='5'";
page+=gt;

page+=lt;
page+="title";
page+=gt;
page+="Vibration Monitor";
page+=lt;
page+="/title";
page+=gt;

page+=lt;
page+="/head";
page+=gt;

page+=lt;
page+="body";
page+=gt;

page+=lt;
page+="h1";
page+=gt;
page+="Smart Vibration Monitor";
page+=lt;
page+="/h1";
page+=gt;

if(excessiveVibration)
{
page+=lt;
page+="h2";
page+=gt;
page+="EXCESSIVE VIBRATION";
page+=lt;
page+="/h2";
page+=gt;

page+=lt;
page+="p";
page+=gt;
page+="Threshold crossed. Alert generated.";
page+=lt;
page+="/p";
page+=gt;
}
else
{
page+=lt;
page+="h2";
page+=gt;
page+="NORMAL";
page+=lt;
page+="/h2";
page+=gt;

page+=lt;
page+="p";
page+=gt;
page+="Vibration level is within the normal range.";
page+=lt;
page+="/p";
page+=gt;
}

page+=lt;
page+="p";
page+=gt;
page+="Page refreshes every 5 seconds.";
page+=lt;
page+="/p";
page+=gt;

page+=lt;
page+="/body";
page+=gt;

page+=lt;
page+="/html";
page+=gt;

server.send(200,"text/html",page);
}

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

pinMode(VIBRATION_PIN,INPUT);

periodStart=millis();

WiFi.softAPConfig(
IPAddress(192,168,1,4),
IPAddress(192,168,1,1),
IPAddress(255,255,255,0)
);

WiFi.softAP(ap_ssid,ap_password);

Serial.println("ESP32 Access Point started");
Serial.print("IP Address: ");
Serial.println(WiFi.softAPIP());

server.on("/",handleRoot);
server.begin();

Serial.println("Web server started");
Serial.println("--------------------");
}

void loop()
{
updateVibration();
server.handleClient();
}

== Code Explanation ==

{| class="wikitable"
! Code or Function
! Explanation
|-
| WiFi.h
| Provides ESP32 Wi-Fi functionality.
|-
| WebServer.h
| Provides web server functionality.
|-
| VIBRATION_PIN
| Defines GPIO 27 as the vibration sensor input.
|-
| WiFi.softAP
| Creates a Wi-Fi Access Point using the ESP32.
|-
| WiFi.softAPConfig
| Sets the Access Point IP address to 192.168.1.4.
|-
| WebServer server(80)
| Creates an HTTP web server on port 80.
|-
| VIBRATION_THRESHOLD
| Defines the number of vibration events required to generate an alert.
|-
| MONITOR_PERIOD
| Defines the time interval over which vibration events are counted.
|-
| vibrationCount
| Stores the number of detected vibration events.
|-
| excessiveVibration
| Stores whether the excessive-vibration condition has been detected.
|-
| digitalRead
| Reads the digital output of the vibration sensor.
|-
| updateVibration
| Detects vibration events and checks the threshold.
|-
| handleRoot
| Generates the web page displayed on the smartphone.
|-
| server.send
| Sends the web page to the browser.
|-
| server.handleClient
| Processes browser requests.
|}

=== Access Point ===

The ESP32 creates its own Wi-Fi network.

The network name is:

<pre>
ESP32-Vibration-Monitor
</pre>

The IP address is:

<pre>
192.168.1.4
</pre>

The smartphone can therefore access the web page using:

<pre>
http://192.168.1.4
</pre>

=== Vibration Detection ===

The ESP32 reads the digital output of the vibration sensor:

<pre>
int sensorState = digitalRead(VIBRATION_PIN);
</pre>

When a vibration event causes the sensor output to change from LOW to HIGH, the vibration count is increased.

<pre>
if (sensorState == HIGH && lastSensorState == LOW)
{
vibrationCount++;
}
</pre>

This allows the ESP32 to count vibration events locally.

=== Threshold Detection ===

The program uses a vibration threshold:

<pre>
const int VIBRATION_THRESHOLD = 5;
</pre>

The monitoring period is:

<pre>
const unsigned long MONITOR_PERIOD = 10000;
</pre>

This means that the ESP32 counts vibration events during a 10 second period.

If the number of detected events is 5 or more, the system generates the excessive vibration alert.

The threshold can be changed depending on the sensor and demonstration requirements.

== Calibration of Vibration Threshold ==

The threshold should be tested before performing the main experiment.

# Upload the program to the ESP32.
# Open the Arduino IDE Serial Monitor.
# Keep the vibration sensor stationary.
# Observe the system under normal conditions.
# Tap or shake the vibration sensor several times.
# Observe how the sensor responds.
# Select a suitable vibration threshold.
# Change the VIBRATION_THRESHOLD value if required.
# Upload the program again.
# Verify that normal vibration does not unnecessarily generate an alert.
# Verify that repeated vibration generates the alert.

For a simple classroom demonstration, the threshold can be kept low so that students can easily trigger the alert by tapping or shaking the sensor.

== Procedure ==

# Connect the vibration sensor to the ESP32.
# Connect VCC to 3.3V.
# Connect GND to GND.
# Connect the digital output of the vibration sensor to GPIO 27.
# Connect the ESP32 to the computer.
# Open Arduino IDE.
# Select the appropriate ESP32 board.
# Select the appropriate COM port.
# Upload the program.
# Open the Serial Monitor.
# Verify that the ESP32 Access Point has started.
# Connect the smartphone to ESP32-Vibration-Monitor.
# Open the smartphone browser.
# Enter http://192.168.1.4.
# Observe the NORMAL status.
# Keep the vibration sensor stationary.
# Tap or shake the sensor repeatedly.
# Generate several vibration events within the monitoring period.
# Observe the EXCESSIVE VIBRATION alert.
# Wait for the next monitoring period and observe the status.
# Verify that the web page refreshes automatically every 5 seconds.
# Perform the data minimization demonstration.

== Observations and Output ==

=== Normal Condition ===

When the vibration sensor is stationary or experiences only minor vibration:

<pre>
Sensor Condition : Normal
System Status : NORMAL
Alert : None
</pre>

The system does not generate an alert.

=== Excessive Vibration Condition ===

When repeated vibration events cross the predefined threshold:

<pre>
Sensor Condition : Excessive vibration
System Status : ALERT
Alert : EXCESSIVE VIBRATION
</pre>

The ESP32 generates the alert locally.

=== Smartphone Output ===

Normal condition:

<pre>
SMART VIBRATION MONITOR

NORMAL

Vibration level is within
the normal range.

Page refreshes every 5 seconds.
</pre>

Excessive vibration condition:

<pre>
SMART VIBRATION MONITOR

EXCESSIVE VIBRATION

Threshold crossed.
Alert generated.

Page refreshes every 5 seconds.
</pre>

== Demonstration of Data Minimization ==

The main purpose of this experiment is to demonstrate that unnecessary raw sensor information does not need to be continuously transmitted.

=== Conventional System ===

In a conventional IoT system, every sensor event or sensor reading could be transmitted to a server.

For example:

<pre>
Vibration event detected
Vibration event detected
Vibration event detected
Vibration event detected
Vibration event detected
</pre>

The server would receive a continuous stream of sensor information.

=== Privacy-by-Design System ===

In the proposed system, the ESP32 processes the vibration activity locally.

The ESP32 counts the vibration events and compares the count with the threshold.

The process is:

<pre>
Vibration activity
|
v
Local processing
|
v
Count events
|
v
Check threshold
|
+---------------------+
| |
v v
Below threshold Threshold reached
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The raw vibration activity is not required outside the ESP32 for the basic application.

Only the required alert needs to be exposed.

== Data Inspection Demonstration ==

The data inspection demonstration is used to compare the amount of information exposed by two system designs.

The demonstration is educational and is intended to show the effect of data minimization.

=== Conventional Design ===

A conventional system may continuously expose individual vibration events:

<pre>
Vibration event
Vibration event
Vibration event
Vibration event
Vibration event
</pre>

An observer can therefore obtain detailed information about the vibration activity.

=== Privacy-by-Design Design ===

The Privacy-by-Design system processes the vibration activity locally.

When the vibration count is below the threshold:

<pre>
No alert
</pre>

When the threshold is reached:

<pre>
EXCESSIVE VIBRATION
</pre>

The application therefore exposes only the information required for the intended purpose.

=== Demonstration Steps ===

# Connect the smartphone to the ESP32 Access Point.
# Open the ESP32 web page.
# Observe the NORMAL condition.
# Tap or shake the vibration sensor repeatedly.
# Generate enough vibration events to cross the threshold.
# Observe the EXCESSIVE VIBRATION alert.
# Inspect the application data using an appropriate network inspection or server logging method.
# Observe that the application does not need to continuously expose every vibration event.
# Explain that the ESP32 processes the vibration activity locally before generating the alert.

'''Note:''' This demonstration is about data minimization. It does not claim that HTTP communication is encrypted or completely secure.

== Conventional System vs Privacy-by-Design System ==

{| class="wikitable"
! Feature
! Conventional System
! Privacy-by-Design System
|-
| Sensor processing
| May be performed at server
| Performed locally on ESP32
|-
| Vibration events
| May be continuously transmitted
| Processed locally
|-
| Normal activity
| May be transmitted
| No unnecessary transmission
|-
| Threshold detection
| May be performed at server
| Performed on ESP32
|-
| Alert
| May contain detailed sensor information
| Only required alert is exposed
|-
| Data volume
| Higher
| Lower
|-
| Data exposure
| Higher
| Minimized
|}

== Why This is Privacy-by-Design ==

The experiment demonstrates Privacy-by-Design through the following design decisions:

# '''Local Processing:''' Vibration activity is processed on the ESP32.
# '''Data Minimization:''' Individual vibration events do not need to be continuously transmitted.
# '''Purpose Limitation:''' The system only needs to detect excessive vibration.
# '''Smart Thresholding:''' An alert is generated only when the vibration threshold is crossed.
# '''Reduced Data Exposure:''' Unnecessary sensor information is not exposed.
# '''Privacy by Default:''' The system is designed to minimize data exposure from the beginning.

The main principle demonstrated is:

<pre>
Do not transmit unnecessary information
when the application does not require it.
</pre>

== Automatic Page Refresh ==

The web page automatically refreshes every 5 seconds.

This is implemented using the page refresh setting in the generated web page.

The refresh interval allows the student to observe the latest vibration status without manually refreshing the browser.

The refresh interval is:

<pre>
5 seconds
</pre>

Therefore, after generating vibration activity, the student can wait for the next page refresh to observe the updated alert status.

== Advantages ==

# Reduces unnecessary sensor data transmission.
# Processes vibration information locally.
# Reduces the amount of sensor information exposed outside the device.
# Allows fast local decision making.
# Demonstrates data minimization clearly.
# Does not require an external cloud server.
# Can be demonstrated easily using a smartphone.
# Vibration can be generated manually by tapping or shaking the sensor.
# The web page automatically refreshes every 5 seconds.
# Can be extended to industrial machine monitoring applications.

== Limitations ==

# The vibration sensor module provides a simple indication of vibration and may not provide precise vibration measurements.
# The sensor may respond differently depending on the strength and duration of vibration.
# The threshold must be calibrated for the actual sensor and application.
# Environmental vibration may cause unwanted detections.
# The HTTP communication used in this experiment is not encrypted.
# This experiment demonstrates data minimization and not complete IoT security.
# A real industrial vibration monitoring system would normally use a more precise vibration sensor and appropriate signal processing.

== Result ==

The smart threshold alert system was successfully implemented using a vibration sensor and ESP32.

The ESP32 locally monitored vibration activity and counted vibration events during a predefined monitoring period.

When the number of vibration events reached the selected threshold, the system generated an EXCESSIVE VIBRATION alert.

The alert was displayed on a smartphone through the ESP32 web server using:

<pre>
http://192.168.1.4
</pre>

The web page automatically refreshed every 5 seconds.

The experiment demonstrated that raw vibration activity does not need to be continuously exposed when the application only requires an excessive-vibration alert.

Thus, the experiment demonstrated data minimization through local processing and smart threshold alerts as a practical Privacy-by-Design approach.

== Viva Questions ==

'''Q1. What is Privacy-by-Design?'''

'''Ans:''' Privacy-by-Design means incorporating privacy considerations into the design of a system from the beginning.

'''Q2. What is data minimization?'''

'''Ans:''' Data minimization means collecting, processing, transmitting, and storing only the data required for the intended purpose.

'''Q3. Why is a vibration sensor used in this experiment?'''

'''Ans:''' A vibration sensor is used because vibration can be generated manually by tapping or shaking the sensor, making the alert easy to demonstrate.

'''Q4. What does excessive vibration represent in this experiment?'''

'''Ans:''' Excessive vibration represents a condition in which the number of vibration events has crossed the predefined threshold.

'''Q5. Why is the raw vibration activity not continuously transmitted?'''

'''Ans:''' The application only needs to know whether excessive vibration has occurred. Therefore, continuously transmitting every vibration event is unnecessary.

'''Q6. Where is the vibration threshold checked?'''

'''Ans:''' The threshold is checked locally on the ESP32.

'''Q7. What happens when the threshold is not crossed?'''

'''Ans:''' No excessive-vibration alert is generated.

'''Q8. What happens when the threshold is crossed?'''

'''Ans:''' The ESP32 detects excessive vibration and generates the EXCESSIVE VIBRATION alert.

'''Q9. What is the purpose of the data inspection demonstration?'''

'''Ans:''' It demonstrates how data minimization reduces the amount of unnecessary sensor information exposed outside the device.

'''Q10. What information is required when the threshold is crossed?'''

'''Ans:''' The required information is the EXCESSIVE VIBRATION alert.

'''Q11. Why does the web page refresh every 5 seconds?'''

'''Ans:''' The page refreshes every 5 seconds so that the smartphone can display the latest system status automatically.

'''Q12. Is the system completely secure?'''

'''Ans:''' No. The main purpose is to demonstrate data minimization and Privacy-by-Design. The HTTP communication used here is not encrypted.

'''Q13. Does data minimization mean that no data is transmitted?'''

'''Ans:''' No. It means that only the data necessary for the intended purpose should be transmitted or exposed.

'''Q14. Why is local processing useful?'''

'''Ans:''' Local processing allows the ESP32 to make decisions using sensor data without unnecessarily exposing the raw sensor activity.

'''Q15. What is a smart threshold alert?'''

'''Ans:''' A smart threshold alert is generated when sensor activity crosses a predefined threshold representing a meaningful condition.

'''Q16. What is the main principle demonstrated by this experiment?'''

'''Ans:''' The main principle is data minimization. Sensor activity is processed locally and only the required alert is exposed.

MDM331AID/Experiment 14

2026-10-08T03:32:37Z

CogWikiEditor:

= Experiment: Smart Threshold Alerts for Data Minimization using Privacy-by-Design =

== Aim ==

To design and implement a Privacy-by-Design IoT system using a vibration sensor and ESP32 that detects excessive vibration using a predefined threshold and generates an alert only when the threshold condition is reached, thereby minimizing unnecessary sensor data transmission.

== Objectives ==

# To understand Privacy-by-Design in an IoT system.
# To understand the concept of data minimization.
# To interface a vibration sensor with ESP32.
# To detect vibration activity using the sensor.
# To define a threshold for excessive vibration.
# To generate an EXCESSIVE VIBRATION alert when the threshold is crossed.
# To process vibration data locally on the ESP32.
# To avoid continuously transmitting raw vibration readings.
# To expose only the required alert information.
# To demonstrate data minimization through a simple web-based monitoring system.

== Components Required ==

{| class="wikitable"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| Reads the vibration sensor and hosts the web server
|-
| 2
| Vibration Sensor Module
| 1
| Detects vibration activity
|-
| 3
| Breadboard
| 1
| Circuit connections
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Smartphone
| 1
| Accesses the ESP32 web page
|-
| 6
| USB Cable
| 1
| Programming and powering ESP32
|-
| 7
| Computer with Arduino IDE
| 1
| Programming the ESP32
|}

== Theory ==

=== Internet of Things ===

The Internet of Things, or IoT, is a system in which physical devices use sensors and communication technologies to collect and exchange information.

In a conventional IoT system, sensor readings may be continuously transmitted even when the application does not require all of the readings.

For example, a vibration monitoring system may continuously generate sensor readings.

If the purpose of the application is only to detect excessive vibration, the application does not necessarily need every individual sensor reading.

The ESP32 can instead process the vibration activity locally and generate an alert only when the required condition occurs.

=== Privacy-by-Design ===

Privacy-by-Design means that privacy considerations are incorporated into the design of a system from the beginning.

One important approach related to Privacy-by-Design is data minimization.

Data minimization means collecting, processing, transmitting, and storing only the information that is necessary for the intended purpose.

In this experiment, the purpose is to detect excessive vibration.

Therefore, the system does not need to continuously expose every raw vibration reading.

The ESP32 processes the vibration activity locally and generates an alert only when the predefined threshold condition is reached.

=== Smart Threshold Alert ===

A threshold is a predefined value used to determine when a particular condition has occurred.

The ESP32 monitors the vibration sensor and keeps track of vibration activity.

When the number of detected vibration events reaches the selected threshold within the monitoring period, the ESP32 considers the vibration level excessive.

The operation is:

<pre>
Vibration Sensor
|
v
ESP32
|
v
Monitor vibration activity
|
v
Check threshold
|
+----------------------+
| |
v v
Normal vibration Excessive vibration
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The threshold can be adjusted according to the sensor and the required application.

=== Data Minimization ===

In a conventional system, raw vibration readings may be continuously sent to another device or server.

In the proposed system:

<pre>
Vibration Sensor
|
v
Local processing on ESP32
|
v
Count vibration activity
|
v
Check threshold
|
+----------------------+
| |
v v
Below threshold Threshold reached
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The raw vibration activity is processed locally for decision making.

Unnecessary continuous sensor data is therefore not exposed outside the device.

== Sensor Connection ==

The vibration sensor module normally provides VCC, GND, and a digital output pin.

{| class="wikitable"
! Vibration Sensor Pin
! ESP32
! Description
|-
| VCC
| 3.3V
| Sensor power supply
|-
| DO or OUT
| GPIO 27
| Digital vibration signal
|-
| GND
| GND
| Common ground
|}

'''Note:''' The exact pin names may vary between vibration sensor modules. Verify the labels on the actual sensor before making the connections.

== Connection Diagram ==

<pre>
Vibration Sensor
+-------------+
| |
3.3V ---| VCC |
| |
GPIO 27 <---| DO / OUT |
| |
GND ----| GND |
+-------------+
|
|
ESP32
|
|
Wi-Fi Access Point
|
|
Smartphone Browser
|
|
192.168.1.4
</pre>

== Working Principle ==

The ESP32 works as a Wi-Fi Access Point and hosts a simple web server.

The smartphone connects directly to the Wi-Fi network created by the ESP32.

The student then opens:

<pre>
http://192.168.1.4
</pre>

The ESP32 monitors the vibration sensor.

Each detected vibration event increases the vibration count during the monitoring period.

When the vibration count reaches the predefined threshold, the ESP32 generates an EXCESSIVE VIBRATION alert.

The web page displays the current status.

The web page automatically refreshes every 5 seconds so that the latest status can be observed.

The raw vibration activity is processed locally on the ESP32.

== Program ==

<pre>
#include <WiFi.h>
#include <WebServer.h>

const int VIBRATION_PIN = 27;

const char* ap_ssid = "ESP32-Vibration-Monitor";
const char* ap_password = "12345678";

WebServer server(80);

/*
Number of vibration events required
to generate an alert.
*/
const int VIBRATION_THRESHOLD = 5;

/*
Monitoring period in milliseconds.
*/
const unsigned long MONITOR_PERIOD = 10000;

int vibrationCount = 0;
bool excessiveVibration = false;

unsigned long periodStart = 0;

int lastSensorState = LOW;

void updateVibration()
{
int sensorState = digitalRead(VIBRATION_PIN);

/*
Count a vibration when the sensor
changes from LOW to HIGH.
*/
if (sensorState == HIGH && lastSensorState == LOW)
{
vibrationCount++;
}

lastSensorState = sensorState;

/*
Check whether the monitoring period
has ended.
*/
if (millis() - periodStart >= MONITOR_PERIOD)
{
if (vibrationCount >= VIBRATION_THRESHOLD)
{
excessiveVibration = true;
}
else
{
excessiveVibration = false;
}

/*
Start a new monitoring period.
*/
vibrationCount = 0;
periodStart = millis();
}
}

void handleRoot()
{
updateVibration();

String page = "";

char lt = 60;
char gt = 62;

page += lt;
page += "html";
page += gt;

page += lt;
page += "head";
page += gt;

page += lt;
page += "meta name='viewport' content='width=device-width, initial-scale=1'";
page += gt;

page += lt;
page += "meta http-equiv='refresh' content='5'";
page += gt;

page += lt;
page += "title";
page += gt;
page += "Vibration Monitor";
page += lt;
page += "/title";
page += gt;

page += lt;
page += "/head";
page += gt;

page += lt;
page += "body";
page += gt;

page += lt;
page += "h1";
page += gt;
page += "Smart Vibration Monitor";
page += lt;
page += "/h1";
page += gt;

if (excessiveVibration)
{
page += lt;
page += "h2";
page += gt;
page += "EXCESSIVE VIBRATION";
page += lt;
page += "/h2";
page += gt;

page += lt;
page += "p";
page += gt;
page += "Threshold crossed. Alert generated.";
page += lt;
page += "/p";
page += gt;
}
else
{
page += lt;
page += "h2";
page += gt;
page += "NORMAL";
page += lt;
page += "/h2";
page += gt;

page += lt;
page += "p";
page += gt;
page += "Vibration level is within the normal range.";
page += lt;
page += "/p";
page += gt;
}

page += lt;
page += "p";
page += gt;
page += "Page refreshes every 5 seconds.";
page += lt;
page += "/p";
page += gt;

page += lt;
page += "/body";
page += gt;

page += lt;
page += "/html";
page += gt;

server.send(200, "text/html", page);
}

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

pinMode(VIBRATION_PIN, INPUT);

periodStart = millis();

WiFi.softAPConfig(
IPAddress(192,168,1,4),
IPAddress(192,168,1,1),
IPAddress(255,255,255,0)
);

WiFi.softAP(ap_ssid, ap_password);

Serial.println("ESP32 Access Point started");
Serial.print("IP Address: ");
Serial.println(WiFi.softAPIP());

server.on("/", handleRoot);

server.begin();

Serial.println("Web server started");
}

void loop()
{
updateVibration();

server.handleClient();
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code or Function
! Explanation
|-
| WiFi.h
| Provides ESP32 Wi-Fi functionality.
|-
| WebServer.h
| Provides web server functionality.
|-
| VIBRATION_PIN
| Defines GPIO 27 as the vibration sensor input.
|-
| WiFi.softAP
| Creates a Wi-Fi Access Point using the ESP32.
|-
| WiFi.softAPConfig
| Sets the Access Point IP address to 192.168.1.4.
|-
| WebServer server(80)
| Creates an HTTP web server on port 80.
|-
| VIBRATION_THRESHOLD
| Defines the number of vibration events required to generate an alert.
|-
| MONITOR_PERIOD
| Defines the time interval over which vibration events are counted.
|-
| vibrationCount
| Stores the number of detected vibration events.
|-
| excessiveVibration
| Stores whether the excessive-vibration condition has been detected.
|-
| digitalRead
| Reads the digital output of the vibration sensor.
|-
| updateVibration
| Detects vibration events and checks the threshold.
|-
| handleRoot
| Generates the web page displayed on the smartphone.
|-
| server.send
| Sends the web page to the browser.
|-
| server.handleClient
| Processes browser requests.
|}

=== Access Point ===

The ESP32 creates its own Wi-Fi network.

The network name is:

<pre>
ESP32-Vibration-Monitor
</pre>

The IP address is:

<pre>
192.168.1.4
</pre>

The smartphone can therefore access the web page using:

<pre>
http://192.168.1.4
</pre>

=== Vibration Detection ===

The ESP32 reads the digital output of the vibration sensor:

<pre>
int sensorState = digitalRead(VIBRATION_PIN);
</pre>

When a vibration event causes the sensor output to change from LOW to HIGH, the vibration count is increased.

<pre>
if (sensorState == HIGH && lastSensorState == LOW)
{
vibrationCount++;
}
</pre>

This allows the ESP32 to count vibration events locally.

=== Threshold Detection ===

The program uses a vibration threshold:

<pre>
const int VIBRATION_THRESHOLD = 5;
</pre>

The monitoring period is:

<pre>
const unsigned long MONITOR_PERIOD = 10000;
</pre>

This means that the ESP32 counts vibration events during a 10 second period.

If the number of detected events is 5 or more, the system generates the excessive vibration alert.

The threshold can be changed depending on the sensor and demonstration requirements.

== Calibration of Vibration Threshold ==

The threshold should be tested before performing the main experiment.

# Upload the program to the ESP32.
# Open the Arduino IDE Serial Monitor.
# Keep the vibration sensor stationary.
# Observe the system under normal conditions.
# Tap or shake the vibration sensor several times.
# Observe how the sensor responds.
# Select a suitable vibration threshold.
# Change the VIBRATION_THRESHOLD value if required.
# Upload the program again.
# Verify that normal vibration does not unnecessarily generate an alert.
# Verify that repeated vibration generates the alert.

For a simple classroom demonstration, the threshold can be kept low so that students can easily trigger the alert by tapping or shaking the sensor.

== Procedure ==

# Connect the vibration sensor to the ESP32.
# Connect VCC to 3.3V.
# Connect GND to GND.
# Connect the digital output of the vibration sensor to GPIO 27.
# Connect the ESP32 to the computer.
# Open Arduino IDE.
# Select the appropriate ESP32 board.
# Select the appropriate COM port.
# Upload the program.
# Open the Serial Monitor.
# Verify that the ESP32 Access Point has started.
# Connect the smartphone to ESP32-Vibration-Monitor.
# Open the smartphone browser.
# Enter http://192.168.1.4.
# Observe the NORMAL status.
# Keep the vibration sensor stationary.
# Tap or shake the sensor repeatedly.
# Generate several vibration events within the monitoring period.
# Observe the EXCESSIVE VIBRATION alert.
# Wait for the next monitoring period and observe the status.
# Verify that the web page refreshes automatically every 5 seconds.
# Perform the data minimization demonstration.

== Observations and Output ==

=== Normal Condition ===

When the vibration sensor is stationary or experiences only minor vibration:

<pre>
Sensor Condition : Normal
System Status : NORMAL
Alert : None
</pre>

The system does not generate an alert.

=== Excessive Vibration Condition ===

When repeated vibration events cross the predefined threshold:

<pre>
Sensor Condition : Excessive vibration
System Status : ALERT
Alert : EXCESSIVE VIBRATION
</pre>

The ESP32 generates the alert locally.

=== Smartphone Output ===

Normal condition:

<pre>
SMART VIBRATION MONITOR

NORMAL

Vibration level is within
the normal range.

Page refreshes every 5 seconds.
</pre>

Excessive vibration condition:

<pre>
SMART VIBRATION MONITOR

EXCESSIVE VIBRATION

Threshold crossed.
Alert generated.

Page refreshes every 5 seconds.
</pre>

== Demonstration of Data Minimization ==

The main purpose of this experiment is to demonstrate that unnecessary raw sensor information does not need to be continuously transmitted.

=== Conventional System ===

In a conventional IoT system, every sensor event or sensor reading could be transmitted to a server.

For example:

<pre>
Vibration event detected
Vibration event detected
Vibration event detected
Vibration event detected
Vibration event detected
</pre>

The server would receive a continuous stream of sensor information.

=== Privacy-by-Design System ===

In the proposed system, the ESP32 processes the vibration activity locally.

The ESP32 counts the vibration events and compares the count with the threshold.

The process is:

<pre>
Vibration activity
|
v
Local processing
|
v
Count events
|
v
Check threshold
|
+---------------------+
| |
v v
Below threshold Threshold reached
| |
v v
No alert EXCESSIVE VIBRATION
</pre>

The raw vibration activity is not required outside the ESP32 for the basic application.

Only the required alert needs to be exposed.

== Data Inspection Demonstration ==

The data inspection demonstration is used to compare the amount of information exposed by two system designs.

The demonstration is educational and is intended to show the effect of data minimization.

=== Conventional Design ===

A conventional system may continuously expose individual vibration events:

<pre>
Vibration event
Vibration event
Vibration event
Vibration event
Vibration event
</pre>

An observer can therefore obtain detailed information about the vibration activity.

=== Privacy-by-Design Design ===

The Privacy-by-Design system processes the vibration activity locally.

When the vibration count is below the threshold:

<pre>
No alert
</pre>

When the threshold is reached:

<pre>
EXCESSIVE VIBRATION
</pre>

The application therefore exposes only the information required for the intended purpose.

=== Demonstration Steps ===

# Connect the smartphone to the ESP32 Access Point.
# Open the ESP32 web page.
# Observe the NORMAL condition.
# Tap or shake the vibration sensor repeatedly.
# Generate enough vibration events to cross the threshold.
# Observe the EXCESSIVE VIBRATION alert.
# Inspect the application data using an appropriate network inspection or server logging method.
# Observe that the application does not need to continuously expose every vibration event.
# Explain that the ESP32 processes the vibration activity locally before generating the alert.

'''Note:''' This demonstration is about data minimization. It does not claim that HTTP communication is encrypted or completely secure.

== Conventional System vs Privacy-by-Design System ==

{| class="wikitable"
! Feature
! Conventional System
! Privacy-by-Design System
|-
| Sensor processing
| May be performed at server
| Performed locally on ESP32
|-
| Vibration events
| May be continuously transmitted
| Processed locally
|-
| Normal activity
| May be transmitted
| No unnecessary transmission
|-
| Threshold detection
| May be performed at server
| Performed on ESP32
|-
| Alert
| May contain detailed sensor information
| Only required alert is exposed
|-
| Data volume
| Higher
| Lower
|-
| Data exposure
| Higher
| Minimized
|}

== Why This is Privacy-by-Design ==

The experiment demonstrates Privacy-by-Design through the following design decisions:

# '''Local Processing:''' Vibration activity is processed on the ESP32.
# '''Data Minimization:''' Individual vibration events do not need to be continuously transmitted.
# '''Purpose Limitation:''' The system only needs to detect excessive vibration.
# '''Smart Thresholding:''' An alert is generated only when the vibration threshold is crossed.
# '''Reduced Data Exposure:''' Unnecessary sensor information is not exposed.
# '''Privacy by Default:''' The system is designed to minimize data exposure from the beginning.

The main principle demonstrated is:

<pre>
Do not transmit unnecessary information
when the application does not require it.
</pre>

== Automatic Page Refresh ==

The web page automatically refreshes every 5 seconds.

This is implemented using the page refresh setting in the generated web page.

The refresh interval allows the student to observe the latest vibration status without manually refreshing the browser.

The refresh interval is:

<pre>
5 seconds
</pre>

Therefore, after generating vibration activity, the student can wait for the next page refresh to observe the updated alert status.

== Advantages ==

# Reduces unnecessary sensor data transmission.
# Processes vibration information locally.
# Reduces the amount of sensor information exposed outside the device.
# Allows fast local decision making.
# Demonstrates data minimization clearly.
# Does not require an external cloud server.
# Can be demonstrated easily using a smartphone.
# Vibration can be generated manually by tapping or shaking the sensor.
# The web page automatically refreshes every 5 seconds.
# Can be extended to industrial machine monitoring applications.

== Limitations ==

# The vibration sensor module provides a simple indication of vibration and may not provide precise vibration measurements.
# The sensor may respond differently depending on the strength and duration of vibration.
# The threshold must be calibrated for the actual sensor and application.
# Environmental vibration may cause unwanted detections.
# The HTTP communication used in this experiment is not encrypted.
# This experiment demonstrates data minimization and not complete IoT security.
# A real industrial vibration monitoring system would normally use a more precise vibration sensor and appropriate signal processing.

== Result ==

The smart threshold alert system was successfully implemented using a vibration sensor and ESP32.

The ESP32 locally monitored vibration activity and counted vibration events during a predefined monitoring period.

When the number of vibration events reached the selected threshold, the system generated an EXCESSIVE VIBRATION alert.

The alert was displayed on a smartphone through the ESP32 web server using:

<pre>
http://192.168.1.4
</pre>

The web page automatically refreshed every 5 seconds.

The experiment demonstrated that raw vibration activity does not need to be continuously exposed when the application only requires an excessive-vibration alert.

Thus, the experiment demonstrated data minimization through local processing and smart threshold alerts as a practical Privacy-by-Design approach.

== Viva Questions ==

'''Q1. What is Privacy-by-Design?'''

'''Ans:''' Privacy-by-Design means incorporating privacy considerations into the design of a system from the beginning.

'''Q2. What is data minimization?'''

'''Ans:''' Data minimization means collecting, processing, transmitting, and storing only the data required for the intended purpose.

'''Q3. Why is a vibration sensor used in this experiment?'''

'''Ans:''' A vibration sensor is used because vibration can be generated manually by tapping or shaking the sensor, making the alert easy to demonstrate.

'''Q4. What does excessive vibration represent in this experiment?'''

'''Ans:''' Excessive vibration represents a condition in which the number of vibration events has crossed the predefined threshold.

'''Q5. Why is the raw vibration activity not continuously transmitted?'''

'''Ans:''' The application only needs to know whether excessive vibration has occurred. Therefore, continuously transmitting every vibration event is unnecessary.

'''Q6. Where is the vibration threshold checked?'''

'''Ans:''' The threshold is checked locally on the ESP32.

'''Q7. What happens when the threshold is not crossed?'''

'''Ans:''' No excessive-vibration alert is generated.

'''Q8. What happens when the threshold is crossed?'''

'''Ans:''' The ESP32 detects excessive vibration and generates the EXCESSIVE VIBRATION alert.

'''Q9. What is the purpose of the data inspection demonstration?'''

'''Ans:''' It demonstrates how data minimization reduces the amount of unnecessary sensor information exposed outside the device.

'''Q10. What information is required when the threshold is crossed?'''

'''Ans:''' The required information is the EXCESSIVE VIBRATION alert.

'''Q11. Why does the web page refresh every 5 seconds?'''

'''Ans:''' The page refreshes every 5 seconds so that the smartphone can display the latest system status automatically.

'''Q12. Is the system completely secure?'''

'''Ans:''' No. The main purpose is to demonstrate data minimization and Privacy-by-Design. The HTTP communication used here is not encrypted.

'''Q13. Does data minimization mean that no data is transmitted?'''

'''Ans:''' No. It means that only the data necessary for the intended purpose should be transmitted or exposed.

'''Q14. Why is local processing useful?'''

'''Ans:''' Local processing allows the ESP32 to make decisions using sensor data without unnecessarily exposing the raw sensor activity.

'''Q15. What is a smart threshold alert?'''

'''Ans:''' A smart threshold alert is generated when sensor activity crosses a predefined threshold representing a meaningful condition.

'''Q16. What is the main principle demonstrated by this experiment?'''

'''Ans:''' The main principle is data minimization. Sensor activity is processed locally and only the required alert is exposed.

AIDS IoT Kits User Manuals

2026-10-08T03:20:42Z

CogWikiEditor: /* Laboratory Objectives */

<div style="text-align:center;">
[[File:Sppu-logo.jpg|200px|SPPU Logo]]
</div>

<div style="text-align:center;">
<span style="font-size:200%; font-weight:bold;">TE AIDS MDM331AID : Internet of Things Lab</span>
<br>
<span style="font-size:120%;">Cognifront IoT Kit for MDM331AID : Internet of Things Lab</span>
</div>

== About the Laboratory ==

The Internet of Things (IoT) laboratory provides hands-on experience in connecting physical devices, sensors, microcontrollers and cloud platforms to develop intelligent, connected systems.

This laboratory manual is designed for students of Third Year B.E. Artificial Intelligence and Data Science Engineering, covering fundamental IoT concepts, embedded programming, sensor interfacing, network communication and cloud-based applications.

== Laboratory Objectives ==

* Understand the architecture and fundamental concepts of the Internet of Things.
* Interface sensors and actuators with embedded development boards.
* Develop programs for acquiring and processing sensor data.
* Implement communication protocols used in IoT systems.
* Connect IoT devices with cloud platforms for data visualization and monitoring.
* Design and implement real-world IoT applications.

{| class="wikitable"
|-
! #
! Experiment Title
|-
! colspan="2" | Part A
|-
| 1
| [[MDM331AID/Experiment 1|Develop an application for the connectivity of the Arduino UNO/Raspberry Pi circuit with sensors.]]
|-
| 2
| [[MDM331AID/Experiment 2|Implement an application to detect obstacles and notify users using LEDs to understand the connectivity of Raspberry Pi / Arduino with IR sensor.]]
|-
| 3
| [[MDM331AID/Experiment 3|Implement a simple IoT application using an Arduino board to control an LED through GPIO pins in order to understand the physical design of IoT devices and device actuation.]]
|-
| 4
| [[MDM331AID/Experiment 4|Develop a program to detect gas leakage in the surrounding environment.]]
|-
| 5
| [[MDM331AID/Experiment 5|Configure and implement an IoT device (Arduino UNO/ESP module/Raspberry Pi) to connect to a Wi-Fi network and transmit sensor data to a remote computer using TCP/IP communication.]]
|-
| 6
| [[MDM331AID/Experiment 6|Implement an edge computing model where sensor data is processed locally on an edge device (Raspberry Pi) before being transmitted to the cloud to reduce latency and bandwidth usage.]]
|-
| 7
| [[MDM331AID/Experiment 7|Design an RFID-based identification system that reads tag information and displays the ID on a monitoring system to demonstrate short-range communication technologies in IoT.]]
|-
! colspan="2" | Part B
|-
| 8
| [[MDM331AID/Experiment 8|Develop an IoT application that uses a communication protocol to transmit sensor data between an IoT device and a server.]]
|-
| 9
| [[MDM331AID/Experiment 9|Perform data cleaning, normalization, and visualization on an IoT sensor dataset (any dataset can be considered).]]
|-
| 10
| [[MDM331AID/Experiment 10|Implement an IoT application to collect real-time temperature data using an IoT sensor and apply a machine learning model to predict future temperature values (any machine learning model).]]
|-
| 11
| [[MDM331AID/Experiment 11|Design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts (any security algorithm can be used).]]
|-
| 12
| [[MDM331AID/Experiment 12|Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-

| 13
| [[MDM331AID/Experiment 13|Develop and implement a machine learning model to perform classification (e.g., activity recognition or device state detection) and anomaly detection (e.g., fault detection in industrial IoT sensors).]]
|-
| 14
| [[MDM331AID/Experiment 14|Case study for data minimization using smart threshold alerts by providing Privacy-by-Design.]]
|-
! colspan="2" | Part C
|-
| 15
| [[MDM331AID/Experiment 15|Develop a Privacy-Aware Intelligent Smart IoT Application: Design and implementation of an AIoT-based smart sensor system with cloud-based data preprocessing and intelligent decision-making using machine learning techniques, incorporating secure communication protocols with built-in security and privacy mechanisms, with complete deliverables including a working demonstration and technical report.]]
|}

MDM331AID/Experiment 12

2026-10-08T03:20:11Z

CogWikiEditor:

= Experiment: Secure Sensor Data Transmission Using Bluetooth Low Energy =

== Aim ==

To implement secure transmission of temperature and humidity data from an IoT sensor using Bluetooth Low Energy (BLE) and demonstrate authenticated and encrypted communication between an ESP32 and a smartphone.

== Objectives ==

* To understand the concept of Bluetooth Low Energy (BLE) communication in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To configure the ESP32 as a BLE server.
* To transmit real-time sensor data from the ESP32 to a smartphone using BLE.
* To understand BLE services and characteristics.
* To implement BLE pairing and authentication using a passkey.
* To understand how BLE encryption protects transmitted sensor data.
* To verify secure sensor-data communication using a smartphone BLE application.

== Components Required ==

{| class="wikitable" style="width: 80%;"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| IoT controller and BLE server
|-
| 2
| DHT11 Sensor
| 1
| Measures temperature and humidity
|-
| 3
| USB Cable
| 1
| Programming and power supply
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Smartphone
| 1
| BLE client for receiving sensor data
|-
| 6
| LightBlue® BLE Application
| 1
| Scanning, connecting and monitoring BLE data
|-
| 7
| Arduino IDE
| 1
| ESP32 programming
|}

=== Smartphone Application ===

The recommended application for this experiment is **LightBlue® by Punch Through**.

LightBlue is a BLE debugging and development application that is available for both Android and iOS. It can scan for BLE peripherals, connect to them, display their services and characteristics, and read or subscribe to characteristic values.

The application can be installed from:

* Android: [LightBlue® on Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)
* iPhone/iPad: [LightBlue® on the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

== Theory ==

=== Bluetooth Low Energy ===

Bluetooth Low Energy (BLE) is a wireless communication technology designed for low-power communication between devices. It is widely used in IoT sensors, wearable devices, smart-home devices and other embedded systems.

An ESP32 can operate as a BLE device and communicate with smartphones and other BLE-enabled devices. The Arduino ESP32 framework provides a BLE library for creating BLE servers, services and characteristics.

In this experiment, the ESP32 operates as a '''BLE GATT server''', while the smartphone operates as the '''BLE client'''.

The communication structure is:

<pre>
DHT11 Sensor
↓
ESP32
↓
BLE GATT Server
↓
Secure BLE Connection
↓
Smartphone
↓
LightBlue Application
</pre>

=== BLE GATT ===

BLE devices commonly organize application data using the Generic Attribute Profile (GATT).

The main components used in this experiment are:

'''Service:'''
A service groups related functionality of a BLE device.

'''Characteristic:'''
A characteristic contains a particular piece of data that can be read, written or notified.

For this experiment, one BLE service is created containing two characteristics:

{| class="wikitable"
! Characteristic
! Data
! Operation
|-
| Temperature
| Temperature in °C
| Read / Notify
|-
| Humidity
| Relative humidity in %
| Read / Notify
|}

The smartphone can connect to the ESP32 and subscribe to notifications so that updated sensor values are received automatically.

=== BLE Security ===

BLE provides security mechanisms for authentication, pairing, bonding and encrypted communication.

In this experiment, BLE security is configured using:

* Pairing
* Bonding
* MITM (Man-in-the-Middle) protection
* Secure Connections
* Passkey authentication

Espressif's ESP32 BLE security documentation supports authentication modes combining bonding, MITM protection and Secure Connections.

=== Pairing ===

Pairing is the process by which two Bluetooth devices establish the information required to create a trusted secure relationship.

In this experiment, the smartphone and ESP32 are paired using a passkey.

Example:

<pre>
ESP32
↓
BLE connection request
↓
Pairing request
↓
Passkey authentication
↓
Secure key establishment
↓
Encrypted BLE communication
</pre>

=== Bonding ===

Bonding allows the security information established during pairing to be stored so that the devices can recognize each other during future connections.

Espressif distinguishes bonding from encryption: bonding stores long-term keys after successful encryption, while encryption protects the communication link.

=== BLE Encryption ===

After successful authentication, the BLE link can be encrypted.

Therefore, the sensor data transmitted over the BLE connection is protected from simple interception of the communication.

The security flow is:

<pre>
Sensor Data
↓
BLE Security / Pairing
↓
Authentication
↓
Encryption
↓
Secure BLE Transmission
↓
Smartphone
</pre>

== Pin Connections ==

=== DHT11 to ESP32 ===

{| class="wikitable"
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital sensor data
|-
| GND
| GND
| Ground
|}

== Connection Diagram ==

<pre>
+----------------+
| DHT11 |
| |
| VCC DATA GND |
+--+----+-----+--+
| | |
3.3V GPIO4 GND
| | |
| | |
+------+----+-----+------+
| ESP32 |
| |
| BLE Server |
| )))) |
+------------))----------+
))
))
Secure BLE Link
))
))
+-----------+
| Smartphone|
| |
| LightBlue |
+-----------+
</pre>

== Program ==

=== Arduino Program ===

<pre>
#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLESecurity.h>
#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT11

#define DEVICE_NAME "ESP32-Secure-Sensor"

#define SERVICE_UUID \
"4fafc201-1fb5-459e-8fcc-c5c9c331914b"

#define TEMP_UUID \
"beb5483e-36e1-4688-b7f5-ea07361b26a8"

#define HUMIDITY_UUID \
"cba1d466-344c-4be3-ab3f-189f80dd7518"

#define BLE_PASSKEY 123456

DHT dht(DHTPIN, DHTTYPE);

BLECharacteristic *temperatureCharacteristic;
BLECharacteristic *humidityCharacteristic;

class SecurityCallbacks : public BLESecurityCallbacks
{
uint32_t onPassKeyRequest()
{
Serial.println("Passkey requested");
return BLE_PASSKEY;
}

void onPassKeyNotify(uint32_t passkey)
{
Serial.print("Passkey: ");
Serial.println(passkey);
}

bool onConfirmPIN(uint32_t pin)
{
Serial.print("Confirm PIN: ");
Serial.println(pin);
return true;
}

bool onSecurityRequest()
{
Serial.println("Security request received");
return true;
}

void onAuthenticationComplete(esp_ble_auth_cmpl_t desc)
{
if (desc.success)
Serial.println("BLE authentication successful");
else
Serial.println("BLE authentication failed");
}
};

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

dht.begin();

BLEDevice::init(DEVICE_NAME);

BLESecurity *security = new BLESecurity();

security->setCapability(ESP_IO_CAP_OUT);

security->setAuthenticationMode(
ESP_LE_AUTH_REQ_SC_MITM_BOND
);

BLEDevice::setSecurityCallbacks(
new SecurityCallbacks()
);

BLEServer *server = BLEDevice::createServer();

BLEService *service =
server->createService(SERVICE_UUID);

temperatureCharacteristic =
service->createCharacteristic(
TEMP_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

humidityCharacteristic =
service->createCharacteristic(
HUMIDITY_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

temperatureCharacteristic->setValue("0.0");
humidityCharacteristic->setValue("0.0");

service->start();

BLEAdvertising *advertising =
BLEDevice::getAdvertising();

advertising->addServiceUUID(SERVICE_UUID);
advertising->setScanResponse(true);

BLEDevice::startAdvertising();

Serial.println();
Serial.println("Secure BLE Sensor Started");
Serial.println("Device Name: ESP32-Secure-Sensor");
Serial.println("Passkey: 123456");
Serial.println("Waiting for BLE connection...");
}

void loop()
{
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

if (isnan(temperature) || isnan(humidity))
{
Serial.println("DHT11 reading failed");
delay(2000);
return;
}

char temperatureValue[10];
char humidityValue[10];

dtostrf(temperature, 1, 2, temperatureValue);
dtostrf(humidity, 1, 2, humidityValue);

temperatureCharacteristic->setValue(
temperatureValue
);

humidityCharacteristic->setValue(
humidityValue
);

temperatureCharacteristic->notify();
humidityCharacteristic->notify();

Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");

Serial.print("Humidity: ");
Serial.print(humidity);
Serial.println(" %");

Serial.println("Sensor data sent using secure BLE");

delay(2000);
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code
! Explanation
|-
| `#include <BLEDevice.h>`
| Provides the main BLE device functionality.
|-
| `#include <BLEServer.h>`
| Provides functionality for creating a BLE server.
|-
| `#include <BLESecurity.h>`
| Provides BLE pairing and security configuration.
|-
| `#include <DHT.h>`
| Provides functions for interfacing with the DHT11 sensor.
|-
| `DHTPIN 4`
| Defines GPIO 4 as the DHT11 data pin.
|-
| `DEVICE_NAME`
| Defines the name advertised by the ESP32.
|-
| `SERVICE_UUID`
| Uniquely identifies the BLE sensor service.
|-
| `TEMP_UUID`
| Identifies the temperature characteristic.
|-
| `HUMIDITY_UUID`
| Identifies the humidity characteristic.
|-
| `BLE_PASSKEY 123456`
| Defines the passkey used for BLE authentication.
|-
| `dht.begin()`
| Initializes the DHT11 sensor.
|-
| `BLEDevice::init()`
| Initializes BLE and assigns the device name.
|-
| `setPassKey()`
| Configures the BLE passkey.
|-
| `setCapability()`
| Defines the input/output capability used during authentication.
|-
| `setAuthenticationMode(true, true, true)`
| Enables bonding, MITM protection and Secure Connections.
|-
| `createServer()`
| Creates the ESP32 BLE server.
|-
| `createService()`
| Creates the BLE sensor service.
|-
| `createCharacteristic()`
| Creates temperature and humidity characteristics.
|-
| `PROPERTY_READ`
| Allows the smartphone to read the sensor value.
|-
| `PROPERTY_NOTIFY`
| Allows the ESP32 to send updated sensor values to the smartphone.
|-
| `service->start()`
| Starts the BLE service.
|-
| `startAdvertising()`
| Makes the ESP32 discoverable by BLE clients.
|-
| `dht.readTemperature()`
| Reads temperature from the DHT11.
|-
| `dht.readHumidity()`
| Reads humidity from the DHT11.
|-
| `setValue()`
| Updates the BLE characteristic value.
|-
| `notify()`
| Sends the updated value to subscribed BLE clients.
|}

== Security Configuration ==

The following security settings are used in the experiment:

{| class="wikitable"
! Security Feature
! Purpose
|-
| Passkey
| Provides authentication during pairing.
|-
| MITM Protection
| Provides protection against certain man-in-the-middle attacks during authenticated pairing.
|-
| Secure Connections
| Uses the BLE Secure Connections pairing mechanism.
|-
| Bonding
| Allows security information to be retained for future connections.
|-
| Encryption
| Protects data transmitted over the established BLE link.
|}

Espressif documents BLE security configurations including bonding, MITM protection and Secure Connections, and provides dedicated BLE security examples.

== Smartphone Setup ==

=== Step 1: Install LightBlue ===

Install '''LightBlue® by Punch Through''' on the smartphone.

For Android:

[Download LightBlue from Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)

For iPhone/iPad:

[Download LightBlue from the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

The same application is available on both platforms.

=== Step 2: Upload the Program ===

1. Connect the ESP32 to the computer using the USB cable.
2. Open Arduino IDE.
3. Select the appropriate ESP32 board.
4. Select the correct COM port.
5. Upload the program.
6. Open the Serial Monitor at '''115200 baud'''.

The Serial Monitor should display:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...
</pre>

=== Step 3: Start LightBlue ===

1. Enable Bluetooth on the smartphone.
2. Open the LightBlue application.
3. Allow the required Bluetooth permissions.
4. Start scanning for nearby BLE devices.
5. Locate:

<pre>
ESP32-Secure-Sensor
</pre>

6. Select the device and tap '''Connect'''.

LightBlue supports BLE scanning, connection, service/characteristic inspection, reading, writing and notifications.

=== Step 4: Pair the Device ===

When the ESP32 requests secure pairing, the smartphone will display the BLE pairing/passkey interaction.

Enter or confirm:

<pre>
123456
</pre>

After successful authentication, the BLE connection becomes secured.

Espressif's BLE documentation demonstrates pairing between an ESP32 BLE server and a mobile phone using LightBlue, including passkey-based pairing.

=== Step 5: View Sensor Data ===

After connecting, LightBlue displays the BLE service and its characteristics.

The structure will be similar to:

<pre>
ESP32-Secure-Sensor

↓↓ Scroll to bottom

beb5483e-36e1-4688-b7f5-ea07361b26a8 (This is Temperature)

cba1d466-344c-4be3-ab3f-189f80dd7518 (This is Humidity)

</pre>

You can change the name of the above services and set them to Temperature and Humidity respectively for easy access.

The exact appearance of the LightBlue interface may vary between Android and iOS versions.

=== Step 6: Enable Notifications ===

The temperature and humidity characteristics support notifications.

Enable notifications for the characteristics in LightBlue.

The ESP32 will then periodically send updated sensor readings.

Example:

<pre>
Temperature: 27.40 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 62.00 %
</pre>

== Data Flow ==

The complete data flow of the experiment is:

<pre>
DHT11 Sensor
↓
Temperature / Humidity
↓
ESP32
↓
BLE GATT Server
↓
BLE Pairing & Authentication
↓
Encrypted BLE Link
↓
Smartphone
↓
LightBlue Application
↓
Temperature / Humidity Data
</pre>

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the given pin connections.
# Install the DHT sensor library in Arduino IDE if required.
# Install the ESP32 board package in Arduino IDE.
# Install the LightBlue BLE application on an Android or iOS smartphone.
# Enter the BLE program into Arduino IDE.
# Connect the ESP32 to the computer.
# Select the correct ESP32 board and COM port.
# Upload the program.
# Open the Serial Monitor at 115200 baud.
# Verify that the ESP32 starts BLE advertising.
# Open LightBlue on the smartphone.
# Scan for nearby BLE devices.
# Select `ESP32-Secure-Sensor`.
# Establish the BLE connection.
# Complete the passkey authentication using `123456`.
# Verify that the BLE connection is authenticated and secured.
# Open the sensor service in LightBlue.
# Locate the temperature and humidity characteristics.
# Enable notifications for the characteristics.
# Observe the temperature and humidity values received from the ESP32.
# Compare the displayed values with the DHT11 readings shown in the Serial Monitor.
# Record the observed values.

== Observations and Output ==

=== Serial Monitor ===

The Serial Monitor displays information similar to:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...

Temperature: 27.40 °C
Humidity: 61.00 %
Sensor data sent using secure BLE

Temperature: 27.50 °C
Humidity: 61.00 %
Sensor data sent using secure BLE
</pre>

=== Smartphone ===

The LightBlue application should show:

{| class="wikitable"
! Parameter
! Example Observation
|-
| BLE Device
| ESP32-Secure-Sensor
|-
| BLE Service
| Sensor Service
|-
| Temperature
| 27.40 °C
|-
| Humidity
| 61.00 %
|-
| Authentication
| Successful
|-
| Communication
| Secure BLE
|}

The actual temperature and humidity values will depend on the environmental conditions.

== Result ==

The DHT11 sensor was successfully interfaced with the ESP32, and temperature and humidity data were transmitted to a smartphone using Bluetooth Low Energy. BLE pairing and security mechanisms were configured to authenticate the smartphone and establish a protected communication link. The sensor values were successfully observed using the LightBlue BLE application.

== Security Considerations ==

* The BLE passkey used in this experiment is intended for educational demonstration.
* A fixed passkey such as `123456` should not be used in a real security-sensitive product.
* Production IoT systems should use appropriate device-specific credentials and security policies.
* Secure Connections and MITM protection improve the security of BLE pairing, but the overall security of an IoT product also depends on its firmware, credential management and application design.
* The experiment demonstrates BLE link security; it should not be interpreted as complete end-to-end IoT security.
* The LightBlue application is being used as a BLE debugging/client tool rather than as a custom end-user IoT application.

== Viva Questions ==

'''Q1. What is BLE?'''

BLE stands for Bluetooth Low Energy. It is a wireless communication technology designed for low-power communication between devices.

'''Q2. Why is BLE suitable for IoT applications?'''

BLE provides short-range wireless communication with relatively low power consumption, making it suitable for sensors and other IoT devices.

'''Q3. What is GATT?'''

GATT stands for Generic Attribute Profile. It defines how BLE devices organize and exchange application data using services and characteristics.

'''Q4. What is a BLE service?'''

A service is a collection of related BLE characteristics that represents a particular function of the device.

'''Q5. What is a BLE characteristic?'''

A characteristic represents a specific piece of data or functionality and can support operations such as read, write and notify.

'''Q6. What is pairing?'''

Pairing is the process of establishing security information between two Bluetooth devices so that a secure relationship can be created.

'''Q7. What is BLE encryption?'''

BLE encryption protects data exchanged over an established secure BLE connection.

'''Q8. What is a passkey used for?'''

A passkey is used as part of the authentication process during BLE pairing.

'''Q9. What is MITM protection?'''

MITM stands for Man-in-the-Middle. MITM protection helps prevent an attacker from impersonating one of the devices during the authentication process.

'''Q10. What is bonding?'''

Bonding is the process of storing security information after pairing so that the devices can establish trusted connections again later.

'''Q11. Why is LightBlue used in this experiment?'''

LightBlue provides a convenient BLE client interface for discovering the ESP32, connecting to it, inspecting services and characteristics, and receiving notifications.

'''Q12. Can the same application be used on Android and iOS?'''

Yes. LightBlue is available for both Android and iOS.

'''Q13. What is the role of the ESP32 in this experiment?'''

The ESP32 reads the DHT11 sensor and acts as a BLE GATT server that provides the sensor data to the smartphone.

'''Q14. What is the difference between `READ` and `NOTIFY` in BLE?'''

`READ` allows the client to request the current value. `NOTIFY` allows the server to send updated values automatically when the client subscribes to notifications.

'''Q15. How is this experiment different from HTTPS-based cloud communication?'''

HTTPS protects communication between an IoT device and a web/cloud server over a network. This experiment demonstrates secure short-range BLE communication directly between an ESP32 and a smartphone.

== Conclusion ==

This experiment demonstrates how Bluetooth Low Energy can be used for secure IoT sensor-data transmission. The ESP32 reads temperature and humidity from the DHT11 sensor and exposes the readings through BLE characteristics. The smartphone connects using the LightBlue application, performs secure pairing, and receives the sensor data through an authenticated and encrypted BLE connection.

MDM331AID/Experiment 12 BLE

2026-10-08T03:05:45Z

CogWikiEditor: /* Step 5: View Sensor Data */

MDM331AID/Experiment 12 BLE

2026-10-08T03:00:36Z

CogWikiEditor: /* Arduino Program */

= Experiment: Secure Sensor Data Transmission Using Bluetooth Low Energy =

== Aim ==

To implement secure transmission of temperature and humidity data from an IoT sensor using Bluetooth Low Energy (BLE) and demonstrate authenticated and encrypted communication between an ESP32 and a smartphone.

== Objectives ==

* To understand the concept of Bluetooth Low Energy (BLE) communication in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To configure the ESP32 as a BLE server.
* To transmit real-time sensor data from the ESP32 to a smartphone using BLE.
* To understand BLE services and characteristics.
* To implement BLE pairing and authentication using a passkey.
* To understand how BLE encryption protects transmitted sensor data.
* To verify secure sensor-data communication using a smartphone BLE application.

== Components Required ==

{| class="wikitable" style="width: 80%;"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| IoT controller and BLE server
|-
| 2
| DHT11 Sensor
| 1
| Measures temperature and humidity
|-
| 3
| USB Cable
| 1
| Programming and power supply
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Smartphone
| 1
| BLE client for receiving sensor data
|-
| 6
| LightBlue® BLE Application
| 1
| Scanning, connecting and monitoring BLE data
|-
| 7
| Arduino IDE
| 1
| ESP32 programming
|}

=== Smartphone Application ===

The recommended application for this experiment is **LightBlue® by Punch Through**.

LightBlue is a BLE debugging and development application that is available for both Android and iOS. It can scan for BLE peripherals, connect to them, display their services and characteristics, and read or subscribe to characteristic values.

The application can be installed from:

* Android: [LightBlue® on Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)
* iPhone/iPad: [LightBlue® on the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

== Theory ==

=== Bluetooth Low Energy ===

Bluetooth Low Energy (BLE) is a wireless communication technology designed for low-power communication between devices. It is widely used in IoT sensors, wearable devices, smart-home devices and other embedded systems.

An ESP32 can operate as a BLE device and communicate with smartphones and other BLE-enabled devices. The Arduino ESP32 framework provides a BLE library for creating BLE servers, services and characteristics.

In this experiment, the ESP32 operates as a '''BLE GATT server''', while the smartphone operates as the '''BLE client'''.

The communication structure is:

<pre>
DHT11 Sensor
↓
ESP32
↓
BLE GATT Server
↓
Secure BLE Connection
↓
Smartphone
↓
LightBlue Application
</pre>

=== BLE GATT ===

BLE devices commonly organize application data using the Generic Attribute Profile (GATT).

The main components used in this experiment are:

'''Service:'''
A service groups related functionality of a BLE device.

'''Characteristic:'''
A characteristic contains a particular piece of data that can be read, written or notified.

For this experiment, one BLE service is created containing two characteristics:

{| class="wikitable"
! Characteristic
! Data
! Operation
|-
| Temperature
| Temperature in °C
| Read / Notify
|-
| Humidity
| Relative humidity in %
| Read / Notify
|}

The smartphone can connect to the ESP32 and subscribe to notifications so that updated sensor values are received automatically.

=== BLE Security ===

BLE provides security mechanisms for authentication, pairing, bonding and encrypted communication.

In this experiment, BLE security is configured using:

* Pairing
* Bonding
* MITM (Man-in-the-Middle) protection
* Secure Connections
* Passkey authentication

Espressif's ESP32 BLE security documentation supports authentication modes combining bonding, MITM protection and Secure Connections.

=== Pairing ===

Pairing is the process by which two Bluetooth devices establish the information required to create a trusted secure relationship.

In this experiment, the smartphone and ESP32 are paired using a passkey.

Example:

<pre>
ESP32
↓
BLE connection request
↓
Pairing request
↓
Passkey authentication
↓
Secure key establishment
↓
Encrypted BLE communication
</pre>

=== Bonding ===

Bonding allows the security information established during pairing to be stored so that the devices can recognize each other during future connections.

Espressif distinguishes bonding from encryption: bonding stores long-term keys after successful encryption, while encryption protects the communication link.

=== BLE Encryption ===

After successful authentication, the BLE link can be encrypted.

Therefore, the sensor data transmitted over the BLE connection is protected from simple interception of the communication.

The security flow is:

<pre>
Sensor Data
↓
BLE Security / Pairing
↓
Authentication
↓
Encryption
↓
Secure BLE Transmission
↓
Smartphone
</pre>

== Pin Connections ==

=== DHT11 to ESP32 ===

{| class="wikitable"
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital sensor data
|-
| GND
| GND
| Ground
|}

== Connection Diagram ==

<pre>
+----------------+
| DHT11 |
| |
| VCC DATA GND |
+--+----+-----+--+
| | |
3.3V GPIO4 GND
| | |
| | |
+------+----+-----+------+
| ESP32 |
| |
| BLE Server |
| )))) |
+------------))----------+
))
))
Secure BLE Link
))
))
+-----------+
| Smartphone|
| |
| LightBlue |
+-----------+
</pre>

== Program ==

=== Arduino Program ===

<pre>
#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLESecurity.h>
#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT11

#define DEVICE_NAME "ESP32-Secure-Sensor"

#define SERVICE_UUID \
"4fafc201-1fb5-459e-8fcc-c5c9c331914b"

#define TEMP_UUID \
"beb5483e-36e1-4688-b7f5-ea07361b26a8"

#define HUMIDITY_UUID \
"cba1d466-344c-4be3-ab3f-189f80dd7518"

#define BLE_PASSKEY 123456

DHT dht(DHTPIN, DHTTYPE);

BLECharacteristic *temperatureCharacteristic;
BLECharacteristic *humidityCharacteristic;

class SecurityCallbacks : public BLESecurityCallbacks
{
uint32_t onPassKeyRequest()
{
Serial.println("Passkey requested");
return BLE_PASSKEY;
}

void onPassKeyNotify(uint32_t passkey)
{
Serial.print("Passkey: ");
Serial.println(passkey);
}

bool onConfirmPIN(uint32_t pin)
{
Serial.print("Confirm PIN: ");
Serial.println(pin);
return true;
}

bool onSecurityRequest()
{
Serial.println("Security request received");
return true;
}

void onAuthenticationComplete(esp_ble_auth_cmpl_t desc)
{
if (desc.success)
Serial.println("BLE authentication successful");
else
Serial.println("BLE authentication failed");
}
};

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

dht.begin();

BLEDevice::init(DEVICE_NAME);

BLESecurity *security = new BLESecurity();

security->setCapability(ESP_IO_CAP_OUT);

security->setAuthenticationMode(
ESP_LE_AUTH_REQ_SC_MITM_BOND
);

BLEDevice::setSecurityCallbacks(
new SecurityCallbacks()
);

BLEServer *server = BLEDevice::createServer();

BLEService *service =
server->createService(SERVICE_UUID);

temperatureCharacteristic =
service->createCharacteristic(
TEMP_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

humidityCharacteristic =
service->createCharacteristic(
HUMIDITY_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

temperatureCharacteristic->setValue("0.0");
humidityCharacteristic->setValue("0.0");

service->start();

BLEAdvertising *advertising =
BLEDevice::getAdvertising();

advertising->addServiceUUID(SERVICE_UUID);
advertising->setScanResponse(true);

BLEDevice::startAdvertising();

Serial.println();
Serial.println("Secure BLE Sensor Started");
Serial.println("Device Name: ESP32-Secure-Sensor");
Serial.println("Passkey: 123456");
Serial.println("Waiting for BLE connection...");
}

void loop()
{
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

if (isnan(temperature) || isnan(humidity))
{
Serial.println("DHT11 reading failed");
delay(2000);
return;
}

char temperatureValue[10];
char humidityValue[10];

dtostrf(temperature, 1, 2, temperatureValue);
dtostrf(humidity, 1, 2, humidityValue);

temperatureCharacteristic->setValue(
temperatureValue
);

humidityCharacteristic->setValue(
humidityValue
);

temperatureCharacteristic->notify();
humidityCharacteristic->notify();

Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");

Serial.print("Humidity: ");
Serial.print(humidity);
Serial.println(" %");

Serial.println("Sensor data sent using secure BLE");

delay(2000);
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code
! Explanation
|-
| `#include <BLEDevice.h>`
| Provides the main BLE device functionality.
|-
| `#include <BLEServer.h>`
| Provides functionality for creating a BLE server.
|-
| `#include <BLESecurity.h>`
| Provides BLE pairing and security configuration.
|-
| `#include <DHT.h>`
| Provides functions for interfacing with the DHT11 sensor.
|-
| `DHTPIN 4`
| Defines GPIO 4 as the DHT11 data pin.
|-
| `DEVICE_NAME`
| Defines the name advertised by the ESP32.
|-
| `SERVICE_UUID`
| Uniquely identifies the BLE sensor service.
|-
| `TEMP_UUID`
| Identifies the temperature characteristic.
|-
| `HUMIDITY_UUID`
| Identifies the humidity characteristic.
|-
| `BLE_PASSKEY 123456`
| Defines the passkey used for BLE authentication.
|-
| `dht.begin()`
| Initializes the DHT11 sensor.
|-
| `BLEDevice::init()`
| Initializes BLE and assigns the device name.
|-
| `setPassKey()`
| Configures the BLE passkey.
|-
| `setCapability()`
| Defines the input/output capability used during authentication.
|-
| `setAuthenticationMode(true, true, true)`
| Enables bonding, MITM protection and Secure Connections.
|-
| `createServer()`
| Creates the ESP32 BLE server.
|-
| `createService()`
| Creates the BLE sensor service.
|-
| `createCharacteristic()`
| Creates temperature and humidity characteristics.
|-
| `PROPERTY_READ`
| Allows the smartphone to read the sensor value.
|-
| `PROPERTY_NOTIFY`
| Allows the ESP32 to send updated sensor values to the smartphone.
|-
| `service->start()`
| Starts the BLE service.
|-
| `startAdvertising()`
| Makes the ESP32 discoverable by BLE clients.
|-
| `dht.readTemperature()`
| Reads temperature from the DHT11.
|-
| `dht.readHumidity()`
| Reads humidity from the DHT11.
|-
| `setValue()`
| Updates the BLE characteristic value.
|-
| `notify()`
| Sends the updated value to subscribed BLE clients.
|}

== Security Configuration ==

The following security settings are used in the experiment:

{| class="wikitable"
! Security Feature
! Purpose
|-
| Passkey
| Provides authentication during pairing.
|-
| MITM Protection
| Provides protection against certain man-in-the-middle attacks during authenticated pairing.
|-
| Secure Connections
| Uses the BLE Secure Connections pairing mechanism.
|-
| Bonding
| Allows security information to be retained for future connections.
|-
| Encryption
| Protects data transmitted over the established BLE link.
|}

Espressif documents BLE security configurations including bonding, MITM protection and Secure Connections, and provides dedicated BLE security examples.

== Smartphone Setup ==

=== Step 1: Install LightBlue ===

Install '''LightBlue® by Punch Through''' on the smartphone.

For Android:

[Download LightBlue from Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)

For iPhone/iPad:

[Download LightBlue from the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

The same application is available on both platforms.

=== Step 2: Upload the Program ===

1. Connect the ESP32 to the computer using the USB cable.
2. Open Arduino IDE.
3. Select the appropriate ESP32 board.
4. Select the correct COM port.
5. Upload the program.
6. Open the Serial Monitor at '''115200 baud'''.

The Serial Monitor should display:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...
</pre>

=== Step 3: Start LightBlue ===

1. Enable Bluetooth on the smartphone.
2. Open the LightBlue application.
3. Allow the required Bluetooth permissions.
4. Start scanning for nearby BLE devices.
5. Locate:

<pre>
ESP32-Secure-Sensor
</pre>

6. Select the device and tap '''Connect'''.

LightBlue supports BLE scanning, connection, service/characteristic inspection, reading, writing and notifications.

=== Step 4: Pair the Device ===

When the ESP32 requests secure pairing, the smartphone will display the BLE pairing/passkey interaction.

Enter or confirm:

<pre>
123456
</pre>

After successful authentication, the BLE connection becomes secured.

Espressif's BLE documentation demonstrates pairing between an ESP32 BLE server and a mobile phone using LightBlue, including passkey-based pairing.

=== Step 5: View Sensor Data ===

After connecting, LightBlue displays the BLE service and its characteristics.

The structure will be similar to:

<pre>
ESP32-Secure-Sensor

Service
└── Sensor Service
│
├── Temperature
│ Value: 27.40
│
└── Humidity
Value: 61.00
</pre>

The exact appearance of the LightBlue interface may vary between Android and iOS versions.

=== Step 6: Enable Notifications ===

The temperature and humidity characteristics support notifications.

Enable notifications for the characteristics in LightBlue.

The ESP32 will then periodically send updated sensor readings.

Example:

<pre>
Temperature: 27.40 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 62.00 %
</pre>

== Data Flow ==

The complete data flow of the experiment is:

<pre>
DHT11 Sensor
↓
Temperature / Humidity
↓
ESP32
↓
BLE GATT Server
↓
BLE Pairing & Authentication
↓
Encrypted BLE Link
↓
Smartphone
↓
LightBlue Application
↓
Temperature / Humidity Data
</pre>

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the given pin connections.
# Install the DHT sensor library in Arduino IDE if required.
# Install the ESP32 board package in Arduino IDE.
# Install the LightBlue BLE application on an Android or iOS smartphone.
# Enter the BLE program into Arduino IDE.
# Connect the ESP32 to the computer.
# Select the correct ESP32 board and COM port.
# Upload the program.
# Open the Serial Monitor at 115200 baud.
# Verify that the ESP32 starts BLE advertising.
# Open LightBlue on the smartphone.
# Scan for nearby BLE devices.
# Select `ESP32-Secure-Sensor`.
# Establish the BLE connection.
# Complete the passkey authentication using `123456`.
# Verify that the BLE connection is authenticated and secured.
# Open the sensor service in LightBlue.
# Locate the temperature and humidity characteristics.
# Enable notifications for the characteristics.
# Observe the temperature and humidity values received from the ESP32.
# Compare the displayed values with the DHT11 readings shown in the Serial Monitor.
# Record the observed values.

== Observations and Output ==

=== Serial Monitor ===

The Serial Monitor displays information similar to:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...

Temperature: 27.40 °C
Humidity: 61.00 %
Sensor data sent using secure BLE

Temperature: 27.50 °C
Humidity: 61.00 %
Sensor data sent using secure BLE
</pre>

=== Smartphone ===

The LightBlue application should show:

{| class="wikitable"
! Parameter
! Example Observation
|-
| BLE Device
| ESP32-Secure-Sensor
|-
| BLE Service
| Sensor Service
|-
| Temperature
| 27.40 °C
|-
| Humidity
| 61.00 %
|-
| Authentication
| Successful
|-
| Communication
| Secure BLE
|}

The actual temperature and humidity values will depend on the environmental conditions.

== Result ==

The DHT11 sensor was successfully interfaced with the ESP32, and temperature and humidity data were transmitted to a smartphone using Bluetooth Low Energy. BLE pairing and security mechanisms were configured to authenticate the smartphone and establish a protected communication link. The sensor values were successfully observed using the LightBlue BLE application.

== Security Considerations ==

* The BLE passkey used in this experiment is intended for educational demonstration.
* A fixed passkey such as `123456` should not be used in a real security-sensitive product.
* Production IoT systems should use appropriate device-specific credentials and security policies.
* Secure Connections and MITM protection improve the security of BLE pairing, but the overall security of an IoT product also depends on its firmware, credential management and application design.
* The experiment demonstrates BLE link security; it should not be interpreted as complete end-to-end IoT security.
* The LightBlue application is being used as a BLE debugging/client tool rather than as a custom end-user IoT application.

== Viva Questions ==

'''Q1. What is BLE?'''

BLE stands for Bluetooth Low Energy. It is a wireless communication technology designed for low-power communication between devices.

'''Q2. Why is BLE suitable for IoT applications?'''

BLE provides short-range wireless communication with relatively low power consumption, making it suitable for sensors and other IoT devices.

'''Q3. What is GATT?'''

GATT stands for Generic Attribute Profile. It defines how BLE devices organize and exchange application data using services and characteristics.

'''Q4. What is a BLE service?'''

A service is a collection of related BLE characteristics that represents a particular function of the device.

'''Q5. What is a BLE characteristic?'''

A characteristic represents a specific piece of data or functionality and can support operations such as read, write and notify.

'''Q6. What is pairing?'''

Pairing is the process of establishing security information between two Bluetooth devices so that a secure relationship can be created.

'''Q7. What is BLE encryption?'''

BLE encryption protects data exchanged over an established secure BLE connection.

'''Q8. What is a passkey used for?'''

A passkey is used as part of the authentication process during BLE pairing.

'''Q9. What is MITM protection?'''

MITM stands for Man-in-the-Middle. MITM protection helps prevent an attacker from impersonating one of the devices during the authentication process.

'''Q10. What is bonding?'''

Bonding is the process of storing security information after pairing so that the devices can establish trusted connections again later.

'''Q11. Why is LightBlue used in this experiment?'''

LightBlue provides a convenient BLE client interface for discovering the ESP32, connecting to it, inspecting services and characteristics, and receiving notifications.

'''Q12. Can the same application be used on Android and iOS?'''

Yes. LightBlue is available for both Android and iOS.

'''Q13. What is the role of the ESP32 in this experiment?'''

The ESP32 reads the DHT11 sensor and acts as a BLE GATT server that provides the sensor data to the smartphone.

'''Q14. What is the difference between `READ` and `NOTIFY` in BLE?'''

`READ` allows the client to request the current value. `NOTIFY` allows the server to send updated values automatically when the client subscribes to notifications.

'''Q15. How is this experiment different from HTTPS-based cloud communication?'''

HTTPS protects communication between an IoT device and a web/cloud server over a network. This experiment demonstrates secure short-range BLE communication directly between an ESP32 and a smartphone.

== Conclusion ==

This experiment demonstrates how Bluetooth Low Energy can be used for secure IoT sensor-data transmission. The ESP32 reads temperature and humidity from the DHT11 sensor and exposes the readings through BLE characteristics. The smartphone connects using the LightBlue application, performs secure pairing, and receives the sensor data through an authenticated and encrypted BLE connection.

MDM331AID/Experiment 6

2026-10-08T02:39:01Z

CogWikiEditor: /* Program */

= Experiment: Edge Computing Using Raspberry Pi for Local Sensor Data Processing =

== Aim ==

To implement an edge computing model using a Raspberry Pi in which sensor data is processed locally before being transmitted to the cloud, thereby reducing unnecessary data transmission, bandwidth usage, and response latency.

== Objectives ==

* To understand the concept and architecture of edge computing.
* To interface a DHT11 temperature and humidity sensor with a Raspberry Pi.
* To read temperature and humidity data from the DHT11 sensor using Python.
* To process and aggregate sensor readings locally on the Raspberry Pi.
* To implement threshold-based temperature event detection at the edge.
* To transmit processed sensor data to the ThingSpeak cloud platform using HTTP.
* To understand how edge processing can reduce unnecessary network traffic and improve response time.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| Raspberry Pi 4 (4 GB) (COG-RPI4)
| 1
|-
| 2
| DHT11 Temperature and Humidity Sensor (COG-MSBA)
| 1
|-
| 3
| MicroSD card with Raspberry Pi OS
| 1
|-
| 4
| Raspberry Pi power supply
| 1
|-
| 5
| Patch cords / jumper wires
| As required
|-
| 6
| Computer with internet access
| 1
|-
| 7
| Wi-Fi network with Internet access
| 1
|}

== Theory ==

=== Edge Computing ===

'''Edge computing''' is a distributed computing approach in which data is processed close to the source where it is generated instead of sending all raw data to a remote cloud server for processing.

In a conventional cloud-based IoT system, sensor data may be transmitted continuously to a remote server where processing and decision-making are performed. In an edge computing system, a local device such as a Raspberry Pi performs some of the processing near the sensor. Only the required or processed information is then transmitted to the cloud.

In this experiment, the Raspberry Pi acts as the '''edge device'''. It reads temperature and humidity data from the DHT11 sensor, collects multiple readings, calculates their averages, performs a temperature threshold check, and sends the processed results to ThingSpeak.

=== Need for Edge Computing ===

The major advantages of edge computing include:

* '''Reduced latency:''' Local processing allows decisions to be made without waiting for remote cloud processing.
* '''Reduced bandwidth usage:''' Processed or aggregated data can be transmitted instead of every raw sensor reading.
* '''Reduced cloud workload:''' Unnecessary raw data processing at the cloud can be reduced.
* '''Local decision-making:''' Conditions such as temperature thresholds can be checked directly on the edge device.
* '''Improved scalability:''' Reducing unnecessary network traffic can be beneficial when many IoT devices are deployed.

=== Role of Raspberry Pi as an Edge Device ===

The Raspberry Pi acts as the local processing unit in this experiment. It receives temperature and humidity readings from the DHT11 sensor through GPIO4.

The Raspberry Pi collects '''10 valid sensor readings''' and calculates the average temperature and average humidity locally. It then compares the average temperature with a predefined threshold of '''30°C'''.

If the average temperature is greater than or equal to 30°C, an alert condition is generated. The processed temperature, humidity and alert status are then transmitted to ThingSpeak.

=== DHT11 Temperature and Humidity Sensor ===

The '''DHT11''' is a digital sensor capable of measuring temperature and relative humidity.

The sensor provides temperature and humidity readings through a digital data interface. In this experiment, the DHT11 is connected to the Raspberry Pi and is read using the Adafruit CircuitPython DHT library.

The DHT11 is suitable for basic environmental monitoring and IoT demonstrations because it provides both temperature and humidity measurements using a single data connection.

=== Local Data Processing ===

In this experiment, sensor data is processed locally on the Raspberry Pi before being transmitted to the cloud.

The processing sequence is:

# The Raspberry Pi reads temperature and humidity from the DHT11.
# Valid readings are stored in local lists.
# The process continues until 10 valid readings are collected.
# The average temperature is calculated from the collected readings.
# The average humidity is calculated from the collected readings.
# The average temperature is compared with the threshold value of 30°C.
# An alert status is generated based on the threshold condition.
# The processed values are transmitted to ThingSpeak.
# The local data lists are cleared and the next batch of readings is collected.

This approach demonstrates how edge computing can reduce the amount of raw sensor data that needs to be transmitted to the cloud.

=== Threshold-Based Event Detection ===

A threshold is a predefined value used to determine whether a measured parameter has reached a specified condition.

In this experiment, the temperature threshold is:

<pre>
Temperature Threshold = 30°C
</pre>

The Raspberry Pi performs the following check:

<pre>
Average Temperature >= 30°C
|
+---- Yes ----> Temperature Alert
|
+---- No -----> Normal Status
</pre>

The resulting alert status is converted into a numerical value before transmission to ThingSpeak:

{| class="wikitable"
|-
! Condition
! Alert Value
|-
| Average temperature < 30°C
| 0
|-
| Average temperature >= 30°C
| 1
|}

=== Cloud Communication ===

'''ThingSpeak''' is a cloud-based IoT platform that can be used to collect, store and visualize sensor data.

In this experiment, the Raspberry Pi communicates with ThingSpeak using an '''HTTP POST request'''. The Python '''Requests''' library is used to send the processed sensor values to the ThingSpeak update API.

The three transmitted values are:

* '''Field 1:''' Average Temperature
* '''Field 2:''' Average Humidity
* '''Field 3:''' Temperature Alert

The ThingSpeak channel stores the received values and provides visualization of the uploaded sensor data.

=== System Architecture ===

<pre>
DHT11 Sensor
|
v
+----------------------+
| Raspberry Pi |
| Edge Device |
| |
| Sensor Reading |
| ↓ |
| Data Collection |
| ↓ |
| Average Calculation |
| ↓ |
| Threshold Detection |
+----------------------+
|
| Processed Data
v
Wi-Fi Network
|
| HTTP POST
v
+----------------------+
| ThingSpeak |
| Cloud Platform |
| |
| Data Storage |
| Visualization |
+----------------------+
</pre>

== Pin Connections ==

The DHT11 sensor is connected to the Raspberry Pi using the following connections. The program initializes the sensor using '''board.D4''', corresponding to '''GPIO4'''.

{| class="wikitable"
|-
! Raspberry Pi Pin
! DHT11 Pin
! Description
|-
| Physical Pin 1 (3.3V)
| VCC
| Sensor power supply
|-
| Physical Pin 7 (GPIO4)
| DATA
| Digital sensor data
|-
| Physical Pin 6 (GND)
| GND
| Common ground
|}

'''Important:''' Raspberry Pi GPIO pins operate at 3.3 V logic and are '''not 5 V tolerant'''. Do not apply 5 V signals directly to Raspberry Pi GPIO pins. Verify the DHT11 module pinout before making connections.

== Software Requirements ==

* Raspberry Pi OS
* Python 3
* Adafruit CircuitPython DHT library
* Adafruit Blinka library
* Requests Python library
* ThingSpeak account
* ThingSpeak channel with three fields
* Wi-Fi connection with Internet access

=== Install Required Libraries ===

If a Python virtual environment is being used, activate it before installing the required packages.

Install the required Python libraries using:

<syntaxhighlight lang="bash">
pip install adafruit-circuitpython-dht
pip install adafruit-blinka
pip install requests
</syntaxhighlight>

The required libraries provide the following functionality:

* '''Adafruit CircuitPython DHT:''' Interfaces with the DHT11 sensor.
* '''Adafruit Blinka:''' Provides compatibility between CircuitPython libraries and Raspberry Pi hardware.
* '''Requests:''' Allows the Raspberry Pi to communicate with the ThingSpeak server using HTTP requests.

== ThingSpeak Cloud Setup ==

Create a ThingSpeak channel before running the program.

Configure the channel with the following fields:

{| class="wikitable"
|-
! Field
! Name
! Data
|-
| Field 1
| Average Temperature
| Average temperature in °C
|-
| Field 2
| Average Humidity
| Average relative humidity in %
|-
| Field 3
| Temperature Alert
| 0 = Normal, 1 = Alert
|}

After creating the channel:

# Open the '''API Keys''' section of the ThingSpeak channel.
# Copy the channel's '''Write API Key'''.
# Replace the placeholder API key in the program with the actual Write API Key.
# Save the Python program.

'''Security Note:''' Do not publish or share the actual ThingSpeak Write API Key in publicly accessible code or documentation.

== Program ==

The following Python program performs local sensor data aggregation and threshold detection on the Raspberry Pi. It uploads the processed data to ThingSpeak after every batch of 10 valid sensor readings.

<pre>
# 2026, Cognifront. Member of the IoT Kits family.
import time
import board
import adafruit_dht
import requests

# Sensor configuration
# board.D4 sets the pin configuration to BOARD, and uses pin 4
dht = adafruit_dht.DHT11(board.D4)

# Cloud configuration
API_KEY = "YOUR_API_KEY_HERE"
THINGSPEAK_URL = "https://api.thingspeak.com/update"

# Edge processing configuration
SAMPLE_INTERVAL = 2
SAMPLES_PER_BATCH = 10
TEMP_THRESHOLD = 30.0

temperature_samples = []
humidity_samples = []

def upload_to_cloud(avg_temp, avg_humidity, alert):
payload = {
"api_key": API_KEY,
"field1": avg_temp,
"field2": avg_humidity,
"field3": int(alert)
}

try:
response = requests.post(
THINGSPEAK_URL,
data=payload,
timeout=10
)

if response.status_code == 200 and response.text != "0":
print("Cloud upload successful")
print("Entry ID:", response.text)
else:
print("Cloud upload failed:", response.text)

except requests.RequestException as error:
print("Network error:", error)

try:
print("Raspberry Pi Edge Computing System Started")

while True:
try:
temperature = dht.temperature
humidity = dht.humidity

if temperature is not None and humidity is not None:
temperature_samples.append(temperature)
humidity_samples.append(humidity)

print("Raw Temperature:", temperature, "°C")
print("Raw Humidity:", humidity, "%")

if len(temperature_samples) >= SAMPLES_PER_BATCH:
# Local data aggregation
avg_temp = sum(temperature_samples) / len(temperature_samples)
avg_humidity = sum(humidity_samples) / len(humidity_samples)

# Local threshold-based decision
alert = avg_temp >= TEMP_THRESHOLD

print("\n--- Edge Processing Result ---")
print("Average Temperature:", round(avg_temp, 2), "°C")
print("Average Humidity:", round(avg_humidity, 2), "%")

if alert:
print("ALERT: Temperature threshold exceeded")
else:
print("Status: Normal")

# Send processed data to cloud
upload_to_cloud(
round(avg_temp, 2),
round(avg_humidity, 2),
alert
)

# Clear batch for next aggregation
temperature_samples.clear()
humidity_samples.clear()

print("------------------------------\n")

except RuntimeError as error:
# Temporary DHT11 reading errors
print("Sensor reading error:", error)

time.sleep(SAMPLE_INTERVAL)

except KeyboardInterrupt:
print("Program stopped by user")

finally:
dht.exit()

</pre>

== Code Explanation ==

{| class="wikitable"
|-
! Statement
! Description
|-
| <code>import time</code>
| Provides timing functions used to control the sensor reading interval.
|-
| <code>import board</code>
| Provides Raspberry Pi board pin definitions used by the sensor library.
|-
| <code>import adafruit_dht</code>
| Provides functions for interfacing with the DHT11 sensor.
|-
| <code>import requests</code>
| Provides HTTP communication with the ThingSpeak cloud server.
|-
| <code>dht = adafruit_dht.DHT11(board.D4)</code>
| Initializes the DHT11 sensor on GPIO4.
|-
| <code>API_KEY</code>
| Stores the ThingSpeak channel Write API Key used for authentication.
|-
| <code>THINGSPEAK_URL</code>
| Specifies the ThingSpeak update API endpoint.
|-
| <code>SAMPLE_INTERVAL = 2</code>
| Sets the delay between sensor-reading attempts to two seconds.
|-
| <code>SAMPLES_PER_BATCH = 10</code>
| Specifies that 10 valid sensor readings are collected before local processing.
|-
| <code>TEMP_THRESHOLD = 30.0</code>
| Sets the temperature threshold to 30°C.
|-
| <code>temperature_samples.append(temperature)</code>
| Stores a valid temperature reading locally.
|-
| <code>humidity_samples.append(humidity)</code>
| Stores a valid humidity reading locally.
|-
| <code>sum(temperature_samples) / len(temperature_samples)</code>
| Calculates the average temperature of the current batch.
|-
| <code>sum(humidity_samples) / len(humidity_samples)</code>
| Calculates the average humidity of the current batch.
|-
| <code>avg_temp >= TEMP_THRESHOLD</code>
| Performs the local threshold-based temperature check.
|-
| <code>requests.post()</code>
| Sends the processed sensor values to ThingSpeak using an HTTP POST request.
|-
| <code>field1</code>
| Stores the average temperature in ThingSpeak.
|-
| <code>field2</code>
| Stores the average humidity in ThingSpeak.
|-
| <code>field3</code>
| Stores the temperature alert status as 0 or 1.
|-
| <code>temperature_samples.clear()</code>
| Clears the collected temperature readings after processing the batch.
|-
| <code>humidity_samples.clear()</code>
| Clears the collected humidity readings after processing the batch.
|-
| <code>dht.exit()</code>
| Releases the DHT sensor resources when the program terminates.
|}

== Procedure ==

=== Step 1: Hardware Setup ===

# Switch off or disconnect the Raspberry Pi from its power supply before making the connections.
# Connect the DHT11 sensor to the Raspberry Pi according to the pin connection table.
# Connect DHT11 VCC to Raspberry Pi 3.3V.
# Connect DHT11 DATA to Raspberry Pi GPIO4 (Physical Pin 7).
# Connect DHT11 GND to Raspberry Pi GND (Physical Pin 6).
# Verify all connections before powering the Raspberry Pi.

=== Step 2: Software Setup ===

# Boot the Raspberry Pi with Raspberry Pi OS.
# Connect the Raspberry Pi to a Wi-Fi network with Internet access.
# Open the terminal.
# Create and activate a Python virtual environment if required.
# Install the required Python libraries.
# Create a Python file, for example <code>edge_computing.py</code>.
# Enter the given program and save the file.

=== Step 3: ThingSpeak Setup ===

# Sign in to ThingSpeak.
# Create a new channel.
# Enable three fields in the channel.
# Name Field 1 as '''Average Temperature'''.
# Name Field 2 as '''Average Humidity'''.
# Name Field 3 as '''Temperature Alert'''.
# Save the channel.
# Open the '''API Keys''' section.
# Copy the channel's '''Write API Key'''.
# Replace <code>YOUR_API_KEY_HERE</code> in the program with the actual Write API Key.
# Save the Python program.

=== Step 4: Execute the Program ===

# Open the terminal on the Raspberry Pi.
# Navigate to the directory containing the Python program.
# Activate the Python virtual environment if one is being used.
# Run the program using:

<syntaxhighlight lang="bash">
python edge_computing.py
</syntaxhighlight>

# Observe the raw temperature and humidity readings displayed in the terminal.
# Allow the program to collect 10 valid readings.
# Observe the calculated average temperature and average humidity.
# Observe the threshold status displayed by the program.
# Check the cloud upload status and ThingSpeak Entry ID.

=== Step 5: Verify Edge Processing ===

# Observe that sensor readings are first stored locally on the Raspberry Pi.
# Verify that an average is calculated after 10 valid readings.
# Check whether the average temperature is below or equal to the threshold condition.
# If the average temperature is 30°C or higher, observe the temperature alert message.
# If the average temperature is below 30°C, observe the normal status message.

=== Step 6: Verify ThingSpeak Data ===

# Open the ThingSpeak channel.
# Open the channel visualization page.
# Observe the value in '''Field 1''' for average temperature.
# Observe the value in '''Field 2''' for average humidity.
# Observe the value in '''Field 3''' for the temperature alert.
# Compare the values displayed on ThingSpeak with the processed values shown in the Raspberry Pi terminal.

== Observations ==

{| class="wikitable"
|-
! Sr. No.
! Processing Stage
! Expected Observation
|-
| 1
| Sensor Reading
| Temperature and humidity readings from the DHT11 are displayed on the Raspberry Pi terminal.
|-
| 2
| Local Data Collection
| Valid sensor readings are stored locally in the Raspberry Pi.
|-
| 3
| Data Aggregation
| Average temperature and average humidity are calculated after 10 valid readings.
|-
| 4
| Threshold Detection
| Temperature alert is generated when the average temperature is greater than or equal to 30°C.
|-
| 5
| Cloud Transmission
| Average temperature, average humidity and alert status are transmitted to ThingSpeak using HTTP.
|-
| 6
| Cloud Visualization
| Processed sensor values are stored and displayed in the ThingSpeak channel.
|}

=== Sample Serial Output ===

The following is an illustrative example. Actual temperature and humidity values will depend on the environment.

<pre>
Raspberry Pi Edge Computing System Started

Raw Temperature: 27.0 °C
Raw Humidity: 61.0 %

Raw Temperature: 27.0 °C
Raw Humidity: 62.0 %

...

--- Edge Processing Result ---
Average Temperature: 27.2 °C
Average Humidity: 61.7 %
Status: Normal
Cloud upload successful
Entry ID: 12345
------------------------------
</pre>

'''Note:''' The Entry ID shown above is only an example. The actual Entry ID is generated by ThingSpeak.

== Comparison: Cloud-Based vs Edge-Based Processing ==

{| class="wikitable"
|-
! Parameter
! Cloud-Based Processing
! Edge-Based Processing
|-
| Data processing
| Performed primarily on a remote cloud server.
| Performed locally on the Raspberry Pi.
|-
| Data transmission
| Raw sensor readings may be transmitted continuously.
| Sensor readings are processed locally before transmission.
|-
| Bandwidth usage
| Can be higher when raw readings are continuously transmitted.
| Can be reduced by aggregating readings locally.
|-
| Response latency
| Depends on network communication and cloud processing.
| Local threshold decisions can be made directly on the Raspberry Pi.
|-
| Local decision-making
| Requires communication with the cloud when processing is remote.
| Threshold detection is performed locally.
|-
| Cloud workload
| Can increase when large amounts of raw data are uploaded.
| Reduced because processed values are transmitted.
|}

== Result ==

An edge computing application was successfully implemented using a Raspberry Pi and DHT11 temperature and humidity sensor. The Raspberry Pi collected sensor readings and processed them locally by calculating the average temperature and humidity over a batch of 10 valid readings.

A threshold-based temperature detection mechanism was implemented locally, using 30°C as the threshold. The processed temperature, humidity and alert status were then transmitted to the ThingSpeak cloud platform using HTTP.

Thus, the experiment demonstrates how edge computing can perform local data processing and decision-making before transmitting relevant information to the cloud, thereby reducing unnecessary data transmission and supporting faster local responses.

== Real-Life Applications ==

* '''Industrial condition monitoring:''' Temperature and humidity sensors can monitor machinery and industrial environments.
* '''Smart agriculture:''' Edge devices can locally process environmental sensor readings and transmit only important information to the cloud.
* '''Environmental monitoring:''' Local processing can be used to detect abnormal temperature or humidity conditions.
* '''Smart buildings:''' Edge devices can monitor environmental conditions and trigger local decisions.
* '''Predictive maintenance:''' Sensor data can be processed locally to detect abnormal operating conditions before transmitting summarized information to a cloud platform.

== Viva Questions ==

# What is edge computing?
# What is the difference between edge computing and cloud computing?
# Why is Raspberry Pi used as an edge device in this experiment?
# What is the role of the DHT11 sensor?
# Which GPIO pin is used to connect the DHT11 data pin?
# Why is GPIO4 used in this experiment?
# How many sensor readings are collected before calculating the average?
# What is the purpose of <code>SAMPLE_INTERVAL</code>?
# What is the value of the temperature threshold used in this experiment?
# What happens when the average temperature reaches or exceeds 30°C?
# What is the purpose of local data aggregation?
# How does edge computing reduce bandwidth usage?
# Which communication protocol is used to transmit data to ThingSpeak?
# What is the purpose of the HTTP POST request?
# What are Field 1, Field 2 and Field 3 used for in ThingSpeak?
# What is a ThingSpeak Write API Key?
# Why should the API key not be publicly shared?
# What is the purpose of the <code>requests</code> Python library?
# What is the difference between raw sensor data and processed sensor data?
# What are the advantages of processing sensor data at the edge?

MDM331AID/Experiment 6

2026-10-08T02:38:35Z

CogWikiEditor:

MDM331AID/Experiment 6

2026-10-08T02:30:33Z

CogWikiEditor: /* Program */

MDM331AID/Experiment 11

2026-10-08T02:13:01Z

CogWikiEditor: /* SHA-256 Hashing */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hashing algorithm used to convert input data of any length into a fixed-size '''256-bit hash'''.

The output is normally represented as a '''64-character hexadecimal value'''.

Basic characteristics of SHA-256 are:

* It accepts input data of any length.
* It always produces a fixed 256-bit output.
* The output is represented using 64 hexadecimal characters.
* The same input always produces the same hash.
* A small change in the input produces a completely different hash.
* It is designed to be difficult to reverse the hash back to the original input.
* SHA-256 is a '''hashing algorithm''', not an encryption algorithm.
* It can be used to verify passwords and detect changes in data.

The basic working process of SHA-256 is:

<pre>
Input Data
↓
Convert into Binary
↓
Add Padding
↓
Divide into 512-bit Blocks
↓
Expand Each Block into 64 Words
↓
Initialize Eight 32-bit Registers
↓
Perform 64 Rounds of Processing
↓
Bitwise Operations and Modular Addition
↓
Combine Eight 32-bit Results
↓
256-bit Hash
↓
64 Hexadecimal Characters
</pre>

During processing, SHA-256 uses operations such as:

* '''XOR''' – performs bit-by-bit exclusive OR operation.
* '''AND''' – performs bit-by-bit AND operation.
* '''NOT''' – inverts the bits.
* '''Bit Rotation''' – rotates bits to the left or right.
* '''Bit Shifting''' – shifts bits to the left or right.
* '''Modular Addition''' – performs addition using a fixed 32-bit word size.

SHA-256 uses '''predefined constants''' and performs '''64 processing rounds''' for each 512-bit block. These operations repeatedly mix the input data to produce the final hash.

For example:

<pre>
Password
↓
admin123
↓
SHA-256
↓
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
</pre>

In this experiment, the password entered by the user is converted into a SHA-256 hash. The generated hash is then compared with the stored password hash. If both hashes are the same, the password is considered correct and the user is allowed to access the protected sensor data.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. For real-world password storage, password-specific algorithms such as salted Argon2, bcrypt, scrypt or PBKDF2 are preferred.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The ESP32 operates in Wi-Fi Station (STA) mode and obtains an IP address from the connected Wi-Fi network. The assigned IP address is displayed in the Serial Monitor and is used to access the ESP32 web server.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "YOUR_WIFI_NAME";
const char* wifiPassword = "YOUR_WIFI_PASSWORD";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and wifiPassword:''' Store the Wi-Fi network name and password required by the ESP32 to connect to the selected Wi-Fi network.

* '''WiFi.mode(WIFI_STA):''' Configures the ESP32 to operate in Station (STA) mode so that it connects to an existing Wi-Fi network.

* '''WiFi.begin():''' Starts the connection process using the configured Wi-Fi network name and password.

* '''WiFi.status():''' Checks the current Wi-Fi connection status of the ESP32.

* '''WL_CONNECTED:''' Indicates that the ESP32 has successfully connected to the Wi-Fi network.

* '''WiFi.localIP():''' Returns the IP address assigned to the ESP32 by the Wi-Fi network.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
The Serial Monitor displays output similar to the following:

<pre>
==============================
ESP32 Smart Sensor Security
==============================
Connecting to Wi-Fi....
Wi-Fi connected.
ESP32 IP address: 192.168.1.105
Web server started.

Open this address in your browser:
http://192.168.1.105

Username: admin
Password: admin123
</pre>
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 11

2026-10-08T01:56:59Z

CogWikiEditor: /* Code Explanation */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The ESP32 operates in Wi-Fi Station (STA) mode and obtains an IP address from the connected Wi-Fi network. The assigned IP address is displayed in the Serial Monitor and is used to access the ESP32 web server.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "YOUR_WIFI_NAME";
const char* wifiPassword = "YOUR_WIFI_PASSWORD";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and wifiPassword:''' Store the Wi-Fi network name and password required by the ESP32 to connect to the selected Wi-Fi network.

* '''WiFi.mode(WIFI_STA):''' Configures the ESP32 to operate in Station (STA) mode so that it connects to an existing Wi-Fi network.

* '''WiFi.begin():''' Starts the connection process using the configured Wi-Fi network name and password.

* '''WiFi.status():''' Checks the current Wi-Fi connection status of the ESP32.

* '''WL_CONNECTED:''' Indicates that the ESP32 has successfully connected to the Wi-Fi network.

* '''WiFi.localIP():''' Returns the IP address assigned to the ESP32 by the Wi-Fi network.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
The Serial Monitor displays output similar to the following:

<pre>
==============================
ESP32 Smart Sensor Security
==============================
Connecting to Wi-Fi....
Wi-Fi connected.
ESP32 IP address: 192.168.1.105
Web server started.

Open this address in your browser:
http://192.168.1.105

Username: admin
Password: admin123
</pre>
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 11

2026-10-08T01:56:01Z

CogWikiEditor: /* Procedure */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The ESP32 operates in Wi-Fi Station (STA) mode and obtains an IP address from the connected Wi-Fi network. The assigned IP address is displayed in the Serial Monitor and is used to access the ESP32 web server.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "YOUR_WIFI_NAME";
const char* wifiPassword = "YOUR_WIFI_PASSWORD";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and password:''' Store the Wi-Fi network credentials required by the ESP32.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
The Serial Monitor displays output similar to the following:

<pre>
==============================
ESP32 Smart Sensor Security
==============================
Connecting to Wi-Fi....
Wi-Fi connected.
ESP32 IP address: 192.168.1.105
Web server started.

Open this address in your browser:
http://192.168.1.105

Username: admin
Password: admin123
</pre>
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 11

2026-10-08T01:55:28Z

CogWikiEditor: /* Observations and Output */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The ESP32 operates in Wi-Fi Station (STA) mode and obtains an IP address from the connected Wi-Fi network. The assigned IP address is displayed in the Serial Monitor and is used to access the ESP32 web server.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "YOUR_WIFI_NAME";
const char* wifiPassword = "YOUR_WIFI_PASSWORD";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and password:''' Store the Wi-Fi network credentials required by the ESP32.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Configure the username and stored password hash.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
The Serial Monitor displays output similar to the following:

<pre>
==============================
ESP32 Smart Sensor Security
==============================
Connecting to Wi-Fi....
Wi-Fi connected.
ESP32 IP address: 192.168.1.105
Web server started.

Open this address in your browser:
http://192.168.1.105

Username: admin
Password: admin123
</pre>
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 11

2026-10-08T01:54:34Z

CogWikiEditor: /* ESP32 Web Server */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The ESP32 operates in Wi-Fi Station (STA) mode and obtains an IP address from the connected Wi-Fi network. The assigned IP address is displayed in the Serial Monitor and is used to access the ESP32 web server.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "YOUR_WIFI_NAME";
const char* wifiPassword = "YOUR_WIFI_PASSWORD";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and password:''' Store the Wi-Fi network credentials required by the ESP32.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Configure the username and stored password hash.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
Smart Sensor Security System
Connecting to Wi-Fi....
Wi-Fi connected
ESP32 IP address: 192.168.1.105
Web server started
</pre>

The initial browser page displays:

<pre>
--------------------------------
Smart Sensor System

Username: [____________]

Password: [____________]

[ Login ]
--------------------------------
</pre>

When an incorrect password is entered:

<pre>
Access Denied

Invalid username or password.
</pre>

After successful authentication:

<pre>
--------------------------------
Smart Sensor System

Authentication Successful

Temperature: 27.6 °C
Humidity: 61.0 %

[Refresh Sensor Data]

[Logout]
--------------------------------
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 11

2026-10-08T01:50:01Z

CogWikiEditor: /* Program */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The exact IP address depends on the network to which the ESP32 is connected.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "YOUR_WIFI_NAME";
const char* wifiPassword = "YOUR_WIFI_PASSWORD";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and password:''' Store the Wi-Fi network credentials required by the ESP32.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Configure the username and stored password hash.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
Smart Sensor Security System
Connecting to Wi-Fi....
Wi-Fi connected
ESP32 IP address: 192.168.1.105
Web server started
</pre>

The initial browser page displays:

<pre>
--------------------------------
Smart Sensor System

Username: [____________]

Password: [____________]

[ Login ]
--------------------------------
</pre>

When an incorrect password is entered:

<pre>
Access Denied

Invalid username or password.
</pre>

After successful authentication:

<pre>
--------------------------------
Smart Sensor System

Authentication Successful

Temperature: 27.6 °C
Humidity: 61.0 %

[Refresh Sensor Data]

[Logout]
--------------------------------
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 11

2026-10-08T01:48:58Z

CogWikiEditor: /* Program */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The exact IP address depends on the network to which the ESP32 is connected.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "Brahmand";
const char* wifiPassword = "cog_wifi#3357";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and password:''' Store the Wi-Fi network credentials required by the ESP32.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Configure the username and stored password hash.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
Smart Sensor Security System
Connecting to Wi-Fi....
Wi-Fi connected
ESP32 IP address: 192.168.1.105
Web server started
</pre>

The initial browser page displays:

<pre>
--------------------------------
Smart Sensor System

Username: [____________]

Password: [____________]

[ Login ]
--------------------------------
</pre>

When an incorrect password is entered:

<pre>
Access Denied

Invalid username or password.
</pre>

After successful authentication:

<pre>
--------------------------------
Smart Sensor System

Authentication Successful

Temperature: 27.6 °C
Humidity: 61.0 %

[Refresh Sensor Data]

[Logout]
--------------------------------
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 11

2026-10-08T01:48:27Z

CogWikiEditor: /* Program */

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The exact IP address depends on the network to which the ESP32 is connected.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

/* ==============================
Wi-Fi Credentials
============================== */

const char* ssid = "Brahmand";
const char* wifiPassword = "cog_wifi#3357";

/* ==============================
Login Credentials
============================== */

const char* loginUsername = "admin";

/*
Password:
admin123

Correct SHA-256 hash:
240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9
*/

const char* storedPasswordHash =
"240be518fabd2724ddb6f04eeb1da5967448d7e831c08c8fa822809f74c720a9";

bool authenticated = false;

/* =========================================
SHA-256 Function
========================================= */

String sha256(String input)
{
unsigned char hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);

/*
0 = SHA-256
1 = SHA-224
*/
mbedtls_sha256_starts(&ctx, 0);

mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);

mbedtls_sha256_finish(&ctx, hash);

mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 0x10)
{
result += "0";
}

result += String(hash[i], HEX);
}

return result;
}

/* =========================================
Login Page
========================================= */

void handleRoot()
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Smart Sensor Login</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:40px;";
html += "}";

html += ".box{";
html += "max-width:400px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += "input{";
html += "width:90%;";
html += "padding:12px;";
html += "margin:8px;";
html += "border:1px solid #ccc;";
html += "border-radius:6px;";
html += "}";

html += "input[type=submit]{";
html += "width:96%;";
html += "background:#1976d2;";
html += "color:white;";
html += "border:none;";
html += "cursor:pointer;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<p>Password Protected IoT System</p>";

html += "<form action='/login' method='POST'>";

html += "<input type='text' ";
html += "name='username' ";
html += "placeholder='Username' required>";

html += "<br>";

html += "<input type='password' ";
html += "name='password' ";
html += "placeholder='Password' required>";

html += "<br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(200, "text/html", html);
}

/* =========================================
Login Authentication
========================================= */

void handleLogin()
{
String enteredUsername = server.arg("username");
String enteredPassword = server.arg("password");

String enteredHash = sha256(enteredPassword);

Serial.println();
Serial.println("Login attempt");
Serial.print("Username: ");
Serial.println(enteredUsername);

Serial.print("Password Hash: ");
Serial.println(enteredHash);

if (
enteredUsername == loginUsername &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

Serial.println("Authentication successful");

server.sendHeader("Location", "/sensor");

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

Serial.println("Authentication failed");

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";
html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<title>Access Denied</title>";

html += "</head>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Access Denied</h1>";

html += "<p>Invalid username or password.</p>";

html += "<br>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

/* =========================================
Protected Sensor Page
========================================= */

void handleSensor()
{
if (!authenticated)
{
server.sendHeader("Location", "/");

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

/*
Check whether DHT11 reading is valid.
*/

if (isnan(temperature) || isnan(humidity))
{
String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<body style='";
html += "font-family:Arial;";
html += "text-align:center;";
html += "padding:40px;";
html += "'>";

html += "<h1>Sensor Error</h1>";

html += "<p>Unable to read DHT11 sensor.</p>";

html += "<a href='/sensor'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
500,
"text/html",
html
);

return;
}

String html = "";

html += "<!DOCTYPE html>";
html += "<html>";

html += "<head>";

html += "<meta name='viewport' ";
html += "content='width=device-width, initial-scale=1'>";

html += "<meta http-equiv='refresh' ";
html += "content='10'>";

html += "<title>Sensor Dashboard</title>";

html += "<style>";

html += "body{";
html += "font-family:Arial;";
html += "background:#f2f2f2;";
html += "text-align:center;";
html += "padding:30px;";
html += "}";

html += ".box{";
html += "max-width:500px;";
html += "margin:auto;";
html += "background:white;";
html += "padding:30px;";
html += "border-radius:12px;";
html += "box-shadow:0 4px 15px rgba(0,0,0,0.15);";
html += "}";

html += ".value{";
html += "font-size:32px;";
html += "font-weight:bold;";
html += "margin:20px;";
html += "}";

html += "a{";
html += "display:inline-block;";
html += "padding:12px 20px;";
html += "margin:8px;";
html += "background:#1976d2;";
html += "color:white;";
html += "text-decoration:none;";
html += "border-radius:6px;";
html += "}";

html += ".logout{";
html += "background:#d32f2f;";
html += "}";

html += "</style>";

html += "</head>";

html += "<body>";

html += "<div class='box'>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>Authentication Successful</h2>";

html += "<p>Temperature</p>";

html += "<div class='value'>";
html += String(temperature, 1);
html += " °C";
html += "</div>";

html += "<p>Humidity</p>";

html += "<div class='value'>";
html += String(humidity, 1);
html += " %";
html += "</div>";

html += "<p>Data refreshes automatically every 10 seconds.</p>";

html += "<a href='/sensor'>Refresh</a>";

html += "<a class='logout' href='/logout'>Logout</a>";

html += "</div>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

/* =========================================
Logout
========================================= */

void handleLogout()
{
authenticated = false;

Serial.println("User logged out.");

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

/* =========================================
Setup
========================================= */

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

delay(1000);

Serial.println();
Serial.println("==============================");
Serial.println("ESP32 Smart Sensor Security");
Serial.println("==============================");

/*
Start DHT11
*/

dht.begin();

/*
Connect to Wi-Fi
*/

WiFi.mode(WIFI_STA);

WiFi.begin(
ssid,
wifiPassword
);

Serial.print("Connecting to Wi-Fi");

int attempts = 0;

while (
WiFi.status() != WL_CONNECTED &&
attempts < 40
)
{
delay(500);

Serial.print(".");

attempts++;
}

Serial.println();

/*
Check Wi-Fi connection
*/

if (WiFi.status() != WL_CONNECTED)
{
Serial.println("Wi-Fi connection failed.");

Serial.println(
"Check SSID and Wi-Fi password."
);

return;
}

Serial.println("Wi-Fi connected.");

Serial.print("ESP32 IP address: ");

Serial.println(WiFi.localIP());

/*
Web server routes
*/

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

/*
Start web server
*/

server.begin();

Serial.println("Web server started.");

Serial.println();
Serial.println("Open this address in your browser:");

Serial.print("http://");
Serial.println(WiFi.localIP());

Serial.println();

Serial.println("Username: admin");
Serial.println("Password: admin123");
}

/* =========================================
Main Loop
========================================= */

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and password:''' Store the Wi-Fi network credentials required by the ESP32.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Configure the username and stored password hash.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
Smart Sensor Security System
Connecting to Wi-Fi....
Wi-Fi connected
ESP32 IP address: 192.168.1.105
Web server started
</pre>

The initial browser page displays:

<pre>
--------------------------------
Smart Sensor System

Username: [____________]

Password: [____________]

[ Login ]
--------------------------------
</pre>

When an incorrect password is entered:

<pre>
Access Denied

Invalid username or password.
</pre>

After successful authentication:

<pre>
--------------------------------
Smart Sensor System

Authentication Successful

Temperature: 27.6 °C
Humidity: 61.0 %

[Refresh Sensor Data]

[Logout]
--------------------------------
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

File:IoT TCP DHT11 Programs.zip

2026-10-08T01:13:27Z

CogWikiEditor: CogWikiEditor uploaded a new version of File:IoT TCP DHT11 Programs.zip

MDM331AID/Experiment 7

2026-10-08T01:08:44Z

CogWikiEditor: /* Viva Questions */

= Experiment: RFID-Based Identification System =

== Aim ==
To design an RFID-based identification system that reads tag information and displays the tag ID on a monitoring system, demonstrating short-range communication technology in IoT.

== Objectives ==
* To understand RFID technology and its role in IoT.
* To interface an RFID reader with an Arduino UNO.
* To read the unique identification number (UID) of an RFID tag.
* To display the tag ID on the Arduino IDE Serial Monitor.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| Arduino UNO
| 1
|-
| 2
| MFRC522 RFID reader module
| 1
|-
| 3
| RFID tags or cards compatible with the reader
| 1 or more
|-
| 4
| USB cable
| 1
|-
| 5
| Patch cords
| As required
|}

== Theory ==

'''Radio Frequency Identification (RFID)''' is a wireless identification technology that uses radio waves to exchange information between an RFID reader and an RFID tag.

An RFID system generally consists of:
* '''RFID tag:''' Stores identification information. Passive tags obtain operating energy from the reader's electromagnetic field.
* '''RFID reader:''' Communicates with the tag and retrieves its identification information.
* '''Controller:''' Processes the information received from the reader. In this experiment, the Arduino UNO acts as the controller.
* '''Monitoring system:''' Displays the received tag ID. In this experiment, the Arduino IDE Serial Monitor is used.

The MFRC522 reader communicates with the Arduino UNO using the SPI (Serial Peripheral Interface) protocol. When a compatible RFID tag is brought close to the reader, the reader detects the tag and retrieves its UID. The Arduino then displays the UID on the Serial Monitor.

RFID is a short-range communication technology. The reading distance depends on the reader, tag, antenna, operating conditions and tag type.

'''Note:''' The UID is used here for demonstration and identification only. UID-based checking alone is not a secure authentication mechanism.

== Pin Connections ==

The following connections assume an MFRC522 RFID module and an Arduino UNO.

{| class="wikitable"
|-
! RFID Module Pin
! Arduino UNO Pin
! Description
|-
| SDA / SS
| D10
| SPI chip select
|-
| SCK
| D13
| SPI clock
|-
| MOSI
| D11
| SPI data from Arduino to reader
|-
| MISO
| D12
| SPI data from reader to Arduino
|-
| RST
| D9
| Reset
|-
| 3.3V
| 3.3V (Connect to 5V if system not working)
| Power supply
|-
| GND
| GND
| Ground
|-
| IRQ
| Not connected
| Not required for this program
|}

== Connection Diagram ==

Connect the MFRC522 RFID reader to the Arduino UNO according to the pin connection table.

The USB cable connects the Arduino UNO to the computer. The computer runs the Arduino IDE and displays the received tag ID through the Serial Monitor.

== Program ==

Install the '''MFRC522''' library using the Arduino IDE Library Manager before uploading the program.

<pre>
#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9

MFRC522 rfid(SS_PIN, RST_PIN);

void setup()
{
Serial.begin(9600);
SPI.begin();
rfid.PCD_Init();

Serial.println("RFID Identification System");
Serial.println("Place an RFID tag near the reader.");
}

void loop()
{
// Check whether a new tag is present
if (!rfid.PICC_IsNewCardPresent())
{
return;
}

// Read the tag serial number
if (!rfid.PICC_ReadCardSerial())
{
return;
}

Serial.print("Tag UID: ");

for (byte i = 0; i < rfid.uid.size; i++)
{
if (rfid.uid.uidByte[i] < 0x10)
{
Serial.print("0");
}

Serial.print(rfid.uid.uidByte[i], HEX);

if (i < rfid.uid.size - 1)
{
Serial.print(":");
}
}

Serial.println();

// Stop communication with the current tag
rfid.PICC_HaltA();
rfid.PCD_StopCrypto1();

delay(500);
}
</pre>

== Code Explanation ==

* '''SPI.begin():''' Initializes SPI communication between the Arduino UNO and the RFID reader.
* '''rfid.PCD_Init():''' Initializes the MFRC522 RFID reader.
* '''PICC_IsNewCardPresent():''' Checks whether a new RFID tag is present in the reader's field.
* '''PICC_ReadCardSerial():''' Reads the UID of the detected RFID tag.
* '''rfid.uid.size:''' Gives the number of bytes in the UID.
* '''Serial.print():''' Displays the UID in hexadecimal format on the Serial Monitor.
* '''PICC_HaltA():''' Stops communication with the selected tag.
* '''PCD_StopCrypto1():''' Stops the reader's Crypto1 authentication state.

== Procedure ==

# Connect the MFRC522 RFID reader to the Arduino UNO according to the pin connection table.
# Verify the power supply and logic-level compatibility of the RFID module.
# Connect the Arduino UNO to the computer using a USB cable.
# Open the Arduino IDE.
# Install the MFRC522 library using the Library Manager.
# Select the appropriate Arduino UNO board and COM port.
# Copy the program into the Arduino IDE.
# Compile and upload the program to the Arduino UNO.
# Open the Serial Monitor and set the baud rate to 9600.
# Bring a compatible RFID tag or card close to the RFID reader.
# Observe the UID displayed on the Serial Monitor.
# Repeat the experiment with different tags and compare the displayed UIDs.

== Observations and Output ==

The following is an illustrative example of the expected Serial Monitor output. Actual UIDs will depend on the RFID tags used.

<pre>
RFID Identification System
Place an RFID tag near the reader.
Tag UID: 23:8A:4F:19
Tag UID: 6B:21:CD:07
Tag UID: 23:8A:4F:19
</pre>

{| class="wikitable"
|-
! Sr. No.
! RFID Tag
! Observed UID
|-
| 1
| Tag 1
| Record the UID displayed
|-
| 2
| Tag 2
| Record the UID displayed
|-
| 3
| Tag 3
| Record the UID displayed
|}

== Result ==

The RFID reader was interfaced with the Arduino UNO using SPI communication. The system read the UIDs of compatible RFID tags and displayed the identification information on the Serial Monitor, demonstrating short-range wireless identification.

== Viva Questions ==

# What is RFID?
# What are the main components of an RFID system?
# What is the difference between an RFID reader and an RFID tag?
# What is the purpose of the UID in an RFID tag?
# Which communication protocol is used between the MFRC522 and Arduino UNO?
# What is SPI communication?
# What factors affect the reading range of an RFID system?
# What is the difference between passive and active RFID tags?
# Why is UID-only identification not considered secure authentication?

MDM331AID/Experiment 7

2026-10-08T01:08:28Z

CogWikiEditor: /* Components Required */

= Experiment: RFID-Based Identification System =

== Aim ==
To design an RFID-based identification system that reads tag information and displays the tag ID on a monitoring system, demonstrating short-range communication technology in IoT.

== Objectives ==
* To understand RFID technology and its role in IoT.
* To interface an RFID reader with an Arduino UNO.
* To read the unique identification number (UID) of an RFID tag.
* To display the tag ID on the Arduino IDE Serial Monitor.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| Arduino UNO
| 1
|-
| 2
| MFRC522 RFID reader module
| 1
|-
| 3
| RFID tags or cards compatible with the reader
| 1 or more
|-
| 4
| USB cable
| 1
|-
| 5
| Patch cords
| As required
|}

== Theory ==

'''Radio Frequency Identification (RFID)''' is a wireless identification technology that uses radio waves to exchange information between an RFID reader and an RFID tag.

An RFID system generally consists of:
* '''RFID tag:''' Stores identification information. Passive tags obtain operating energy from the reader's electromagnetic field.
* '''RFID reader:''' Communicates with the tag and retrieves its identification information.
* '''Controller:''' Processes the information received from the reader. In this experiment, the Arduino UNO acts as the controller.
* '''Monitoring system:''' Displays the received tag ID. In this experiment, the Arduino IDE Serial Monitor is used.

The MFRC522 reader communicates with the Arduino UNO using the SPI (Serial Peripheral Interface) protocol. When a compatible RFID tag is brought close to the reader, the reader detects the tag and retrieves its UID. The Arduino then displays the UID on the Serial Monitor.

RFID is a short-range communication technology. The reading distance depends on the reader, tag, antenna, operating conditions and tag type.

'''Note:''' The UID is used here for demonstration and identification only. UID-based checking alone is not a secure authentication mechanism.

== Pin Connections ==

The following connections assume an MFRC522 RFID module and an Arduino UNO.

{| class="wikitable"
|-
! RFID Module Pin
! Arduino UNO Pin
! Description
|-
| SDA / SS
| D10
| SPI chip select
|-
| SCK
| D13
| SPI clock
|-
| MOSI
| D11
| SPI data from Arduino to reader
|-
| MISO
| D12
| SPI data from reader to Arduino
|-
| RST
| D9
| Reset
|-
| 3.3V
| 3.3V (Connect to 5V if system not working)
| Power supply
|-
| GND
| GND
| Ground
|-
| IRQ
| Not connected
| Not required for this program
|}

== Connection Diagram ==

Connect the MFRC522 RFID reader to the Arduino UNO according to the pin connection table.

The USB cable connects the Arduino UNO to the computer. The computer runs the Arduino IDE and displays the received tag ID through the Serial Monitor.

== Program ==

Install the '''MFRC522''' library using the Arduino IDE Library Manager before uploading the program.

<pre>
#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9

MFRC522 rfid(SS_PIN, RST_PIN);

void setup()
{
Serial.begin(9600);
SPI.begin();
rfid.PCD_Init();

Serial.println("RFID Identification System");
Serial.println("Place an RFID tag near the reader.");
}

void loop()
{
// Check whether a new tag is present
if (!rfid.PICC_IsNewCardPresent())
{
return;
}

// Read the tag serial number
if (!rfid.PICC_ReadCardSerial())
{
return;
}

Serial.print("Tag UID: ");

for (byte i = 0; i < rfid.uid.size; i++)
{
if (rfid.uid.uidByte[i] < 0x10)
{
Serial.print("0");
}

Serial.print(rfid.uid.uidByte[i], HEX);

if (i < rfid.uid.size - 1)
{
Serial.print(":");
}
}

Serial.println();

// Stop communication with the current tag
rfid.PICC_HaltA();
rfid.PCD_StopCrypto1();

delay(500);
}
</pre>

== Code Explanation ==

* '''SPI.begin():''' Initializes SPI communication between the Arduino UNO and the RFID reader.
* '''rfid.PCD_Init():''' Initializes the MFRC522 RFID reader.
* '''PICC_IsNewCardPresent():''' Checks whether a new RFID tag is present in the reader's field.
* '''PICC_ReadCardSerial():''' Reads the UID of the detected RFID tag.
* '''rfid.uid.size:''' Gives the number of bytes in the UID.
* '''Serial.print():''' Displays the UID in hexadecimal format on the Serial Monitor.
* '''PICC_HaltA():''' Stops communication with the selected tag.
* '''PCD_StopCrypto1():''' Stops the reader's Crypto1 authentication state.

== Procedure ==

# Connect the MFRC522 RFID reader to the Arduino UNO according to the pin connection table.
# Verify the power supply and logic-level compatibility of the RFID module.
# Connect the Arduino UNO to the computer using a USB cable.
# Open the Arduino IDE.
# Install the MFRC522 library using the Library Manager.
# Select the appropriate Arduino UNO board and COM port.
# Copy the program into the Arduino IDE.
# Compile and upload the program to the Arduino UNO.
# Open the Serial Monitor and set the baud rate to 9600.
# Bring a compatible RFID tag or card close to the RFID reader.
# Observe the UID displayed on the Serial Monitor.
# Repeat the experiment with different tags and compare the displayed UIDs.

== Observations and Output ==

The following is an illustrative example of the expected Serial Monitor output. Actual UIDs will depend on the RFID tags used.

<pre>
RFID Identification System
Place an RFID tag near the reader.
Tag UID: 23:8A:4F:19
Tag UID: 6B:21:CD:07
Tag UID: 23:8A:4F:19
</pre>

{| class="wikitable"
|-
! Sr. No.
! RFID Tag
! Observed UID
|-
| 1
| Tag 1
| Record the UID displayed
|-
| 2
| Tag 2
| Record the UID displayed
|-
| 3
| Tag 3
| Record the UID displayed
|}

== Result ==

The RFID reader was interfaced with the Arduino UNO using SPI communication. The system read the UIDs of compatible RFID tags and displayed the identification information on the Serial Monitor, demonstrating short-range wireless identification.

== Viva Questions ==

# What is RFID?
# What are the main components of an RFID system?
# What is the difference between an RFID reader and an RFID tag?
# What is the purpose of the UID in an RFID tag?
# Which communication protocol is used between the MFRC522 and Arduino UNO?
# What is SPI communication?
# Why does the MFRC522 require a 3.3 V supply?
# What factors affect the reading range of an RFID system?
# What is the difference between passive and active RFID tags?
# Why is UID-only identification not considered secure authentication?

MDM331AID/Experiment 7

2026-10-08T01:08:12Z

CogWikiEditor: /* Pin Connections */

= Experiment: RFID-Based Identification System =

== Aim ==
To design an RFID-based identification system that reads tag information and displays the tag ID on a monitoring system, demonstrating short-range communication technology in IoT.

== Objectives ==
* To understand RFID technology and its role in IoT.
* To interface an RFID reader with an Arduino UNO.
* To read the unique identification number (UID) of an RFID tag.
* To display the tag ID on the Arduino IDE Serial Monitor.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| Arduino UNO
| 1
|-
| 2
| MFRC522 RFID reader module
| 1
|-
| 3
| RFID tags or cards compatible with the reader
| 1 or more
|-
| 4
| USB cable
| 1
|-
| 5
| Patch cords
| As required
|-
| 6
| 3.3 V-compatible logic-level interface, if required by the RFID module
| 1
|}

== Theory ==

'''Radio Frequency Identification (RFID)''' is a wireless identification technology that uses radio waves to exchange information between an RFID reader and an RFID tag.

An RFID system generally consists of:
* '''RFID tag:''' Stores identification information. Passive tags obtain operating energy from the reader's electromagnetic field.
* '''RFID reader:''' Communicates with the tag and retrieves its identification information.
* '''Controller:''' Processes the information received from the reader. In this experiment, the Arduino UNO acts as the controller.
* '''Monitoring system:''' Displays the received tag ID. In this experiment, the Arduino IDE Serial Monitor is used.

The MFRC522 reader communicates with the Arduino UNO using the SPI (Serial Peripheral Interface) protocol. When a compatible RFID tag is brought close to the reader, the reader detects the tag and retrieves its UID. The Arduino then displays the UID on the Serial Monitor.

RFID is a short-range communication technology. The reading distance depends on the reader, tag, antenna, operating conditions and tag type.

'''Note:''' The UID is used here for demonstration and identification only. UID-based checking alone is not a secure authentication mechanism.

== Pin Connections ==

The following connections assume an MFRC522 RFID module and an Arduino UNO.

{| class="wikitable"
|-
! RFID Module Pin
! Arduino UNO Pin
! Description
|-
| SDA / SS
| D10
| SPI chip select
|-
| SCK
| D13
| SPI clock
|-
| MOSI
| D11
| SPI data from Arduino to reader
|-
| MISO
| D12
| SPI data from reader to Arduino
|-
| RST
| D9
| Reset
|-
| 3.3V
| 3.3V (Connect to 5V if system not working)
| Power supply
|-
| GND
| GND
| Ground
|-
| IRQ
| Not connected
| Not required for this program
|}

== Connection Diagram ==

Connect the MFRC522 RFID reader to the Arduino UNO according to the pin connection table.

The USB cable connects the Arduino UNO to the computer. The computer runs the Arduino IDE and displays the received tag ID through the Serial Monitor.

== Program ==

Install the '''MFRC522''' library using the Arduino IDE Library Manager before uploading the program.

<pre>
#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9

MFRC522 rfid(SS_PIN, RST_PIN);

void setup()
{
Serial.begin(9600);
SPI.begin();
rfid.PCD_Init();

Serial.println("RFID Identification System");
Serial.println("Place an RFID tag near the reader.");
}

void loop()
{
// Check whether a new tag is present
if (!rfid.PICC_IsNewCardPresent())
{
return;
}

// Read the tag serial number
if (!rfid.PICC_ReadCardSerial())
{
return;
}

Serial.print("Tag UID: ");

for (byte i = 0; i < rfid.uid.size; i++)
{
if (rfid.uid.uidByte[i] < 0x10)
{
Serial.print("0");
}

Serial.print(rfid.uid.uidByte[i], HEX);

if (i < rfid.uid.size - 1)
{
Serial.print(":");
}
}

Serial.println();

// Stop communication with the current tag
rfid.PICC_HaltA();
rfid.PCD_StopCrypto1();

delay(500);
}
</pre>

== Code Explanation ==

* '''SPI.begin():''' Initializes SPI communication between the Arduino UNO and the RFID reader.
* '''rfid.PCD_Init():''' Initializes the MFRC522 RFID reader.
* '''PICC_IsNewCardPresent():''' Checks whether a new RFID tag is present in the reader's field.
* '''PICC_ReadCardSerial():''' Reads the UID of the detected RFID tag.
* '''rfid.uid.size:''' Gives the number of bytes in the UID.
* '''Serial.print():''' Displays the UID in hexadecimal format on the Serial Monitor.
* '''PICC_HaltA():''' Stops communication with the selected tag.
* '''PCD_StopCrypto1():''' Stops the reader's Crypto1 authentication state.

== Procedure ==

# Connect the MFRC522 RFID reader to the Arduino UNO according to the pin connection table.
# Verify the power supply and logic-level compatibility of the RFID module.
# Connect the Arduino UNO to the computer using a USB cable.
# Open the Arduino IDE.
# Install the MFRC522 library using the Library Manager.
# Select the appropriate Arduino UNO board and COM port.
# Copy the program into the Arduino IDE.
# Compile and upload the program to the Arduino UNO.
# Open the Serial Monitor and set the baud rate to 9600.
# Bring a compatible RFID tag or card close to the RFID reader.
# Observe the UID displayed on the Serial Monitor.
# Repeat the experiment with different tags and compare the displayed UIDs.

== Observations and Output ==

The following is an illustrative example of the expected Serial Monitor output. Actual UIDs will depend on the RFID tags used.

<pre>
RFID Identification System
Place an RFID tag near the reader.
Tag UID: 23:8A:4F:19
Tag UID: 6B:21:CD:07
Tag UID: 23:8A:4F:19
</pre>

{| class="wikitable"
|-
! Sr. No.
! RFID Tag
! Observed UID
|-
| 1
| Tag 1
| Record the UID displayed
|-
| 2
| Tag 2
| Record the UID displayed
|-
| 3
| Tag 3
| Record the UID displayed
|}

== Result ==

The RFID reader was interfaced with the Arduino UNO using SPI communication. The system read the UIDs of compatible RFID tags and displayed the identification information on the Serial Monitor, demonstrating short-range wireless identification.

== Viva Questions ==

# What is RFID?
# What are the main components of an RFID system?
# What is the difference between an RFID reader and an RFID tag?
# What is the purpose of the UID in an RFID tag?
# Which communication protocol is used between the MFRC522 and Arduino UNO?
# What is SPI communication?
# Why does the MFRC522 require a 3.3 V supply?
# What factors affect the reading range of an RFID system?
# What is the difference between passive and active RFID tags?
# Why is UID-only identification not considered secure authentication?

File:IoT TCP DHT11 Programs.zip

2026-10-08T01:00:20Z

CogWikiEditor:

MDM331AID/Experiment 5

2026-10-08T00:54:33Z

CogWikiEditor:

= Experiment: Wi-Fi Connectivity and TCP/IP-Based Sensor Data Transmission Using ESP32 =

== Aim ==

To configure and implement an IoT device using ESP32 to connect to a Wi-Fi network and transmit temperature and humidity data from a DHT11 sensor to a remote computer using TCP/IP communication.

== Objectives ==

* To understand Wi-Fi connectivity in IoT devices.
* To interface a DHT11 temperature and humidity sensor with ESP32.
* To understand TCP/IP communication and socket programming.
* To configure a computer as a TCP server.
* To configure ESP32 as a TCP client.
* To establish a TCP connection between an ESP32 and a remote computer.
* To transmit and receive sensor data over a Wi-Fi network.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 Development Board (COG-E32)
| 1
|-
| 2
| DHT11 Temperature and Humidity Sensor (COG-MSBA)
| 1
|-
| 3
| USB Data Cable
| 1
|-
| 4
| Patch Cords
| As required
|-
| 5
| Computer with Arduino IDE
| 1
|-
| 6
| Remote Computer with Python 3
| 1
|-
| 7
| Wi-Fi Network
| 1
|}

== Theory ==

=== Internet of Things (IoT) Device ===

An IoT device is a physical device equipped with sensors, processing capabilities, and communication interfaces. It collects data from its surroundings and transmits the information to another device, computer, or remote server.

In this experiment, the ESP32 acts as the IoT device. The DHT11 sensor measures temperature and relative humidity. The ESP32 processes these readings and transmits them to a remote computer through a Wi-Fi network using TCP/IP communication.

=== Wi-Fi Connectivity ===

Wi-Fi is a wireless networking technology based on IEEE 802.11 standards. It allows devices to communicate over a wireless local area network.

The ESP32 contains built-in Wi-Fi capability. Therefore, no separate Wi-Fi module is required.

In this experiment, both the ESP32 and the remote computer should be connected to the same Wi-Fi network so that the ESP32 can establish a TCP connection with the computer.

=== TCP/IP Communication ===

TCP/IP is a protocol suite used for communication between networked devices.

* '''IP (Internet Protocol):''' Provides addressing and routing of packets between devices.
* '''TCP (Transmission Control Protocol):''' Provides reliable, ordered and connection-oriented communication.
* '''Port:''' A logical communication endpoint used to identify a particular application or service.
* '''Socket:''' A software interface used by applications to establish network communication.

In this experiment:

* The remote computer operates as the TCP server.
* The ESP32 operates as the TCP client.
* The Python program listens for incoming TCP connections.
* The ESP32 connects to the IP address and port of the remote computer.
* The DHT11 readings are transmitted through the established TCP connection.

=== TCP Client and TCP Server ===

The TCP server waits for incoming client connections. In this experiment, the Python program running on the remote computer is the TCP server.

The TCP client initiates a connection to the server. In this experiment, the ESP32 is the TCP client.

The communication flow is:

<pre>
DHT11 Sensor
|
| Temperature and Humidity
v
+------------------+
| ESP32 |
| TCP Client |
+------------------+
|
| Wi-Fi
v
+------------------+
| Wi-Fi Network |
+------------------+
|
| TCP/IP
v
+------------------+
| Remote Computer |
| TCP Server |
| Python Program |
+------------------+
|
v
Display Sensor Data
</pre>

=== DHT11 Sensor ===

The DHT11 is a digital temperature and humidity sensor. It provides temperature and relative humidity measurements through a digital data interface.

Typical specifications include:

* Temperature measurement range: 0 °C to 50 °C
* Relative humidity measurement range: 20% to 90%
* Digital single-wire data interface

The DHT11 is suitable for basic IoT and environmental monitoring experiments.

== System Architecture ==

<pre>
DHT11
|
Temperature
& Humidity
|
v
+----------------+
| ESP32 |
| TCP Client |
+----------------+
|
| Wi-Fi
v
+----------------+
| Wi-Fi Router |
+----------------+
|
| TCP/IP
v
+----------------+
| Remote Computer|
| Python Server |
+----------------+
|
v
Temperature &
Humidity Display
</pre>

== Pin Connections ==

{| class="wikitable"
|-
! ESP32 Pin
! DHT11 Pin
! Description
|-
| 3V3
| VCC
| Sensor power supply
|-
| GPIO 4
| DATA
| Digital data connection
|-
| GND
| GND
| Common ground
|}

'''Note:''' The connections assume a compatible DHT11 module with clearly identified VCC, DATA and GND pins. Verify the actual sensor-board pinout before making the connections.

== Software Requirements ==

=== ESP32 ===

* Arduino IDE
* ESP32 board support package
* DHT sensor library
* Adafruit Unified Sensor library
* Wi-Fi library included with the ESP32 board package

=== Remote Computer ===

* Python 3
* Wi-Fi connection
* TCP/IP network connectivity
* TCP port 5000 available for the experiment

The Python '''socket''' module is included with Python 3. No additional Python package is required.

== Programs ==

Two programs are required for this experiment.

{| class="wikitable"
|-
! Program
! Platform
! Function
|-
| Program 1: TCP Server
| Remote Computer
| Receives temperature and humidity data from ESP32.
|-
| Program 2: ESP32 TCP Client
| ESP32
| Connects to Wi-Fi, reads DHT11 data and transmits it to the TCP server.
|}

=== Download Programs ===

The complete source code for both programs is provided in a single ZIP file.

'''Download:'''

[[Media:IoT_TCP_DHT11_Programs.zip|Download ESP32 and Python TCP/IP Programs]]

The ZIP file contains:

<pre>
IoT_TCP_DHT11_Programs.zip
|
+-- tcp_server.py
|
+-- ESP32_DHT11_TCP_Client
|
+-- ESP32_DHT11_TCP_Client.ino
</pre>

=== Program 1: Python TCP Server ===

The Python TCP Server runs on the remote computer.

Its functions are:

* Creates a TCP socket.
* Listens for incoming connections on port 5000.
* Accepts the connection from the ESP32.
* Receives sensor data transmitted by the ESP32.
* Displays the received temperature and humidity values.
* Detects when the ESP32 disconnects.

The Python program is provided in the downloaded ZIP file as:

<pre>
tcp_server.py
</pre>

=== Program 2: ESP32 TCP Client ===

The ESP32 TCP Client runs on the ESP32.

Its functions are:

* Connects the ESP32 to the specified Wi-Fi network.
* Reads temperature from the DHT11 sensor.
* Reads relative humidity from the DHT11 sensor.
* Establishes a TCP connection with the remote computer.
* Transmits temperature and humidity data to the Python TCP server.
* Displays Wi-Fi, TCP and sensor information on the Serial Monitor.

The Arduino program is provided in the downloaded ZIP file as:

<pre>
ESP32_DHT11_TCP_Client/ESP32_DHT11_TCP_Client.ino
</pre>

== Program Configuration ==

Before uploading the ESP32 program, configure the following parameters in the downloaded Arduino program.

{| class="wikitable"
|-
! Parameter
! Description
! Example
|-
| Wi-Fi SSID
| Name of the Wi-Fi network
| MyWiFi
|-
| Wi-Fi Password
| Password of the Wi-Fi network
| mypassword123
|-
| Server IP Address
| IPv4 address of the remote computer running the Python server
| 192.168.1.100
|-
| Server Port
| TCP port used by the Python server
| 5000
|-
| DHT Pin
| ESP32 GPIO connected to DHT11 DATA
| GPIO 4
|}

The Wi-Fi SSID, Wi-Fi password and Server IP Address must be changed according to the actual laboratory setup.

The TCP port must remain the same in both programs.

== Procedure ==

=== Step 1: Connect the Hardware ===

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using the USB data cable.
# Connect the remote computer to the Wi-Fi network.

=== Step 2: Find the IP Address of the Remote Computer ===

The IP address of the remote computer is required because the ESP32 must know where the TCP server is located.

==== Windows ====

# Connect the remote computer to the required Wi-Fi network.
# Open '''Command Prompt'''.
# Type the following command:

<pre>
ipconfig
</pre>

# Press Enter.
# Locate the '''Wireless LAN adapter Wi-Fi''' section.
# Find the '''IPv4 Address''' entry.

Example:

<pre>
Wireless LAN adapter Wi-Fi:

IPv4 Address. . . . . . . . . . . : 192.168.1.100
</pre>

In this example, the remote computer IP address is:

<pre>
192.168.1.100
</pre>

# Record this address.
# Enter this address as the TCP server IP address in the ESP32 program.

'''Important:''' Use the '''IPv4 Address''' of the remote computer. Do not use the '''Default Gateway''' address.

==== Linux ====

Open the Terminal and use:

<pre>
hostname -I
</pre>

or:

<pre>
ip addr
</pre>

Identify the IPv4 address of the Wi-Fi interface.

Example:

<pre>
192.168.1.100
</pre>

Use this address as the TCP server IP address in the ESP32 program.

=== Step 3: Download the Programs ===

# Download the program ZIP file:

[[Media:IoT_TCP_DHT11_Programs.zip|Download ESP32 and Python TCP/IP Programs]]

# Extract the ZIP file.
# Verify that the following files are available:

<pre>
tcp_server.py

ESP32_DHT11_TCP_Client/
ESP32_DHT11_TCP_Client.ino
</pre>

=== Step 4: Configure the Python TCP Server ===

# Open the extracted '''tcp_server.py''' file.
# The Python server uses TCP port 5000.
# Open Command Prompt or Terminal.
# Navigate to the folder containing '''tcp_server.py'''.
# Run the following command:

<pre>
python tcp_server.py
</pre>

If required, use:

<pre>
python3 tcp_server.py
</pre>

The expected output is:

<pre>
----------------------------------
ESP32 DHT11 TCP Receiver
----------------------------------
TCP Server started
Listening on port: 5000
Waiting for ESP32 connection...
</pre>

Keep the Python TCP server running during the experiment.

=== Step 5: Configure the ESP32 Program ===

# Open Arduino IDE.
# Open the file '''ESP32_DHT11_TCP_Client.ino''' from the downloaded ZIP file.
# Enter the Wi-Fi network name.
# Enter the Wi-Fi password.
# Enter the IPv4 address of the remote computer.
# Verify that the TCP port is set to 5000.
# Verify that the DHT11 DATA pin is configured as GPIO 4.
# Select the appropriate ESP32 board.
# Select the correct COM port.

=== Step 6: Install Required Arduino Libraries ===

# Open Arduino IDE.
# Open Library Manager.
# Search for '''DHT sensor library'''.
# Install the '''DHT sensor library by Adafruit'''.
# Install '''Adafruit Unified Sensor''' if required.
# Ensure that the ESP32 board package is installed.

The '''WiFi''' library is included with the ESP32 board support package.

=== Step 7: Upload the ESP32 Program ===

# Compile the ESP32 program.
# Upload the program to the ESP32.
# Open the Serial Monitor.
# Set the baud rate to '''115200'''.
# Observe the Wi-Fi connection status.
# Observe the ESP32 IP address.
# Observe the TCP connection status.
# Observe the transmitted DHT11 readings.

Expected output:

<pre>
ESP32 DHT11 TCP/IP Client
----------------------------------
Connecting to Wi-Fi....
Wi-Fi connected!
ESP32 IP Address: 192.168.1.120

Connecting to TCP server: 192.168.1.100:5000
TCP server connected!

Sent: Temperature: 28.4 C, Humidity: 61.0 %
Sent: Temperature: 28.5 C, Humidity: 61.0 %
</pre>

=== Step 8: Verify Data on the Remote Computer ===

The Python TCP server should display:

<pre>
ESP32 connected!
Client IP: 192.168.1.120
----------------------------------
Received: Temperature: 28.4 C, Humidity: 61.0 %
Received: Temperature: 28.5 C, Humidity: 61.0 %
</pre>

The IP addresses and sensor readings shown above are illustrative examples. Actual values will depend on the network and environment.

=== Step 9: Verify TCP/IP Communication ===

# Confirm that the ESP32 successfully connects to Wi-Fi.
# Confirm that the ESP32 obtains an IP address.
# Confirm that the ESP32 establishes a TCP connection with the remote computer.
# Confirm that the Python server reports the ESP32 connection.
# Verify that temperature and humidity values are received.
# Compare the values transmitted by the ESP32 with the values displayed by the Python server.
# Disconnect or reset the ESP32.
# Observe the disconnection message on the Python server.

== TCP Communication Sequence ==

<pre>
1. Start Python TCP Server
|
v
2. Server listens on TCP port 5000
|
v
3. ESP32 connects to Wi-Fi
|
v
4. ESP32 connects to Remote Computer
|
v
5. TCP connection established
|
v
6. ESP32 reads DHT11
|
v
7. ESP32 transmits sensor data
|
v
8. Python server receives data
|
v
9. Temperature and humidity displayed
</pre>

== Important Network Configuration ==

The following conditions must be satisfied for successful communication.

{| class="wikitable"
|-
! Parameter
! Requirement
|-
| ESP32 Wi-Fi
| Connected to the Wi-Fi network
|-
| Remote Computer
| Connected to the same Wi-Fi or LAN
|-
| Server IP
| Must be the IPv4 address of the remote computer
|-
| TCP Port
| 5000
|-
| Python Server
| Must be running before the ESP32 attempts connection
|-
| Firewall
| Must allow TCP communication on port 5000
|}

'''Important:''' The IP address of the remote computer may change when it reconnects to the Wi-Fi network. If the ESP32 cannot connect after a network change, check the computer's IPv4 address again using '''ipconfig''' and update the ESP32 program if necessary.

== Windows Firewall Configuration ==

If the ESP32 cannot connect to the Python server, Windows Firewall may be blocking incoming connections.

# Open '''Windows Security'''.
# Select '''Firewall & network protection'''.
# Select '''Advanced settings'''.
# Select '''Inbound Rules'''.
# Create a new inbound rule.
# Select '''Port'''.
# Select '''TCP'''.
# Enter port '''5000'''.
# Select '''Allow the connection'''.
# Apply the rule to the appropriate network profile.
# Give the rule a suitable name such as '''ESP32 TCP Server Port 5000'''.

Alternatively, Windows may display a firewall permission dialog when Python first attempts to accept a network connection. Allow Python to communicate on the appropriate network.

== Troubleshooting ==

{| class="wikitable"
|-
! Problem
! Possible Cause
! Solution
|-
| ESP32 cannot connect to Wi-Fi
| Incorrect SSID or password
| Verify the Wi-Fi name and password.
|-
| ESP32 connects to Wi-Fi but TCP connection fails
| Incorrect server IP
| Run '''ipconfig''' and verify the computer's IPv4 address.
|-
| Python server does not receive data
| Server not running
| Start '''python tcp_server.py'''.
|-
| Connection refused
| TCP server is not listening
| Start the Python TCP server and verify port 5000.
|-
| Connection timeout
| Firewall blocking TCP communication
| Allow TCP port 5000 through the firewall.
|-
| DHT11 reading fails
| Incorrect sensor connection
| Check VCC, DATA, GND and GPIO 4 connections.
|-
| Devices cannot communicate
| Different Wi-Fi networks
| Connect ESP32 and remote computer to the same network.
|-
| Wrong IP address
| Gateway address used instead of computer IP
| Use the computer's IPv4 Address shown by '''ipconfig'''.
|-
| Python command not recognized
| Python is not installed or not added to PATH
| Install Python 3 and add Python to PATH.
|}

== Observations ==

{| class="wikitable"
|-
! Sr. No.
! Temperature (C)
! Relative Humidity (percent)
! TCP Transmission Status
|-
| 1
| Record measured value
| Record measured value
| Successful / Failed
|-
| 2
| Record measured value
| Record measured value
| Successful / Failed
|-
| 3
| Record measured value
| Record measured value
| Successful / Failed
|-
| 4
| Record measured value
| Record measured value
| Successful / Failed
|-
| 5
| Record measured value
| Record measured value
| Successful / Failed
|}

== Expected Output ==

=== ESP32 Serial Monitor ===

<pre>
ESP32 DHT11 TCP/IP Client
----------------------------------
Connecting to Wi-Fi....
Wi-Fi connected!
ESP32 IP Address: 192.168.1.120

Connecting to TCP server: 192.168.1.100:5000
TCP server connected!

Sent: Temperature: 28.4 C, Humidity: 61.0 %
Sent: Temperature: 28.5 C, Humidity: 61.0 %
Sent: Temperature: 28.5 C, Humidity: 62.0 %
</pre>

=== Remote Computer ===

<pre>
----------------------------------
ESP32 DHT11 TCP Receiver
----------------------------------
TCP Server started
Listening on port: 5000
Waiting for ESP32 connection...

ESP32 connected!
Client IP: 192.168.1.120
----------------------------------
Received: Temperature: 28.4 C, Humidity: 61.0 %
Received: Temperature: 28.5 C, Humidity: 61.0 %
Received: Temperature: 28.5 C, Humidity: 62.0 %
</pre>

The IP addresses and sensor readings shown above are illustrative examples and may differ during the actual experiment.

== Result ==

An IoT application was successfully implemented using ESP32 and DHT11. The ESP32 was connected to a Wi-Fi network and configured as a TCP client. A remote computer was configured as a Python TCP server. Temperature and humidity data obtained from the DHT11 sensor was successfully transmitted from the ESP32 to the remote computer using TCP/IP socket communication.

== Viva Questions ==

# What is the role of Wi-Fi in this experiment?
# What is TCP?
# What is the difference between TCP and UDP?
# What is an IP address?
# How do you find the IPv4 address of a Windows computer?
# Why is the remote computer's IPv4 address entered in the ESP32 program?
# What is a TCP socket?
# What is the difference between a TCP client and a TCP server?
# Why is the ESP32 configured as a TCP client?
# Why is the remote computer configured as a TCP server?
# Why is TCP considered a reliable protocol?
# What is the purpose of the '''bind()''' function?
# What is the purpose of the '''listen()''' function?
# What is the purpose of the '''accept()''' function?
# What is the purpose of the '''recv()''' function?
# What is the purpose of '''client.connect()''' in the ESP32 program?
# Why must the TCP port number be the same in both programs?
# Why is port 5000 used in this experiment?
# What happens if Windows Firewall blocks port 5000?
# Why should the ESP32 and remote computer normally be connected to the same Wi-Fi network?
# What is the purpose of '''WiFi.localIP()'''?
# What is the difference between the ESP32 IP address and the remote computer IP address?
# How can this experiment be extended to store sensor readings in a database?
# How can this experiment be extended to send data to a cloud platform?
# What are the advantages of using TCP for sensor data transmission?

MDM331AID/Experiment 9

2026-10-07T17:31:15Z

CogWikiEditor: /* Introducing Manual Anomalies */

= Experiment: Perform Data Cleaning, Normalization, and Visualization on IoT Sensor Dataset =

== Aim ==
To perform data cleaning, normalization, and visualization on an IoT sensor dataset and prepare the data for further analysis.

== Objectives ==
* To understand the importance of data preprocessing in IoT applications.
* To inspect and identify missing, duplicate, inconsistent, and anomalous sensor data.
* To clean an IoT sensor dataset using appropriate data-cleaning techniques.
* To normalize sensor values to a standard numerical range.
* To visualize sensor data using suitable graphs.
* To compare the dataset before and after data cleaning and normalization.
* To understand how data preprocessing improves the quality and usability of IoT sensor data.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| Computer or laptop
| 1
|-
| 2
| IoT sensor dataset in CSV format
| 1
|-
| 3
| Python
| 1
|-
| 4
| Jupyter Notebook / Google Colab / Python IDE
| 1
|-
| 5
| Pandas library
| 1
|-
| 6
| NumPy library
| 1
|-
| 7
| Matplotlib library
| 1
|}

== Theory ==

'''Data preprocessing''' is the process of preparing raw data for analysis by identifying and correcting problems such as missing values, duplicate records, incorrect data types, inconsistent values, and anomalous observations.

IoT systems continuously generate sensor data. The collected data may contain errors due to sensor limitations, communication problems, transmission errors, incorrect entries, or abnormal operating conditions. Therefore, raw IoT data should be cleaned and transformed before it is used for analysis or visualization.

The main stages of data preprocessing performed in this experiment are:

* '''Data inspection:''' Examining the structure, columns, data types, number of records, and statistical properties of the dataset.
* '''Data cleaning:''' Identifying and handling missing values, duplicate records, invalid values, and anomalous observations.
* '''Data transformation:''' Converting data into suitable formats for analysis, such as converting timestamp values into a proper date-time format.
* '''Data normalization:''' Scaling numerical sensor values to a standard range so that they can be compared and processed more easily.
* '''Data visualization:''' Representing the processed data graphically to identify patterns, trends, variations, and anomalies.

The dataset used in this experiment is an IoT temperature dataset obtained from the Cognifront cloud platform. The dataset contains the following fields:

{| class="wikitable"
|-
! Column
! Description
|-
| ID
| Unique record identifier generated for the sensor data record
|-
| Name
| Name of the sensor variable. In this dataset, it is DHT-Temp
|-
| Value
| Temperature value recorded by the sensor
|-
| Date
| Date and time at which the sensor reading was recorded
|}

The original dataset contains '''547 records''' and four columns: ID, Name, Value and Date. The Value column contains temperature readings, while the Date column contains the corresponding timestamps.

'''Missing values''' are records where one or more required fields contain no valid value. Missing values may be removed or replaced depending on the nature of the dataset and the purpose of the analysis.

'''Duplicate records''' are repeated records that contain the same data more than once. Duplicate records can occur because of repeated data transmission or storage operations and may need to be removed.

'''Anomalies''' are observations that differ significantly from the normal pattern of the dataset. In a temperature dataset, an unusually high or low value may represent a sensor error, transmission error, or abnormal environmental condition. Anomalies should be investigated before deciding whether they should be removed, corrected, or retained.

'''Normalization''' is the process of transforming numerical values to a common scale. In this experiment, Min-Max normalization is used to transform the temperature values into the range 0 to 1.

The Min-Max normalization formula is:

<pre>
Normalized Value = (X - Xmin) / (Xmax - Xmin)
</pre>

where:

* '''X''' is the original sensor value.
* '''Xmin''' is the minimum value in the dataset.
* '''Xmax''' is the maximum value in the dataset.

After normalization, the smallest value becomes 0 and the largest value becomes 1.

'''Data visualization''' is used to represent the processed sensor data graphically. A line graph can be used to show temperature variation with time, while a histogram can be used to observe the distribution of temperature values.

The overall data-processing flow is:

<pre>
Raw IoT CSV Dataset
↓
Data Inspection
↓
Data Cleaning
↓
Data Transformation
↓
Normalization
↓
Visualization
↓
Processed Dataset
</pre>

== Dataset Used ==

The dataset used for this experiment is a DHT11 temperature dataset exported from the Cognifront cloud platform.

The original dataset contains:

{| class="wikitable"
|-
! Parameter
! Value
|-
| Number of records
| 547
|-
| Number of columns
| 4
|-
| Sensor variable
| DHT-Temp
|-
| Minimum temperature
| 27.1 °C
|-
| Maximum temperature
| 27.8 °C
|-
| Missing values
| None in the original dataset
|-
| Duplicate timestamps
| None in the original dataset
|}

== Program ==

Install the required Python libraries before running the program.

<pre>
pip install pandas numpy matplotlib
</pre>

The following program loads the IoT dataset, inspects the data, performs data cleaning, normalizes the temperature values using Min-Max normalization, and generates visualizations.

<pre>
from google.colab import files
dht_data = files.upload()

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# Load the dataset
df = pd.read_csv('anomalous-dht11-data.csv')

print("Original Dataset")
print(df.head())

print("\nDataset Information")
print(df.info())

print("\nMissing Values")
print(df.isnull().sum())

print("\nDuplicate Records")
print(df.duplicated().sum())

print("\nStatistical Summary")
print(df.describe())

# Convert Date column to datetime
df["Date"] = pd.to_datetime(df["Date"], errors="coerce")

# Convert Value column to numeric
df["Value"] = pd.to_numeric(df["Value"], errors="coerce")

# Remove rows with missing required values
df = df.dropna(subset=["ID", "Name", "Value", "Date"])

# Remove duplicate records
df = df.drop_duplicates()

"""# Now to remove *outliers*, we will use 2 methods:

1. Using IQR (Interquartile Range) method
2. Using Domain-based method

For our particular dataset, you will see why Domain-based method is more applicable by looking at the output of IQR method.

**1) IQR (Interquartile Range) method**
"""

# Detect temperature outliers using IQR
Q1 = df["Value"].quantile(0.25)
Q3 = df["Value"].quantile(0.75)
IQR = Q3 - Q1

lower_limit = Q1 - 1.5 * IQR
upper_limit = Q3 + 1.5 * IQR

outliers = df[
(df["Value"] < lower_limit) |
(df["Value"] > upper_limit)
]

print("\nDetected Outliers")
print(outliers)

# Remove detected outliers
df_clean = df[
(df["Value"] >= lower_limit) &
(df["Value"] <= upper_limit)
].copy()

"""**2) Domain-based method**"""

lower_limit = 15
upper_limit = 50

df_clean = df[
(df["Value"] >= lower_limit) &
(df["Value"] <= upper_limit)
].copy()

# Min-Max normalization
min_value = df_clean["Value"].min()
max_value = df_clean["Value"].max()

df_clean["Normalized_Value"] = (
(df_clean["Value"] - min_value) /
(max_value - min_value)
)

# Save cleaned and normalized dataset
df_clean.to_csv(
"cleaned_normalized_dht11_data.csv",
index=False
)

print("\nCleaned Dataset")
print(df_clean.head())

print("\nNormalized Dataset")
print(df_clean[["Value", "Normalized_Value"]].head())

# Visualization 1: Temperature vs Time
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Temperature (°C)")
plt.title("DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Visualization 2: Temperature distribution
plt.figure(figsize=(8, 5))

plt.hist(
df_clean["Value"],
bins=10
)

plt.xlabel("Temperature (°C)")
plt.ylabel("Frequency")
plt.title("Distribution of DHT11 Temperature Values")
plt.tight_layout()
plt.show()

# Visualization 3: Normalized temperature
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Normalized_Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Normalized Temperature")
plt.title("Normalized DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
</pre>

== Code Explanation ==

* '''files.upload():''' Opens a file-upload interface in Google Colab so that the IoT sensor CSV dataset can be uploaded.

* '''pd.read_csv():''' Loads the uploaded CSV dataset into a Pandas DataFrame.

* '''df.head():''' Displays the first few records of the dataset.

* '''df.info():''' Displays information about the columns, data types and number of non-null records.

* '''isnull().sum():''' Counts the number of missing values in each column.

* '''duplicated().sum():''' Counts the number of duplicate records in the dataset.

* '''df.describe():''' Displays statistical information such as count, mean, standard deviation, minimum and maximum values of numerical columns.

* '''pd.to_datetime():''' Converts the Date column into a proper date-time format. Invalid date values are converted to missing values using '''errors="coerce"'''.

* '''pd.to_numeric():''' Converts the Value column into numerical data. Invalid values are converted to missing values using '''errors="coerce"'''.

* '''dropna():''' Removes records containing missing values in the required ID, Name, Value or Date fields.

* '''drop_duplicates():''' Removes duplicate records from the dataset.

* '''Q1 and Q3:''' Represent the first and third quartiles of the temperature data and are used for IQR-based outlier detection.

* '''IQR:''' Represents the Interquartile Range and is calculated as Q3 − Q1.

* '''IQR outlier limits:''' Values below Q1 − 1.5 × IQR or above Q3 + 1.5 × IQR are identified as potential outliers.

* '''IQR outlier detection:''' Identifies and displays potential outliers using the statistical IQR method. In this experiment, the IQR method is demonstrated for comparison but is not used for the final cleaning because the normal temperature readings are closely clustered.

* '''Domain-based outlier detection:''' Defines an acceptable temperature range of 15 °C to 50 °C. Values outside this range are treated as anomalous temperature readings.

* '''df_clean:''' Stores the final cleaned dataset after applying the domain-based temperature limits.

* '''Min-Max normalization:''' Transforms the cleaned temperature values into the range 0 to 1 using the formula:

<pre>
Normalized Value = (X - Xmin) / (Xmax - Xmin)
</pre>

* '''to_csv():''' Saves the cleaned and normalized dataset as a new CSV file named '''cleaned_normalized_dht11_data.csv'''.

* '''plt.plot():''' Creates a line graph showing the variation of temperature with respect to date and time.

* '''plt.hist():''' Creates a histogram showing the distribution and frequency of the cleaned temperature values.

* '''Normalized temperature plot:''' Displays the normalized temperature values against time to show the sensor readings after Min-Max normalization.

== Procedure ==

# Obtain the DHT11 sensor dataset in CSV format from the Cognifront cloud platform.
# Make a copy of the original CSV file and use the copy for data-cleaning experiments.
# Open the Python environment such as Jupyter Notebook, Google Colab or a Python IDE.
# Install the required Pandas, NumPy and Matplotlib libraries.
# Load the CSV dataset using Pandas.
# Inspect the dataset and identify its columns, data types and number of records.
# Check the dataset for missing values.
# Check the dataset for duplicate records.
# Convert the Date column into the appropriate date-time format.
# Convert the sensor Value column into numerical format.
# Identify anomalous sensor values using statistical methods such as the IQR method.
# Remove or handle the identified invalid or anomalous records as required.
# Normalize the cleaned sensor values using Min-Max normalization.
# Save the cleaned and normalized dataset as a new CSV file.
# Plot the temperature values against time using a line graph.
# Plot the distribution of temperature values using a histogram.
# Plot the normalized temperature values against time.
# Compare the original and processed datasets and observe the effect of data cleaning and normalization.

== Introducing Manual Anomalies ==

The original Cognifront dataset is relatively clean. Therefore, for demonstrating data-cleaning techniques, controlled anomalies can be introduced into a '''copy''' of the original dataset.

'''Do not modify the original downloaded dataset.''' Keep the original file as the raw dataset and create a separate file such as:

<pre>
anomalous-dht11-data.csv
</pre>

The following anomalies can be introduced for demonstration:

{| class="wikitable"
|-
! Anomaly
! Example
! Purpose
|-
| Missing value
| Replace a Value entry with an empty cell
| Demonstrates missing-value handling
|-
| Duplicate record
| Copy one complete row and insert it again
| Demonstrates duplicate detection
|-
| Extreme temperature
| Change one Value to 80 °C
| Demonstrates outlier detection
|-
| Very low temperature
| Change one Value to -20 °C
| Demonstrates anomalous-value detection
|-
| Invalid value
| Replace one Value with text such as "ERROR"
| Demonstrates invalid data handling
|}

For example, if the original data contains:

<pre>
296900,DHT-Temp,27.5,2026-10-07 08:49:35
</pre>

the Value can be changed to:

<pre>
296900,DHT-Temp,80,2026-10-07 08:49:35
</pre>

Similarly, another record can be changed to:

<pre>
296950,DHT-Temp,,2026-10-07 08:51:15
</pre>

to demonstrate a missing sensor value.

An existing row can also be copied and inserted again to create a duplicate record.

The modified dataset can then be processed using the Python program. The program should identify the missing, duplicate and anomalous records and produce a cleaned dataset.

'''Note:''' These manually introduced anomalies are artificial and are used only to demonstrate data-cleaning techniques. They should not be presented as actual errors produced by the DHT11 sensor or Cognifront cloud platform.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Operation
! Observation
|-
| 1
| Dataset inspection
| Dataset contains 547 records and 4 columns
|-
| 2
| Missing-value check
| Original dataset contains no missing values
|-
| 3
| Duplicate check
| Original dataset contains no duplicate records
|-
| 4
| Data type conversion
| Date converted to datetime and Value converted to numeric
|-
| 5
| Anomaly detection
| Artificial anomalous records are identified in the modified dataset
|-
| 6
| Data cleaning
| Missing, duplicate and anomalous records are handled
|-
| 7
| Normalization
| Temperature values are converted to the range 0 to 1
|-
| 8
| Visualization
| Temperature variation and distribution are represented graphically
|-
| 9
| CSV export
| Cleaned and normalized data is saved as a new CSV file
|}

== Result ==

The IoT sensor dataset was successfully inspected, cleaned and normalized using Python. Missing values, duplicate records and anomalous sensor readings were identified and handled. The temperature values were normalized using Min-Max normalization, and the processed data was visualized using suitable graphs. The cleaned and normalized dataset was successfully exported as a CSV file.

== Viva Questions ==

# What is data preprocessing?
# Why is data cleaning required for IoT sensor data?
# What is the difference between raw data and cleaned data?
# What is a missing value?
# What is a duplicate record?
# What is an anomaly in a sensor dataset?
# Why are artificial anomalies introduced during this experiment?
# What is the IQR method?
# How is an outlier detected using the IQR method?
# What is data normalization?
# What is Min-Max normalization?
# What is the range of values produced by Min-Max normalization?
# Why is the Date column converted into datetime format?
# What is the purpose of the Pandas library?
# What is the purpose of NumPy?
# What is Matplotlib used for?
# What is the purpose of a histogram?
# What information can be obtained from a line graph of sensor data?
# Why should the original dataset be preserved before data cleaning?
# Why should manually introduced anomalies not be considered actual sensor errors?
# What is the purpose of exporting the processed dataset as a CSV file?

MDM331AID/Experiment 5

2026-10-07T16:27:15Z

CogWikiEditor:

MDM331AID/Experiment 4

2026-10-07T16:00:19Z

CogWikiEditor: /* Arduino Program */

= Experiment: Gas Leakage Detection Using Arduino UNO =

== Aim ==

To develop a gas leakage detection application using an Arduino UNO and an MQ-2 gas sensor to monitor the surrounding environment and generate an alert when the sensor reading exceeds a predefined threshold.

== Objectives ==

* To understand the working principle of the MQ-2 gas sensor.
* To interface a gas sensor with the Arduino UNO.
* To read analog sensor values using the ADC of the Arduino.
* To implement threshold-based gas detection.
* To activate an alert using an LED and buzzer when the sensor reading exceeds the set threshold.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| Arduino UNO Development Board (COG-U1)
| 1
|-
| 2
| MQ-2 Gas Sensor (COG-MSBA)
| 1
|-
| 3
| LED bar
| 1
|-
| 4
| Buzzer
| 1
|-
| 5
| USB data cable
| 1
|-
| 6
| Patch cords
| As required
|-
| 7
| Computer with Arduino IDE
| 1
|}

== Theory ==

=== Gas Leakage Detection ===

Gas leakage detection is an important application in homes, industries, laboratories, and other environments where combustible gases may be present. A gas sensor detects changes in the surrounding gas concentration and generates an electrical signal that can be processed by a microcontroller.

=== MQ-2 Gas Sensor ===

The MQ-2 is a semiconductor gas sensor commonly used for detecting combustible gases and smoke. It is sensitive to gases such as LPG, propane, methane, hydrogen, and smoke.

The sensor contains a sensing element whose electrical resistance changes in the presence of certain gases. The sensor module converts this change into an electrical output.

Common MQ-2 module interfaces include:

* '''VCC:''' Power supply input.
* '''GND:''' Ground connection.
* '''AO:''' Analog output voltage related to the sensor response.
* '''DO:''' Digital output from an onboard comparator, often with an adjustable threshold.

In this experiment, the analog output is used to read sensor values through the Arduino UNO's analog input.

=== Analog-to-Digital Conversion ===

The Arduino UNO has a 10-bit analog-to-digital converter (ADC). The analogRead() function converts the analog input voltage into a digital value ranging from 0 to 1023 when using the default reference.

=== Threshold-Based Detection ===

The Arduino continuously reads the analog output of the MQ-2 sensor. The measured value is compared with a predefined threshold.

* If the sensor reading is below the threshold, the system indicates normal operation.
* If the sensor reading is equal to or above the threshold, the system activates the alert LED and buzzer.

The threshold used in this experiment is a demonstration value and must be adjusted based on actual sensor readings. It does not represent a calibrated gas concentration.

== Pin Connections ==

{| class="wikitable"
|-
! Arduino UNO Pin
! MQ-2 / Output Connection
! Description
|-
| 5V
| MQ-2 VCC
| Sensor power supply
|-
| GND
| MQ-2 GND
| Common ground
|-
| A0
| MQ-2 AO
| Analog sensor output
|-
| D8
| LED bar input
| Visual alert output
|-
| D9
| Buzzer input
| Audible alert output
|}

'''Note:''' These connections assume that the MQ-2 board exposes an analog output compatible with the Arduino UNO and that the LED bar and buzzer accept active-HIGH digital control. Verify the actual pin labels and interface of your Cognifront sensor and output boards before connecting.

== Connection Diagram ==

<pre>
MQ-2 Gas Sensor
+---------------+
| |
| VCC ---------+---- 5V
| GND ---------+---- GND
| AO ---------+---- A0
+---------------+

Arduino UNO
+------------------+
| |
| A0 <--- MQ-2 AO |
| |
| D8 ------------+---- LED Bar Input
| |
| D9 ------------+---- Buzzer Input
| |
| GND ------------+---- Common GND
+------------------+
</pre>

== Arduino Program ==

<pre>
const int gasPin = A0;
const int ledPin = 8;
const int buzzerPin = 9;

// Demonstration threshold; calibrate for your setup
const int gasThreshold = 400;

int gasValue = 0;

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

pinMode(ledPin, OUTPUT);
pinMode(buzzerPin, OUTPUT);

digitalWrite(ledPin, LOW);
digitalWrite(buzzerPin, LOW);

Serial.println("MQ-2 Gas Detection System");
}

void loop() {
gasValue = analogRead(gasPin);

Serial.print("Gas Sensor Value: ");
Serial.println(gasValue);

if (gasValue >= gasThreshold) {
digitalWrite(ledPin, HIGH);
digitalWrite(buzzerPin, HIGH);
Serial.println("WARNING: Gas level threshold exceeded!");
} else {
digitalWrite(ledPin, LOW);
digitalWrite(buzzerPin, LOW);
Serial.println("Status: Normal");
}

delay(1000);
}
</pre>

== Code Explanation ==

{| class="wikitable"
|-
! Statement
! Description
|-
| const int gasPin = A0;
| Defines analog pin A0 as the gas sensor input.
|-
| const int ledPin = 8;
| Defines digital pin D8 as the LED control output.
|-
| const int buzzerPin = 9;
| Defines digital pin D9 as the buzzer control output.
|-
| const int gasThreshold = 400;
| Sets a demonstration threshold for gas detection.
|-
| analogRead(gasPin)
| Reads the analog output of the gas sensor and returns a value from 0 to 1023.
|-
| Serial.println(gasValue)
| Displays the sensor reading on the Serial Monitor.
|-
| if (gasValue >= gasThreshold)
| Checks whether the sensor reading has reached or exceeded the threshold.
|-
| digitalWrite(ledPin, HIGH)
| Activates the LED alert output.
|-
| digitalWrite(buzzerPin, HIGH)
| Activates the buzzer alert output.
|-
| delay(1000)
| Pauses the program for one second before the next reading.
|}

== Procedure ==

# Connect the MQ-2 sensor's VCC and GND pins to the Arduino UNO's 5V and GND, respectively.
# Connect the sensor's analog output (AO) to the Arduino analog input A0.
# Connect the LED bar input to D8 and the buzzer input to D9, ensuring that the output interfaces are compatible.
# Connect the Arduino UNO to the computer using the USB data cable.
# Open the Arduino IDE and select the Arduino UNO board and appropriate COM port.
# Enter the program and upload it to the Arduino UNO.
# Open the Serial Monitor and set the baud rate to 9600.
# Allow the MQ-2 sensor to warm up and stabilize according to its datasheet and module instructions.
# Observe the sensor readings under the available ambient conditions.
# Adjust the demonstration threshold based on observed readings, if required.
# Observe the LED and buzzer response when the reading crosses the configured threshold.

'''Safety precaution:''' Do not intentionally release LPG, lighter gas, smoke, or other combustible gases to test the circuit. This is an educational demonstration, not a certified gas alarm or safety system. Conduct any controlled sensor testing only with appropriate laboratory safety procedures.

== Observations ==

{| class="wikitable"
|-
! Sr. No.
! Sensor Reading
! Condition
! LED
! Buzzer
|-
| 1
| Below threshold
| Normal
| OFF
| OFF
|-
| 2
| Equal to or above threshold
| Threshold exceeded
| ON
| ON
|}

The readings and alert response should be recorded during the experiment. The table describes expected behavior, not measured results.

== Result ==

An Arduino UNO-based gas detection demonstration was developed using an MQ-2 sensor. The sensor's analog output was read and compared against a predefined threshold. An LED and buzzer were programmed to provide alerts when the reading exceeded the threshold.

== Viva Questions ==

# What is the purpose of a gas sensor?
# What is the working principle of the MQ-2 sensor?
# Which gases can the MQ-2 sensor detect?
# What is the difference between the analog and digital outputs of an MQ-2 module?
# What is the resolution of the Arduino UNO ADC?
# What is the purpose of the analogRead() function?
# Why is a threshold used in gas detection?
# Why does an MQ-2 sensor require a warm-up period?
# Can an MQ-2 sensor directly measure gas concentration in parts per million without calibration?
# What are the limitations of a threshold-based gas detection system?
# How can this project be extended to send gas alerts through an IoT cloud platform?

MDM331AID/Experiment 3

2026-10-07T15:57:43Z

CogWikiEditor: /* Arduino Program */

= Experiment 3: Arduino-Based LED Control Using GPIO Pins =

== Aim ==
To implement a simple IoT-oriented application using an Arduino UNO board to control an LED through GPIO pins and understand the physical design of IoT devices and the concept of device actuation.

== Objectives ==
* To understand the physical components of an IoT device.
* To configure Arduino GPIO pins as digital outputs.
* To control an LED using digital signals.
* To understand the role of actuators in IoT applications.
* To observe the relationship between software commands and physical device actions.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| Arduino UNO Development Board (COG-U1)
| 1
|-
| 2
| LED bar available on the Arduino kit
| 1
|-
| 3
| USB data cable
| 1
|-
| 4
| Patch cords
| As required
|-
| 5
| Computer with Arduino IDE
| 1
|}

== Theory ==

=== Physical Design of an IoT Device ===

An IoT device consists of physical hardware and software that work together to sense, process, communicate, and perform actions. A typical IoT device includes the following components:

* '''Processing unit:''' A microcontroller or processor that executes the program and controls device operations.
* '''Input interface:''' GPIO pins and sensor interfaces used to receive data from external components.
* '''Output interface:''' GPIO pins used to control actuators such as LEDs, buzzers, relays, and motors.
* '''Communication interface:''' Wi-Fi, Bluetooth, Ethernet, or other communication technologies used to exchange data.
* '''Power supply:''' Provides the electrical energy required for device operation.

In this experiment, the Arduino UNO acts as the processing unit, and the LED acts as a simple output actuator.

=== GPIO Pins ===

GPIO stands for General Purpose Input/Output. These pins allow a microcontroller to interact with external electronic components.

Arduino UNO digital pins can be configured as:

* '''INPUT:''' To read digital signals.
* '''OUTPUT:''' To generate digital signals.
* '''INPUT_PULLUP:''' To read digital signals using an internal pull-up resistor.

For LED control, the GPIO pin is configured as an output.

=== Device Actuation ===

Actuation is the process of converting a control signal into a physical action. In this experiment, the Arduino generates a digital HIGH or LOW signal on a GPIO pin to switch the LED on or off.

* '''HIGH:''' The output pin is set to a logic HIGH voltage, approximately 5 V on an Arduino UNO.
* '''LOW:''' The output pin is set to a logic LOW voltage, approximately 0 V.

This demonstrates a basic form of device actuation. In a complete IoT system, commands could be received over a network and used to control the same GPIO output.

== Pin Connections ==

{| class="wikitable"
|-
! Arduino UNO Pin
! LED Bar Connection
! Description
|-
| D8
| LED bar input
| Digital output for LED control
|-
| GND
| LED bar GND
| Common ground
|}

'''Note:''' The connection above assumes that the LED bar has a compatible input connection for direct GPIO control. Verify the LED bar's actual pin labels and current-limiting arrangement before connecting it. If the kit's LED bar uses a different interface, follow its board-specific connection details.

== Connection Diagram ==

<pre>
Arduino UNO
+-------------+
| |
| D8 |---------------- LED Bar Input
| |
| GND |---------------- LED Bar GND
| |
+-------------+
</pre>

== Arduino Program ==

<pre>
const int ledPin = 8;

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop() {
// Turn LED ON
digitalWrite(ledPin, HIGH);
delay(1000);

// Turn LED OFF
digitalWrite(ledPin, LOW);
delay(1000);
}
</pre>

== Code Explanation ==

{| class="wikitable"
|-
! Statement
! Description
|-
| const int ledPin = 8;
| Defines digital pin 8 as the LED control pin.
|-
| pinMode(ledPin, OUTPUT);
| Configures the selected GPIO pin as an output.
|-
| digitalWrite(ledPin, HIGH);
| Sets the GPIO output to HIGH to turn the LED on, assuming active-HIGH wiring.
|-
| delay(1000);
| Pauses program execution for 1000 milliseconds.
|-
| digitalWrite(ledPin, LOW);
| Sets the GPIO output to LOW to turn the LED off, assuming active-HIGH wiring.
|}

== Procedure ==

# Connect the Arduino UNO board to the computer using the USB data cable.
# Connect the LED bar input to digital pin D8 and its ground to Arduino GND, after verifying the LED bar's pinout and compatibility.
# Open the Arduino IDE.
# Select the appropriate Arduino UNO board and COM port.
# Enter the given Arduino program.
# Compile and upload the program to the Arduino UNO.
# Observe the LED switching on and off at one-second intervals.
# Modify the delay values and observe how the blinking speed changes.

== Observations ==

{| class="wikitable"
|-
! Sr. No.
! GPIO Output
! Expected LED State
|-
| 1
| HIGH
| ON
|-
| 2
| LOW
| OFF
|-
| 3
| HIGH
| ON
|-
| 4
| LOW
| OFF
|}

The expected output is a repeating sequence of one second ON followed by one second OFF. Actual behavior depends on the LED bar's electrical interface and polarity.

== Result ==

The Arduino UNO was programmed to control an LED through a GPIO pin. The experiment demonstrates GPIO output configuration and basic device actuation, illustrating how software commands can produce physical actions in an IoT device.

== Viva Questions ==

# What is the full form of GPIO?
# What is the function of a microcontroller in an IoT device?
# What is the difference between digital input and digital output?
# What is device actuation?
# What is the purpose of the pinMode() function?
# What is the function of digitalWrite()?
# What is the difference between HIGH and LOW logic levels?
# Why is a current-limiting resistor required for a conventional LED?
# What is the role of a communication interface in an IoT device?
# How could this experiment be extended to control an LED remotely over Wi-Fi?

MDM331AID/Experiment 14

2026-10-07T13:29:38Z

CogWikiEditor: Created page with "= Experiment: Smart Threshold Alerts for Data Minimization using Privacy-by-Design = == Aim == To design and implement a Privacy-by-Design IoT system using an LDR sensor and ESP32 that generates an alert only when a predefined threshold is crossed, thereby minimizing unnecessary sensor data transmission. == Objectives == # To understand Privacy-by-Design in an IoT system. # To understand the concept of data minimization. # To interface an LDR sensor with ESP32. # To..."

= Experiment: Smart Threshold Alerts for Data Minimization using Privacy-by-Design =

== Aim ==

To design and implement a Privacy-by-Design IoT system using an LDR sensor and ESP32 that generates an alert only when a predefined threshold is crossed, thereby minimizing unnecessary sensor data transmission.

== Objectives ==

# To understand Privacy-by-Design in an IoT system.
# To understand the concept of data minimization.
# To interface an LDR sensor with ESP32.
# To detect changes in light intensity.
# To define a threshold for detecting darkness.
# To generate a POWER CUT alert when darkness is detected.
# To process raw sensor data locally on the ESP32.
# To avoid continuously transmitting raw LDR readings.
# To transmit or expose only the required alert information.
# To demonstrate data minimization through data inspection.

== Components Required ==

{| class="wikitable"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| Reads the LDR and hosts the web server
|-
| 2
| LDR
| 1
| Detects light intensity
|-
| 3
| 10 kOhm Resistor
| 1
| Forms the LDR voltage divider
|-
| 4
| Breadboard
| 1
| Circuit connections
|-
| 5
| Jumper Wires
| As required
| Electrical connections
|-
| 6
| Smartphone
| 1
| Accesses the ESP32 web page
|-
| 7
| USB Cable
| 1
| Programming and powering ESP32
|-
| 8
| Computer with Arduino IDE
| 1
| Programming the ESP32
|}

== Theory ==

=== Internet of Things ===

The Internet of Things, or IoT, is a system in which physical devices use sensors and communication technologies to collect and exchange information.

In a conventional IoT system, sensor readings may be continuously transmitted even when the application does not require all of the readings.

For example, an LDR monitoring system may continuously generate values such as:

<pre>
3860
3715
3521
3480
3405
</pre>

If the purpose of the application is only to detect a power cut, the application does not need every individual LDR reading.

The ESP32 can instead process the sensor data locally and generate an alert only when the required condition occurs.

=== Privacy-by-Design ===

Privacy-by-Design means that privacy is considered while designing the system rather than being added later.

One important part of Privacy-by-Design is data minimization.

Data minimization means collecting, processing, transmitting, and storing only the information that is necessary for the intended purpose.

In this experiment, the purpose is to detect a possible power cut.

Therefore, the system does not need to continuously expose the exact LDR readings.

The ESP32 processes the readings locally and only generates the required alert when the threshold is crossed.

=== Smart Threshold Alert ===

A threshold is a predefined value used to identify a particular condition.

The ESP32 reads the LDR value and compares it with the selected threshold.

The operation is:

<pre>
LDR reading
|
v
ESP32
|
v
Check threshold
|
+-------------------+
| |
v v
Normal condition Dark condition
| |
v v
No alert POWER CUT
alert
</pre>

The threshold value depends on the LDR circuit and surrounding lighting conditions.

Therefore, the threshold should be calibrated before performing the experiment.

=== Data Minimization ===

In a conventional system, raw LDR readings may be continuously sent to another device or server.

In the proposed system:

<pre>
LDR reading
|
v
Local processing on ESP32
|
v
Threshold check
|
+------------------+
| |
v v
Normal Dark
| |
v v
No alert POWER CUT
</pre>

The raw LDR value is used locally for decision making.

Unnecessary raw readings are therefore not continuously exposed outside the device.

== Pin Connections ==

{| class="wikitable"
! LDR Circuit
! ESP32
! Description
|-
| LDR voltage divider output
| GPIO 34
| Analog input
|-
| Supply
| 3.3V
| Circuit supply
|-
| Ground
| GND
| Common ground
|}

A typical voltage divider is:

<pre>
3.3V
|
LDR
|
+-------- GPIO 34
|
10 kOhm
|
GND
</pre>

The voltage at GPIO 34 changes according to the amount of light falling on the LDR.

'''Note:''' Depending on the circuit arrangement, the LDR reading may increase or decrease when the sensor is covered. The actual behavior should be checked during calibration.

== Connection Diagram ==

<pre>
ESP32
+------------+
| |
3.3V --| |
| |
| GPIO 34 <--|------ LDR Circuit
| |
GND --| |
| |
+------------+
|
|
Wi-Fi Access Point
|
|
Smartphone Browser
|
|
192.168.1.4
</pre>

== Working Principle ==

The ESP32 works as a Wi-Fi Access Point and hosts a web server.

The smartphone connects directly to the Wi-Fi network created by the ESP32.

The student then opens:

<pre>
http://192.168.1.4
</pre>

The ESP32 reads the LDR value.

The value is compared with the threshold.

When sufficient light is present, the system remains in the normal condition.

When the LDR is covered and the reading crosses the threshold, the ESP32 considers the condition to represent a power cut.

The smartphone then displays the POWER CUT alert.

The raw LDR value is processed locally.

== Program ==

The following program avoids embedding HTML source directly into the MediaWiki page.

The web page is constructed using character values so that the program does not contain HTML tags as literal text.

<pre>
#include <WiFi.h>
#include <WebServer.h>

const int LDR_PIN = 34;

const char* ap_ssid = "ESP32-Power-Monitor";
const char* ap_password = "12345678";

WebServer server(80);

const int LDR_THRESHOLD = 2000;

bool powerCut = false;

void handleRoot()
{
int ldrValue = analogRead(LDR_PIN);

if (ldrValue < LDR_THRESHOLD)
{
powerCut = true;
}
else
{
powerCut = false;
}

String page = "";

char lt = 60;
char gt = 62;

page += lt;
page += "html";
page += gt;

page += lt;
page += "head";
page += gt;

page += lt;
page += "meta name='viewport' content='width=device-width, initial-scale=1'";
page += gt;

page += lt;
page += "title";
page += gt;
page += "Smart Power Monitor";
page += lt;
page += "/title";
page += gt;

page += lt;
page += "/head";
page += gt;

page += lt;
page += "body";
page += gt;

page += lt;
page += "h1";
page += gt;
page += "Smart Power Monitor";
page += lt;
page += "/h1";
page += gt;

if (powerCut)
{
page += lt;
page += "h2";
page += gt;
page += "POWER CUT";
page += lt;
page += "/h2";
page += gt;

page += lt;
page += "p";
page += gt;
page += "Dark condition detected.";
page += lt;
page += "/p";
page += gt;
}
else
{
page += lt;
page += "h2";
page += gt;
page += "NORMAL";
page += lt;
page += "/h2";
page += gt;

page += lt;
page += "p";
page += gt;
page += "No power cut detected.";
page += lt;
page += "/p";
page += gt;
}

page += lt;
page += "/body";
page += gt;

page += lt;
page += "/html";
page += gt;

server.send(200, "text/html", page);
}

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

pinMode(LDR_PIN, INPUT);

WiFi.softAPConfig(
IPAddress(192,168,1,4),
IPAddress(192,168,1,1),
IPAddress(255,255,255,0)
);

WiFi.softAP(ap_ssid, ap_password);

Serial.println("ESP32 Access Point started");
Serial.print("IP Address: ");
Serial.println(WiFi.softAPIP());

server.on("/", handleRoot);

server.begin();

Serial.println("Web server started");
}

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code or Function
! Explanation
|-
| WiFi.h
| Provides ESP32 Wi-Fi functionality.
|-
| WebServer.h
| Provides the web server functionality.
|-
| LDR_PIN
| Defines GPIO 34 as the LDR analog input.
|-
| WiFi.softAP
| Creates a Wi-Fi Access Point using the ESP32.
|-
| WiFi.softAPConfig
| Sets the Access Point IP address to 192.168.1.4.
|-
| WebServer server(80)
| Creates an HTTP web server on port 80.
|-
| LDR_THRESHOLD
| Defines the value used to detect the dark condition.
|-
| analogRead
| Reads the analog value from the LDR circuit.
|-
| powerCut
| Stores whether a dark condition has been detected.
|-
| handleRoot
| Generates the web page displayed on the smartphone.
|-
| server.send
| Sends the web page to the browser.
|-
| server.handleClient
| Processes browser requests.
|}

=== Access Point ===

The ESP32 creates its own Wi-Fi network.

The network name is:

<pre>
ESP32-Power-Monitor
</pre>

The IP address is:

<pre>
192.168.1.4
</pre>

The smartphone can therefore access the web page using:

<pre>
http://192.168.1.4
</pre>

=== Threshold Detection ===

The ESP32 reads the LDR using:

<pre>
int ldrValue = analogRead(LDR_PIN);
</pre>

The value is compared with the threshold:

<pre>
if (ldrValue < LDR_THRESHOLD)
{
powerCut = true;
}
</pre>

If the condition is satisfied, the ESP32 generates the POWER CUT alert.

== Calibration of LDR Threshold ==

The threshold should be calibrated before the experiment.

# Upload the program to the ESP32.
# Open the Arduino IDE Serial Monitor.
# Observe the LDR readings under normal light.
# Cover the LDR with a finger.
# Observe the LDR readings again.
# Compare the readings for bright and dark conditions.
# Select a suitable threshold between the two conditions.
# Change the LDR_THRESHOLD value in the program.
# Upload the program again.
# Test the system.

For example, the readings may be:

<pre>
Normal light:
3000 to 3800

LDR covered:
500 to 1200
</pre>

In such a case, a threshold somewhere between these ranges can be selected.

'''The above values are examples only. Actual values depend on the LDR circuit and lighting conditions.'''

== Procedure ==

# Connect the LDR and resistor as a voltage divider.
# Connect the output of the voltage divider to GPIO 34.
# Connect the circuit to 3.3V and GND.
# Connect the ESP32 to the computer.
# Open Arduino IDE.
# Select the appropriate ESP32 board.
# Select the appropriate COM port.
# Upload the program.
# Open the Serial Monitor.
# Verify that the ESP32 Access Point has started.
# Connect the smartphone to ESP32-Power-Monitor.
# Open the smartphone browser.
# Enter http://192.168.1.4.
# Observe the NORMAL status.
# Keep the LDR exposed to light.
# Cover the LDR using a finger.
# Observe the POWER CUT alert.
# Remove the finger.
# Verify that the normal condition is restored.
# Perform the data inspection demonstration.

== Observations and Output ==

=== Normal Condition ===

When the LDR is exposed to sufficient light:

<pre>
LDR Condition : Bright
System Status : NORMAL
Alert : None
</pre>

No power-cut alert is generated.

=== Dark Condition ===

When the LDR is covered with a finger:

<pre>
LDR Condition : Dark
System Status : ALERT
Alert : POWER CUT
</pre>

The ESP32 detects the threshold crossing and generates the alert.

=== Smartphone Output ===

Normal condition:

<pre>
SMART POWER MONITOR

NORMAL

No power cut detected.
</pre>

Dark condition:

<pre>
SMART POWER MONITOR

POWER CUT

Dark condition detected.
</pre>

== Demonstration of Data Minimization ==

The main purpose of this experiment is to demonstrate that unnecessary raw sensor data does not need to be transmitted.

=== Conventional System ===

In a conventional IoT system, the server may receive raw LDR readings continuously.

For example:

<pre>
LDR value: 3860

LDR value: 3715

LDR value: 3521

LDR value: 3480
</pre>

The server therefore receives detailed sensor information.

=== Privacy-by-Design System ===

In the proposed system, the ESP32 processes the LDR reading locally.

During normal conditions:

<pre>
LDR reading
|
v
Local threshold check
|
v
Normal condition
|
v
No alert
</pre>

When the threshold is crossed:

<pre>
LDR reading
|
v
Local threshold check
|
v
Dark condition
|
v
POWER CUT
</pre>

The application only needs to expose the required event.

The raw LDR measurement does not need to be exposed.

== Data Inspection Demonstration ==

The data inspection demonstration is used to compare the amount of information exposed by two system designs.

The demonstration is educational and is intended to show the effect of data minimization.

=== Conventional Design ===

A conventional system may expose information such as:

<pre>
LDR value: 3860
LDR value: 3715
LDR value: 3521
LDR value: 1200
</pre>

An observer can therefore obtain detailed information about the sensor readings.

=== Privacy-by-Design Design ===

The Privacy-by-Design system processes the raw value locally.

When there is no threshold event:

<pre>
No alert
</pre>

When darkness is detected:

<pre>
POWER CUT
</pre>

The application therefore exposes only the information needed for the intended purpose.

The raw LDR values are not required by the application.

=== Demonstration Steps ===

# Connect the smartphone to the ESP32 Access Point.
# Open the ESP32 web page.
# Observe the normal condition.
# Cover the LDR with a finger.
# Observe the POWER CUT alert.
# Inspect the application data using an appropriate network inspection or server logging method.
# Observe that the useful application information is the alert rather than a continuous stream of raw LDR values.
# Explain that the raw reading was processed locally before the alert was generated.

'''Note:''' This demonstration is about data minimization. It does not claim that HTTP communication is encrypted or completely secure.

== Conventional System vs Privacy-by-Design System ==

{| class="wikitable"
! Feature
! Conventional System
! Privacy-by-Design System
|-
| Sensor processing
| May be performed at server
| Performed locally on ESP32
|-
| Raw LDR readings
| May be continuously transmitted
| Processed locally
|-
| Normal readings
| May be transmitted
| No unnecessary transmission
|-
| Threshold detection
| May be performed at server
| Performed on ESP32
|-
| Alert
| May contain sensor information
| Only required alert is exposed
|-
| Data volume
| Higher
| Lower
|-
| Data exposure
| Higher
| Minimized
|}

== Why This is Privacy-by-Design ==

The experiment demonstrates Privacy-by-Design through the following design decisions:

# '''Local Processing:''' Raw LDR readings are processed on the ESP32.
# '''Data Minimization:''' Continuous raw readings are not unnecessarily transmitted.
# '''Purpose Limitation:''' The system only needs to detect a possible power-cut condition.
# '''Smart Thresholding:''' An alert is generated only when the threshold is crossed.
# '''Reduced Data Exposure:''' Unnecessary sensor information is not exposed.
# '''Privacy by Default:''' The system is designed to minimize data exposure from the beginning.

The main principle demonstrated is:

<pre>
Do not transmit unnecessary information
when the application does not require it.
</pre>

== Advantages ==

# Reduces unnecessary data transmission.
# Reduces the amount of sensor information exposed outside the device.
# Reduces network traffic.
# Allows fast local decision making.
# Demonstrates data minimization clearly.
# Does not require an external cloud server.
# Can be demonstrated easily using a smartphone.
# Can be extended to other IoT alert applications.

== Limitations ==

# The LDR provides an indirect indication of a power cut.
# Changes in environmental lighting can also trigger the alert.
# The threshold must be calibrated.
# The HTTP communication used in this experiment is not encrypted.
# This experiment demonstrates data minimization and not complete IoT security.
# A real power monitoring system would use an appropriate electrical sensing method.

== Result ==

The smart threshold alert system was successfully implemented using an LDR sensor and ESP32.

The ESP32 locally processed the LDR readings and detected a dark condition using a predefined threshold.

When the threshold was crossed, the smartphone displayed a POWER CUT alert through the ESP32 web server.

The ESP32 used the IP address:

<pre>
192.168.1.4
</pre>

The experiment demonstrated that raw LDR readings do not need to be continuously exposed when the application only requires an event notification.

Thus, the experiment demonstrated data minimization through local processing and smart threshold alerts as a practical Privacy-by-Design approach.

== Viva Questions ==

'''Q1. What is Privacy-by-Design?'''

'''Ans:''' Privacy-by-Design means incorporating privacy considerations into the design of a system from the beginning.

'''Q2. What is data minimization?'''

'''Ans:''' Data minimization means collecting, processing, transmitting, and storing only the data required for the intended purpose.

'''Q3. Why is an LDR used?'''

'''Ans:''' An LDR is used because its light-sensitive behavior makes it easy to manually generate a threshold event by covering it with a finger.

'''Q4. What does darkness represent in this experiment?'''

'''Ans:''' Darkness is treated as an indication of a possible power cut.

'''Q5. Why is the raw LDR value not continuously transmitted?'''

'''Ans:''' The application only needs to know whether the threshold has been crossed. Therefore, continuous transmission of the raw value is unnecessary.

'''Q6. Where is the threshold checked?'''

'''Ans:''' The threshold is checked locally on the ESP32.

'''Q7. What happens when the threshold is not crossed?'''

'''Ans:''' No power-cut alert is generated and unnecessary sensor data is not exposed.

'''Q8. What happens when the threshold is crossed?'''

'''Ans:''' The ESP32 detects the dark condition and generates the POWER CUT alert.

'''Q9. What is the purpose of the data inspection demonstration?'''

'''Ans:''' It demonstrates how much sensor information is exposed and how data minimization reduces unnecessary information.

'''Q10. What information is required when the threshold is crossed?'''

'''Ans:''' The required information is the POWER CUT alert.

'''Q11. Is the system completely secure?'''

'''Ans:''' No. The main purpose is to demonstrate data minimization and Privacy-by-Design. HTTP communication is not encrypted.

'''Q12. Does data minimization mean that no data is transmitted?'''

'''Ans:''' No. It means that only the data necessary for the intended purpose should be transmitted or exposed.

'''Q13. Why is local processing useful?'''

'''Ans:''' Local processing allows the ESP32 to make decisions using raw sensor data without unnecessarily exposing that raw data.

'''Q14. What is a smart threshold alert?'''

'''Ans:''' A smart threshold alert is generated when a sensor reading crosses a predefined threshold representing a meaningful condition.

'''Q15. What is the main principle demonstrated by this experiment?'''

'''Ans:''' The main principle is data minimization. Raw sensor information is processed locally and only the required alert is exposed.

MDM331AID/Experiment 12 ESPNOW

2026-10-07T12:13:58Z

CogWikiEditor: Created page with "= Experiment: Secure Sensor Data Transmission Using ESP-NOW = == Aim == To implement secure wireless transmission of temperature and humidity data between two ESP32 devices using ESP-NOW with AES-128-based encryption. == Objectives == * To understand the concept of ESP-NOW communication in IoT systems. * To interface a DHT11 temperature and humidity sensor with an ESP32. * To transmit sensor data directly between two ESP32 devices without using an access point or clo..."

= Experiment: Secure Sensor Data Transmission Using ESP-NOW =

== Aim ==

To implement secure wireless transmission of temperature and humidity data between two ESP32 devices using ESP-NOW with AES-128-based encryption.

== Objectives ==

* To understand the concept of ESP-NOW communication in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To transmit sensor data directly between two ESP32 devices without using an access point or cloud server.
* To configure ESP-NOW communication between a transmitter and receiver.
* To understand peer-to-peer wireless communication in IoT systems.
* To configure ESP-NOW encryption using a Primary Master Key (PMK) and Local Master Key (LMK).
* To understand how AES-128-based encryption protects ESP-NOW communication.
* To verify that the receiver successfully obtains the transmitted sensor data.

== Components Required ==

{| class="wikitable" style="width: 80%;"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 2
| One transmitter and one receiver
|-
| 2
| DHT11 Sensor
| 1
| Measures temperature and humidity
|-
| 3
| USB Cable
| 2
| Programming and powering ESP32 boards
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Computer
| 1
| Programming and monitoring
|-
| 6
| Arduino IDE
| 1
| ESP32 programming
|}

== Theory ==

=== ESP-NOW ===

ESP-NOW is a connectionless wireless communication protocol developed by Espressif for communication between ESP devices.

It allows ESP32 devices to exchange data directly without requiring a traditional Wi-Fi access point or Internet connection. It is suitable for IoT applications such as sensors, remote controls and local device-to-device communication.

The communication structure used in this experiment is:

<pre>
DHT11 Sensor
↓
ESP32 Transmitter
↓
ESP-NOW
↓
ESP32 Receiver
↓
Serial Monitor
</pre>

=== ESP-NOW Peer Communication ===

In ESP-NOW, devices communicate using peer-to-peer wireless communication.

The transmitter sends a sensor-data packet to the MAC address of the receiver.

Unlike a normal Wi-Fi application, the devices do not need to establish a conventional IP connection with each other.

=== ESP-NOW Security ===

ESP-NOW provides security using the '''CCMP''' security mechanism.

A Primary Master Key (PMK) and Local Master Keys (LMKs) are used for encrypted peer communication.

The PMK is used to protect the LMK using AES-128, while the LMK associated with a paired device is used to encrypt the ESP-NOW communication frame.

The basic security structure is:

<pre>
Primary Master Key
↓
Protects LMK
↓
Local Master Key
↓
AES-128 / CCMP
↓
Encrypted ESP-NOW
Communication
</pre>

If an LMK is not configured for a paired device, that ESP-NOW communication is not encrypted. Therefore, configuring the encrypted peer correctly is an important part of this experiment.

=== AES-128 ===

AES stands for Advanced Encryption Standard.

ESP-NOW uses AES-128 as part of its security mechanism. AES-128 uses a 128-bit key to protect the communication.

In this experiment, the encryption is handled by the ESP-NOW security mechanism rather than manually implementing AES encryption in the application code.

Therefore:

<pre>
Sensor Data
↓
ESP-NOW Security
↓
AES-128 / CCMP Protection
↓
Wireless Transmission
↓
ESP32 Receiver
↓
Decrypted Sensor Data
</pre>

=== Advantages of ESP-NOW ===

* Direct communication between ESP32 devices.
* Does not require an Internet connection.
* Does not require a cloud server.
* Low communication overhead.
* Suitable for local IoT applications.
* Supports encrypted peer communication.
* Suitable for sensor and control applications.

== Pin Connections ==

=== DHT11 to ESP32 Transmitter ===

{| class="wikitable"
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital sensor data
|-
| GND
| GND
| Ground
|}

The second ESP32 is used only as the receiver and does not require a DHT11 sensor.

== Connection Diagram ==

<pre>
TRANSMITTER

+-------------------+
| DHT11 |
| |
| VCC DATA GND |
+--+----+----+------+
| | |
3.3V GPIO4 GND
| | |
+-----+----+----+-----+
| ESP32 #1 |
| TRANSMITTER |
+----------+----------+
|
|
| Secure ESP-NOW
| AES-128 / CCMP
|
↓
+---------------------+
| ESP32 #2 |
| RECEIVER |
+----------+----------+
|
↓
Serial Monitor
</pre>

== Program ==

=== Important Configuration ===

The following example uses:

* ESP32 #1 as the transmitter.
* ESP32 #2 as the receiver.
* DHT11 connected to GPIO 4 of ESP32 #1.
* A fixed PMK for the ESP-NOW security configuration.
* A fixed LMK for the encrypted transmitter-receiver peer.
* The receiver's MAC address configured in the transmitter.
* The transmitter's MAC address configured in the receiver.

'''The MAC addresses must be changed to match the two ESP32 boards being used.'''

=== Step 1: Find the MAC Address ===

Upload the following program to each ESP32 separately:

<pre>
#include <WiFi.h>

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

WiFi.mode(WIFI_STA);

Serial.print("ESP32 MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop()
{
}
</pre>

Open the Serial Monitor at '''115200 baud'''.

Example:

<pre>
ESP32 MAC Address: 24:6F:28:AA:BB:CC
</pre>

Record the MAC address of both ESP32 boards.

=== Step 2: ESP32 Transmitter Program ===

<pre>
#include <WiFi.h>
#include <esp_now.h>
#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

/*
Replace this with the MAC address
of ESP32 Receiver.
*/
uint8_t receiverAddress[] =
{
0x24, 0x6F, 0x28, 0xAA, 0xBB, 0xCC
};

/*
16-byte Primary Master Key.
*/
uint8_t PMK[] =
{
'P','M','K','1','2','3','4','5',
'6','7','8','9','A','B','C','D'
};

/*
16-byte Local Master Key.
*/
uint8_t LMK[] =
{
'L','M','K','1','2','3','4','5',
'6','7','8','9','A','B','C','D'
};

typedef struct
{
float temperature;
float humidity;
} SensorData;

SensorData data;

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

dht.begin();

WiFi.mode(WIFI_STA);

Serial.print("Transmitter MAC: ");
Serial.println(WiFi.macAddress());

if (esp_now_init() != ESP_OK)
{
Serial.println("ESP-NOW initialization failed");
return;
}

/*
Set Primary Master Key.
*/
if (esp_now_set_pmk(PMK) != ESP_OK)
{
Serial.println("PMK configuration failed");
return;
}

/*
Configure encrypted receiver.
*/
esp_now_peer_info_t peerInfo = {};

memcpy(
peerInfo.peer_addr,
receiverAddress,
6
);

peerInfo.channel = 0;
peerInfo.encrypt = true;

memcpy(
peerInfo.lmk,
LMK,
16
);

if (esp_now_add_peer(&peerInfo) != ESP_OK)
{
Serial.println("Failed to add encrypted peer");
return;
}

Serial.println("Secure ESP-NOW transmitter ready");
}

void loop()
{
data.temperature = dht.readTemperature();
data.humidity = dht.readHumidity();

if (isnan(data.temperature) ||
isnan(data.humidity))
{
Serial.println("DHT11 reading failed");
delay(2000);
return;
}

esp_err_t result = esp_now_send(
receiverAddress,
(uint8_t *)&data,
sizeof(data)
);

if (result == ESP_OK)
{
Serial.println("Encrypted sensor data sent");
}
else
{
Serial.println("Data transmission failed");
}

Serial.print("Temperature: ");
Serial.print(data.temperature);
Serial.println(" °C");

Serial.print("Humidity: ");
Serial.print(data.humidity);
Serial.println(" %");

Serial.println();

delay(2000);
}
</pre>

=== Step 3: ESP32 Receiver Program ===

<pre>
#include <WiFi.h>
#include <esp_now.h>

/*
Replace this with the MAC address
of ESP32 Transmitter.
*/
uint8_t transmitterAddress[] =
{
0x24, 0x6F, 0x28, 0x11, 0x22, 0x33
};

/*
Same 16-byte Primary Master Key
used by the transmitter.
*/
uint8_t PMK[] =
{
'P','M','K','1','2','3','4','5',
'6','7','8','9','A','B','C','D'
};

/*
Same 16-byte Local Master Key
used by the transmitter.
*/
uint8_t LMK[] =
{
'L','M','K','1','2','3','4','5',
'6','7','8','9','A','B','C','D'
};

typedef struct
{
float temperature;
float humidity;
} SensorData;

SensorData receivedData;

void onDataReceive(
const esp_now_recv_info_t *info,
const uint8_t *incomingData,
int len
)
{
if (len != sizeof(SensorData))
{
Serial.println("Invalid data size");
return;
}

memcpy(
&receivedData,
incomingData,
sizeof(receivedData)
);

Serial.println("Secure sensor data received");

Serial.print("Temperature: ");
Serial.print(receivedData.temperature);
Serial.println(" °C");

Serial.print("Humidity: ");
Serial.print(receivedData.humidity);
Serial.println(" %");

Serial.println();
}

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

WiFi.mode(WIFI_STA);

Serial.print("Receiver MAC: ");
Serial.println(WiFi.macAddress());

if (esp_now_init() != ESP_OK)
{
Serial.println("ESP-NOW initialization failed");
return;
}

/*
Set Primary Master Key.
*/
if (esp_now_set_pmk(PMK) != ESP_OK)
{
Serial.println("PMK configuration failed");
return;
}

/*
Configure the encrypted transmitter peer.
*/
esp_now_peer_info_t peerInfo = {};

memcpy(
peerInfo.peer_addr,
transmitterAddress,
6
);

peerInfo.channel = 0;
peerInfo.encrypt = true;

memcpy(
peerInfo.lmk,
LMK,
16
);

if (esp_now_add_peer(&peerInfo) != ESP_OK)
{
Serial.println("Failed to add encrypted peer");
return;
}

esp_now_register_recv_cb(onDataReceive);

Serial.println("Secure ESP-NOW receiver ready");
}

void loop()
{
delay(100);
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code / Function
! Explanation
|-
| `WiFi.mode(WIFI_STA)`
| Configures the ESP32 Wi-Fi interface in station mode.
|-
| `esp_now_init()`
| Initializes ESP-NOW communication.
|-
| `esp_now_set_pmk()`
| Sets the Primary Master Key used by ESP-NOW security.
|-
| `esp_now_peer_info_t`
| Stores information about the ESP-NOW peer.
|-
| `peer_addr`
| Stores the MAC address of the communication peer.
|-
| `peerInfo.encrypt = true`
| Enables encrypted ESP-NOW communication with the configured peer.
|-
| `peerInfo.lmk`
| Stores the Local Master Key associated with the peer.
|-
| `esp_now_add_peer()`
| Adds the encrypted peer to the ESP-NOW peer list.
|-
| `dht.readTemperature()`
| Reads temperature from the DHT11.
|-
| `dht.readHumidity()`
| Reads humidity from the DHT11.
|-
| `esp_now_send()`
| Sends the sensor-data packet to the receiver.
|-
| `esp_now_register_recv_cb()`
| Registers the function that is called when ESP-NOW data is received.
|-
| `memcpy()`
| Copies the received byte data into the sensor-data structure.
|}

== Security Configuration ==

Two keys are used in the practical.

{| class="wikitable"
! Key
! Size
! Purpose
|-
| PMK
| 16 bytes
| Primary Master Key used to protect the LMK.
|-
| LMK
| 16 bytes
| Local Master Key associated with the encrypted peer.
|}

ESP-NOW documentation specifies 16-byte PMK and LMK values. The PMK is used to encrypt the LMK using AES-128, while the LMK is used for protecting the communication frame with CCMP.

The transmitter and receiver must use the corresponding key configuration.

== Security Flow ==

The complete security process is:

<pre>
Sensor Data
↓
ESP32 Transmitter
↓
ESP-NOW Peer
↓
LMK / PMK
↓
AES-128 / CCMP
↓
Encrypted Frame
↓
Wireless Transfer
↓
ESP32 Receiver
↓
Decryption /
Security Check
↓
Sensor Data
</pre>

== Procedure ==

# Connect the DHT11 sensor to GPIO 4 of the transmitter ESP32.
# Connect both ESP32 boards to the computer using USB cables.
# Install the ESP32 board package in Arduino IDE.
# Install the DHT sensor library if required.
# Upload the MAC-address program to both ESP32 boards.
# Record the MAC address of the transmitter.
# Record the MAC address of the receiver.
# Enter the receiver MAC address in the transmitter program.
# Enter the transmitter MAC address in the receiver program.
# Keep the PMK and LMK identical on both ESP32 programs.
# Upload the receiver program to ESP32 #2.
# Open the receiver Serial Monitor at 115200 baud.
# Upload the transmitter program to ESP32 #1.
# Open the transmitter Serial Monitor at 115200 baud.
# Verify that both devices report successful ESP-NOW initialization.
# Verify that the encrypted peer is added successfully.
# Observe the DHT11 temperature and humidity readings on the transmitter.
# Observe the corresponding readings on the receiver.
# Verify that the receiver obtains the sensor data through the secured ESP-NOW link.
# Record the observed values.

== Observations and Output ==

=== Transmitter Output ===

The transmitter Serial Monitor should display output similar to:

<pre>
Transmitter MAC: 24:6F:28:AA:BB:CC
Secure ESP-NOW transmitter ready

Encrypted sensor data sent
Temperature: 27.40 °C
Humidity: 61.00 %

Encrypted sensor data sent
Temperature: 27.50 °C
Humidity: 61.00 %
</pre>

=== Receiver Output ===

The receiver Serial Monitor should display:

<pre>
Receiver MAC: 24:6F:28:11:22:33
Secure ESP-NOW receiver ready

Secure sensor data received
Temperature: 27.40 °C
Humidity: 61.00 %

Secure sensor data received
Temperature: 27.50 °C
Humidity: 61.00 %
</pre>

=== Observation Table ===

{| class="wikitable"
! Sr. No.
! Transmitter Temperature
! Receiver Temperature
! Transmitter Humidity
! Receiver Humidity
|-
| 1
| 27.40 °C
| 27.40 °C
| 61 %
| 61 %
|-
| 2
| 27.50 °C
| 27.50 °C
| 61 %
| 61 %
|-
| 3
| 27.50 °C
| 27.50 °C
| 62 %
| 62 %
|}

'''Note:''' The values shown above are example observations. Actual readings depend on the DHT11 sensor and surrounding environmental conditions.

== Security Verification ==

The security can be demonstrated by intentionally changing the security configuration.

For example, the following tests can be performed:

{| class="wikitable"
! Test
! Expected Result
|-
| Correct receiver MAC and matching PMK/LMK
| Sensor data is successfully received.
|-
| Incorrect receiver MAC
| Data is not delivered to the intended receiver.
|-
| Incorrect LMK
| Encrypted peer communication does not work correctly.
|-
| ESP-NOW peer encryption disabled
| Communication is no longer using the configured encrypted peer mechanism.
|}

This demonstrates that secure ESP-NOW communication depends on correctly configured peer security parameters.

== ESP-NOW vs Normal Wi-Fi Communication ==

{| class="wikitable"
! Feature
! Normal Wi-Fi Application
! ESP-NOW
|-
| Communication
| Usually through an IP network
| Direct device-to-device
|-
| Internet required
| May be required
| No
|-
| Access point required
| Usually
| Not for direct ESP-NOW communication
|-
| IoT sensor applications
| Yes
| Yes
|-
| Encrypted peer communication
| Depends on the Wi-Fi/security protocol used
| Supported through ESP-NOW security
|}

ESP-NOW is specifically designed for direct communication between ESP devices and does not require an access point for device-to-device communication.

== Security Considerations ==

* The PMK and LMK used in this experiment are demonstration keys.
* Real IoT systems should use properly managed, unique keys.
* Keys should not be exposed publicly or hard-coded in production firmware without appropriate protection.
* The experiment demonstrates link-level ESP-NOW security and does not represent complete IoT security.
* Broadcast ESP-NOW communication does not provide the same encrypted peer mechanism as an encrypted unicast peer. Espressif notes that multicast vendor-specific action frames are not supported for encryption.
* Only authorized peers should be added when transmitting sensitive information.

== Result ==

The DHT11 sensor was successfully interfaced with the ESP32 transmitter, and temperature and humidity data were transmitted wirelessly to a second ESP32 using ESP-NOW. Encrypted peer communication was configured using a PMK and LMK, providing AES-128-based protection through ESP-NOW's CCMP security mechanism. The transmitted sensor values were successfully received by the second ESP32.

== Viva Questions ==

'''Q1. What is ESP-NOW?'''

ESP-NOW is a connectionless wireless communication protocol developed by Espressif for direct communication between ESP devices.

'''Q2. Does ESP-NOW require an Internet connection?'''

No. ESP-NOW can communicate directly between ESP devices without an Internet connection.

'''Q3. Does ESP-NOW require a Wi-Fi router?'''

No. Direct ESP-NOW communication between ESP devices does not require a conventional Wi-Fi access point.

'''Q4. What is the role of the MAC address?'''

The MAC address identifies the ESP-NOW peer to which the data is transmitted.

'''Q5. What is PMK?'''

PMK stands for Primary Master Key. It is a 16-byte key used as part of the ESP-NOW security mechanism.

'''Q6. What is LMK?'''

LMK stands for Local Master Key. It is associated with an individual encrypted ESP-NOW peer.

'''Q7. Which encryption algorithm is associated with ESP-NOW security?'''

ESP-NOW security uses AES-128 as part of its PMK/LMK and CCMP-based protection mechanism.

'''Q8. What is CCMP?'''

CCMP stands for Counter Mode with Cipher Block Chaining Message Authentication Code Protocol. It is used to protect ESP-NOW communication frames.

'''Q9. Why is `peerInfo.encrypt = true` used?'''

It enables encrypted communication for the configured ESP-NOW peer.

'''Q10. What happens if the LMK is not configured for an encrypted peer?'''

The peer's ESP-NOW communication will not use the configured encrypted peer mechanism.

'''Q11. Why are two ESP32 boards used?'''

One ESP32 acts as the sensor transmitter and the other acts as the receiver, demonstrating direct IoT device-to-device communication.

'''Q12. Why is DHT11 connected only to the transmitter?'''

The transmitter reads the sensor data and sends it to the receiver. Therefore, the receiver does not need its own DHT11 sensor.

'''Q13. What is the advantage of ESP-NOW for IoT applications?'''

It provides direct, low-overhead communication between ESP devices and is suitable for sensor and control applications.

'''Q14. How is this experiment different from HTTPS communication?'''

HTTPS secures communication between a client and a server using TLS. This experiment demonstrates encrypted local device-to-device communication using ESP-NOW.

'''Q15. Is ESP-NOW itself an encryption algorithm?'''

No. ESP-NOW is a communication protocol. Its security mechanism uses CCMP and AES-128-based key management to protect encrypted peer communication.

== Conclusion ==

This experiment demonstrates secure wireless sensor-data transmission between two ESP32 devices using ESP-NOW. The DHT11 sensor data is transmitted directly from the transmitter ESP32 to the receiver ESP32 without using the Internet or a cloud server. ESP-NOW peer encryption is configured using PMK and LMK keys, providing AES-128-based protection through CCMP. The experiment demonstrates how secure device-to-device communication can be implemented in an IoT system.

AIDS IoT Kits User Manuals

2026-10-07T12:13:09Z

CogWikiEditor: /* Laboratory Objectives */

<div style="text-align:center;">
[[File:Sppu-logo.jpg|200px|SPPU Logo]]
</div>

<div style="text-align:center;">
<span style="font-size:200%; font-weight:bold;">TE AIDS MDM331AID : Internet of Things Lab</span>
<br>
<span style="font-size:120%;">Cognifront IoT Kit for MDM331AID : Internet of Things Lab</span>
</div>

== About the Laboratory ==

The Internet of Things (IoT) laboratory provides hands-on experience in connecting physical devices, sensors, microcontrollers and cloud platforms to develop intelligent, connected systems.

This laboratory manual is designed for students of Third Year B.E. Artificial Intelligence and Data Science Engineering, covering fundamental IoT concepts, embedded programming, sensor interfacing, network communication and cloud-based applications.

== Laboratory Objectives ==

* Understand the architecture and fundamental concepts of the Internet of Things.
* Interface sensors and actuators with embedded development boards.
* Develop programs for acquiring and processing sensor data.
* Implement communication protocols used in IoT systems.
* Connect IoT devices with cloud platforms for data visualization and monitoring.
* Design and implement real-world IoT applications.

{| class="wikitable"
|-
! #
! Experiment Title
|-
! colspan="2" | Part A
|-
| 1
| [[MDM331AID/Experiment 1|Develop an application for the connectivity of the Arduino UNO/Raspberry Pi circuit with sensors.]]
|-
| 2
| [[MDM331AID/Experiment 2|Implement an application to detect obstacles and notify users using LEDs to understand the connectivity of Raspberry Pi / Arduino with IR sensor.]]
|-
| 3
| [[MDM331AID/Experiment 3|Implement a simple IoT application using an Arduino board to control an LED through GPIO pins in order to understand the physical design of IoT devices and device actuation.]]
|-
| 4
| [[MDM331AID/Experiment 4|Develop a program to detect gas leakage in the surrounding environment.]]
|-
| 5
| [[MDM331AID/Experiment 5|Configure and implement an IoT device (Arduino UNO/ESP module/Raspberry Pi) to connect to a Wi-Fi network and transmit sensor data to a remote computer using TCP/IP communication.]]
|-
| 6
| [[MDM331AID/Experiment 6|Implement an edge computing model where sensor data is processed locally on an edge device (Raspberry Pi) before being transmitted to the cloud to reduce latency and bandwidth usage.]]
|-
| 7
| [[MDM331AID/Experiment 7|Design an RFID-based identification system that reads tag information and displays the ID on a monitoring system to demonstrate short-range communication technologies in IoT.]]
|-
! colspan="2" | Part B
|-
| 8
| [[MDM331AID/Experiment 8|Develop an IoT application that uses a communication protocol to transmit sensor data between an IoT device and a server.]]
|-
| 9
| [[MDM331AID/Experiment 9|Perform data cleaning, normalization, and visualization on an IoT sensor dataset (any dataset can be considered).]]
|-
| 10
| [[MDM331AID/Experiment 10|Implement an IoT application to collect real-time temperature data using an IoT sensor and apply a machine learning model to predict future temperature values (any machine learning model).]]
|-
| 11
| [[MDM331AID/Experiment 11|Design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts (any security algorithm can be used).]]
|-
| 12
| [[MDM331AID/Experiment 12|(Final Page)Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-
| 12/1
| [[MDM331AID/Experiment 12_BLE|(BLE)Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-
| 12/2
| [[MDM331AID/Experiment 12_ESPNOW|(ESPNOW) Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-
| 13
| [[MDM331AID/Experiment 13|Develop and implement a machine learning model to perform classification (e.g., activity recognition or device state detection) and anomaly detection (e.g., fault detection in industrial IoT sensors).]]
|-
| 14
| [[MDM331AID/Experiment 14|Case study for data minimization using smart threshold alerts by providing Privacy-by-Design.]]
|-
! colspan="2" | Part C
|-
| 15
| [[MDM331AID/Experiment 15|Develop a Privacy-Aware Intelligent Smart IoT Application: Design and implementation of an AIoT-based smart sensor system with cloud-based data preprocessing and intelligent decision-making using machine learning techniques, incorporating secure communication protocols with built-in security and privacy mechanisms, with complete deliverables including a working demonstration and technical report.]]
|}

MDM331AID/Experiment 12 BLE

2026-10-07T12:12:09Z

CogWikiEditor: Created page with "= Experiment: Secure Sensor Data Transmission Using Bluetooth Low Energy = == Aim == To implement secure transmission of temperature and humidity data from an IoT sensor using Bluetooth Low Energy (BLE) and demonstrate authenticated and encrypted communication between an ESP32 and a smartphone. == Objectives == * To understand the concept of Bluetooth Low Energy (BLE) communication in IoT systems. * To interface a DHT11 temperature and humidity sensor with an ESP32...."

= Experiment: Secure Sensor Data Transmission Using Bluetooth Low Energy =

== Aim ==

To implement secure transmission of temperature and humidity data from an IoT sensor using Bluetooth Low Energy (BLE) and demonstrate authenticated and encrypted communication between an ESP32 and a smartphone.

== Objectives ==

* To understand the concept of Bluetooth Low Energy (BLE) communication in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To configure the ESP32 as a BLE server.
* To transmit real-time sensor data from the ESP32 to a smartphone using BLE.
* To understand BLE services and characteristics.
* To implement BLE pairing and authentication using a passkey.
* To understand how BLE encryption protects transmitted sensor data.
* To verify secure sensor-data communication using a smartphone BLE application.

== Components Required ==

{| class="wikitable" style="width: 80%;"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| IoT controller and BLE server
|-
| 2
| DHT11 Sensor
| 1
| Measures temperature and humidity
|-
| 3
| USB Cable
| 1
| Programming and power supply
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Smartphone
| 1
| BLE client for receiving sensor data
|-
| 6
| LightBlue® BLE Application
| 1
| Scanning, connecting and monitoring BLE data
|-
| 7
| Arduino IDE
| 1
| ESP32 programming
|}

=== Smartphone Application ===

The recommended application for this experiment is **LightBlue® by Punch Through**.

LightBlue is a BLE debugging and development application that is available for both Android and iOS. It can scan for BLE peripherals, connect to them, display their services and characteristics, and read or subscribe to characteristic values.

The application can be installed from:

* Android: [LightBlue® on Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)
* iPhone/iPad: [LightBlue® on the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

== Theory ==

=== Bluetooth Low Energy ===

Bluetooth Low Energy (BLE) is a wireless communication technology designed for low-power communication between devices. It is widely used in IoT sensors, wearable devices, smart-home devices and other embedded systems.

An ESP32 can operate as a BLE device and communicate with smartphones and other BLE-enabled devices. The Arduino ESP32 framework provides a BLE library for creating BLE servers, services and characteristics.

In this experiment, the ESP32 operates as a '''BLE GATT server''', while the smartphone operates as the '''BLE client'''.

The communication structure is:

<pre>
DHT11 Sensor
↓
ESP32
↓
BLE GATT Server
↓
Secure BLE Connection
↓
Smartphone
↓
LightBlue Application
</pre>

=== BLE GATT ===

BLE devices commonly organize application data using the Generic Attribute Profile (GATT).

The main components used in this experiment are:

'''Service:'''
A service groups related functionality of a BLE device.

'''Characteristic:'''
A characteristic contains a particular piece of data that can be read, written or notified.

For this experiment, one BLE service is created containing two characteristics:

{| class="wikitable"
! Characteristic
! Data
! Operation
|-
| Temperature
| Temperature in °C
| Read / Notify
|-
| Humidity
| Relative humidity in %
| Read / Notify
|}

The smartphone can connect to the ESP32 and subscribe to notifications so that updated sensor values are received automatically.

=== BLE Security ===

BLE provides security mechanisms for authentication, pairing, bonding and encrypted communication.

In this experiment, BLE security is configured using:

* Pairing
* Bonding
* MITM (Man-in-the-Middle) protection
* Secure Connections
* Passkey authentication

Espressif's ESP32 BLE security documentation supports authentication modes combining bonding, MITM protection and Secure Connections.

=== Pairing ===

Pairing is the process by which two Bluetooth devices establish the information required to create a trusted secure relationship.

In this experiment, the smartphone and ESP32 are paired using a passkey.

Example:

<pre>
ESP32
↓
BLE connection request
↓
Pairing request
↓
Passkey authentication
↓
Secure key establishment
↓
Encrypted BLE communication
</pre>

=== Bonding ===

Bonding allows the security information established during pairing to be stored so that the devices can recognize each other during future connections.

Espressif distinguishes bonding from encryption: bonding stores long-term keys after successful encryption, while encryption protects the communication link.

=== BLE Encryption ===

After successful authentication, the BLE link can be encrypted.

Therefore, the sensor data transmitted over the BLE connection is protected from simple interception of the communication.

The security flow is:

<pre>
Sensor Data
↓
BLE Security / Pairing
↓
Authentication
↓
Encryption
↓
Secure BLE Transmission
↓
Smartphone
</pre>

== Pin Connections ==

=== DHT11 to ESP32 ===

{| class="wikitable"
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital sensor data
|-
| GND
| GND
| Ground
|}

== Connection Diagram ==

<pre>
+----------------+
| DHT11 |
| |
| VCC DATA GND |
+--+----+-----+--+
| | |
3.3V GPIO4 GND
| | |
| | |
+------+----+-----+------+
| ESP32 |
| |
| BLE Server |
| )))) |
+------------))----------+
))
))
Secure BLE Link
))
))
+-----------+
| Smartphone|
| |
| LightBlue |
+-----------+
</pre>

== Program ==

=== Arduino Program ===

<pre>
#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLESecurity.h>
#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT11

#define DEVICE_NAME "ESP32-Secure-Sensor"

#define SERVICE_UUID \
"4fafc201-1fb5-459e-8fcc-c5c9c331914b"

#define TEMP_UUID \
"beb5483e-36e1-4688-b7f5-ea07361b26a8"

#define HUMIDITY_UUID \
"cba1d466-344c-4be3-ab3f-189f80dd7518"

#define BLE_PASSKEY 123456

DHT dht(DHTPIN, DHTTYPE);

BLECharacteristic *temperatureCharacteristic;
BLECharacteristic *humidityCharacteristic;

class SecurityCallbacks : public BLESecurityCallbacks
{
uint32_t onPassKeyRequest()
{
Serial.println("Passkey requested");
return BLE_PASSKEY;
}

void onPassKeyNotify(uint32_t passkey)
{
Serial.print("Passkey: ");
Serial.println(passkey);
}

bool onConfirmPIN(uint32_t pin)
{
Serial.print("Confirm PIN: ");
Serial.println(pin);
return true;
}

bool onSecurityRequest()
{
Serial.println("Security request received");
return true;
}

void onAuthenticationComplete(esp_ble_auth_cmpl_t desc)
{
if (desc.success)
Serial.println("BLE authentication successful");
else
Serial.println("BLE authentication failed");
}
};

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

dht.begin();

BLEDevice::init(DEVICE_NAME);

BLESecurity *security = new BLESecurity();

security->setPassKey(true, BLE_PASSKEY);

security->setCapability(ESP_IO_CAP_OUT);

security->setAuthenticationMode(
true, // Bonding
true, // MITM protection
true // Secure Connections
);

BLEDevice::setSecurityCallbacks(
new SecurityCallbacks()
);

BLEServer *server = BLEDevice::createServer();

BLEService *service =
server->createService(SERVICE_UUID);

temperatureCharacteristic =
service->createCharacteristic(
TEMP_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

humidityCharacteristic =
service->createCharacteristic(
HUMIDITY_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

temperatureCharacteristic->setValue("0.0");
humidityCharacteristic->setValue("0.0");

service->start();

BLEAdvertising *advertising =
BLEDevice::getAdvertising();

advertising->addServiceUUID(SERVICE_UUID);
advertising->setScanResponse(true);

BLEDevice::startAdvertising();

Serial.println();
Serial.println("Secure BLE Sensor Started");
Serial.println("Device Name: ESP32-Secure-Sensor");
Serial.println("Passkey: 123456");
Serial.println("Waiting for BLE connection...");
}

void loop()
{
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

if (isnan(temperature) || isnan(humidity))
{
Serial.println("DHT11 reading failed");
delay(2000);
return;
}

char temperatureValue[10];
char humidityValue[10];

dtostrf(temperature, 1, 2, temperatureValue);
dtostrf(humidity, 1, 2, humidityValue);

temperatureCharacteristic->setValue(
temperatureValue
);

humidityCharacteristic->setValue(
humidityValue
);

temperatureCharacteristic->notify();
humidityCharacteristic->notify();

Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");

Serial.print("Humidity: ");
Serial.print(humidity);
Serial.println(" %");

Serial.println("Sensor data sent using secure BLE");

delay(2000);
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code
! Explanation
|-
| `#include <BLEDevice.h>`
| Provides the main BLE device functionality.
|-
| `#include <BLEServer.h>`
| Provides functionality for creating a BLE server.
|-
| `#include <BLESecurity.h>`
| Provides BLE pairing and security configuration.
|-
| `#include <DHT.h>`
| Provides functions for interfacing with the DHT11 sensor.
|-
| `DHTPIN 4`
| Defines GPIO 4 as the DHT11 data pin.
|-
| `DEVICE_NAME`
| Defines the name advertised by the ESP32.
|-
| `SERVICE_UUID`
| Uniquely identifies the BLE sensor service.
|-
| `TEMP_UUID`
| Identifies the temperature characteristic.
|-
| `HUMIDITY_UUID`
| Identifies the humidity characteristic.
|-
| `BLE_PASSKEY 123456`
| Defines the passkey used for BLE authentication.
|-
| `dht.begin()`
| Initializes the DHT11 sensor.
|-
| `BLEDevice::init()`
| Initializes BLE and assigns the device name.
|-
| `setPassKey()`
| Configures the BLE passkey.
|-
| `setCapability()`
| Defines the input/output capability used during authentication.
|-
| `setAuthenticationMode(true, true, true)`
| Enables bonding, MITM protection and Secure Connections.
|-
| `createServer()`
| Creates the ESP32 BLE server.
|-
| `createService()`
| Creates the BLE sensor service.
|-
| `createCharacteristic()`
| Creates temperature and humidity characteristics.
|-
| `PROPERTY_READ`
| Allows the smartphone to read the sensor value.
|-
| `PROPERTY_NOTIFY`
| Allows the ESP32 to send updated sensor values to the smartphone.
|-
| `service->start()`
| Starts the BLE service.
|-
| `startAdvertising()`
| Makes the ESP32 discoverable by BLE clients.
|-
| `dht.readTemperature()`
| Reads temperature from the DHT11.
|-
| `dht.readHumidity()`
| Reads humidity from the DHT11.
|-
| `setValue()`
| Updates the BLE characteristic value.
|-
| `notify()`
| Sends the updated value to subscribed BLE clients.
|}

== Security Configuration ==

The following security settings are used in the experiment:

{| class="wikitable"
! Security Feature
! Purpose
|-
| Passkey
| Provides authentication during pairing.
|-
| MITM Protection
| Provides protection against certain man-in-the-middle attacks during authenticated pairing.
|-
| Secure Connections
| Uses the BLE Secure Connections pairing mechanism.
|-
| Bonding
| Allows security information to be retained for future connections.
|-
| Encryption
| Protects data transmitted over the established BLE link.
|}

Espressif documents BLE security configurations including bonding, MITM protection and Secure Connections, and provides dedicated BLE security examples.

== Smartphone Setup ==

=== Step 1: Install LightBlue ===

Install '''LightBlue® by Punch Through''' on the smartphone.

For Android:

[Download LightBlue from Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)

For iPhone/iPad:

[Download LightBlue from the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

The same application is available on both platforms.

=== Step 2: Upload the Program ===

1. Connect the ESP32 to the computer using the USB cable.
2. Open Arduino IDE.
3. Select the appropriate ESP32 board.
4. Select the correct COM port.
5. Upload the program.
6. Open the Serial Monitor at '''115200 baud'''.

The Serial Monitor should display:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...
</pre>

=== Step 3: Start LightBlue ===

1. Enable Bluetooth on the smartphone.
2. Open the LightBlue application.
3. Allow the required Bluetooth permissions.
4. Start scanning for nearby BLE devices.
5. Locate:

<pre>
ESP32-Secure-Sensor
</pre>

6. Select the device and tap '''Connect'''.

LightBlue supports BLE scanning, connection, service/characteristic inspection, reading, writing and notifications.

=== Step 4: Pair the Device ===

When the ESP32 requests secure pairing, the smartphone will display the BLE pairing/passkey interaction.

Enter or confirm:

<pre>
123456
</pre>

After successful authentication, the BLE connection becomes secured.

Espressif's BLE documentation demonstrates pairing between an ESP32 BLE server and a mobile phone using LightBlue, including passkey-based pairing.

=== Step 5: View Sensor Data ===

After connecting, LightBlue displays the BLE service and its characteristics.

The structure will be similar to:

<pre>
ESP32-Secure-Sensor

Service
└── Sensor Service
│
├── Temperature
│ Value: 27.40
│
└── Humidity
Value: 61.00
</pre>

The exact appearance of the LightBlue interface may vary between Android and iOS versions.

=== Step 6: Enable Notifications ===

The temperature and humidity characteristics support notifications.

Enable notifications for the characteristics in LightBlue.

The ESP32 will then periodically send updated sensor readings.

Example:

<pre>
Temperature: 27.40 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 62.00 %
</pre>

== Data Flow ==

The complete data flow of the experiment is:

<pre>
DHT11 Sensor
↓
Temperature / Humidity
↓
ESP32
↓
BLE GATT Server
↓
BLE Pairing & Authentication
↓
Encrypted BLE Link
↓
Smartphone
↓
LightBlue Application
↓
Temperature / Humidity Data
</pre>

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the given pin connections.
# Install the DHT sensor library in Arduino IDE if required.
# Install the ESP32 board package in Arduino IDE.
# Install the LightBlue BLE application on an Android or iOS smartphone.
# Enter the BLE program into Arduino IDE.
# Connect the ESP32 to the computer.
# Select the correct ESP32 board and COM port.
# Upload the program.
# Open the Serial Monitor at 115200 baud.
# Verify that the ESP32 starts BLE advertising.
# Open LightBlue on the smartphone.
# Scan for nearby BLE devices.
# Select `ESP32-Secure-Sensor`.
# Establish the BLE connection.
# Complete the passkey authentication using `123456`.
# Verify that the BLE connection is authenticated and secured.
# Open the sensor service in LightBlue.
# Locate the temperature and humidity characteristics.
# Enable notifications for the characteristics.
# Observe the temperature and humidity values received from the ESP32.
# Compare the displayed values with the DHT11 readings shown in the Serial Monitor.
# Record the observed values.

== Observations and Output ==

=== Serial Monitor ===

The Serial Monitor displays information similar to:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...

Temperature: 27.40 °C
Humidity: 61.00 %
Sensor data sent using secure BLE

Temperature: 27.50 °C
Humidity: 61.00 %
Sensor data sent using secure BLE
</pre>

=== Smartphone ===

The LightBlue application should show:

{| class="wikitable"
! Parameter
! Example Observation
|-
| BLE Device
| ESP32-Secure-Sensor
|-
| BLE Service
| Sensor Service
|-
| Temperature
| 27.40 °C
|-
| Humidity
| 61.00 %
|-
| Authentication
| Successful
|-
| Communication
| Secure BLE
|}

The actual temperature and humidity values will depend on the environmental conditions.

== Result ==

The DHT11 sensor was successfully interfaced with the ESP32, and temperature and humidity data were transmitted to a smartphone using Bluetooth Low Energy. BLE pairing and security mechanisms were configured to authenticate the smartphone and establish a protected communication link. The sensor values were successfully observed using the LightBlue BLE application.

== Security Considerations ==

* The BLE passkey used in this experiment is intended for educational demonstration.
* A fixed passkey such as `123456` should not be used in a real security-sensitive product.
* Production IoT systems should use appropriate device-specific credentials and security policies.
* Secure Connections and MITM protection improve the security of BLE pairing, but the overall security of an IoT product also depends on its firmware, credential management and application design.
* The experiment demonstrates BLE link security; it should not be interpreted as complete end-to-end IoT security.
* The LightBlue application is being used as a BLE debugging/client tool rather than as a custom end-user IoT application.

== Viva Questions ==

'''Q1. What is BLE?'''

BLE stands for Bluetooth Low Energy. It is a wireless communication technology designed for low-power communication between devices.

'''Q2. Why is BLE suitable for IoT applications?'''

BLE provides short-range wireless communication with relatively low power consumption, making it suitable for sensors and other IoT devices.

'''Q3. What is GATT?'''

GATT stands for Generic Attribute Profile. It defines how BLE devices organize and exchange application data using services and characteristics.

'''Q4. What is a BLE service?'''

A service is a collection of related BLE characteristics that represents a particular function of the device.

'''Q5. What is a BLE characteristic?'''

A characteristic represents a specific piece of data or functionality and can support operations such as read, write and notify.

'''Q6. What is pairing?'''

Pairing is the process of establishing security information between two Bluetooth devices so that a secure relationship can be created.

'''Q7. What is BLE encryption?'''

BLE encryption protects data exchanged over an established secure BLE connection.

'''Q8. What is a passkey used for?'''

A passkey is used as part of the authentication process during BLE pairing.

'''Q9. What is MITM protection?'''

MITM stands for Man-in-the-Middle. MITM protection helps prevent an attacker from impersonating one of the devices during the authentication process.

'''Q10. What is bonding?'''

Bonding is the process of storing security information after pairing so that the devices can establish trusted connections again later.

'''Q11. Why is LightBlue used in this experiment?'''

LightBlue provides a convenient BLE client interface for discovering the ESP32, connecting to it, inspecting services and characteristics, and receiving notifications.

'''Q12. Can the same application be used on Android and iOS?'''

Yes. LightBlue is available for both Android and iOS.

'''Q13. What is the role of the ESP32 in this experiment?'''

The ESP32 reads the DHT11 sensor and acts as a BLE GATT server that provides the sensor data to the smartphone.

'''Q14. What is the difference between `READ` and `NOTIFY` in BLE?'''

`READ` allows the client to request the current value. `NOTIFY` allows the server to send updated values automatically when the client subscribes to notifications.

'''Q15. How is this experiment different from HTTPS-based cloud communication?'''

HTTPS protects communication between an IoT device and a web/cloud server over a network. This experiment demonstrates secure short-range BLE communication directly between an ESP32 and a smartphone.

== Conclusion ==

This experiment demonstrates how Bluetooth Low Energy can be used for secure IoT sensor-data transmission. The ESP32 reads temperature and humidity from the DHT11 sensor and exposes the readings through BLE characteristics. The smartphone connects using the LightBlue application, performs secure pairing, and receives the sensor data through an authenticated and encrypted BLE connection.

AIDS IoT Kits User Manuals

2026-10-07T12:11:43Z

CogWikiEditor: /* Laboratory Objectives */

<div style="text-align:center;">
[[File:Sppu-logo.jpg|200px|SPPU Logo]]
</div>

<div style="text-align:center;">
<span style="font-size:200%; font-weight:bold;">TE AIDS MDM331AID : Internet of Things Lab</span>
<br>
<span style="font-size:120%;">Cognifront IoT Kit for MDM331AID : Internet of Things Lab</span>
</div>

== About the Laboratory ==

The Internet of Things (IoT) laboratory provides hands-on experience in connecting physical devices, sensors, microcontrollers and cloud platforms to develop intelligent, connected systems.

This laboratory manual is designed for students of Third Year B.E. Artificial Intelligence and Data Science Engineering, covering fundamental IoT concepts, embedded programming, sensor interfacing, network communication and cloud-based applications.

== Laboratory Objectives ==

* Understand the architecture and fundamental concepts of the Internet of Things.
* Interface sensors and actuators with embedded development boards.
* Develop programs for acquiring and processing sensor data.
* Implement communication protocols used in IoT systems.
* Connect IoT devices with cloud platforms for data visualization and monitoring.
* Design and implement real-world IoT applications.

{| class="wikitable"
|-
! #
! Experiment Title
|-
! colspan="2" | Part A
|-
| 1
| [[MDM331AID/Experiment 1|Develop an application for the connectivity of the Arduino UNO/Raspberry Pi circuit with sensors.]]
|-
| 2
| [[MDM331AID/Experiment 2|Implement an application to detect obstacles and notify users using LEDs to understand the connectivity of Raspberry Pi / Arduino with IR sensor.]]
|-
| 3
| [[MDM331AID/Experiment 3|Implement a simple IoT application using an Arduino board to control an LED through GPIO pins in order to understand the physical design of IoT devices and device actuation.]]
|-
| 4
| [[MDM331AID/Experiment 4|Develop a program to detect gas leakage in the surrounding environment.]]
|-
| 5
| [[MDM331AID/Experiment 5|Configure and implement an IoT device (Arduino UNO/ESP module/Raspberry Pi) to connect to a Wi-Fi network and transmit sensor data to a remote computer using TCP/IP communication.]]
|-
| 6
| [[MDM331AID/Experiment 6|Implement an edge computing model where sensor data is processed locally on an edge device (Raspberry Pi) before being transmitted to the cloud to reduce latency and bandwidth usage.]]
|-
| 7
| [[MDM331AID/Experiment 7|Design an RFID-based identification system that reads tag information and displays the ID on a monitoring system to demonstrate short-range communication technologies in IoT.]]
|-
! colspan="2" | Part B
|-
| 8
| [[MDM331AID/Experiment 8|Develop an IoT application that uses a communication protocol to transmit sensor data between an IoT device and a server.]]
|-
| 9
| [[MDM331AID/Experiment 9|Perform data cleaning, normalization, and visualization on an IoT sensor dataset (any dataset can be considered).]]
|-
| 10
| [[MDM331AID/Experiment 10|Implement an IoT application to collect real-time temperature data using an IoT sensor and apply a machine learning model to predict future temperature values (any machine learning model).]]
|-
| 11
| [[MDM331AID/Experiment 11|Design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts (any security algorithm can be used).]]
|-
| 12/1
| [[MDM331AID/Experiment 12_BLE|(BLE)Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-
| 12/2
| [[MDM331AID/Experiment 12_ESPNOW|(ESPNOW) Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-
| 13
| [[MDM331AID/Experiment 13|Develop and implement a machine learning model to perform classification (e.g., activity recognition or device state detection) and anomaly detection (e.g., fault detection in industrial IoT sensors).]]
|-
| 14
| [[MDM331AID/Experiment 14|Case study for data minimization using smart threshold alerts by providing Privacy-by-Design.]]
|-
! colspan="2" | Part C
|-
| 15
| [[MDM331AID/Experiment 15|Develop a Privacy-Aware Intelligent Smart IoT Application: Design and implementation of an AIoT-based smart sensor system with cloud-based data preprocessing and intelligent decision-making using machine learning techniques, incorporating secure communication protocols with built-in security and privacy mechanisms, with complete deliverables including a working demonstration and technical report.]]
|}

AIDS IoT Kits User Manuals

2026-10-07T12:10:47Z

CogWikiEditor: /* Laboratory Objectives */

<div style="text-align:center;">
[[File:Sppu-logo.jpg|200px|SPPU Logo]]
</div>

<div style="text-align:center;">
<span style="font-size:200%; font-weight:bold;">TE AIDS MDM331AID : Internet of Things Lab</span>
<br>
<span style="font-size:120%;">Cognifront IoT Kit for MDM331AID : Internet of Things Lab</span>
</div>

== About the Laboratory ==

The Internet of Things (IoT) laboratory provides hands-on experience in connecting physical devices, sensors, microcontrollers and cloud platforms to develop intelligent, connected systems.

This laboratory manual is designed for students of Third Year B.E. Artificial Intelligence and Data Science Engineering, covering fundamental IoT concepts, embedded programming, sensor interfacing, network communication and cloud-based applications.

== Laboratory Objectives ==

* Understand the architecture and fundamental concepts of the Internet of Things.
* Interface sensors and actuators with embedded development boards.
* Develop programs for acquiring and processing sensor data.
* Implement communication protocols used in IoT systems.
* Connect IoT devices with cloud platforms for data visualization and monitoring.
* Design and implement real-world IoT applications.

{| class="wikitable"
|-
! #
! Experiment Title
|-
! colspan="2" | Part A
|-
| 1
| [[MDM331AID/Experiment 1|Develop an application for the connectivity of the Arduino UNO/Raspberry Pi circuit with sensors.]]
|-
| 2
| [[MDM331AID/Experiment 2|Implement an application to detect obstacles and notify users using LEDs to understand the connectivity of Raspberry Pi / Arduino with IR sensor.]]
|-
| 3
| [[MDM331AID/Experiment 3|Implement a simple IoT application using an Arduino board to control an LED through GPIO pins in order to understand the physical design of IoT devices and device actuation.]]
|-
| 4
| [[MDM331AID/Experiment 4|Develop a program to detect gas leakage in the surrounding environment.]]
|-
| 5
| [[MDM331AID/Experiment 5|Configure and implement an IoT device (Arduino UNO/ESP module/Raspberry Pi) to connect to a Wi-Fi network and transmit sensor data to a remote computer using TCP/IP communication.]]
|-
| 6
| [[MDM331AID/Experiment 6|Implement an edge computing model where sensor data is processed locally on an edge device (Raspberry Pi) before being transmitted to the cloud to reduce latency and bandwidth usage.]]
|-
| 7
| [[MDM331AID/Experiment 7|Design an RFID-based identification system that reads tag information and displays the ID on a monitoring system to demonstrate short-range communication technologies in IoT.]]
|-
! colspan="2" | Part B
|-
| 8
| [[MDM331AID/Experiment 8|Develop an IoT application that uses a communication protocol to transmit sensor data between an IoT device and a server.]]
|-
| 9
| [[MDM331AID/Experiment 9|Perform data cleaning, normalization, and visualization on an IoT sensor dataset (any dataset can be considered).]]
|-
| 10
| [[MDM331AID/Experiment 10|Implement an IoT application to collect real-time temperature data using an IoT sensor and apply a machine learning model to predict future temperature values (any machine learning model).]]
|-
| 11
| [[MDM331AID/Experiment 11|Design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts (any security algorithm can be used).]]
|-
| 12/1
| [[MDM331AID/Experiment 12|(BLE)Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-
| 12/2
| [[MDM331AID/Experiment 12|(ESPNOW) Implement secure data transmission in an IoT system using a sensor and any communication security protocol.]]
|-
| 13
| [[MDM331AID/Experiment 13|Develop and implement a machine learning model to perform classification (e.g., activity recognition or device state detection) and anomaly detection (e.g., fault detection in industrial IoT sensors).]]
|-
| 14
| [[MDM331AID/Experiment 14|Case study for data minimization using smart threshold alerts by providing Privacy-by-Design.]]
|-
! colspan="2" | Part C
|-
| 15
| [[MDM331AID/Experiment 15|Develop a Privacy-Aware Intelligent Smart IoT Application: Design and implementation of an AIoT-based smart sensor system with cloud-based data preprocessing and intelligent decision-making using machine learning techniques, incorporating secure communication protocols with built-in security and privacy mechanisms, with complete deliverables including a working demonstration and technical report.]]
|}

MDM331AID/Experiment 12

2026-10-07T12:05:47Z

= Experiment: Secure Sensor Data Transmission Using Bluetooth Low Energy =

== Aim ==

To implement secure transmission of temperature and humidity data from an IoT sensor using Bluetooth Low Energy (BLE) and demonstrate authenticated and encrypted communication between an ESP32 and a smartphone.

== Objectives ==

* To understand the concept of Bluetooth Low Energy (BLE) communication in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To configure the ESP32 as a BLE server.
* To transmit real-time sensor data from the ESP32 to a smartphone using BLE.
* To understand BLE services and characteristics.
* To implement BLE pairing and authentication using a passkey.
* To understand how BLE encryption protects transmitted sensor data.
* To verify secure sensor-data communication using a smartphone BLE application.

== Components Required ==

{| class="wikitable" style="width: 80%;"
! Sr. No.
! Component
! Quantity
! Purpose
|-
| 1
| ESP32 Development Board
| 1
| IoT controller and BLE server
|-
| 2
| DHT11 Sensor
| 1
| Measures temperature and humidity
|-
| 3
| USB Cable
| 1
| Programming and power supply
|-
| 4
| Jumper Wires
| As required
| Electrical connections
|-
| 5
| Smartphone
| 1
| BLE client for receiving sensor data
|-
| 6
| LightBlue® BLE Application
| 1
| Scanning, connecting and monitoring BLE data
|-
| 7
| Arduino IDE
| 1
| ESP32 programming
|}

=== Smartphone Application ===

The recommended application for this experiment is **LightBlue® by Punch Through**.

LightBlue is a BLE debugging and development application that is available for both Android and iOS. It can scan for BLE peripherals, connect to them, display their services and characteristics, and read or subscribe to characteristic values.

The application can be installed from:

* Android: [LightBlue® on Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)
* iPhone/iPad: [LightBlue® on the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

== Theory ==

=== Bluetooth Low Energy ===

Bluetooth Low Energy (BLE) is a wireless communication technology designed for low-power communication between devices. It is widely used in IoT sensors, wearable devices, smart-home devices and other embedded systems.

An ESP32 can operate as a BLE device and communicate with smartphones and other BLE-enabled devices. The Arduino ESP32 framework provides a BLE library for creating BLE servers, services and characteristics.

In this experiment, the ESP32 operates as a '''BLE GATT server''', while the smartphone operates as the '''BLE client'''.

The communication structure is:

<pre>
DHT11 Sensor
↓
ESP32
↓
BLE GATT Server
↓
Secure BLE Connection
↓
Smartphone
↓
LightBlue Application
</pre>

=== BLE GATT ===

BLE devices commonly organize application data using the Generic Attribute Profile (GATT).

The main components used in this experiment are:

'''Service:'''
A service groups related functionality of a BLE device.

'''Characteristic:'''
A characteristic contains a particular piece of data that can be read, written or notified.

For this experiment, one BLE service is created containing two characteristics:

{| class="wikitable"
! Characteristic
! Data
! Operation
|-
| Temperature
| Temperature in °C
| Read / Notify
|-
| Humidity
| Relative humidity in %
| Read / Notify
|}

The smartphone can connect to the ESP32 and subscribe to notifications so that updated sensor values are received automatically.

=== BLE Security ===

BLE provides security mechanisms for authentication, pairing, bonding and encrypted communication.

In this experiment, BLE security is configured using:

* Pairing
* Bonding
* MITM (Man-in-the-Middle) protection
* Secure Connections
* Passkey authentication

Espressif's ESP32 BLE security documentation supports authentication modes combining bonding, MITM protection and Secure Connections.

=== Pairing ===

Pairing is the process by which two Bluetooth devices establish the information required to create a trusted secure relationship.

In this experiment, the smartphone and ESP32 are paired using a passkey.

Example:

<pre>
ESP32
↓
BLE connection request
↓
Pairing request
↓
Passkey authentication
↓
Secure key establishment
↓
Encrypted BLE communication
</pre>

=== Bonding ===

Bonding allows the security information established during pairing to be stored so that the devices can recognize each other during future connections.

Espressif distinguishes bonding from encryption: bonding stores long-term keys after successful encryption, while encryption protects the communication link.

=== BLE Encryption ===

After successful authentication, the BLE link can be encrypted.

Therefore, the sensor data transmitted over the BLE connection is protected from simple interception of the communication.

The security flow is:

<pre>
Sensor Data
↓
BLE Security / Pairing
↓
Authentication
↓
Encryption
↓
Secure BLE Transmission
↓
Smartphone
</pre>

== Pin Connections ==

=== DHT11 to ESP32 ===

{| class="wikitable"
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital sensor data
|-
| GND
| GND
| Ground
|}

== Connection Diagram ==

<pre>
+----------------+
| DHT11 |
| |
| VCC DATA GND |
+--+----+-----+--+
| | |
3.3V GPIO4 GND
| | |
| | |
+------+----+-----+------+
| ESP32 |
| |
| BLE Server |
| )))) |
+------------))----------+
))
))
Secure BLE Link
))
))
+-----------+
| Smartphone|
| |
| LightBlue |
+-----------+
</pre>

== Program ==

=== Arduino Program ===

<pre>
#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLESecurity.h>
#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT11

#define DEVICE_NAME "ESP32-Secure-Sensor"

#define SERVICE_UUID \
"4fafc201-1fb5-459e-8fcc-c5c9c331914b"

#define TEMP_UUID \
"beb5483e-36e1-4688-b7f5-ea07361b26a8"

#define HUMIDITY_UUID \
"cba1d466-344c-4be3-ab3f-189f80dd7518"

#define BLE_PASSKEY 123456

DHT dht(DHTPIN, DHTTYPE);

BLECharacteristic *temperatureCharacteristic;
BLECharacteristic *humidityCharacteristic;

class SecurityCallbacks : public BLESecurityCallbacks
{
uint32_t onPassKeyRequest()
{
Serial.println("Passkey requested");
return BLE_PASSKEY;
}

void onPassKeyNotify(uint32_t passkey)
{
Serial.print("Passkey: ");
Serial.println(passkey);
}

bool onConfirmPIN(uint32_t pin)
{
Serial.print("Confirm PIN: ");
Serial.println(pin);
return true;
}

bool onSecurityRequest()
{
Serial.println("Security request received");
return true;
}

void onAuthenticationComplete(esp_ble_auth_cmpl_t desc)
{
if (desc.success)
Serial.println("BLE authentication successful");
else
Serial.println("BLE authentication failed");
}
};

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

dht.begin();

BLEDevice::init(DEVICE_NAME);

BLESecurity *security = new BLESecurity();

security->setPassKey(true, BLE_PASSKEY);

security->setCapability(ESP_IO_CAP_OUT);

security->setAuthenticationMode(
true, // Bonding
true, // MITM protection
true // Secure Connections
);

BLEDevice::setSecurityCallbacks(
new SecurityCallbacks()
);

BLEServer *server = BLEDevice::createServer();

BLEService *service =
server->createService(SERVICE_UUID);

temperatureCharacteristic =
service->createCharacteristic(
TEMP_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

humidityCharacteristic =
service->createCharacteristic(
HUMIDITY_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_NOTIFY
);

temperatureCharacteristic->setValue("0.0");
humidityCharacteristic->setValue("0.0");

service->start();

BLEAdvertising *advertising =
BLEDevice::getAdvertising();

advertising->addServiceUUID(SERVICE_UUID);
advertising->setScanResponse(true);

BLEDevice::startAdvertising();

Serial.println();
Serial.println("Secure BLE Sensor Started");
Serial.println("Device Name: ESP32-Secure-Sensor");
Serial.println("Passkey: 123456");
Serial.println("Waiting for BLE connection...");
}

void loop()
{
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();

if (isnan(temperature) || isnan(humidity))
{
Serial.println("DHT11 reading failed");
delay(2000);
return;
}

char temperatureValue[10];
char humidityValue[10];

dtostrf(temperature, 1, 2, temperatureValue);
dtostrf(humidity, 1, 2, humidityValue);

temperatureCharacteristic->setValue(
temperatureValue
);

humidityCharacteristic->setValue(
humidityValue
);

temperatureCharacteristic->notify();
humidityCharacteristic->notify();

Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");

Serial.print("Humidity: ");
Serial.print(humidity);
Serial.println(" %");

Serial.println("Sensor data sent using secure BLE");

delay(2000);
}
</pre>

== Code Explanation ==

{| class="wikitable"
! Code
! Explanation
|-
| `#include <BLEDevice.h>`
| Provides the main BLE device functionality.
|-
| `#include <BLEServer.h>`
| Provides functionality for creating a BLE server.
|-
| `#include <BLESecurity.h>`
| Provides BLE pairing and security configuration.
|-
| `#include <DHT.h>`
| Provides functions for interfacing with the DHT11 sensor.
|-
| `DHTPIN 4`
| Defines GPIO 4 as the DHT11 data pin.
|-
| `DEVICE_NAME`
| Defines the name advertised by the ESP32.
|-
| `SERVICE_UUID`
| Uniquely identifies the BLE sensor service.
|-
| `TEMP_UUID`
| Identifies the temperature characteristic.
|-
| `HUMIDITY_UUID`
| Identifies the humidity characteristic.
|-
| `BLE_PASSKEY 123456`
| Defines the passkey used for BLE authentication.
|-
| `dht.begin()`
| Initializes the DHT11 sensor.
|-
| `BLEDevice::init()`
| Initializes BLE and assigns the device name.
|-
| `setPassKey()`
| Configures the BLE passkey.
|-
| `setCapability()`
| Defines the input/output capability used during authentication.
|-
| `setAuthenticationMode(true, true, true)`
| Enables bonding, MITM protection and Secure Connections.
|-
| `createServer()`
| Creates the ESP32 BLE server.
|-
| `createService()`
| Creates the BLE sensor service.
|-
| `createCharacteristic()`
| Creates temperature and humidity characteristics.
|-
| `PROPERTY_READ`
| Allows the smartphone to read the sensor value.
|-
| `PROPERTY_NOTIFY`
| Allows the ESP32 to send updated sensor values to the smartphone.
|-
| `service->start()`
| Starts the BLE service.
|-
| `startAdvertising()`
| Makes the ESP32 discoverable by BLE clients.
|-
| `dht.readTemperature()`
| Reads temperature from the DHT11.
|-
| `dht.readHumidity()`
| Reads humidity from the DHT11.
|-
| `setValue()`
| Updates the BLE characteristic value.
|-
| `notify()`
| Sends the updated value to subscribed BLE clients.
|}

== Security Configuration ==

The following security settings are used in the experiment:

{| class="wikitable"
! Security Feature
! Purpose
|-
| Passkey
| Provides authentication during pairing.
|-
| MITM Protection
| Provides protection against certain man-in-the-middle attacks during authenticated pairing.
|-
| Secure Connections
| Uses the BLE Secure Connections pairing mechanism.
|-
| Bonding
| Allows security information to be retained for future connections.
|-
| Encryption
| Protects data transmitted over the established BLE link.
|}

Espressif documents BLE security configurations including bonding, MITM protection and Secure Connections, and provides dedicated BLE security examples.

== Smartphone Setup ==

=== Step 1: Install LightBlue ===

Install '''LightBlue® by Punch Through''' on the smartphone.

For Android:

[Download LightBlue from Google Play](https://play.google.com/store/apps/details?hl=en&id=com.punchthrough.lightblueexplorer&utm_source=chatgpt.com)

For iPhone/iPad:

[Download LightBlue from the App Store](https://apps.apple.com/in/app/lightblue/id557428110?platform=vision&utm_source=chatgpt.com)

The same application is available on both platforms.

=== Step 2: Upload the Program ===

1. Connect the ESP32 to the computer using the USB cable.
2. Open Arduino IDE.
3. Select the appropriate ESP32 board.
4. Select the correct COM port.
5. Upload the program.
6. Open the Serial Monitor at '''115200 baud'''.

The Serial Monitor should display:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...
</pre>

=== Step 3: Start LightBlue ===

1. Enable Bluetooth on the smartphone.
2. Open the LightBlue application.
3. Allow the required Bluetooth permissions.
4. Start scanning for nearby BLE devices.
5. Locate:

<pre>
ESP32-Secure-Sensor
</pre>

6. Select the device and tap '''Connect'''.

LightBlue supports BLE scanning, connection, service/characteristic inspection, reading, writing and notifications.

=== Step 4: Pair the Device ===

When the ESP32 requests secure pairing, the smartphone will display the BLE pairing/passkey interaction.

Enter or confirm:

<pre>
123456
</pre>

After successful authentication, the BLE connection becomes secured.

Espressif's BLE documentation demonstrates pairing between an ESP32 BLE server and a mobile phone using LightBlue, including passkey-based pairing.

=== Step 5: View Sensor Data ===

After connecting, LightBlue displays the BLE service and its characteristics.

The structure will be similar to:

<pre>
ESP32-Secure-Sensor

Service
└── Sensor Service
│
├── Temperature
│ Value: 27.40
│
└── Humidity
Value: 61.00
</pre>

The exact appearance of the LightBlue interface may vary between Android and iOS versions.

=== Step 6: Enable Notifications ===

The temperature and humidity characteristics support notifications.

Enable notifications for the characteristics in LightBlue.

The ESP32 will then periodically send updated sensor readings.

Example:

<pre>
Temperature: 27.40 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 61.00 %

Temperature: 27.50 °C
Humidity: 62.00 %
</pre>

== Data Flow ==

The complete data flow of the experiment is:

<pre>
DHT11 Sensor
↓
Temperature / Humidity
↓
ESP32
↓
BLE GATT Server
↓
BLE Pairing & Authentication
↓
Encrypted BLE Link
↓
Smartphone
↓
LightBlue Application
↓
Temperature / Humidity Data
</pre>

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the given pin connections.
# Install the DHT sensor library in Arduino IDE if required.
# Install the ESP32 board package in Arduino IDE.
# Install the LightBlue BLE application on an Android or iOS smartphone.
# Enter the BLE program into Arduino IDE.
# Connect the ESP32 to the computer.
# Select the correct ESP32 board and COM port.
# Upload the program.
# Open the Serial Monitor at 115200 baud.
# Verify that the ESP32 starts BLE advertising.
# Open LightBlue on the smartphone.
# Scan for nearby BLE devices.
# Select `ESP32-Secure-Sensor`.
# Establish the BLE connection.
# Complete the passkey authentication using `123456`.
# Verify that the BLE connection is authenticated and secured.
# Open the sensor service in LightBlue.
# Locate the temperature and humidity characteristics.
# Enable notifications for the characteristics.
# Observe the temperature and humidity values received from the ESP32.
# Compare the displayed values with the DHT11 readings shown in the Serial Monitor.
# Record the observed values.

== Observations and Output ==

=== Serial Monitor ===

The Serial Monitor displays information similar to:

<pre>
Secure BLE Sensor Started
Device Name: ESP32-Secure-Sensor
Passkey: 123456
Waiting for BLE connection...

Temperature: 27.40 °C
Humidity: 61.00 %
Sensor data sent using secure BLE

Temperature: 27.50 °C
Humidity: 61.00 %
Sensor data sent using secure BLE
</pre>

=== Smartphone ===

The LightBlue application should show:

{| class="wikitable"
! Parameter
! Example Observation
|-
| BLE Device
| ESP32-Secure-Sensor
|-
| BLE Service
| Sensor Service
|-
| Temperature
| 27.40 °C
|-
| Humidity
| 61.00 %
|-
| Authentication
| Successful
|-
| Communication
| Secure BLE
|}

The actual temperature and humidity values will depend on the environmental conditions.

== Result ==

The DHT11 sensor was successfully interfaced with the ESP32, and temperature and humidity data were transmitted to a smartphone using Bluetooth Low Energy. BLE pairing and security mechanisms were configured to authenticate the smartphone and establish a protected communication link. The sensor values were successfully observed using the LightBlue BLE application.

== Security Considerations ==

* The BLE passkey used in this experiment is intended for educational demonstration.
* A fixed passkey such as `123456` should not be used in a real security-sensitive product.
* Production IoT systems should use appropriate device-specific credentials and security policies.
* Secure Connections and MITM protection improve the security of BLE pairing, but the overall security of an IoT product also depends on its firmware, credential management and application design.
* The experiment demonstrates BLE link security; it should not be interpreted as complete end-to-end IoT security.
* The LightBlue application is being used as a BLE debugging/client tool rather than as a custom end-user IoT application.

== Viva Questions ==

'''Q1. What is BLE?'''

BLE stands for Bluetooth Low Energy. It is a wireless communication technology designed for low-power communication between devices.

'''Q2. Why is BLE suitable for IoT applications?'''

BLE provides short-range wireless communication with relatively low power consumption, making it suitable for sensors and other IoT devices.

'''Q3. What is GATT?'''

GATT stands for Generic Attribute Profile. It defines how BLE devices organize and exchange application data using services and characteristics.

'''Q4. What is a BLE service?'''

A service is a collection of related BLE characteristics that represents a particular function of the device.

'''Q5. What is a BLE characteristic?'''

A characteristic represents a specific piece of data or functionality and can support operations such as read, write and notify.

'''Q6. What is pairing?'''

Pairing is the process of establishing security information between two Bluetooth devices so that a secure relationship can be created.

'''Q7. What is BLE encryption?'''

BLE encryption protects data exchanged over an established secure BLE connection.

'''Q8. What is a passkey used for?'''

A passkey is used as part of the authentication process during BLE pairing.

'''Q9. What is MITM protection?'''

MITM stands for Man-in-the-Middle. MITM protection helps prevent an attacker from impersonating one of the devices during the authentication process.

'''Q10. What is bonding?'''

Bonding is the process of storing security information after pairing so that the devices can establish trusted connections again later.

'''Q11. Why is LightBlue used in this experiment?'''

LightBlue provides a convenient BLE client interface for discovering the ESP32, connecting to it, inspecting services and characteristics, and receiving notifications.

'''Q12. Can the same application be used on Android and iOS?'''

Yes. LightBlue is available for both Android and iOS.

'''Q13. What is the role of the ESP32 in this experiment?'''

The ESP32 reads the DHT11 sensor and acts as a BLE GATT server that provides the sensor data to the smartphone.

'''Q14. What is the difference between `READ` and `NOTIFY` in BLE?'''

`READ` allows the client to request the current value. `NOTIFY` allows the server to send updated values automatically when the client subscribes to notifications.

'''Q15. How is this experiment different from HTTPS-based cloud communication?'''

HTTPS protects communication between an IoT device and a web/cloud server over a network. This experiment demonstrates secure short-range BLE communication directly between an ESP32 and a smartphone.

== Conclusion ==

This experiment demonstrates how Bluetooth Low Energy can be used for secure IoT sensor-data transmission. The ESP32 reads temperature and humidity from the DHT11 sensor and exposes the readings through BLE characteristics. The smartphone connects using the LightBlue application, performs secure pairing, and receives the sensor data through an authenticated and encrypted BLE connection.

MDM331AID/Experiment 11

2026-10-07T11:37:52Z

CogWikiEditor: Created page with "= Experiment: Password-Protected Smart Sensor System = == Aim == To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts. == Objectives == * To understand the importance of security in IoT systems. * To interface a DHT11 temperature and humidity sensor with an ESP32. * To connect the ESP32 to a Wi-Fi network. * To implement a web server on the ESP3..."

= Experiment: Password-Protected Smart Sensor System =

== Aim ==
To design and implement a password-protected smart sensor system that allows access to sensor data only after successful authentication, demonstrating basic IoT security concepts.

== Objectives ==
* To understand the importance of security in IoT systems.
* To interface a DHT11 temperature and humidity sensor with an ESP32.
* To connect the ESP32 to a Wi-Fi network.
* To implement a web server on the ESP32 for accessing sensor data.
* To implement password-based authentication for protecting sensor data.
* To use the SHA-256 hashing algorithm for secure password verification.
* To allow access to sensor data only after successful authentication.
* To demonstrate access denial when incorrect authentication credentials are provided.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi router / hotspot
| 1
|-
| 6
| Computer or smartphone with a web browser
| 1
|-
| 7
| Arduino IDE
| 1
|-
| 8
| DHT sensor library
| 1
|-
| 9
| ESP32 Arduino core / Wi-Fi library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. Since IoT devices are often connected to networks, protecting their data and controlling access to the devices are important security requirements.

An IoT security system should ensure that only authorized users can access protected sensor data or device functions. '''Authentication''' is the process of verifying the identity of a user or device before granting access to a protected resource.

In this experiment, an ESP32 is connected to a DHT11 temperature and humidity sensor. The ESP32 connects to a Wi-Fi network and operates as a small web server. A user can access the ESP32 using a web browser by entering its IP address.

The sensor data is not displayed immediately. The user must first provide valid authentication credentials. If authentication is successful, the ESP32 provides access to the sensor dashboard. If the credentials are incorrect, access to the sensor data is denied.

The basic operation of the system is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Web Server
↓
Authentication
↓
┌───────────────┐
│ │
↓ ↓
Valid Invalid
Password Password
│ │
↓ ↓
Sensor Access
Data Denied
</pre>

=== Password Authentication ===

'''Password authentication''' is a method of verifying a user's identity by comparing credentials provided by the user with the credentials stored by the system.

A simple implementation could directly compare the entered password with a stored password. However, storing passwords directly is not considered a good security practice.

Instead, this experiment demonstrates '''password hashing'''.

=== SHA-256 Hashing ===

'''SHA-256 (Secure Hash Algorithm 256-bit)''' is a cryptographic hash function that converts input data into a fixed-length 256-bit hash value, normally represented as a 64-character hexadecimal string.

For example:

<pre>
Password
↓
SHA-256
↓
64-character hash
</pre>

The original password does not need to be stored directly. During authentication, the password entered by the user is hashed using SHA-256 and the resulting hash is compared with the stored hash.

The authentication process is:

<pre>
User enters password
↓
SHA-256 Hash
↓
Compare with stored hash
↓
Match?
/ \
Yes No
↓ ↓
Allow Deny
access access
</pre>

If the calculated hash matches the stored hash, the user is considered authenticated.

'''Note:''' SHA-256 is used in this experiment to demonstrate the basic concept of password hashing. A production IoT system should use stronger password-storage practices such as salted password hashing and should protect network communication using HTTPS/TLS.

=== ESP32 Web Server ===

The ESP32 contains built-in Wi-Fi capability and can operate as a web server. A web server listens for requests from a client such as a web browser and sends an appropriate response.

In this experiment, the ESP32 provides:

* '''Login page:''' Allows the user to enter authentication credentials.
* '''Authentication:''' Verifies the entered password.
* '''Sensor dashboard:''' Displays temperature and humidity after successful authentication.
* '''Access denial:''' Prevents unauthorized users from accessing the sensor data.

The user can access the system using the IP address assigned to the ESP32.

For example:

<pre>
http://192.168.1.105
</pre>

The exact IP address depends on the network to which the ESP32 is connected.

== Pin Connections ==

The following connections are used to interface the DHT11 sensor with the ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the corresponding pin number is changed in the program.

== Connection Diagram ==

The DHT11 sensor is connected to the ESP32 according to the pin connection table. The ESP32 connects to the Wi-Fi network and hosts the authentication and sensor-data web pages.

The overall connection is:

<pre>
DHT11
┌─────────┐
│ │
VCC ─┤ VCC │
3.3V │ │
│ DATA ───────── GPIO 4
GND ─┤ GND │
└─────────┘
│
↓
ESP32
│
Wi-Fi
│
↓
Web Browser
</pre>

== Program ==

Install the '''DHT sensor library''' and the required ESP32 board support package using the Arduino IDE.

The program creates a web server on the ESP32, reads temperature and humidity from the DHT11 and protects the sensor dashboard using password authentication.

<pre>
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include "mbedtls/sha256.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);
WebServer server(80);

// Wi-Fi credentials
const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

// Login credentials
const char* username = "admin";

// SHA-256 hash of the password
// Password used for this experiment: admin123
const char* storedPasswordHash =
"240be518fabd27242f2e4c59b8c9b0d9"
"8f0f6f5e8a9a9b7e7b5f4f7f9a5d5e6f";

// Authentication status
bool authenticated = false;

// -------------------------------------------------
// SHA-256 function
// -------------------------------------------------

String sha256(String input)
{
byte hash[32];

mbedtls_sha256_context ctx;

mbedtls_sha256_init(&ctx);
mbedtls_sha256_starts(&ctx, 0);
mbedtls_sha256_update(
&ctx,
(const unsigned char*)input.c_str(),
input.length()
);
mbedtls_sha256_finish(&ctx, hash);
mbedtls_sha256_free(&ctx);

String result = "";

for (int i = 0; i < 32; i++)
{
if (hash[i] < 16)
result += "0";

result += String(hash[i], HEX);
}

return result;
}

// -------------------------------------------------
// Login page
// -------------------------------------------------

void handleRoot()
{
String html = "";

html += "<html>";
html += "<head>";
html += "<title>Smart Sensor System</title>";
html += "</head>";

html += "<body>";
html += "<h1>Smart Sensor System</h1>";

html += "<form action='/login' method='POST'>";

html += "Username:<br>";
html += "<input type='text' name='username'><br><br>";

html += "Password:<br>";
html += "<input type='password' name='password'><br><br>";

html += "<input type='submit' value='Login'>";

html += "</form>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

// -------------------------------------------------
// Login authentication
// -------------------------------------------------

void handleLogin()
{
String enteredUsername =
server.arg("username");

String enteredPassword =
server.arg("password");

String enteredHash =
sha256(enteredPassword);

if (
enteredUsername == username &&
enteredHash == storedPasswordHash
)
{
authenticated = true;

server.sendHeader(
"Location",
"/sensor"
);

server.send(
302,
"text/plain",
"Login successful"
);
}
else
{
authenticated = false;

String html = "";

html += "<html>";
html += "<body>";

html += "<h1>Access Denied</h1>";

html += "<p>";
html += "Invalid username or password.";
html += "</p>";

html += "<a href='/'>Try Again</a>";

html += "</body>";
html += "</html>";

server.send(
401,
"text/html",
html
);
}
}

// -------------------------------------------------
// Protected sensor page
// -------------------------------------------------

void handleSensor()
{
if (!authenticated)
{
server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Authentication required"
);

return;
}

float temperature =
dht.readTemperature();

float humidity =
dht.readHumidity();

String html = "";

html += "<html>";
html += "<head>";
html += "<title>Sensor Dashboard</title>";
html += "</head>";

html += "<body>";

html += "<h1>Smart Sensor System</h1>";

html += "<h2>";
html += "Authentication Successful";
html += "</h2>";

html += "<p>";
html += "Temperature: ";
html += String(temperature, 1);
html += " °C";
html += "</p>";

html += "<p>";
html += "Humidity: ";
html += String(humidity, 1);
html += " %";
html += "</p>";

html += "<br>";

html += "<a href='/sensor'>";
html += "Refresh Sensor Data";
html += "</a>";

html += "<br><br>";

html += "<a href='/logout'>";
html += "Logout";
html += "</a>";

html += "</body>";
html += "</html>";

server.send(
200,
"text/html",
html
);
}

// -------------------------------------------------
// Logout
// -------------------------------------------------

void handleLogout()
{
authenticated = false;

server.sendHeader(
"Location",
"/"
);

server.send(
302,
"text/plain",
"Logged out"
);
}

// -------------------------------------------------
// Setup
// -------------------------------------------------

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

dht.begin();

Serial.println();
Serial.println("Smart Sensor Security System");

WiFi.begin(
ssid,
password
);

Serial.print(
"Connecting to Wi-Fi"
);

while (
WiFi.status() != WL_CONNECTED
)
{
delay(500);
Serial.print(".");
}

Serial.println();
Serial.println(
"Wi-Fi connected"
);

Serial.print(
"ESP32 IP address: "
);

Serial.println(
WiFi.localIP()
);

server.on(
"/",
HTTP_GET,
handleRoot
);

server.on(
"/login",
HTTP_POST,
handleLogin
);

server.on(
"/sensor",
HTTP_GET,
handleSensor
);

server.on(
"/logout",
HTTP_GET,
handleLogout
);

server.begin();

Serial.println(
"Web server started"
);
}

// -------------------------------------------------
// Main loop
// -------------------------------------------------

void loop()
{
server.handleClient();
}
</pre>

== Code Explanation ==

* '''WiFi.h:''' Provides functions required to connect the ESP32 to a Wi-Fi network.

* '''WebServer.h:''' Provides the functionality required to create a web server on the ESP32 and handle HTTP requests.

* '''DHT.h:''' Provides functions for communicating with the DHT11 sensor.

* '''mbedtls/sha256.h:''' Provides the SHA-256 cryptographic hashing functionality available in the ESP32 environment.

* '''DHT():''' Creates the DHT11 sensor object using the configured GPIO pin and sensor type.

* '''WebServer server(80):''' Creates a web server that listens for HTTP requests on port 80.

* '''ssid and password:''' Store the Wi-Fi network credentials required by the ESP32.

* '''username:''' Stores the username required for authentication.

* '''storedPasswordHash:''' Stores the SHA-256 hash used for password verification instead of storing the plaintext password.

* '''sha256():''' Converts the entered password into a SHA-256 hash.

* '''handleRoot():''' Displays the login page to the user.

* '''handleLogin():''' Receives the username and password entered by the user and verifies the credentials.

* '''server.arg():''' Retrieves form data submitted by the browser.

* '''authenticated:''' Stores the current authentication state of the user.

* '''handleSensor():''' Displays the protected sensor dashboard only when authentication has been successful.

* '''dht.readTemperature():''' Reads the temperature measured by the DHT11.

* '''dht.readHumidity():''' Reads the relative humidity measured by the DHT11.

* '''handleLogout():''' Ends the current authentication state and redirects the user to the login page.

* '''WiFi.localIP():''' Displays the IP address assigned to the ESP32.

* '''server.on():''' Associates a URL path with a particular function that handles the request.

* '''server.begin():''' Starts the ESP32 web server.

* '''server.handleClient():''' Processes incoming HTTP requests from connected clients.

== Authentication Process ==

The authentication process consists of the following steps:

# The user connects the computer or smartphone to the same Wi-Fi network as the ESP32.
# The user enters the IP address of the ESP32 into a web browser.
# The ESP32 displays the login page.
# The user enters the username and password.
# The ESP32 receives the submitted credentials.
# The entered password is processed using the SHA-256 hashing algorithm.
# The resulting hash is compared with the stored password hash.
# If both the username and password hash match, authentication is successful.
# The ESP32 allows access to the sensor dashboard.
# If the credentials do not match, access is denied.
# The user can log out to terminate the authenticated state.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Open the Arduino IDE.
# Install the ESP32 board support package if it is not already installed.
# Install the DHT sensor library using the Arduino IDE Library Manager.
# Enter the Wi-Fi network name and password in the program.
# Configure the username and stored password hash.
# Select the appropriate ESP32 board and COM port.
# Compile and upload the program to the ESP32.
# Open the Serial Monitor and set the baud rate to 115200.
# Wait for the ESP32 to connect to the Wi-Fi network.
# Note the IP address displayed in the Serial Monitor.
# Connect a computer or smartphone to the same Wi-Fi network.
# Open a web browser and enter the ESP32 IP address.
# Observe the login page.
# Enter an incorrect username or password and observe that access is denied.
# Return to the login page and enter the correct credentials.
# Observe that the sensor dashboard becomes accessible after successful authentication.
# Observe the temperature and humidity values displayed on the dashboard.
# Change the environmental conditions around the sensor if required and refresh the dashboard.
# Observe the updated sensor readings.
# Select the Logout option.
# Verify that the system returns to the login page and requires authentication again.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Test Condition
! Expected Result
|-
| 1
| ESP32 connected to Wi-Fi
| ESP32 obtains an IP address
|-
| 2
| Open ESP32 IP address
| Login page is displayed
|-
| 3
| Incorrect username
| Access denied
|-
| 4
| Incorrect password
| Access denied
|-
| 5
| Correct username and password
| Authentication successful
|-
| 6
| Access protected sensor page
| Temperature and humidity are displayed
|-
| 7
| Logout
| User is returned to login page
|}

An illustrative Serial Monitor output is:

<pre>
Smart Sensor Security System
Connecting to Wi-Fi....
Wi-Fi connected
ESP32 IP address: 192.168.1.105
Web server started
</pre>

The initial browser page displays:

<pre>
--------------------------------
Smart Sensor System

Username: [____________]

Password: [____________]

[ Login ]
--------------------------------
</pre>

When an incorrect password is entered:

<pre>
Access Denied

Invalid username or password.
</pre>

After successful authentication:

<pre>
--------------------------------
Smart Sensor System

Authentication Successful

Temperature: 27.6 °C
Humidity: 61.0 %

[Refresh Sensor Data]

[Logout]
--------------------------------
</pre>

== Security Considerations ==

The experiment demonstrates basic authentication and password hashing, but the implementation is intended for educational purposes.

The following security considerations should be understood:

* '''Password hashing:''' The password is converted into a SHA-256 hash before comparison.
* '''Authentication:''' Sensor data is not displayed until valid credentials are provided.
* '''Access control:''' The protected sensor page checks the authentication state before displaying sensor data.
* '''Logout:''' The authentication state is cleared when the user logs out.
* '''Network security:''' The demonstration uses HTTP on a local Wi-Fi network. HTTP does not encrypt network traffic.
* '''HTTPS/TLS:''' A production IoT application should use HTTPS/TLS to protect credentials and sensor data while they are transmitted.
* '''Password storage:''' Production systems should use a properly salted password-hashing scheme rather than relying on a simple stored SHA-256 hash.
* '''Session management:''' A production system should use secure sessions or authentication tokens rather than a simple boolean authentication state.

== Result ==

A password-protected smart sensor system was successfully designed and implemented using an ESP32 and DHT11 sensor. The ESP32 connected to a Wi-Fi network and operated as a web server for providing access to temperature and humidity data.

Password-based authentication was implemented using SHA-256 hashing. Incorrect credentials resulted in access denial, while successful authentication allowed the user to access the protected sensor dashboard.

Thus, the experiment demonstrated basic IoT security concepts including authentication, password hashing and access control for sensor data.

== Viva Questions ==

# What is IoT security?
# Why is security important in IoT systems?
# What is authentication?
# What is the difference between authentication and authorization?
# What is password hashing?
# What is SHA-256?
# Why should passwords not be stored directly in plaintext?
# What is the purpose of hashing the entered password?
# What is the role of the ESP32 web server in this experiment?
# What is an HTTP request?
# What is the purpose of port 80?
# How does the ESP32 obtain its IP address?
# What happens when an incorrect password is entered?
# What happens after successful authentication?
# What is the purpose of the logout operation?
# Why is a boolean authentication variable used in this experiment?
# Is SHA-256 encryption?
# What is the difference between hashing and encryption?
# Why is HTTPS preferred over HTTP for real IoT applications?
# What is TLS?
# Why is the implemented system considered a basic security demonstration rather than a production security system?
# What is a salted password hash?
# What other security mechanisms can be used in IoT systems?

MDM331AID/Experiment 13

2026-10-07T08:26:31Z

CogWikiEditor: Created page with "= Experiment: Classification and Anomaly Detection on IoT Sensor Data = == Aim == To develop and implement machine learning models to classify IoT sensor data into different device or environmental states and detect anomalous sensor readings. == Objectives == * To understand the application of machine learning in IoT systems. * To collect and prepare temperature and humidity sensor data for machine learning. * To classify IoT sensor readings into Normal, Warning and Cr..."

= Experiment: Classification and Anomaly Detection on IoT Sensor Data =

== Aim ==
To develop and implement machine learning models to classify IoT sensor data into different device or environmental states and detect anomalous sensor readings.

== Objectives ==
* To understand the application of machine learning in IoT systems.
* To collect and prepare temperature and humidity sensor data for machine learning.
* To classify IoT sensor readings into Normal, Warning and Critical states.
* To implement a Decision Tree classification model.
* To evaluate the performance of the classification model.
* To understand the concept of anomaly detection in IoT sensor data.
* To implement an Isolation Forest model for detecting anomalous sensor readings.
* To visualize the classification results and detected anomalies.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer or laptop
| 1
|-
| 7
| Cognifront Cloud platform
| 1
|-
| 8
| Python
| 1
|-
| 9
| Jupyter Notebook / Google Colab / VS Code
| 1
|-
| 10
| Pandas library
| 1
|-
| 11
| NumPy library
| 1
|-
| 12
| Matplotlib library
| 1
|-
| 13
| Scikit-learn library
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT systems continuously generate sensor data that can be transmitted to cloud platforms and used for monitoring, analysis and intelligent decision-making.

In this experiment, a DHT11 sensor is used to measure temperature and humidity. The sensor is connected to an ESP32 development board. The ESP32 reads the sensor values and can transmit the collected data to a cloud platform using Wi-Fi. The collected sensor data can be exported as a CSV file and used as input for machine learning.

'''Machine Learning (ML)''' is a branch of artificial intelligence in which computer systems learn patterns from data and use those patterns to make predictions or decisions.

Machine learning techniques can be used in IoT systems for applications such as device-state classification, activity recognition, fault detection and abnormal-condition detection.

This experiment demonstrates two machine learning tasks:

# '''Classification''' using a Decision Tree.
# '''Anomaly Detection''' using Isolation Forest.

=== Classification ===

'''Classification''' is a supervised machine learning task in which a model learns to assign input data to predefined classes.

In this experiment, temperature and humidity values are used as input features. The sensor readings are classified into three environmental states:

{| class="wikitable"
|-
! Class
! Description
|-
| Normal
| Temperature and humidity values are within the normal operating range.
|-
| Warning
| Temperature or humidity values indicate a condition that requires attention.
|-
| Critical
| Temperature or humidity values indicate a significantly abnormal condition.
|}

A '''Decision Tree Classifier''' is used for classification. A decision tree makes decisions by applying a sequence of conditions to the input features.

For example, a simplified decision process may be represented as:

<pre>
Temperature
|
┌─────────┼─────────┐
↓ ↓ ↓
Normal Warning Critical
</pre>

The actual model uses temperature and humidity together to learn the classification boundaries from the training data.

=== Anomaly Detection ===

'''Anomaly detection''' is the process of identifying observations that differ significantly from the normal pattern of data.

An anomaly in an IoT sensor dataset may occur because of:

* Sensor malfunction.
* Communication errors.
* Incorrect sensor readings.
* Environmental disturbances.
* Hardware faults.
* Data transmission errors.

Unlike classification, anomaly detection does not require every abnormal observation to have a predefined class label.

In this experiment, '''Isolation Forest''' is used for anomaly detection.

Isolation Forest is an unsupervised machine learning algorithm that identifies unusual observations by isolating them from the rest of the dataset. Observations that are significantly different from normal observations are more easily isolated and are therefore considered potential anomalies.

For example, if normal temperature readings are approximately between 23 °C and 32 °C, values such as 80 °C or -10 °C may be identified as anomalous.

The classification and anomaly-detection processes are therefore different:

<pre>
Classification:

Temperature + Humidity
↓
Decision Tree
↓
Normal / Warning / Critical

Anomaly Detection:

Temperature + Humidity
↓
Isolation Forest
↓
Normal / Anomaly
</pre>

The overall workflow of the experiment is:

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
IoT Dataset
↓
Data Preprocessing
↓
┌───────────────────────┐
│ │
↓ ↓
Classification Anomaly Detection
│ │
↓ ↓
Decision Tree Isolation Forest
│ │
↓ ↓
Normal/Warning/ Normal/Anomaly
Critical
</pre>

== DHT11 Pin Connections ==

The following connections can be used when collecting the temperature and humidity data using an ESP32.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the program is modified accordingly.

== Dataset ==

The dataset used in this experiment contains temperature and humidity readings obtained from a DHT11 sensor.

The dataset contains the following fields:

{| class="wikitable"
|-
! Column
! Description
|-
| ID
| Unique record identifier
|-
| Temperature
| Temperature measured by the DHT11 sensor in °C
|-
| Humidity
| Relative humidity measured by the DHT11 sensor in %
|-
| Date
| Date and time of the sensor reading
|}

The clean dataset is used as the original reference dataset.

A separate copy of the dataset can be created for anomaly detection. Controlled anomalous values can be introduced into this copy to demonstrate the ability of the Isolation Forest model to detect abnormal sensor readings.

'''Important:''' The original clean dataset should not be modified. The anomalous dataset should be created as a separate copy.

== Preparing the Dataset ==

For the classification task, a class label named '''State''' is generated from the temperature and humidity values.

The following example rules are used to generate the labels:

{| class="wikitable"
|-
! Condition
! State
|-
| Temperature < 30 °C and Humidity < 70 %
| Normal
|-
| Temperature ≥ 30 °C or Humidity ≥ 70 %
| Warning
|-
| Temperature ≥ 33 °C or Humidity ≥ 80 %
| Critical
|}

The '''Critical''' condition is checked before the Warning condition so that a critical reading is not incorrectly classified as Warning.

These labels are used only to create the labelled dataset required for demonstrating supervised classification.

== Program ==

Install the required Python libraries before running the program.

<pre>
pip install pandas numpy matplotlib scikit-learn
</pre>

The following program can be executed using Jupyter Notebook, Google Colab or VS Code.

<pre>
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.metrics import (
accuracy_score,
confusion_matrix,
classification_report
)
from sklearn.ensemble import IsolationForest

# -------------------------------------------------
# 1. Load the dataset
# -------------------------------------------------

df = pd.read_csv("clean-dht11-temperature-humidity.csv")

print("Original Dataset")
print(df.head())

print("\nDataset Information")
print(df.info())

print("\nMissing Values")
print(df.isnull().sum())

print("\nDuplicate Records")
print(df.duplicated().sum())

# -------------------------------------------------
# 2. Data preprocessing
# -------------------------------------------------

df["Temperature"] = pd.to_numeric(
df["Temperature"],
errors="coerce"
)

df["Humidity"] = pd.to_numeric(
df["Humidity"],
errors="coerce"
)

df["Date"] = pd.to_datetime(
df["Date"],
errors="coerce"
)

# Remove invalid records
df = df.dropna(
subset=["Temperature", "Humidity", "Date"]
)

# Remove duplicate records
df = df.drop_duplicates()

# -------------------------------------------------
# 3. Create classification labels
# -------------------------------------------------

def classify_state(row):

temperature = row["Temperature"]
humidity = row["Humidity"]

if temperature >= 33 or humidity >= 80:
return "Critical"

elif temperature >= 30 or humidity >= 70:
return "Warning"

else:
return "Normal"

df["State"] = df.apply(
classify_state,
axis=1
)

print("\nClass Distribution")
print(df["State"].value_counts())

# -------------------------------------------------
# 4. Classification
# -------------------------------------------------

# Input features
X = df[
["Temperature", "Humidity"]
]

# Target class
y = df["State"]

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
X,
y,
test_size=0.2,
random_state=42,
stratify=y
)

# Create Decision Tree model
classifier = DecisionTreeClassifier(
max_depth=4,
random_state=42
)

# Train the model
classifier.fit(
X_train,
y_train
)

# Predict test data
y_pred = classifier.predict(X_test)

# -------------------------------------------------
# 5. Classification evaluation
# -------------------------------------------------

accuracy = accuracy_score(
y_test,
y_pred
)

print("\nClassification Accuracy:")
print(accuracy)

print("\nClassification Report:")
print(
classification_report(
y_test,
y_pred
)
)

print("\nConfusion Matrix:")
cm = confusion_matrix(
y_test,
y_pred
)

print(cm)

# -------------------------------------------------
# 6. Visualize the Decision Tree
# -------------------------------------------------

plt.figure(figsize=(14, 8))

plot_tree(
classifier,
feature_names=[
"Temperature",
"Humidity"
],
class_names=classifier.classes_,
filled=True
)

plt.title(
"Decision Tree for IoT Sensor Classification"
)

plt.show()

# -------------------------------------------------
# 7. Load anomalous dataset
# -------------------------------------------------

anomaly_df = pd.read_csv(
"anomalous-dht11-temperature-humidity.csv"
)

anomaly_df["Temperature"] = pd.to_numeric(
anomaly_df["Temperature"],
errors="coerce"
)

anomaly_df["Humidity"] = pd.to_numeric(
anomaly_df["Humidity"],
errors="coerce"
)

anomaly_df = anomaly_df.dropna(
subset=[
"Temperature",
"Humidity"
]
)

# -------------------------------------------------
# 8. Isolation Forest anomaly detection
# -------------------------------------------------

features = anomaly_df[
["Temperature", "Humidity"]
]

isolation_model = IsolationForest(
contamination=0.02,
random_state=42
)

isolation_model.fit(
features
)

# Predict anomalies
anomaly_prediction = isolation_model.predict(
features
)

anomaly_df["Anomaly"] = anomaly_prediction

# Convert prediction to readable labels
anomaly_df["Status"] = anomaly_df[
"Anomaly"
].map({
1: "Normal",
-1: "Anomaly"
})

# -------------------------------------------------
# 9. Display detected anomalies
# -------------------------------------------------

detected_anomalies = anomaly_df[
anomaly_df["Status"] == "Anomaly"
]

print("\nDetected Anomalies:")
print(
detected_anomalies[
[
"ID",
"Temperature",
"Humidity",
"Date",
"Status"
]
]
)

print(
"\nNumber of detected anomalies:",
len(detected_anomalies)
)

# -------------------------------------------------
# 10. Visualize anomaly detection
# -------------------------------------------------

plt.figure(figsize=(10, 6))

normal_data = anomaly_df[
anomaly_df["Status"] == "Normal"
]

anomaly_data = anomaly_df[
anomaly_df["Status"] == "Anomaly"
]

plt.scatter(
normal_data["Temperature"],
normal_data["Humidity"],
label="Normal"
)

plt.scatter(
anomaly_data["Temperature"],
anomaly_data["Humidity"],
label="Anomaly",
marker="x",
s=80
)

plt.xlabel("Temperature (°C)")
plt.ylabel("Humidity (%)")
plt.title(
"IoT Sensor Anomaly Detection"
)

plt.legend()
plt.tight_layout()
plt.show()

# -------------------------------------------------
# 11. Save classification dataset
# -------------------------------------------------

df.to_csv(
"classified-dht11-data.csv",
index=False
)

# Save anomaly detection results
anomaly_df.to_csv(
"dht11-anomaly-detection-results.csv",
index=False
)

print(
"\nProcessed datasets saved successfully."
)
</pre>

== Code Explanation ==

* '''pd.read_csv():''' Loads the IoT temperature and humidity dataset from a CSV file.

* '''pd.to_numeric():''' Converts the Temperature and Humidity columns into numerical values. Invalid values are converted to missing values.

* '''pd.to_datetime():''' Converts the Date column into a date-time format.

* '''dropna():''' Removes records containing invalid or missing temperature, humidity or date values.

* '''drop_duplicates():''' Removes duplicate records from the dataset.

* '''classify_state():''' Generates the target class label based on the temperature and humidity values.

* '''State:''' Represents the class assigned to each sensor reading. The classes used are Normal, Warning and Critical.

* '''train_test_split():''' Divides the labelled dataset into training and testing datasets.

* '''stratify:''' Maintains approximately the same proportion of each class in the training and testing datasets.

* '''DecisionTreeClassifier():''' Creates a Decision Tree machine learning classification model.

* '''max_depth:''' Limits the maximum depth of the decision tree and helps keep the model simple and interpretable.

* '''fit():''' Trains the Decision Tree model using the training data.

* '''predict():''' Uses the trained model to predict the class of unseen sensor readings.

* '''accuracy_score():''' Calculates the percentage of correctly classified test samples.

* '''classification_report():''' Displays precision, recall and F1-score for each class.

* '''confusion_matrix():''' Shows the number of correctly and incorrectly classified observations for each class.

* '''plot_tree():''' Displays the structure of the trained Decision Tree.

* '''IsolationForest():''' Creates an unsupervised machine learning model for detecting anomalous sensor observations.

* '''contamination:''' Specifies the approximate proportion of observations expected to be anomalous. In this experiment, 0.02 represents approximately 2% of the data.

* '''fit():''' Trains the Isolation Forest model using the temperature and humidity features.

* '''Isolation Forest prediction:''' A value of '''1''' represents a normal observation, while '''-1''' represents a potential anomaly.

* '''Status:''' Converts the numerical Isolation Forest output into readable labels such as Normal and Anomaly.

* '''detected_anomalies:''' Contains only the sensor observations identified as anomalous by the Isolation Forest model.

* '''plt.scatter():''' Creates a scatter plot showing the relationship between temperature and humidity and highlights detected anomalies.

* '''to_csv():''' Saves the classification results and anomaly-detection results as CSV files.

== Introducing Manual Anomalies ==

The original clean dataset should be preserved.

Create a copy of the original dataset and rename it:

<pre>
anomalous-dht11-temperature-humidity.csv
</pre>

Artificial anomalies can then be introduced into this copy.

For example:

{| class="wikitable"
|-
! Anomaly Type
! Example Temperature
! Example Humidity
! Purpose
|-
| Normal reading
| 27.5 °C
| 60 %
| Represents normal sensor operation
|-
| High temperature
| 80 °C
| 60 %
| Demonstrates abnormal temperature
|-
| Very low temperature
| -10 °C
| 60 %
| Demonstrates abnormal temperature
|-
| High humidity
| 27 °C
| 98 %
| Demonstrates abnormal humidity
|-
| Unusual combination
| 80 °C
| 10 %
| Demonstrates an unusual sensor condition
|}

Only a small number of anomalous records should be introduced. For example, approximately 10–15 anomalous records can be added or modified in a dataset containing several hundred records.

The anomalies should be distributed at different positions in the dataset rather than placed together.

'''Important:''' These values are intentionally introduced for demonstrating anomaly detection. They should not be presented as actual DHT11 sensor faults.

The original dataset remains unchanged:

<pre>
clean-dht11-temperature-humidity.csv
</pre>

The modified dataset is used for anomaly detection:

<pre>
anomalous-dht11-temperature-humidity.csv
</pre>

The output of the anomaly-detection program is:

<pre>
dht11-anomaly-detection-results.csv
</pre>

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Configure the ESP32 to read temperature and humidity from the DHT11 sensor.
# Connect the ESP32 to a Wi-Fi network.
# Transmit the sensor readings to the cloud platform if real-time data collection is being performed.
# Export the collected sensor data as a CSV file.
# Alternatively, use the provided clean DHT11 temperature and humidity dataset.
# Preserve the original clean dataset.
# Create a copy of the dataset for anomaly-detection experiments.
# Introduce a small number of controlled anomalous temperature and humidity values into the copied dataset.
# Open Jupyter Notebook, Google Colab or VS Code.
# Install Pandas, NumPy, Matplotlib and Scikit-learn.
# Load the clean dataset using Pandas.
# Inspect the dataset for missing values and duplicate records.
# Convert the temperature, humidity and date columns into appropriate data types.
# Generate Normal, Warning and Critical class labels.
# Separate the temperature and humidity columns as input features.
# Split the labelled data into training and testing datasets.
# Create and train the Decision Tree classification model.
# Predict the classes of the testing data.
# Calculate the classification accuracy.
# Generate the classification report and confusion matrix.
# Visualize the trained Decision Tree.
# Load the anomalous dataset.
# Select temperature and humidity as the features for anomaly detection.
# Create and train the Isolation Forest model.
# Predict normal and anomalous observations.
# Display the sensor readings identified as anomalies.
# Visualize normal and anomalous observations using a scatter plot.
# Save the classification and anomaly-detection results as CSV files.
# Observe and compare the machine learning results.

== Observations and Output ==

=== Classification ===

The following table can be used to record the classification results:

{| class="wikitable"
|-
! Sr. No.
! Parameter
! Observation
|-
| 1
| Input features
| Temperature and Humidity
|-
| 2
| Classification model
| Decision Tree
|-
| 3
| Number of classes
| 3
|-
| 4
| Classes
| Normal, Warning, Critical
|-
| 5
| Training samples
| Record the calculated value
|-
| 6
| Testing samples
| Record the calculated value
|-
| 7
| Accuracy
| Record the calculated value
|-
| 8
| Precision
| Record the calculated value
|-
| 9
| Recall
| Record the calculated value
|-
| 10
| F1-score
| Record the calculated value
|}

An illustrative classification output is:

<pre>
Class Distribution

Normal ...
Warning ...
Critical ...

Classification Accuracy:
...

Classification Report:

precision recall f1-score

Normal ... ... ...
Warning ... ... ...
Critical ... ... ...
</pre>

=== Anomaly Detection ===

The following table can be used to record the anomaly-detection results:

{| class="wikitable"
|-
! Sr. No.
! Parameter
! Observation
|-
| 1
| Anomaly detection model
| Isolation Forest
|-
| 2
| Input features
| Temperature and Humidity
|-
| 3
| Contamination
| 2%
|-
| 4
| Total records
| Record the calculated value
|-
| 5
| Detected anomalies
| Record the calculated value
|-
| 6
| Normal observations
| Record the calculated value
|}

An illustrative output is:

<pre>
Detected Anomalies:

ID Temperature Humidity Status
... 80.0 60 Anomaly
... -10.0 60 Anomaly
... 27.0 98 Anomaly

Number of detected anomalies: ...
</pre>

The scatter plot represents temperature and humidity observations. Normal observations and observations identified as anomalies are displayed using different markers.

== Result ==

The IoT sensor dataset was successfully prepared for machine learning. A Decision Tree classification model was implemented to classify sensor readings into Normal, Warning and Critical states. The classification model was evaluated using accuracy, precision, recall, F1-score and a confusion matrix.

An Isolation Forest model was also implemented to identify anomalous temperature and humidity readings. The detected anomalies were visualized and the processed classification and anomaly-detection results were exported as CSV files.

Thus, machine learning techniques were successfully applied to IoT sensor data for both classification and anomaly detection.

== Viva Questions ==

# What is machine learning?
# What is the difference between supervised and unsupervised learning?
# What is classification?
# What is anomaly detection?
# What is the difference between classification and anomaly detection?
# What are the input features used in this experiment?
# What is the target variable in the classification task?
# What is a Decision Tree?
# Why is a Decision Tree used for classification?
# What is the purpose of training and testing datasets?
# What is classification accuracy?
# What is precision?
# What is recall?
# What is an F1-score?
# What is a confusion matrix?
# What is Isolation Forest?
# Why is Isolation Forest suitable for anomaly detection?
# What does an Isolation Forest prediction of -1 represent?
# What does an Isolation Forest prediction of 1 represent?
# What is the contamination parameter?
# Why are artificial anomalies introduced into the dataset?
# Give examples of anomalies in IoT sensor data.
# How can anomaly detection be useful in industrial IoT?
# What is the difference between an actual sensor fault and an artificially introduced anomaly?
# How can the classification model be improved?
# How can the anomaly-detection system be improved?

MDM331AID/Experiment 10

2026-10-07T07:52:34Z

CogWikiEditor: Created page with "= Experiment: Real-Time IoT Temperature Data Collection and Machine Learning-Based Prediction = == Aim == To implement an IoT application to collect temperature data using a DHT11 sensor and ESP32, and apply a machine learning model to predict future temperature values. == Objectives == * To understand the integration of IoT sensor data with machine learning. * To collect temperature data from a DHT11 sensor using an ESP32. * To transmit the sensor data to a cloud plat..."

= Experiment: Real-Time IoT Temperature Data Collection and Machine Learning-Based Prediction =

== Aim ==
To implement an IoT application to collect temperature data using a DHT11 sensor and ESP32, and apply a machine learning model to predict future temperature values.

== Objectives ==
* To understand the integration of IoT sensor data with machine learning.
* To collect temperature data from a DHT11 sensor using an ESP32.
* To transmit the sensor data to a cloud platform using Wi-Fi.
* To obtain the collected temperature dataset in CSV format.
* To preprocess the IoT temperature dataset for machine learning.
* To train a machine learning model using historical temperature data.
* To predict future temperature values using the trained model.
* To visualize the actual and predicted temperature values.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature and humidity sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer or laptop
| 1
|-
| 7
| Cognifront Cloud platform
| 1
|-
| 8
| Python
| 1
|-
| 9
| Jupyter Notebook / Google Colab / VS Code
| 1
|-
| 10
| Pandas, NumPy, Matplotlib and Scikit-learn libraries
| 1
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. In an IoT system, sensor data can be transmitted to a cloud platform for storage and further processing.

In this experiment, a DHT11 sensor is connected to an ESP32 development board. The DHT11 measures the temperature of the surrounding environment and provides the sensor reading to the ESP32. The ESP32 uses its built-in Wi-Fi capability to transmit the collected temperature data to the Cognifront Cloud platform.

The collected temperature readings are stored on the cloud platform and can be exported as a CSV file. The historical temperature data is then used as input for a machine learning model.

'''Machine Learning (ML)''' is a branch of artificial intelligence in which computer systems learn patterns from data and use those patterns to make predictions or decisions without being explicitly programmed for every individual case.

For temperature prediction, historical sensor readings can be used to train a machine learning model. The model learns the relationship between the input data and the corresponding temperature values. After training, the model can be given a future time value and can estimate the corresponding temperature.

In this experiment, '''Linear Regression''' is used as the machine learning model. Linear Regression is a supervised machine learning algorithm used to model the relationship between an independent variable and a dependent variable.

The basic equation of Linear Regression is:

<pre>
y = mx + c
</pre>

where:

* '''y''' is the predicted temperature.
* '''x''' is the input time or time index.
* '''m''' is the slope of the regression line.
* '''c''' is the intercept.

For this experiment, the timestamp of each temperature reading is converted into a numerical time representation or time index. The machine learning model uses the historical time and temperature relationship to predict future temperature values.

The overall system consists of two major stages:

'''Stage 1 — IoT Data Collection'''

<pre>
DHT11 Sensor
↓
ESP32
↓
Wi-Fi
↓
Cognifront Cloud
↓
Temperature CSV
</pre>

'''Stage 2 — Machine Learning Prediction'''

<pre>
Historical Temperature CSV
↓
Data Preprocessing
↓
Feature Preparation
↓
Train-Test Split
↓
Linear Regression
↓
Future Prediction
↓
Actual vs Predicted Graph
</pre>

The accuracy of the prediction depends on the amount and quality of historical sensor data and the behavior of the temperature during the data-collection period. A simple Linear Regression model is suitable for demonstrating the machine learning workflow, but more advanced models may be required for complex temperature patterns.

== DHT11 and ESP32 Pin Connections ==

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| VCC
| 3.3V
| Power supply
|-
| DATA
| GPIO 4
| Digital temperature and humidity data
|-
| GND
| GND
| Ground connection
|}

'''Note:''' The DATA pin can be connected to another suitable ESP32 GPIO if the program is modified accordingly.

== IoT Data Collection Program ==

The ESP32 is programmed to read the temperature from the DHT11 and transmit the sensor data to the Cognifront Cloud platform.

A typical data collection program follows the same cloud communication mechanism used in the previous experiment.

<pre>
#include "cogcloudesp.h"
#include "DHT.h"

#define DHT_PIN 4
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);

String ssid = "********";
String pass = "********";
String apikey = "YOUR_API_KEY_HERE";

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

dht.begin();

cogInitCloud(ssid, pass, apikey);
}

void loop()
{
cogAppLoop();

float temperature = dht.readTemperature();

if (isnan(temperature))
{
Serial.println("Failed to read temperature");
delay(2000);
return;
}

Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");

cogStoreCloudVariable(
"DHT-Temp",
String(temperature, 2)
);

delay(2000);
}
</pre>

== Machine Learning Program ==

The following Python program loads the temperature dataset exported from the Cognifront Cloud platform, preprocesses the data, trains a Linear Regression model and predicts future temperature values.

Install the required libraries if they are not already available:

<pre>
pip install pandas numpy matplotlib scikit-learn
</pre>

The following program can be executed using Jupyter Notebook, Google Colab or VS Code.

<pre>
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# Load the IoT temperature dataset
df = pd.read_csv("dht11-data-logger-dht-temp.csv")

print("Original Dataset")
print(df.head())

# Convert Date column to datetime
df["Date"] = pd.to_datetime(
df["Date"],
errors="coerce"
)

# Convert temperature values to numeric
df["Value"] = pd.to_numeric(
df["Value"],
errors="coerce"
)

# Remove invalid records
df = df.dropna(
subset=["Date", "Value"]
)

# Sort data according to time
df = df.sort_values("Date")

# Create a time index
df["Time_Index"] = np.arange(len(df))

# Input and output variables
X = df[["Time_Index"]]
y = df["Value"]

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
X,
y,
test_size=0.2,
random_state=42
)

# Create Linear Regression model
model = LinearRegression()

# Train the model
model.fit(X_train, y_train)

# Predict test values
y_pred = model.predict(X_test)

# Calculate evaluation metrics
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print("\nModel Evaluation")
print("MAE:", mae)
print("MSE:", mse)
print("RMSE:", rmse)
print("R2 Score:", r2)

# Predict future temperature values
future_steps = 10

last_index = df["Time_Index"].max()

future_index = np.arange(
last_index + 1,
last_index + 1 + future_steps
)

future_df = pd.DataFrame({
"Time_Index": future_index
})

future_predictions = model.predict(
future_df[["Time_Index"]]
)

future_df["Predicted_Temperature"] = future_predictions

print("\nFuture Temperature Predictions")
print(future_df)

# Plot actual temperature data
plt.figure(figsize=(10, 5))

plt.plot(
df["Time_Index"],
df["Value"],
label="Actual Temperature"
)

# Plot regression prediction
plt.plot(
X_test["Time_Index"],
y_pred,
label="Predicted Temperature"
)

plt.xlabel("Time Index")
plt.ylabel("Temperature (°C)")
plt.title("Actual vs Predicted Temperature")
plt.legend()
plt.tight_layout()
plt.show()

# Plot future predictions
plt.figure(figsize=(10, 5))

plt.plot(
df["Time_Index"],
df["Value"],
label="Historical Temperature"
)

plt.plot(
future_df["Time_Index"],
future_df["Predicted_Temperature"],
label="Future Prediction"
)

plt.xlabel("Time Index")
plt.ylabel("Temperature (°C)")
plt.title("Future Temperature Prediction")
plt.legend()
plt.tight_layout()
plt.show()
</pre>

== Code Explanation ==

* '''pd.read_csv():''' Loads the historical IoT temperature dataset from the CSV file.
* '''pd.to_datetime():''' Converts the Date column into a date-time format.
* '''pd.to_numeric():''' Converts the temperature values into numerical data.
* '''dropna():''' Removes records with invalid or missing date or temperature values.
* '''sort_values():''' Arranges the sensor readings chronologically.
* '''Time_Index:''' Creates a numerical representation of the sequence of temperature readings.
* '''train_test_split():''' Divides the dataset into training and testing subsets.
* '''LinearRegression():''' Creates the Linear Regression machine learning model.
* '''fit():''' Trains the model using the training data.
* '''predict():''' Generates temperature predictions using the trained model.
* '''MAE:''' Measures the average absolute difference between actual and predicted temperature values.
* '''MSE:''' Measures the average squared difference between actual and predicted values.
* '''RMSE:''' Represents the square root of the Mean Squared Error and indicates the typical prediction error in the same unit as temperature.
* '''R² Score:''' Indicates how well the model explains the variation in the target temperature values.
* '''future_index:''' Generates future time-index values for prediction.
* '''future_predictions:''' Contains the temperature values predicted by the trained model.
* '''plt.plot():''' Creates graphs showing the actual, predicted and future temperature values.

== Procedure ==

# Connect the DHT11 sensor to the ESP32 according to the pin connection table.
# Connect the ESP32 to the computer using a USB cable.
# Configure the Wi-Fi network and Cognifront Cloud API key in the ESP32 program.
# Upload the IoT data collection program to the ESP32.
# Allow the ESP32 to collect temperature readings from the DHT11 sensor.
# Verify that the temperature readings are being transmitted to the Cognifront Cloud platform.
# Collect a sufficient number of temperature readings.
# Export the collected sensor data from the cloud platform as a CSV file.
# Open Jupyter Notebook, Google Colab or VS Code.
# Install the required Python libraries.
# Load the exported temperature dataset using Pandas.
# Convert the Date and Value columns into suitable data types.
# Remove invalid or missing records.
# Sort the dataset according to the timestamp.
# Create a numerical time index for the machine learning model.
# Divide the dataset into training and testing subsets.
# Create and train the Linear Regression model.
# Predict the temperature values for the testing dataset.
# Calculate the MAE, MSE, RMSE and R² evaluation metrics.
# Generate future time-index values.
# Use the trained model to predict future temperature values.
# Plot the actual and predicted temperature values.
# Plot the future temperature predictions.
# Observe the performance of the machine learning model.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Parameter
! Observation
|-
| 1
| Sensor
| DHT11
|-
| 2
| IoT device
| ESP32
|-
| 3
| Communication
| Wi-Fi
|-
| 4
| Cloud platform
| Cognifront Cloud
|-
| 5
| Dataset
| DHT11 temperature CSV dataset
|-
| 6
| Machine learning model
| Linear Regression
|-
| 7
| Training data
| Record the number of training samples
|-
| 8
| Testing data
| Record the number of testing samples
|-
| 9
| MAE
| Record the calculated value
|-
| 10
| RMSE
| Record the calculated value
|-
| 11
| R² Score
| Record the calculated value
|-
| 12
| Future temperature
| Record the predicted values
|}

An illustrative output may appear as:

<pre>
Model Evaluation
MAE: [calculated value]
MSE: [calculated value]
RMSE: [calculated value]
R2 Score: [calculated value]

Future Temperature Predictions

Time_Index Predicted_Temperature
0 ... ...
1 ... ...
2 ... ...
</pre>

The actual values depend on the temperature dataset collected from the IoT sensor.

== Result ==

The IoT application successfully collected temperature data from the DHT11 sensor using the ESP32 and transmitted the data to the Cognifront Cloud platform. The collected sensor data was exported as a CSV dataset and used to train a Linear Regression machine learning model. The trained model was used to predict future temperature values, and the actual and predicted temperature values were visualized.

== Viva Questions ==

# What is an IoT system?
# What is the role of the DHT11 sensor in this experiment?
# Why is an ESP32 used as the IoT device?
# How is the sensor data transmitted to the cloud?
# What is machine learning?
# What is supervised learning?
# What is Linear Regression?
# What are the independent and dependent variables in this experiment?
# Why is the timestamp converted into a numerical time index?
# What is the purpose of splitting the dataset into training and testing data?
# What is the purpose of the training dataset?
# What is the purpose of the testing dataset?
# What is MAE?
# What is MSE?
# What is RMSE?
# What does the R² score represent?
# What is the difference between prediction and actual sensor measurement?
# Why is historical sensor data required for machine learning?
# What factors can affect the accuracy of temperature prediction?
# Why might Linear Regression not perform well for rapidly changing temperature data?
# How could the prediction system be improved using another machine learning model?

MDM331AID/Experiment 9

2026-10-07T06:53:27Z

CogWikiEditor: /* Code Explanation */

= Experiment: Perform Data Cleaning, Normalization, and Visualization on IoT Sensor Dataset =

== Aim ==
To perform data cleaning, normalization, and visualization on an IoT sensor dataset and prepare the data for further analysis.

== Objectives ==
* To understand the importance of data preprocessing in IoT applications.
* To inspect and identify missing, duplicate, inconsistent, and anomalous sensor data.
* To clean an IoT sensor dataset using appropriate data-cleaning techniques.
* To normalize sensor values to a standard numerical range.
* To visualize sensor data using suitable graphs.
* To compare the dataset before and after data cleaning and normalization.
* To understand how data preprocessing improves the quality and usability of IoT sensor data.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| Computer or laptop
| 1
|-
| 2
| IoT sensor dataset in CSV format
| 1
|-
| 3
| Python
| 1
|-
| 4
| Jupyter Notebook / Google Colab / Python IDE
| 1
|-
| 5
| Pandas library
| 1
|-
| 6
| NumPy library
| 1
|-
| 7
| Matplotlib library
| 1
|}

== Theory ==

'''Data preprocessing''' is the process of preparing raw data for analysis by identifying and correcting problems such as missing values, duplicate records, incorrect data types, inconsistent values, and anomalous observations.

IoT systems continuously generate sensor data. The collected data may contain errors due to sensor limitations, communication problems, transmission errors, incorrect entries, or abnormal operating conditions. Therefore, raw IoT data should be cleaned and transformed before it is used for analysis or visualization.

The main stages of data preprocessing performed in this experiment are:

* '''Data inspection:''' Examining the structure, columns, data types, number of records, and statistical properties of the dataset.
* '''Data cleaning:''' Identifying and handling missing values, duplicate records, invalid values, and anomalous observations.
* '''Data transformation:''' Converting data into suitable formats for analysis, such as converting timestamp values into a proper date-time format.
* '''Data normalization:''' Scaling numerical sensor values to a standard range so that they can be compared and processed more easily.
* '''Data visualization:''' Representing the processed data graphically to identify patterns, trends, variations, and anomalies.

The dataset used in this experiment is an IoT temperature dataset obtained from the Cognifront cloud platform. The dataset contains the following fields:

{| class="wikitable"
|-
! Column
! Description
|-
| ID
| Unique record identifier generated for the sensor data record
|-
| Name
| Name of the sensor variable. In this dataset, it is DHT-Temp
|-
| Value
| Temperature value recorded by the sensor
|-
| Date
| Date and time at which the sensor reading was recorded
|}

The original dataset contains '''547 records''' and four columns: ID, Name, Value and Date. The Value column contains temperature readings, while the Date column contains the corresponding timestamps.

'''Missing values''' are records where one or more required fields contain no valid value. Missing values may be removed or replaced depending on the nature of the dataset and the purpose of the analysis.

'''Duplicate records''' are repeated records that contain the same data more than once. Duplicate records can occur because of repeated data transmission or storage operations and may need to be removed.

'''Anomalies''' are observations that differ significantly from the normal pattern of the dataset. In a temperature dataset, an unusually high or low value may represent a sensor error, transmission error, or abnormal environmental condition. Anomalies should be investigated before deciding whether they should be removed, corrected, or retained.

'''Normalization''' is the process of transforming numerical values to a common scale. In this experiment, Min-Max normalization is used to transform the temperature values into the range 0 to 1.

The Min-Max normalization formula is:

<pre>
Normalized Value = (X - Xmin) / (Xmax - Xmin)
</pre>

where:

* '''X''' is the original sensor value.
* '''Xmin''' is the minimum value in the dataset.
* '''Xmax''' is the maximum value in the dataset.

After normalization, the smallest value becomes 0 and the largest value becomes 1.

'''Data visualization''' is used to represent the processed sensor data graphically. A line graph can be used to show temperature variation with time, while a histogram can be used to observe the distribution of temperature values.

The overall data-processing flow is:

<pre>
Raw IoT CSV Dataset
↓
Data Inspection
↓
Data Cleaning
↓
Data Transformation
↓
Normalization
↓
Visualization
↓
Processed Dataset
</pre>

== Dataset Used ==

The dataset used for this experiment is a DHT11 temperature dataset exported from the Cognifront cloud platform.

The original dataset contains:

{| class="wikitable"
|-
! Parameter
! Value
|-
| Number of records
| 547
|-
| Number of columns
| 4
|-
| Sensor variable
| DHT-Temp
|-
| Minimum temperature
| 27.1 °C
|-
| Maximum temperature
| 27.8 °C
|-
| Missing values
| None in the original dataset
|-
| Duplicate timestamps
| None in the original dataset
|}

== Program ==

Install the required Python libraries before running the program.

<pre>
pip install pandas numpy matplotlib
</pre>

The following program loads the IoT dataset, inspects the data, performs data cleaning, normalizes the temperature values using Min-Max normalization, and generates visualizations.

<pre>
from google.colab import files
dht_data = files.upload()

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# Load the dataset
df = pd.read_csv('anomalous-dht11-data.csv')

print("Original Dataset")
print(df.head())

print("\nDataset Information")
print(df.info())

print("\nMissing Values")
print(df.isnull().sum())

print("\nDuplicate Records")
print(df.duplicated().sum())

print("\nStatistical Summary")
print(df.describe())

# Convert Date column to datetime
df["Date"] = pd.to_datetime(df["Date"], errors="coerce")

# Convert Value column to numeric
df["Value"] = pd.to_numeric(df["Value"], errors="coerce")

# Remove rows with missing required values
df = df.dropna(subset=["ID", "Name", "Value", "Date"])

# Remove duplicate records
df = df.drop_duplicates()

"""# Now to remove *outliers*, we will use 2 methods:

1. Using IQR (Interquartile Range) method
2. Using Domain-based method

For our particular dataset, you will see why Domain-based method is more applicable by looking at the output of IQR method.

**1) IQR (Interquartile Range) method**
"""

# Detect temperature outliers using IQR
Q1 = df["Value"].quantile(0.25)
Q3 = df["Value"].quantile(0.75)
IQR = Q3 - Q1

lower_limit = Q1 - 1.5 * IQR
upper_limit = Q3 + 1.5 * IQR

outliers = df[
(df["Value"] < lower_limit) |
(df["Value"] > upper_limit)
]

print("\nDetected Outliers")
print(outliers)

# Remove detected outliers
df_clean = df[
(df["Value"] >= lower_limit) &
(df["Value"] <= upper_limit)
].copy()

"""**2) Domain-based method**"""

lower_limit = 15
upper_limit = 50

df_clean = df[
(df["Value"] >= lower_limit) &
(df["Value"] <= upper_limit)
].copy()

# Min-Max normalization
min_value = df_clean["Value"].min()
max_value = df_clean["Value"].max()

df_clean["Normalized_Value"] = (
(df_clean["Value"] - min_value) /
(max_value - min_value)
)

# Save cleaned and normalized dataset
df_clean.to_csv(
"cleaned_normalized_dht11_data.csv",
index=False
)

print("\nCleaned Dataset")
print(df_clean.head())

print("\nNormalized Dataset")
print(df_clean[["Value", "Normalized_Value"]].head())

# Visualization 1: Temperature vs Time
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Temperature (°C)")
plt.title("DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Visualization 2: Temperature distribution
plt.figure(figsize=(8, 5))

plt.hist(
df_clean["Value"],
bins=10
)

plt.xlabel("Temperature (°C)")
plt.ylabel("Frequency")
plt.title("Distribution of DHT11 Temperature Values")
plt.tight_layout()
plt.show()

# Visualization 3: Normalized temperature
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Normalized_Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Normalized Temperature")
plt.title("Normalized DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
</pre>

== Code Explanation ==

* '''files.upload():''' Opens a file-upload interface in Google Colab so that the IoT sensor CSV dataset can be uploaded.

* '''pd.read_csv():''' Loads the uploaded CSV dataset into a Pandas DataFrame.

* '''df.head():''' Displays the first few records of the dataset.

* '''df.info():''' Displays information about the columns, data types and number of non-null records.

* '''isnull().sum():''' Counts the number of missing values in each column.

* '''duplicated().sum():''' Counts the number of duplicate records in the dataset.

* '''df.describe():''' Displays statistical information such as count, mean, standard deviation, minimum and maximum values of numerical columns.

* '''pd.to_datetime():''' Converts the Date column into a proper date-time format. Invalid date values are converted to missing values using '''errors="coerce"'''.

* '''pd.to_numeric():''' Converts the Value column into numerical data. Invalid values are converted to missing values using '''errors="coerce"'''.

* '''dropna():''' Removes records containing missing values in the required ID, Name, Value or Date fields.

* '''drop_duplicates():''' Removes duplicate records from the dataset.

* '''Q1 and Q3:''' Represent the first and third quartiles of the temperature data and are used for IQR-based outlier detection.

* '''IQR:''' Represents the Interquartile Range and is calculated as Q3 − Q1.

* '''IQR outlier limits:''' Values below Q1 − 1.5 × IQR or above Q3 + 1.5 × IQR are identified as potential outliers.

* '''IQR outlier detection:''' Identifies and displays potential outliers using the statistical IQR method. In this experiment, the IQR method is demonstrated for comparison but is not used for the final cleaning because the normal temperature readings are closely clustered.

* '''Domain-based outlier detection:''' Defines an acceptable temperature range of 15 °C to 50 °C. Values outside this range are treated as anomalous temperature readings.

* '''df_clean:''' Stores the final cleaned dataset after applying the domain-based temperature limits.

* '''Min-Max normalization:''' Transforms the cleaned temperature values into the range 0 to 1 using the formula:

<pre>
Normalized Value = (X - Xmin) / (Xmax - Xmin)
</pre>

* '''to_csv():''' Saves the cleaned and normalized dataset as a new CSV file named '''cleaned_normalized_dht11_data.csv'''.

* '''plt.plot():''' Creates a line graph showing the variation of temperature with respect to date and time.

* '''plt.hist():''' Creates a histogram showing the distribution and frequency of the cleaned temperature values.

* '''Normalized temperature plot:''' Displays the normalized temperature values against time to show the sensor readings after Min-Max normalization.

== Procedure ==

# Obtain the DHT11 sensor dataset in CSV format from the Cognifront cloud platform.
# Make a copy of the original CSV file and use the copy for data-cleaning experiments.
# Open the Python environment such as Jupyter Notebook, Google Colab or a Python IDE.
# Install the required Pandas, NumPy and Matplotlib libraries.
# Load the CSV dataset using Pandas.
# Inspect the dataset and identify its columns, data types and number of records.
# Check the dataset for missing values.
# Check the dataset for duplicate records.
# Convert the Date column into the appropriate date-time format.
# Convert the sensor Value column into numerical format.
# Identify anomalous sensor values using statistical methods such as the IQR method.
# Remove or handle the identified invalid or anomalous records as required.
# Normalize the cleaned sensor values using Min-Max normalization.
# Save the cleaned and normalized dataset as a new CSV file.
# Plot the temperature values against time using a line graph.
# Plot the distribution of temperature values using a histogram.
# Plot the normalized temperature values against time.
# Compare the original and processed datasets and observe the effect of data cleaning and normalization.

== Introducing Manual Anomalies ==

The original Cognifront dataset is relatively clean. Therefore, for demonstrating data-cleaning techniques, controlled anomalies can be introduced into a '''copy''' of the original dataset.

'''Do not modify the original downloaded dataset.''' Keep the original file as the raw dataset and create a separate file such as:

<pre>
dht11-data-logger-dht-temp-anomalous.csv
</pre>

The following anomalies can be introduced for demonstration:

{| class="wikitable"
|-
! Anomaly
! Example
! Purpose
|-
| Missing value
| Replace a Value entry with an empty cell
| Demonstrates missing-value handling
|-
| Duplicate record
| Copy one complete row and insert it again
| Demonstrates duplicate detection
|-
| Extreme temperature
| Change one Value to 80 °C
| Demonstrates outlier detection
|-
| Very low temperature
| Change one Value to -20 °C
| Demonstrates anomalous-value detection
|-
| Invalid value
| Replace one Value with text such as "ERROR"
| Demonstrates invalid data handling
|}

For example, if the original data contains:

<pre>
296900,DHT-Temp,27.5,2026-10-07 08:49:35
</pre>

the Value can be changed to:

<pre>
296900,DHT-Temp,80,2026-10-07 08:49:35
</pre>

Similarly, another record can be changed to:

<pre>
296950,DHT-Temp,,2026-10-07 08:51:15
</pre>

to demonstrate a missing sensor value.

An existing row can also be copied and inserted again to create a duplicate record.

The modified dataset can then be processed using the Python program. The program should identify the missing, duplicate and anomalous records and produce a cleaned dataset.

'''Note:''' These manually introduced anomalies are artificial and are used only to demonstrate data-cleaning techniques. They should not be presented as actual errors produced by the DHT11 sensor or Cognifront cloud platform.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Operation
! Observation
|-
| 1
| Dataset inspection
| Dataset contains 547 records and 4 columns
|-
| 2
| Missing-value check
| Original dataset contains no missing values
|-
| 3
| Duplicate check
| Original dataset contains no duplicate records
|-
| 4
| Data type conversion
| Date converted to datetime and Value converted to numeric
|-
| 5
| Anomaly detection
| Artificial anomalous records are identified in the modified dataset
|-
| 6
| Data cleaning
| Missing, duplicate and anomalous records are handled
|-
| 7
| Normalization
| Temperature values are converted to the range 0 to 1
|-
| 8
| Visualization
| Temperature variation and distribution are represented graphically
|-
| 9
| CSV export
| Cleaned and normalized data is saved as a new CSV file
|}

== Result ==

The IoT sensor dataset was successfully inspected, cleaned and normalized using Python. Missing values, duplicate records and anomalous sensor readings were identified and handled. The temperature values were normalized using Min-Max normalization, and the processed data was visualized using suitable graphs. The cleaned and normalized dataset was successfully exported as a CSV file.

== Viva Questions ==

# What is data preprocessing?
# Why is data cleaning required for IoT sensor data?
# What is the difference between raw data and cleaned data?
# What is a missing value?
# What is a duplicate record?
# What is an anomaly in a sensor dataset?
# Why are artificial anomalies introduced during this experiment?
# What is the IQR method?
# How is an outlier detected using the IQR method?
# What is data normalization?
# What is Min-Max normalization?
# What is the range of values produced by Min-Max normalization?
# Why is the Date column converted into datetime format?
# What is the purpose of the Pandas library?
# What is the purpose of NumPy?
# What is Matplotlib used for?
# What is the purpose of a histogram?
# What information can be obtained from a line graph of sensor data?
# Why should the original dataset be preserved before data cleaning?
# Why should manually introduced anomalies not be considered actual sensor errors?
# What is the purpose of exporting the processed dataset as a CSV file?

MDM331AID/Experiment 9

2026-10-07T06:49:31Z

CogWikiEditor: /* Program */

= Experiment: Perform Data Cleaning, Normalization, and Visualization on IoT Sensor Dataset =

== Aim ==
To perform data cleaning, normalization, and visualization on an IoT sensor dataset and prepare the data for further analysis.

== Objectives ==
* To understand the importance of data preprocessing in IoT applications.
* To inspect and identify missing, duplicate, inconsistent, and anomalous sensor data.
* To clean an IoT sensor dataset using appropriate data-cleaning techniques.
* To normalize sensor values to a standard numerical range.
* To visualize sensor data using suitable graphs.
* To compare the dataset before and after data cleaning and normalization.
* To understand how data preprocessing improves the quality and usability of IoT sensor data.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| Computer or laptop
| 1
|-
| 2
| IoT sensor dataset in CSV format
| 1
|-
| 3
| Python
| 1
|-
| 4
| Jupyter Notebook / Google Colab / Python IDE
| 1
|-
| 5
| Pandas library
| 1
|-
| 6
| NumPy library
| 1
|-
| 7
| Matplotlib library
| 1
|}

== Theory ==

'''Data preprocessing''' is the process of preparing raw data for analysis by identifying and correcting problems such as missing values, duplicate records, incorrect data types, inconsistent values, and anomalous observations.

IoT systems continuously generate sensor data. The collected data may contain errors due to sensor limitations, communication problems, transmission errors, incorrect entries, or abnormal operating conditions. Therefore, raw IoT data should be cleaned and transformed before it is used for analysis or visualization.

The main stages of data preprocessing performed in this experiment are:

* '''Data inspection:''' Examining the structure, columns, data types, number of records, and statistical properties of the dataset.
* '''Data cleaning:''' Identifying and handling missing values, duplicate records, invalid values, and anomalous observations.
* '''Data transformation:''' Converting data into suitable formats for analysis, such as converting timestamp values into a proper date-time format.
* '''Data normalization:''' Scaling numerical sensor values to a standard range so that they can be compared and processed more easily.
* '''Data visualization:''' Representing the processed data graphically to identify patterns, trends, variations, and anomalies.

The dataset used in this experiment is an IoT temperature dataset obtained from the Cognifront cloud platform. The dataset contains the following fields:

{| class="wikitable"
|-
! Column
! Description
|-
| ID
| Unique record identifier generated for the sensor data record
|-
| Name
| Name of the sensor variable. In this dataset, it is DHT-Temp
|-
| Value
| Temperature value recorded by the sensor
|-
| Date
| Date and time at which the sensor reading was recorded
|}

The original dataset contains '''547 records''' and four columns: ID, Name, Value and Date. The Value column contains temperature readings, while the Date column contains the corresponding timestamps.

'''Missing values''' are records where one or more required fields contain no valid value. Missing values may be removed or replaced depending on the nature of the dataset and the purpose of the analysis.

'''Duplicate records''' are repeated records that contain the same data more than once. Duplicate records can occur because of repeated data transmission or storage operations and may need to be removed.

'''Anomalies''' are observations that differ significantly from the normal pattern of the dataset. In a temperature dataset, an unusually high or low value may represent a sensor error, transmission error, or abnormal environmental condition. Anomalies should be investigated before deciding whether they should be removed, corrected, or retained.

'''Normalization''' is the process of transforming numerical values to a common scale. In this experiment, Min-Max normalization is used to transform the temperature values into the range 0 to 1.

The Min-Max normalization formula is:

<pre>
Normalized Value = (X - Xmin) / (Xmax - Xmin)
</pre>

where:

* '''X''' is the original sensor value.
* '''Xmin''' is the minimum value in the dataset.
* '''Xmax''' is the maximum value in the dataset.

After normalization, the smallest value becomes 0 and the largest value becomes 1.

'''Data visualization''' is used to represent the processed sensor data graphically. A line graph can be used to show temperature variation with time, while a histogram can be used to observe the distribution of temperature values.

The overall data-processing flow is:

<pre>
Raw IoT CSV Dataset
↓
Data Inspection
↓
Data Cleaning
↓
Data Transformation
↓
Normalization
↓
Visualization
↓
Processed Dataset
</pre>

== Dataset Used ==

The dataset used for this experiment is a DHT11 temperature dataset exported from the Cognifront cloud platform.

The original dataset contains:

{| class="wikitable"
|-
! Parameter
! Value
|-
| Number of records
| 547
|-
| Number of columns
| 4
|-
| Sensor variable
| DHT-Temp
|-
| Minimum temperature
| 27.1 °C
|-
| Maximum temperature
| 27.8 °C
|-
| Missing values
| None in the original dataset
|-
| Duplicate timestamps
| None in the original dataset
|}

== Program ==

Install the required Python libraries before running the program.

<pre>
pip install pandas numpy matplotlib
</pre>

The following program loads the IoT dataset, inspects the data, performs data cleaning, normalizes the temperature values using Min-Max normalization, and generates visualizations.

<pre>
from google.colab import files
dht_data = files.upload()

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# Load the dataset
df = pd.read_csv('anomalous-dht11-data.csv')

print("Original Dataset")
print(df.head())

print("\nDataset Information")
print(df.info())

print("\nMissing Values")
print(df.isnull().sum())

print("\nDuplicate Records")
print(df.duplicated().sum())

print("\nStatistical Summary")
print(df.describe())

# Convert Date column to datetime
df["Date"] = pd.to_datetime(df["Date"], errors="coerce")

# Convert Value column to numeric
df["Value"] = pd.to_numeric(df["Value"], errors="coerce")

# Remove rows with missing required values
df = df.dropna(subset=["ID", "Name", "Value", "Date"])

# Remove duplicate records
df = df.drop_duplicates()

"""# Now to remove *outliers*, we will use 2 methods:

1. Using IQR (Interquartile Range) method
2. Using Domain-based method

For our particular dataset, you will see why Domain-based method is more applicable by looking at the output of IQR method.

**1) IQR (Interquartile Range) method**
"""

# Detect temperature outliers using IQR
Q1 = df["Value"].quantile(0.25)
Q3 = df["Value"].quantile(0.75)
IQR = Q3 - Q1

lower_limit = Q1 - 1.5 * IQR
upper_limit = Q3 + 1.5 * IQR

outliers = df[
(df["Value"] < lower_limit) |
(df["Value"] > upper_limit)
]

print("\nDetected Outliers")
print(outliers)

# Remove detected outliers
df_clean = df[
(df["Value"] >= lower_limit) &
(df["Value"] <= upper_limit)
].copy()

"""**2) Domain-based method**"""

lower_limit = 15
upper_limit = 50

df_clean = df[
(df["Value"] >= lower_limit) &
(df["Value"] <= upper_limit)
].copy()

# Min-Max normalization
min_value = df_clean["Value"].min()
max_value = df_clean["Value"].max()

df_clean["Normalized_Value"] = (
(df_clean["Value"] - min_value) /
(max_value - min_value)
)

# Save cleaned and normalized dataset
df_clean.to_csv(
"cleaned_normalized_dht11_data.csv",
index=False
)

print("\nCleaned Dataset")
print(df_clean.head())

print("\nNormalized Dataset")
print(df_clean[["Value", "Normalized_Value"]].head())

# Visualization 1: Temperature vs Time
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Temperature (°C)")
plt.title("DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Visualization 2: Temperature distribution
plt.figure(figsize=(8, 5))

plt.hist(
df_clean["Value"],
bins=10
)

plt.xlabel("Temperature (°C)")
plt.ylabel("Frequency")
plt.title("Distribution of DHT11 Temperature Values")
plt.tight_layout()
plt.show()

# Visualization 3: Normalized temperature
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Normalized_Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Normalized Temperature")
plt.title("Normalized DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
</pre>

== Code Explanation ==

* '''pd.read_csv():''' Loads the IoT sensor dataset from the CSV file.
* '''df.info():''' Displays information about the columns, data types and number of non-null records.
* '''isnull().sum():''' Counts the missing values in each column.
* '''duplicated():''' Identifies duplicate records in the dataset.
* '''pd.to_datetime():''' Converts the Date column into a proper date-time format.
* '''pd.to_numeric():''' Converts the sensor Value column into numerical data.
* '''dropna():''' Removes records containing missing values in required fields.
* '''drop_duplicates():''' Removes duplicate records.
* '''Q1 and Q3:''' Represent the first and third quartiles of the temperature data.
* '''IQR:''' Represents the interquartile range and is calculated as Q3 − Q1.
* '''Outlier limits:''' Values outside Q1 − 1.5 × IQR and Q3 + 1.5 × IQR are identified as potential outliers.
* '''Min-Max normalization:''' Converts the temperature values into the range 0 to 1.
* '''to_csv():''' Saves the cleaned and normalized dataset as a new CSV file.
* '''plt.plot():''' Creates a line graph showing the variation of sensor values.
* '''plt.hist():''' Creates a histogram showing the distribution of temperature values.

== Procedure ==

# Obtain the DHT11 sensor dataset in CSV format from the Cognifront cloud platform.
# Make a copy of the original CSV file and use the copy for data-cleaning experiments.
# Open the Python environment such as Jupyter Notebook, Google Colab or a Python IDE.
# Install the required Pandas, NumPy and Matplotlib libraries.
# Load the CSV dataset using Pandas.
# Inspect the dataset and identify its columns, data types and number of records.
# Check the dataset for missing values.
# Check the dataset for duplicate records.
# Convert the Date column into the appropriate date-time format.
# Convert the sensor Value column into numerical format.
# Identify anomalous sensor values using statistical methods such as the IQR method.
# Remove or handle the identified invalid or anomalous records as required.
# Normalize the cleaned sensor values using Min-Max normalization.
# Save the cleaned and normalized dataset as a new CSV file.
# Plot the temperature values against time using a line graph.
# Plot the distribution of temperature values using a histogram.
# Plot the normalized temperature values against time.
# Compare the original and processed datasets and observe the effect of data cleaning and normalization.

== Introducing Manual Anomalies ==

The original Cognifront dataset is relatively clean. Therefore, for demonstrating data-cleaning techniques, controlled anomalies can be introduced into a '''copy''' of the original dataset.

'''Do not modify the original downloaded dataset.''' Keep the original file as the raw dataset and create a separate file such as:

<pre>
dht11-data-logger-dht-temp-anomalous.csv
</pre>

The following anomalies can be introduced for demonstration:

{| class="wikitable"
|-
! Anomaly
! Example
! Purpose
|-
| Missing value
| Replace a Value entry with an empty cell
| Demonstrates missing-value handling
|-
| Duplicate record
| Copy one complete row and insert it again
| Demonstrates duplicate detection
|-
| Extreme temperature
| Change one Value to 80 °C
| Demonstrates outlier detection
|-
| Very low temperature
| Change one Value to -20 °C
| Demonstrates anomalous-value detection
|-
| Invalid value
| Replace one Value with text such as "ERROR"
| Demonstrates invalid data handling
|}

For example, if the original data contains:

<pre>
296900,DHT-Temp,27.5,2026-10-07 08:49:35
</pre>

the Value can be changed to:

<pre>
296900,DHT-Temp,80,2026-10-07 08:49:35
</pre>

Similarly, another record can be changed to:

<pre>
296950,DHT-Temp,,2026-10-07 08:51:15
</pre>

to demonstrate a missing sensor value.

An existing row can also be copied and inserted again to create a duplicate record.

The modified dataset can then be processed using the Python program. The program should identify the missing, duplicate and anomalous records and produce a cleaned dataset.

'''Note:''' These manually introduced anomalies are artificial and are used only to demonstrate data-cleaning techniques. They should not be presented as actual errors produced by the DHT11 sensor or Cognifront cloud platform.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Operation
! Observation
|-
| 1
| Dataset inspection
| Dataset contains 547 records and 4 columns
|-
| 2
| Missing-value check
| Original dataset contains no missing values
|-
| 3
| Duplicate check
| Original dataset contains no duplicate records
|-
| 4
| Data type conversion
| Date converted to datetime and Value converted to numeric
|-
| 5
| Anomaly detection
| Artificial anomalous records are identified in the modified dataset
|-
| 6
| Data cleaning
| Missing, duplicate and anomalous records are handled
|-
| 7
| Normalization
| Temperature values are converted to the range 0 to 1
|-
| 8
| Visualization
| Temperature variation and distribution are represented graphically
|-
| 9
| CSV export
| Cleaned and normalized data is saved as a new CSV file
|}

== Result ==

The IoT sensor dataset was successfully inspected, cleaned and normalized using Python. Missing values, duplicate records and anomalous sensor readings were identified and handled. The temperature values were normalized using Min-Max normalization, and the processed data was visualized using suitable graphs. The cleaned and normalized dataset was successfully exported as a CSV file.

== Viva Questions ==

# What is data preprocessing?
# Why is data cleaning required for IoT sensor data?
# What is the difference between raw data and cleaned data?
# What is a missing value?
# What is a duplicate record?
# What is an anomaly in a sensor dataset?
# Why are artificial anomalies introduced during this experiment?
# What is the IQR method?
# How is an outlier detected using the IQR method?
# What is data normalization?
# What is Min-Max normalization?
# What is the range of values produced by Min-Max normalization?
# Why is the Date column converted into datetime format?
# What is the purpose of the Pandas library?
# What is the purpose of NumPy?
# What is Matplotlib used for?
# What is the purpose of a histogram?
# What information can be obtained from a line graph of sensor data?
# Why should the original dataset be preserved before data cleaning?
# Why should manually introduced anomalies not be considered actual sensor errors?
# What is the purpose of exporting the processed dataset as a CSV file?

MDM331AID/Experiment 9

2026-10-07T05:37:10Z

CogWikiEditor: Created page with "= Experiment: Perform Data Cleaning, Normalization, and Visualization on IoT Sensor Dataset = == Aim == To perform data cleaning, normalization, and visualization on an IoT sensor dataset and prepare the data for further analysis. == Objectives == * To understand the importance of data preprocessing in IoT applications. * To inspect and identify missing, duplicate, inconsistent, and anomalous sensor data. * To clean an IoT sensor dataset using appropriate data-cleaning..."

= Experiment: Perform Data Cleaning, Normalization, and Visualization on IoT Sensor Dataset =

== Aim ==
To perform data cleaning, normalization, and visualization on an IoT sensor dataset and prepare the data for further analysis.

== Objectives ==
* To understand the importance of data preprocessing in IoT applications.
* To inspect and identify missing, duplicate, inconsistent, and anomalous sensor data.
* To clean an IoT sensor dataset using appropriate data-cleaning techniques.
* To normalize sensor values to a standard numerical range.
* To visualize sensor data using suitable graphs.
* To compare the dataset before and after data cleaning and normalization.
* To understand how data preprocessing improves the quality and usability of IoT sensor data.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component / Software
! Quantity
|-
| 1
| Computer or laptop
| 1
|-
| 2
| IoT sensor dataset in CSV format
| 1
|-
| 3
| Python
| 1
|-
| 4
| Jupyter Notebook / Google Colab / Python IDE
| 1
|-
| 5
| Pandas library
| 1
|-
| 6
| NumPy library
| 1
|-
| 7
| Matplotlib library
| 1
|}

== Theory ==

'''Data preprocessing''' is the process of preparing raw data for analysis by identifying and correcting problems such as missing values, duplicate records, incorrect data types, inconsistent values, and anomalous observations.

IoT systems continuously generate sensor data. The collected data may contain errors due to sensor limitations, communication problems, transmission errors, incorrect entries, or abnormal operating conditions. Therefore, raw IoT data should be cleaned and transformed before it is used for analysis or visualization.

The main stages of data preprocessing performed in this experiment are:

* '''Data inspection:''' Examining the structure, columns, data types, number of records, and statistical properties of the dataset.
* '''Data cleaning:''' Identifying and handling missing values, duplicate records, invalid values, and anomalous observations.
* '''Data transformation:''' Converting data into suitable formats for analysis, such as converting timestamp values into a proper date-time format.
* '''Data normalization:''' Scaling numerical sensor values to a standard range so that they can be compared and processed more easily.
* '''Data visualization:''' Representing the processed data graphically to identify patterns, trends, variations, and anomalies.

The dataset used in this experiment is an IoT temperature dataset obtained from the Cognifront cloud platform. The dataset contains the following fields:

{| class="wikitable"
|-
! Column
! Description
|-
| ID
| Unique record identifier generated for the sensor data record
|-
| Name
| Name of the sensor variable. In this dataset, it is DHT-Temp
|-
| Value
| Temperature value recorded by the sensor
|-
| Date
| Date and time at which the sensor reading was recorded
|}

The original dataset contains '''547 records''' and four columns: ID, Name, Value and Date. The Value column contains temperature readings, while the Date column contains the corresponding timestamps.

'''Missing values''' are records where one or more required fields contain no valid value. Missing values may be removed or replaced depending on the nature of the dataset and the purpose of the analysis.

'''Duplicate records''' are repeated records that contain the same data more than once. Duplicate records can occur because of repeated data transmission or storage operations and may need to be removed.

'''Anomalies''' are observations that differ significantly from the normal pattern of the dataset. In a temperature dataset, an unusually high or low value may represent a sensor error, transmission error, or abnormal environmental condition. Anomalies should be investigated before deciding whether they should be removed, corrected, or retained.

'''Normalization''' is the process of transforming numerical values to a common scale. In this experiment, Min-Max normalization is used to transform the temperature values into the range 0 to 1.

The Min-Max normalization formula is:

<pre>
Normalized Value = (X - Xmin) / (Xmax - Xmin)
</pre>

where:

* '''X''' is the original sensor value.
* '''Xmin''' is the minimum value in the dataset.
* '''Xmax''' is the maximum value in the dataset.

After normalization, the smallest value becomes 0 and the largest value becomes 1.

'''Data visualization''' is used to represent the processed sensor data graphically. A line graph can be used to show temperature variation with time, while a histogram can be used to observe the distribution of temperature values.

The overall data-processing flow is:

<pre>
Raw IoT CSV Dataset
↓
Data Inspection
↓
Data Cleaning
↓
Data Transformation
↓
Normalization
↓
Visualization
↓
Processed Dataset
</pre>

== Dataset Used ==

The dataset used for this experiment is a DHT11 temperature dataset exported from the Cognifront cloud platform.

The original dataset contains:

{| class="wikitable"
|-
! Parameter
! Value
|-
| Number of records
| 547
|-
| Number of columns
| 4
|-
| Sensor variable
| DHT-Temp
|-
| Minimum temperature
| 27.1 °C
|-
| Maximum temperature
| 27.8 °C
|-
| Missing values
| None in the original dataset
|-
| Duplicate timestamps
| None in the original dataset
|}

== Program ==

Install the required Python libraries before running the program.

<pre>
pip install pandas numpy matplotlib
</pre>

The following program loads the IoT dataset, inspects the data, performs data cleaning, normalizes the temperature values using Min-Max normalization, and generates visualizations.

<pre>
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Load the dataset
df = pd.read_csv("dht11-data-logger-dht-temp.csv")

print("Original Dataset")
print(df.head())

print("\nDataset Information")
print(df.info())

print("\nMissing Values")
print(df.isnull().sum())

print("\nDuplicate Records")
print(df.duplicated().sum())

print("\nStatistical Summary")
print(df.describe())

# Convert Date column to datetime
df["Date"] = pd.to_datetime(df["Date"], errors="coerce")

# Convert Value column to numeric
df["Value"] = pd.to_numeric(df["Value"], errors="coerce")

# Remove rows with missing required values
df = df.dropna(subset=["ID", "Name", "Value", "Date"])

# Remove duplicate records
df = df.drop_duplicates()

# Detect temperature outliers using IQR
Q1 = df["Value"].quantile(0.25)
Q3 = df["Value"].quantile(0.75)

IQR = Q3 - Q1

lower_limit = Q1 - 1.5 * IQR
upper_limit = Q3 + 1.5 * IQR

outliers = df[
(df["Value"] < lower_limit) |
(df["Value"] > upper_limit)
]

print("\nDetected Outliers")
print(outliers)

# Remove detected outliers
df_clean = df[
(df["Value"] >= lower_limit) &
(df["Value"] <= upper_limit)
].copy()

# Min-Max normalization
min_value = df_clean["Value"].min()
max_value = df_clean["Value"].max()

df_clean["Normalized_Value"] = (
(df_clean["Value"] - min_value) /
(max_value - min_value)
)

# Save cleaned and normalized dataset
df_clean.to_csv(
"cleaned_normalized_dht11_data.csv",
index=False
)

print("\nCleaned Dataset")
print(df_clean.head())

print("\nNormalized Dataset")
print(df_clean[["Value", "Normalized_Value"]].head())

# Visualization 1: Temperature vs Time
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Temperature (°C)")
plt.title("DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Visualization 2: Temperature distribution
plt.figure(figsize=(8, 5))

plt.hist(
df_clean["Value"],
bins=10
)

plt.xlabel("Temperature (°C)")
plt.ylabel("Frequency")
plt.title("Distribution of DHT11 Temperature Values")
plt.tight_layout()
plt.show()

# Visualization 3: Normalized temperature
plt.figure(figsize=(10, 5))

plt.plot(
df_clean["Date"],
df_clean["Normalized_Value"]
)

plt.xlabel("Date and Time")
plt.ylabel("Normalized Temperature")
plt.title("Normalized DHT11 Temperature vs Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
</pre>

== Code Explanation ==

* '''pd.read_csv():''' Loads the IoT sensor dataset from the CSV file.
* '''df.info():''' Displays information about the columns, data types and number of non-null records.
* '''isnull().sum():''' Counts the missing values in each column.
* '''duplicated():''' Identifies duplicate records in the dataset.
* '''pd.to_datetime():''' Converts the Date column into a proper date-time format.
* '''pd.to_numeric():''' Converts the sensor Value column into numerical data.
* '''dropna():''' Removes records containing missing values in required fields.
* '''drop_duplicates():''' Removes duplicate records.
* '''Q1 and Q3:''' Represent the first and third quartiles of the temperature data.
* '''IQR:''' Represents the interquartile range and is calculated as Q3 − Q1.
* '''Outlier limits:''' Values outside Q1 − 1.5 × IQR and Q3 + 1.5 × IQR are identified as potential outliers.
* '''Min-Max normalization:''' Converts the temperature values into the range 0 to 1.
* '''to_csv():''' Saves the cleaned and normalized dataset as a new CSV file.
* '''plt.plot():''' Creates a line graph showing the variation of sensor values.
* '''plt.hist():''' Creates a histogram showing the distribution of temperature values.

== Procedure ==

# Obtain the DHT11 sensor dataset in CSV format from the Cognifront cloud platform.
# Make a copy of the original CSV file and use the copy for data-cleaning experiments.
# Open the Python environment such as Jupyter Notebook, Google Colab or a Python IDE.
# Install the required Pandas, NumPy and Matplotlib libraries.
# Load the CSV dataset using Pandas.
# Inspect the dataset and identify its columns, data types and number of records.
# Check the dataset for missing values.
# Check the dataset for duplicate records.
# Convert the Date column into the appropriate date-time format.
# Convert the sensor Value column into numerical format.
# Identify anomalous sensor values using statistical methods such as the IQR method.
# Remove or handle the identified invalid or anomalous records as required.
# Normalize the cleaned sensor values using Min-Max normalization.
# Save the cleaned and normalized dataset as a new CSV file.
# Plot the temperature values against time using a line graph.
# Plot the distribution of temperature values using a histogram.
# Plot the normalized temperature values against time.
# Compare the original and processed datasets and observe the effect of data cleaning and normalization.

== Introducing Manual Anomalies ==

The original Cognifront dataset is relatively clean. Therefore, for demonstrating data-cleaning techniques, controlled anomalies can be introduced into a '''copy''' of the original dataset.

'''Do not modify the original downloaded dataset.''' Keep the original file as the raw dataset and create a separate file such as:

<pre>
dht11-data-logger-dht-temp-anomalous.csv
</pre>

The following anomalies can be introduced for demonstration:

{| class="wikitable"
|-
! Anomaly
! Example
! Purpose
|-
| Missing value
| Replace a Value entry with an empty cell
| Demonstrates missing-value handling
|-
| Duplicate record
| Copy one complete row and insert it again
| Demonstrates duplicate detection
|-
| Extreme temperature
| Change one Value to 80 °C
| Demonstrates outlier detection
|-
| Very low temperature
| Change one Value to -20 °C
| Demonstrates anomalous-value detection
|-
| Invalid value
| Replace one Value with text such as "ERROR"
| Demonstrates invalid data handling
|}

For example, if the original data contains:

<pre>
296900,DHT-Temp,27.5,2026-10-07 08:49:35
</pre>

the Value can be changed to:

<pre>
296900,DHT-Temp,80,2026-10-07 08:49:35
</pre>

Similarly, another record can be changed to:

<pre>
296950,DHT-Temp,,2026-10-07 08:51:15
</pre>

to demonstrate a missing sensor value.

An existing row can also be copied and inserted again to create a duplicate record.

The modified dataset can then be processed using the Python program. The program should identify the missing, duplicate and anomalous records and produce a cleaned dataset.

'''Note:''' These manually introduced anomalies are artificial and are used only to demonstrate data-cleaning techniques. They should not be presented as actual errors produced by the DHT11 sensor or Cognifront cloud platform.

== Observations and Output ==

The following observations can be recorded during the experiment:

{| class="wikitable"
|-
! Sr. No.
! Operation
! Observation
|-
| 1
| Dataset inspection
| Dataset contains 547 records and 4 columns
|-
| 2
| Missing-value check
| Original dataset contains no missing values
|-
| 3
| Duplicate check
| Original dataset contains no duplicate records
|-
| 4
| Data type conversion
| Date converted to datetime and Value converted to numeric
|-
| 5
| Anomaly detection
| Artificial anomalous records are identified in the modified dataset
|-
| 6
| Data cleaning
| Missing, duplicate and anomalous records are handled
|-
| 7
| Normalization
| Temperature values are converted to the range 0 to 1
|-
| 8
| Visualization
| Temperature variation and distribution are represented graphically
|-
| 9
| CSV export
| Cleaned and normalized data is saved as a new CSV file
|}

== Result ==

The IoT sensor dataset was successfully inspected, cleaned and normalized using Python. Missing values, duplicate records and anomalous sensor readings were identified and handled. The temperature values were normalized using Min-Max normalization, and the processed data was visualized using suitable graphs. The cleaned and normalized dataset was successfully exported as a CSV file.

== Viva Questions ==

# What is data preprocessing?
# Why is data cleaning required for IoT sensor data?
# What is the difference between raw data and cleaned data?
# What is a missing value?
# What is a duplicate record?
# What is an anomaly in a sensor dataset?
# Why are artificial anomalies introduced during this experiment?
# What is the IQR method?
# How is an outlier detected using the IQR method?
# What is data normalization?
# What is Min-Max normalization?
# What is the range of values produced by Min-Max normalization?
# Why is the Date column converted into datetime format?
# What is the purpose of the Pandas library?
# What is the purpose of NumPy?
# What is Matplotlib used for?
# What is the purpose of a histogram?
# What information can be obtained from a line graph of sensor data?
# Why should the original dataset be preserved before data cleaning?
# Why should manually introduced anomalies not be considered actual sensor errors?
# What is the purpose of exporting the processed dataset as a CSV file?

MDM331AID/Experiment 8

2026-10-07T05:32:59Z

CogWikiEditor: /* Pin Connections */

= Experiment: Transmit sensor data between an IoT device and a server =

== Aim ==
To develop an IoT application that uses the communication protocol to transmit sensor data between an IoT device and a server

== Objectives ==
* To understand the concept of IoT-based sensor data communication.
* To interface an DHT11 temperature sensor with an ESP32 development board.
* To read temperature data from the DHT11 sensor using the ESP32.
* To connect the ESP32 to a Wi-Fi network and transmit sensor data to a cloud server.
* To store and log the transmitted sensor data in CSV format.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer with Arduino IDE
| 1
|-
| 7
| Cloud IoT platform / server (Cognifront IoT Cloud)
| 1 account per user/student
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT enables sensor data to be transmitted to a remote server or cloud platform for storage and monitoring.

An IoT-based sensor data transmission system generally consists of:
* '''Sensor:''' Measures physical parameters and provides the measured data to the IoT device. In this experiment, the DHT11 is used to measure temperature and humidity.
* '''IoT device / Controller:''' Reads the sensor data, processes it and provides network connectivity. In this experiment, the ESP32 acts as the IoT device.
* '''Communication network:''' Provides connectivity between the IoT device and the server or cloud platform. The ESP32 uses Wi-Fi for communication.
* '''Cloud server:''' Receives and stores the sensor data transmitted by the ESP32. The cloud platform used in this experiment provides facilities for storing the sensor data.
* '''Data storage:''' The collected sensor data can be stored on the server and exported in CSV format for further use.

'''DHT11''' is a digital temperature and humidity sensor that measures temperature and relative humidity. Unlike an analog temperature sensor such as the LM35, the DHT11 provides digital sensor data through its data pin. The sensor contains temperature and humidity sensing elements along with internal signal-processing circuitry.

The ESP32 communicates with the DHT11 through its digital data pin. It reads the temperature and humidity values from the sensor and processes the received data. The ESP32 then connects to a Wi-Fi network and transmits the sensor data to the cloud server using the configured cloud communication mechanism.

The cloud server receives the temperature and humidity readings and stores them as data records. In this experiment, the sensor readings are collected at regular intervals and stored on the server. The stored data can be exported as a '''CSV (Comma-Separated Values)''' file, allowing the collected sensor data to be saved in a standard tabular format.

The overall data flow of the system is:

<pre>
DHT11 Temperature & Humidity Sensor
↓
ESP32
↓
Wi-Fi
↓
Cloud Server
↓
Data Storage / CSV
</pre>

This type of IoT-based data logging system can be used for applications such as environmental monitoring, indoor temperature and humidity monitoring, weather monitoring and other systems where sensor measurements need to be collected remotely and stored for later use.

== Actions: ==
# Write ESP32 code to read temperature data from the DHT11 sensor and send it to a cloud server using Wi-Fi.
# Display this reading on a web-based dashboard in real-time.
# Download readings data in CSV format.

== Setting Up Cloud ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 15px; text-align: center;">

<div>
[[File:cloud-01.png|frameless|300px|alt=Step 1]]
<br /><b>Step 1</b><br />Visit [https://www.cognifront.com www.cognifront.com] and scroll down to the footer section.
</div>

<div>
[[File:cloud-02.png|frameless|300px|alt=Step 2]]
<br /><b>Step 2</b><br />Click on the <b>IoT Cloud</b> option.
</div>

<div>
[[File:cloud-03.png|frameless|300px|alt=Step 3]]
<br /><b>Step 3</b><br />Click on <i>Login</i> or <i>Sign Up / Registration</i> to access your account.
</div>

<div>
[[File:cloud-04.png|frameless|300px|alt=Step 4]]
<br /><b>Step 4</b><br />After logging in, navigate to the <b>Dashboard</b> section.
</div>

<div>
[[File:cloud-05.png|frameless|300px|alt=Step 5]]
<br /><b>Step 5</b><br />Click on <b>Create New App</b> to start a new cloud application.
</div>

<div>
[[File:cloud-06.png|frameless|300px|alt=Step 6]]
<br /><b>Step 6</b><br />Enter your app name — for example, <b>Data Logger</b>.
</div>

<div>
[[File:cloud-07.png|frameless|300px|alt=Step 7]]
<br /><b>Step 7</b><br />Your dashboard will update and display the newly created app.
</div>

<div>
[[File:cloud-08.png|frameless|300px|alt=Step 8]]
<br /><b>Step 8</b><br />Each app shows buttons for <i>Edit</i>, <i>Delete</i>, <i>Launch</i>, and <i>API Key</i>.
</div>

<div>
[[File:cloud-09.png|frameless|300px|alt=Step 9]]
<br /><b>Step 9</b><br />Click <b>Edit App</b> to open your app and create variables.
</div>

<div>
[[File:cloud-10.png|frameless|300px|alt=Step 10]]
<br /><b>Step 10</b><br />Click on <b>Create Variable</b> to define a new data variable.
</div>

<div>
[[File:cloud-11.png|frameless|300px|alt=Step 11]]
<br /><b>Step 11</b><br />Enter a variable name and select its type (defines input/output behavior).
</div>

<div>
[[File:cloud-12.png|frameless|300px|alt=Step 12]]
<br /><b>Step 12</b><br />For example: Name – <b>LM35</b>, Type – <b>Continuous</b>.
</div>

<div>
[[File:cloud-13.png|frameless|300px|alt=Step 13]]
<br /><b>Step 13</b><br />Return to the home page and click <b>View App</b> to launch your application.
Congratulations! Your cloud app is now ready.
</div>

<div>
[[File:cloud-14.png|frameless|400px|alt=Step 14]]
<br /><b>Step 14</b><br />Open the program folder — you will find two files:
<i>eecit-exp-06-data-logger.ino</i> (main program) and <i>cogcloudesp.h</i> (library header file).
Open the <b>.ino</b> file in Arduino IDE.
</div>

<div>
[[File:cloud-15.png|frameless|400px|alt=Step 15]]
<br /><b>Step 15</b><br />Ensure the <b>cogcloudesp.h</b> header file is included properly in your project.
</div>

<div>
[[File:cloud-16.png|frameless|300px|alt=Step 16]]
<br /><b>Step 16</b><br />Update your code with your Wi-Fi SSID, password, and API key.
A stable internet connection is required.
</div>

<div>
[[File:cloud-17.png|frameless|300px|alt=Step 17]]
<br /><b>Step 17</b><br />Change the variable name in your code to match the one you created in the cloud app.
</div>

<div>
[[File:code-esp32-upload-settings.png|frameless|300px|alt=Step 18]]
<br /><b>Step 18</b><br />Connect your ESP32 to your computer and upload the code.
</div>

<div>
[[File:cloud-19.png|frameless|300px|alt=Step 19]]
<br /><b>Step 19</b><br />Open or launch your cloud app to visualize real-time sensor data from the <b>LM35</b>.
</div>

<div>
[[File:cloud-20.png|frameless|300px|alt=Step 20]]
<br /><b>Step 20</b><br />In the app settings, click the <b>Download .CSV</b> button to export data.
</div>

<div>
[[File:cloud-21.png|frameless|300px|alt=Step 21]]
<br /><b>Step 21</b><br />Set the desired time range for data export, or leave it blank to download all records.
</div>

<div>
[[File:cloud-22.png|frameless|300px|alt=Step 22]]
<br /><b>Step 22</b><br />Open the downloaded <b>.CSV</b> file in Microsoft Excel to view the logged data.
</div>

</div>

== Circuit & Board Connections ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; text-align: center; align-items: start;">

<div>
[[File:eecit-esp32-06.png|frameless|400px|alt=Circuit Diagram]]
<br /><b>Circuit Diagram</b><br />
The complete connection diagram of ESP32-based setup.
</div>

<div>
[[File:eecit-kit-esp32-06.png|frameless|400px|alt=Board Connections]]
<br /><b>Board Connections</b><br />
Actual board wiring layout showing sensor and module connections.
</div>

</div>

== Pin Connections ==

The following connections are based on the ESP32 and DHT11 configuration used in the program.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| GND
| GND
| Ground connection
|-
| VCC
| VIN (5V supply)
| Power supply
|-
| DATA / VOUT
| GPIO4
| Analog temperature output
|}

The USB cable connects the ESP32 to the computer. The computer runs the Arduino IDE and uploads your code to ESP32.
<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your ESP32 from the computer while making or removing component connections.
</span>

== ESP32 Code ==
<pre>
// © 2026, Cognifront. Member of The IoT Kits Family.
//Experiment 6: Data Logging Using ESP32 and Excel (Cloud Communication)

#include "cogcloudesp.h"

//int cogLed = 15;
const int lm35_pin = 34;

String ssid = "********"; // wifi/hotspot name
String pass = "********"; // wifi/hotspot password 2.4 hz band only

String apikey = "YOUR_API_KEY_HERE"; // API key from app. Keep the "" (quotes)

void setup ()
{
// pinMode (cogLed,OUTPUT);
pinMode (lm35_pin, INPUT);

Serial.begin(115200);
while (!Serial)
delay(100);
cogInitCloud (ssid,pass,apikey);

// cogBindPin (cogLed, "LED");
}

void loop ()
{
cogAppLoop();

int voltage_mv = analogReadMilliVolts(lm35_pin);
float temp_val = voltage_mv / 10.0; // LM35 = 10 mV per °C

// Send value to cloud
cogStoreCloudVariable("LM35", String(temp_val, 2));

delay(2000);
}

</pre>

<div style="text-align: center; margin-top: 25px;">
[[:Media:eecit-exp-06-data-logger.zip|<span style="background-color:#007BFF;color:white;padding:10px 20px;border-radius:8px;text-decoration:none;font-weight:bold;">⬇ Click Here to Download Code File</span>]]
<br />
<span style="font-size: 90%;">(Contains ESP32 source code)</span>
<br />
[[File:Code-esp32-upload-settings.png|frameless|400px|alt=Board Connections]]
<br />
Connect your ESP32 to your computer and upload the code make sure right port selected.
</div>

== Observation ==
* The ESP32 successfully reads temperature data from the DHT11 sensor.
* Data is properly being logged in CSV file, and file is downloaded successfully.

== Conclusion ==
This experiment demonstrates how to log real-time sensor data from ESP32 to a computer using cloud communication.



== Real Life Example ==
Condition Monitoring in Machines and Data Logging: Sensors collect data such as vibration, temperature, or pressure from mechanical systems, which is logged and analysed for predictive maintenance and fault diagnosis. Also this data can be fed for training a machine learning model.

MDM331AID/Experiment 8

2026-10-07T05:31:04Z

CogWikiEditor: /* Real Life Example */

= Experiment: Transmit sensor data between an IoT device and a server =

== Aim ==
To develop an IoT application that uses the communication protocol to transmit sensor data between an IoT device and a server

== Objectives ==
* To understand the concept of IoT-based sensor data communication.
* To interface an DHT11 temperature sensor with an ESP32 development board.
* To read temperature data from the DHT11 sensor using the ESP32.
* To connect the ESP32 to a Wi-Fi network and transmit sensor data to a cloud server.
* To store and log the transmitted sensor data in CSV format.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer with Arduino IDE
| 1
|-
| 7
| Cloud IoT platform / server (Cognifront IoT Cloud)
| 1 account per user/student
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT enables sensor data to be transmitted to a remote server or cloud platform for storage and monitoring.

An IoT-based sensor data transmission system generally consists of:
* '''Sensor:''' Measures physical parameters and provides the measured data to the IoT device. In this experiment, the DHT11 is used to measure temperature and humidity.
* '''IoT device / Controller:''' Reads the sensor data, processes it and provides network connectivity. In this experiment, the ESP32 acts as the IoT device.
* '''Communication network:''' Provides connectivity between the IoT device and the server or cloud platform. The ESP32 uses Wi-Fi for communication.
* '''Cloud server:''' Receives and stores the sensor data transmitted by the ESP32. The cloud platform used in this experiment provides facilities for storing the sensor data.
* '''Data storage:''' The collected sensor data can be stored on the server and exported in CSV format for further use.

'''DHT11''' is a digital temperature and humidity sensor that measures temperature and relative humidity. Unlike an analog temperature sensor such as the LM35, the DHT11 provides digital sensor data through its data pin. The sensor contains temperature and humidity sensing elements along with internal signal-processing circuitry.

The ESP32 communicates with the DHT11 through its digital data pin. It reads the temperature and humidity values from the sensor and processes the received data. The ESP32 then connects to a Wi-Fi network and transmits the sensor data to the cloud server using the configured cloud communication mechanism.

The cloud server receives the temperature and humidity readings and stores them as data records. In this experiment, the sensor readings are collected at regular intervals and stored on the server. The stored data can be exported as a '''CSV (Comma-Separated Values)''' file, allowing the collected sensor data to be saved in a standard tabular format.

The overall data flow of the system is:

<pre>
DHT11 Temperature & Humidity Sensor
↓
ESP32
↓
Wi-Fi
↓
Cloud Server
↓
Data Storage / CSV
</pre>

This type of IoT-based data logging system can be used for applications such as environmental monitoring, indoor temperature and humidity monitoring, weather monitoring and other systems where sensor measurements need to be collected remotely and stored for later use.

== Actions: ==
# Write ESP32 code to read temperature data from the DHT11 sensor and send it to a cloud server using Wi-Fi.
# Display this reading on a web-based dashboard in real-time.
# Download readings data in CSV format.

== Setting Up Cloud ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 15px; text-align: center;">

<div>
[[File:cloud-01.png|frameless|300px|alt=Step 1]]
<br /><b>Step 1</b><br />Visit [https://www.cognifront.com www.cognifront.com] and scroll down to the footer section.
</div>

<div>
[[File:cloud-02.png|frameless|300px|alt=Step 2]]
<br /><b>Step 2</b><br />Click on the <b>IoT Cloud</b> option.
</div>

<div>
[[File:cloud-03.png|frameless|300px|alt=Step 3]]
<br /><b>Step 3</b><br />Click on <i>Login</i> or <i>Sign Up / Registration</i> to access your account.
</div>

<div>
[[File:cloud-04.png|frameless|300px|alt=Step 4]]
<br /><b>Step 4</b><br />After logging in, navigate to the <b>Dashboard</b> section.
</div>

<div>
[[File:cloud-05.png|frameless|300px|alt=Step 5]]
<br /><b>Step 5</b><br />Click on <b>Create New App</b> to start a new cloud application.
</div>

<div>
[[File:cloud-06.png|frameless|300px|alt=Step 6]]
<br /><b>Step 6</b><br />Enter your app name — for example, <b>Data Logger</b>.
</div>

<div>
[[File:cloud-07.png|frameless|300px|alt=Step 7]]
<br /><b>Step 7</b><br />Your dashboard will update and display the newly created app.
</div>

<div>
[[File:cloud-08.png|frameless|300px|alt=Step 8]]
<br /><b>Step 8</b><br />Each app shows buttons for <i>Edit</i>, <i>Delete</i>, <i>Launch</i>, and <i>API Key</i>.
</div>

<div>
[[File:cloud-09.png|frameless|300px|alt=Step 9]]
<br /><b>Step 9</b><br />Click <b>Edit App</b> to open your app and create variables.
</div>

<div>
[[File:cloud-10.png|frameless|300px|alt=Step 10]]
<br /><b>Step 10</b><br />Click on <b>Create Variable</b> to define a new data variable.
</div>

<div>
[[File:cloud-11.png|frameless|300px|alt=Step 11]]
<br /><b>Step 11</b><br />Enter a variable name and select its type (defines input/output behavior).
</div>

<div>
[[File:cloud-12.png|frameless|300px|alt=Step 12]]
<br /><b>Step 12</b><br />For example: Name – <b>LM35</b>, Type – <b>Continuous</b>.
</div>

<div>
[[File:cloud-13.png|frameless|300px|alt=Step 13]]
<br /><b>Step 13</b><br />Return to the home page and click <b>View App</b> to launch your application.
Congratulations! Your cloud app is now ready.
</div>

<div>
[[File:cloud-14.png|frameless|400px|alt=Step 14]]
<br /><b>Step 14</b><br />Open the program folder — you will find two files:
<i>eecit-exp-06-data-logger.ino</i> (main program) and <i>cogcloudesp.h</i> (library header file).
Open the <b>.ino</b> file in Arduino IDE.
</div>

<div>
[[File:cloud-15.png|frameless|400px|alt=Step 15]]
<br /><b>Step 15</b><br />Ensure the <b>cogcloudesp.h</b> header file is included properly in your project.
</div>

<div>
[[File:cloud-16.png|frameless|300px|alt=Step 16]]
<br /><b>Step 16</b><br />Update your code with your Wi-Fi SSID, password, and API key.
A stable internet connection is required.
</div>

<div>
[[File:cloud-17.png|frameless|300px|alt=Step 17]]
<br /><b>Step 17</b><br />Change the variable name in your code to match the one you created in the cloud app.
</div>

<div>
[[File:code-esp32-upload-settings.png|frameless|300px|alt=Step 18]]
<br /><b>Step 18</b><br />Connect your ESP32 to your computer and upload the code.
</div>

<div>
[[File:cloud-19.png|frameless|300px|alt=Step 19]]
<br /><b>Step 19</b><br />Open or launch your cloud app to visualize real-time sensor data from the <b>LM35</b>.
</div>

<div>
[[File:cloud-20.png|frameless|300px|alt=Step 20]]
<br /><b>Step 20</b><br />In the app settings, click the <b>Download .CSV</b> button to export data.
</div>

<div>
[[File:cloud-21.png|frameless|300px|alt=Step 21]]
<br /><b>Step 21</b><br />Set the desired time range for data export, or leave it blank to download all records.
</div>

<div>
[[File:cloud-22.png|frameless|300px|alt=Step 22]]
<br /><b>Step 22</b><br />Open the downloaded <b>.CSV</b> file in Microsoft Excel to view the logged data.
</div>

</div>

== Circuit & Board Connections ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; text-align: center; align-items: start;">

<div>
[[File:eecit-esp32-06.png|frameless|400px|alt=Circuit Diagram]]
<br /><b>Circuit Diagram</b><br />
The complete connection diagram of ESP32-based setup.
</div>

<div>
[[File:eecit-kit-esp32-06.png|frameless|400px|alt=Board Connections]]
<br /><b>Board Connections</b><br />
Actual board wiring layout showing sensor and module connections.
</div>

</div>

== Pin Connections ==

The following connections are based on the ESP32 and DHT11 configuration used in the program.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| GND
| GND
| Ground connection
|-
| VCC
| 3.3V
| Power supply
|-
| DATA / VOUT
| GPIO4
| Analog temperature output
|}

The USB cable connects the ESP32 to the computer. The computer runs the Arduino IDE and uploads your code to ESP32.
<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your ESP32 from the computer while making or removing component connections.
</span>

== ESP32 Code ==
<pre>
// © 2026, Cognifront. Member of The IoT Kits Family.
//Experiment 6: Data Logging Using ESP32 and Excel (Cloud Communication)

#include "cogcloudesp.h"

//int cogLed = 15;
const int lm35_pin = 34;

String ssid = "********"; // wifi/hotspot name
String pass = "********"; // wifi/hotspot password 2.4 hz band only

String apikey = "YOUR_API_KEY_HERE"; // API key from app. Keep the "" (quotes)

void setup ()
{
// pinMode (cogLed,OUTPUT);
pinMode (lm35_pin, INPUT);

Serial.begin(115200);
while (!Serial)
delay(100);
cogInitCloud (ssid,pass,apikey);

// cogBindPin (cogLed, "LED");
}

void loop ()
{
cogAppLoop();

int voltage_mv = analogReadMilliVolts(lm35_pin);
float temp_val = voltage_mv / 10.0; // LM35 = 10 mV per °C

// Send value to cloud
cogStoreCloudVariable("LM35", String(temp_val, 2));

delay(2000);
}

</pre>

<div style="text-align: center; margin-top: 25px;">
[[:Media:eecit-exp-06-data-logger.zip|<span style="background-color:#007BFF;color:white;padding:10px 20px;border-radius:8px;text-decoration:none;font-weight:bold;">⬇ Click Here to Download Code File</span>]]
<br />
<span style="font-size: 90%;">(Contains ESP32 source code)</span>
<br />
[[File:Code-esp32-upload-settings.png|frameless|400px|alt=Board Connections]]
<br />
Connect your ESP32 to your computer and upload the code make sure right port selected.
</div>

== Observation ==
* The ESP32 successfully reads temperature data from the DHT11 sensor.
* Data is properly being logged in CSV file, and file is downloaded successfully.

== Conclusion ==
This experiment demonstrates how to log real-time sensor data from ESP32 to a computer using cloud communication.



== Real Life Example ==
Condition Monitoring in Machines and Data Logging: Sensors collect data such as vibration, temperature, or pressure from mechanical systems, which is logged and analysed for predictive maintenance and fault diagnosis. Also this data can be fed for training a machine learning model.

MDM331AID/Experiment 8

2026-10-07T05:30:20Z

CogWikiEditor: /* Observation */

= Experiment: Transmit sensor data between an IoT device and a server =

== Aim ==
To develop an IoT application that uses the communication protocol to transmit sensor data between an IoT device and a server

== Objectives ==
* To understand the concept of IoT-based sensor data communication.
* To interface an DHT11 temperature sensor with an ESP32 development board.
* To read temperature data from the DHT11 sensor using the ESP32.
* To connect the ESP32 to a Wi-Fi network and transmit sensor data to a cloud server.
* To store and log the transmitted sensor data in CSV format.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer with Arduino IDE
| 1
|-
| 7
| Cloud IoT platform / server (Cognifront IoT Cloud)
| 1 account per user/student
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT enables sensor data to be transmitted to a remote server or cloud platform for storage and monitoring.

An IoT-based sensor data transmission system generally consists of:
* '''Sensor:''' Measures physical parameters and provides the measured data to the IoT device. In this experiment, the DHT11 is used to measure temperature and humidity.
* '''IoT device / Controller:''' Reads the sensor data, processes it and provides network connectivity. In this experiment, the ESP32 acts as the IoT device.
* '''Communication network:''' Provides connectivity between the IoT device and the server or cloud platform. The ESP32 uses Wi-Fi for communication.
* '''Cloud server:''' Receives and stores the sensor data transmitted by the ESP32. The cloud platform used in this experiment provides facilities for storing the sensor data.
* '''Data storage:''' The collected sensor data can be stored on the server and exported in CSV format for further use.

'''DHT11''' is a digital temperature and humidity sensor that measures temperature and relative humidity. Unlike an analog temperature sensor such as the LM35, the DHT11 provides digital sensor data through its data pin. The sensor contains temperature and humidity sensing elements along with internal signal-processing circuitry.

The ESP32 communicates with the DHT11 through its digital data pin. It reads the temperature and humidity values from the sensor and processes the received data. The ESP32 then connects to a Wi-Fi network and transmits the sensor data to the cloud server using the configured cloud communication mechanism.

The cloud server receives the temperature and humidity readings and stores them as data records. In this experiment, the sensor readings are collected at regular intervals and stored on the server. The stored data can be exported as a '''CSV (Comma-Separated Values)''' file, allowing the collected sensor data to be saved in a standard tabular format.

The overall data flow of the system is:

<pre>
DHT11 Temperature & Humidity Sensor
↓
ESP32
↓
Wi-Fi
↓
Cloud Server
↓
Data Storage / CSV
</pre>

This type of IoT-based data logging system can be used for applications such as environmental monitoring, indoor temperature and humidity monitoring, weather monitoring and other systems where sensor measurements need to be collected remotely and stored for later use.

== Actions: ==
# Write ESP32 code to read temperature data from the DHT11 sensor and send it to a cloud server using Wi-Fi.
# Display this reading on a web-based dashboard in real-time.
# Download readings data in CSV format.

== Setting Up Cloud ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 15px; text-align: center;">

<div>
[[File:cloud-01.png|frameless|300px|alt=Step 1]]
<br /><b>Step 1</b><br />Visit [https://www.cognifront.com www.cognifront.com] and scroll down to the footer section.
</div>

<div>
[[File:cloud-02.png|frameless|300px|alt=Step 2]]
<br /><b>Step 2</b><br />Click on the <b>IoT Cloud</b> option.
</div>

<div>
[[File:cloud-03.png|frameless|300px|alt=Step 3]]
<br /><b>Step 3</b><br />Click on <i>Login</i> or <i>Sign Up / Registration</i> to access your account.
</div>

<div>
[[File:cloud-04.png|frameless|300px|alt=Step 4]]
<br /><b>Step 4</b><br />After logging in, navigate to the <b>Dashboard</b> section.
</div>

<div>
[[File:cloud-05.png|frameless|300px|alt=Step 5]]
<br /><b>Step 5</b><br />Click on <b>Create New App</b> to start a new cloud application.
</div>

<div>
[[File:cloud-06.png|frameless|300px|alt=Step 6]]
<br /><b>Step 6</b><br />Enter your app name — for example, <b>Data Logger</b>.
</div>

<div>
[[File:cloud-07.png|frameless|300px|alt=Step 7]]
<br /><b>Step 7</b><br />Your dashboard will update and display the newly created app.
</div>

<div>
[[File:cloud-08.png|frameless|300px|alt=Step 8]]
<br /><b>Step 8</b><br />Each app shows buttons for <i>Edit</i>, <i>Delete</i>, <i>Launch</i>, and <i>API Key</i>.
</div>

<div>
[[File:cloud-09.png|frameless|300px|alt=Step 9]]
<br /><b>Step 9</b><br />Click <b>Edit App</b> to open your app and create variables.
</div>

<div>
[[File:cloud-10.png|frameless|300px|alt=Step 10]]
<br /><b>Step 10</b><br />Click on <b>Create Variable</b> to define a new data variable.
</div>

<div>
[[File:cloud-11.png|frameless|300px|alt=Step 11]]
<br /><b>Step 11</b><br />Enter a variable name and select its type (defines input/output behavior).
</div>

<div>
[[File:cloud-12.png|frameless|300px|alt=Step 12]]
<br /><b>Step 12</b><br />For example: Name – <b>LM35</b>, Type – <b>Continuous</b>.
</div>

<div>
[[File:cloud-13.png|frameless|300px|alt=Step 13]]
<br /><b>Step 13</b><br />Return to the home page and click <b>View App</b> to launch your application.
Congratulations! Your cloud app is now ready.
</div>

<div>
[[File:cloud-14.png|frameless|400px|alt=Step 14]]
<br /><b>Step 14</b><br />Open the program folder — you will find two files:
<i>eecit-exp-06-data-logger.ino</i> (main program) and <i>cogcloudesp.h</i> (library header file).
Open the <b>.ino</b> file in Arduino IDE.
</div>

<div>
[[File:cloud-15.png|frameless|400px|alt=Step 15]]
<br /><b>Step 15</b><br />Ensure the <b>cogcloudesp.h</b> header file is included properly in your project.
</div>

<div>
[[File:cloud-16.png|frameless|300px|alt=Step 16]]
<br /><b>Step 16</b><br />Update your code with your Wi-Fi SSID, password, and API key.
A stable internet connection is required.
</div>

<div>
[[File:cloud-17.png|frameless|300px|alt=Step 17]]
<br /><b>Step 17</b><br />Change the variable name in your code to match the one you created in the cloud app.
</div>

<div>
[[File:code-esp32-upload-settings.png|frameless|300px|alt=Step 18]]
<br /><b>Step 18</b><br />Connect your ESP32 to your computer and upload the code.
</div>

<div>
[[File:cloud-19.png|frameless|300px|alt=Step 19]]
<br /><b>Step 19</b><br />Open or launch your cloud app to visualize real-time sensor data from the <b>LM35</b>.
</div>

<div>
[[File:cloud-20.png|frameless|300px|alt=Step 20]]
<br /><b>Step 20</b><br />In the app settings, click the <b>Download .CSV</b> button to export data.
</div>

<div>
[[File:cloud-21.png|frameless|300px|alt=Step 21]]
<br /><b>Step 21</b><br />Set the desired time range for data export, or leave it blank to download all records.
</div>

<div>
[[File:cloud-22.png|frameless|300px|alt=Step 22]]
<br /><b>Step 22</b><br />Open the downloaded <b>.CSV</b> file in Microsoft Excel to view the logged data.
</div>

</div>

== Circuit & Board Connections ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; text-align: center; align-items: start;">

<div>
[[File:eecit-esp32-06.png|frameless|400px|alt=Circuit Diagram]]
<br /><b>Circuit Diagram</b><br />
The complete connection diagram of ESP32-based setup.
</div>

<div>
[[File:eecit-kit-esp32-06.png|frameless|400px|alt=Board Connections]]
<br /><b>Board Connections</b><br />
Actual board wiring layout showing sensor and module connections.
</div>

</div>

== Pin Connections ==

The following connections are based on the ESP32 and DHT11 configuration used in the program.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| GND
| GND
| Ground connection
|-
| VCC
| 3.3V
| Power supply
|-
| DATA / VOUT
| GPIO4
| Analog temperature output
|}

The USB cable connects the ESP32 to the computer. The computer runs the Arduino IDE and uploads your code to ESP32.
<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your ESP32 from the computer while making or removing component connections.
</span>

== ESP32 Code ==
<pre>
// © 2026, Cognifront. Member of The IoT Kits Family.
//Experiment 6: Data Logging Using ESP32 and Excel (Cloud Communication)

#include "cogcloudesp.h"

//int cogLed = 15;
const int lm35_pin = 34;

String ssid = "********"; // wifi/hotspot name
String pass = "********"; // wifi/hotspot password 2.4 hz band only

String apikey = "YOUR_API_KEY_HERE"; // API key from app. Keep the "" (quotes)

void setup ()
{
// pinMode (cogLed,OUTPUT);
pinMode (lm35_pin, INPUT);

Serial.begin(115200);
while (!Serial)
delay(100);
cogInitCloud (ssid,pass,apikey);

// cogBindPin (cogLed, "LED");
}

void loop ()
{
cogAppLoop();

int voltage_mv = analogReadMilliVolts(lm35_pin);
float temp_val = voltage_mv / 10.0; // LM35 = 10 mV per °C

// Send value to cloud
cogStoreCloudVariable("LM35", String(temp_val, 2));

delay(2000);
}

</pre>

<div style="text-align: center; margin-top: 25px;">
[[:Media:eecit-exp-06-data-logger.zip|<span style="background-color:#007BFF;color:white;padding:10px 20px;border-radius:8px;text-decoration:none;font-weight:bold;">⬇ Click Here to Download Code File</span>]]
<br />
<span style="font-size: 90%;">(Contains ESP32 source code)</span>
<br />
[[File:Code-esp32-upload-settings.png|frameless|400px|alt=Board Connections]]
<br />
Connect your ESP32 to your computer and upload the code make sure right port selected.
</div>

== Observation ==
* The ESP32 successfully reads temperature data from the DHT11 sensor.
* Data is properly being logged in CSV file, and file is downloaded successfully.

== Conclusion ==
This experiment demonstrates how to log real-time sensor data from ESP32 to a computer using cloud communication.



== Real Life Example ==
Condition Monitoring in Machines and Data Logging: Sensors collect data such as vibration, temperature, or pressure from mechanical systems, which is logged and analysed in Excel for predictive maintenance and fault diagnosis. Also this data can be fed for training a machine learning model.

MDM331AID/Experiment 8

2026-10-07T05:29:24Z

CogWikiEditor: /* Observation */

= Experiment: Transmit sensor data between an IoT device and a server =

== Aim ==
To develop an IoT application that uses the communication protocol to transmit sensor data between an IoT device and a server

== Objectives ==
* To understand the concept of IoT-based sensor data communication.
* To interface an DHT11 temperature sensor with an ESP32 development board.
* To read temperature data from the DHT11 sensor using the ESP32.
* To connect the ESP32 to a Wi-Fi network and transmit sensor data to a cloud server.
* To store and log the transmitted sensor data in CSV format.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer with Arduino IDE
| 1
|-
| 7
| Cloud IoT platform / server (Cognifront IoT Cloud)
| 1 account per user/student
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT enables sensor data to be transmitted to a remote server or cloud platform for storage and monitoring.

An IoT-based sensor data transmission system generally consists of:
* '''Sensor:''' Measures physical parameters and provides the measured data to the IoT device. In this experiment, the DHT11 is used to measure temperature and humidity.
* '''IoT device / Controller:''' Reads the sensor data, processes it and provides network connectivity. In this experiment, the ESP32 acts as the IoT device.
* '''Communication network:''' Provides connectivity between the IoT device and the server or cloud platform. The ESP32 uses Wi-Fi for communication.
* '''Cloud server:''' Receives and stores the sensor data transmitted by the ESP32. The cloud platform used in this experiment provides facilities for storing the sensor data.
* '''Data storage:''' The collected sensor data can be stored on the server and exported in CSV format for further use.

'''DHT11''' is a digital temperature and humidity sensor that measures temperature and relative humidity. Unlike an analog temperature sensor such as the LM35, the DHT11 provides digital sensor data through its data pin. The sensor contains temperature and humidity sensing elements along with internal signal-processing circuitry.

The ESP32 communicates with the DHT11 through its digital data pin. It reads the temperature and humidity values from the sensor and processes the received data. The ESP32 then connects to a Wi-Fi network and transmits the sensor data to the cloud server using the configured cloud communication mechanism.

The cloud server receives the temperature and humidity readings and stores them as data records. In this experiment, the sensor readings are collected at regular intervals and stored on the server. The stored data can be exported as a '''CSV (Comma-Separated Values)''' file, allowing the collected sensor data to be saved in a standard tabular format.

The overall data flow of the system is:

<pre>
DHT11 Temperature & Humidity Sensor
↓
ESP32
↓
Wi-Fi
↓
Cloud Server
↓
Data Storage / CSV
</pre>

This type of IoT-based data logging system can be used for applications such as environmental monitoring, indoor temperature and humidity monitoring, weather monitoring and other systems where sensor measurements need to be collected remotely and stored for later use.

== Actions: ==
# Write ESP32 code to read temperature data from the DHT11 sensor and send it to a cloud server using Wi-Fi.
# Display this reading on a web-based dashboard in real-time.
# Download readings data in CSV format.

== Setting Up Cloud ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 15px; text-align: center;">

<div>
[[File:cloud-01.png|frameless|300px|alt=Step 1]]
<br /><b>Step 1</b><br />Visit [https://www.cognifront.com www.cognifront.com] and scroll down to the footer section.
</div>

<div>
[[File:cloud-02.png|frameless|300px|alt=Step 2]]
<br /><b>Step 2</b><br />Click on the <b>IoT Cloud</b> option.
</div>

<div>
[[File:cloud-03.png|frameless|300px|alt=Step 3]]
<br /><b>Step 3</b><br />Click on <i>Login</i> or <i>Sign Up / Registration</i> to access your account.
</div>

<div>
[[File:cloud-04.png|frameless|300px|alt=Step 4]]
<br /><b>Step 4</b><br />After logging in, navigate to the <b>Dashboard</b> section.
</div>

<div>
[[File:cloud-05.png|frameless|300px|alt=Step 5]]
<br /><b>Step 5</b><br />Click on <b>Create New App</b> to start a new cloud application.
</div>

<div>
[[File:cloud-06.png|frameless|300px|alt=Step 6]]
<br /><b>Step 6</b><br />Enter your app name — for example, <b>Data Logger</b>.
</div>

<div>
[[File:cloud-07.png|frameless|300px|alt=Step 7]]
<br /><b>Step 7</b><br />Your dashboard will update and display the newly created app.
</div>

<div>
[[File:cloud-08.png|frameless|300px|alt=Step 8]]
<br /><b>Step 8</b><br />Each app shows buttons for <i>Edit</i>, <i>Delete</i>, <i>Launch</i>, and <i>API Key</i>.
</div>

<div>
[[File:cloud-09.png|frameless|300px|alt=Step 9]]
<br /><b>Step 9</b><br />Click <b>Edit App</b> to open your app and create variables.
</div>

<div>
[[File:cloud-10.png|frameless|300px|alt=Step 10]]
<br /><b>Step 10</b><br />Click on <b>Create Variable</b> to define a new data variable.
</div>

<div>
[[File:cloud-11.png|frameless|300px|alt=Step 11]]
<br /><b>Step 11</b><br />Enter a variable name and select its type (defines input/output behavior).
</div>

<div>
[[File:cloud-12.png|frameless|300px|alt=Step 12]]
<br /><b>Step 12</b><br />For example: Name – <b>LM35</b>, Type – <b>Continuous</b>.
</div>

<div>
[[File:cloud-13.png|frameless|300px|alt=Step 13]]
<br /><b>Step 13</b><br />Return to the home page and click <b>View App</b> to launch your application.
Congratulations! Your cloud app is now ready.
</div>

<div>
[[File:cloud-14.png|frameless|400px|alt=Step 14]]
<br /><b>Step 14</b><br />Open the program folder — you will find two files:
<i>eecit-exp-06-data-logger.ino</i> (main program) and <i>cogcloudesp.h</i> (library header file).
Open the <b>.ino</b> file in Arduino IDE.
</div>

<div>
[[File:cloud-15.png|frameless|400px|alt=Step 15]]
<br /><b>Step 15</b><br />Ensure the <b>cogcloudesp.h</b> header file is included properly in your project.
</div>

<div>
[[File:cloud-16.png|frameless|300px|alt=Step 16]]
<br /><b>Step 16</b><br />Update your code with your Wi-Fi SSID, password, and API key.
A stable internet connection is required.
</div>

<div>
[[File:cloud-17.png|frameless|300px|alt=Step 17]]
<br /><b>Step 17</b><br />Change the variable name in your code to match the one you created in the cloud app.
</div>

<div>
[[File:code-esp32-upload-settings.png|frameless|300px|alt=Step 18]]
<br /><b>Step 18</b><br />Connect your ESP32 to your computer and upload the code.
</div>

<div>
[[File:cloud-19.png|frameless|300px|alt=Step 19]]
<br /><b>Step 19</b><br />Open or launch your cloud app to visualize real-time sensor data from the <b>LM35</b>.
</div>

<div>
[[File:cloud-20.png|frameless|300px|alt=Step 20]]
<br /><b>Step 20</b><br />In the app settings, click the <b>Download .CSV</b> button to export data.
</div>

<div>
[[File:cloud-21.png|frameless|300px|alt=Step 21]]
<br /><b>Step 21</b><br />Set the desired time range for data export, or leave it blank to download all records.
</div>

<div>
[[File:cloud-22.png|frameless|300px|alt=Step 22]]
<br /><b>Step 22</b><br />Open the downloaded <b>.CSV</b> file in Microsoft Excel to view the logged data.
</div>

</div>

== Circuit & Board Connections ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; text-align: center; align-items: start;">

<div>
[[File:eecit-esp32-06.png|frameless|400px|alt=Circuit Diagram]]
<br /><b>Circuit Diagram</b><br />
The complete connection diagram of ESP32-based setup.
</div>

<div>
[[File:eecit-kit-esp32-06.png|frameless|400px|alt=Board Connections]]
<br /><b>Board Connections</b><br />
Actual board wiring layout showing sensor and module connections.
</div>

</div>

== Pin Connections ==

The following connections are based on the ESP32 and DHT11 configuration used in the program.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| GND
| GND
| Ground connection
|-
| VCC
| 3.3V
| Power supply
|-
| DATA / VOUT
| GPIO4
| Analog temperature output
|}

The USB cable connects the ESP32 to the computer. The computer runs the Arduino IDE and uploads your code to ESP32.
<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your ESP32 from the computer while making or removing component connections.
</span>

== ESP32 Code ==
<pre>
// © 2026, Cognifront. Member of The IoT Kits Family.
//Experiment 6: Data Logging Using ESP32 and Excel (Cloud Communication)

#include "cogcloudesp.h"

//int cogLed = 15;
const int lm35_pin = 34;

String ssid = "********"; // wifi/hotspot name
String pass = "********"; // wifi/hotspot password 2.4 hz band only

String apikey = "YOUR_API_KEY_HERE"; // API key from app. Keep the "" (quotes)

void setup ()
{
// pinMode (cogLed,OUTPUT);
pinMode (lm35_pin, INPUT);

Serial.begin(115200);
while (!Serial)
delay(100);
cogInitCloud (ssid,pass,apikey);

// cogBindPin (cogLed, "LED");
}

void loop ()
{
cogAppLoop();

int voltage_mv = analogReadMilliVolts(lm35_pin);
float temp_val = voltage_mv / 10.0; // LM35 = 10 mV per °C

// Send value to cloud
cogStoreCloudVariable("LM35", String(temp_val, 2));

delay(2000);
}

</pre>

<div style="text-align: center; margin-top: 25px;">
[[:Media:eecit-exp-06-data-logger.zip|<span style="background-color:#007BFF;color:white;padding:10px 20px;border-radius:8px;text-decoration:none;font-weight:bold;">⬇ Click Here to Download Code File</span>]]
<br />
<span style="font-size: 90%;">(Contains ESP32 source code)</span>
<br />
[[File:Code-esp32-upload-settings.png|frameless|400px|alt=Board Connections]]
<br />
Connect your ESP32 to your computer and upload the code make sure right port selected.
</div>

== Observation ==
* The ESP32 successfully reads temperature data from the DHT11 sensor.

== Conclusion ==
This experiment demonstrates how to log real-time sensor data from ESP32 to a computer using cloud communication.



== Real Life Example ==
Condition Monitoring in Machines and Data Logging: Sensors collect data such as vibration, temperature, or pressure from mechanical systems, which is logged and analysed in Excel for predictive maintenance and fault diagnosis. Also this data can be fed for training a machine learning model.

MDM331AID/Experiment 8

2026-10-07T05:28:53Z

CogWikiEditor: /* Pin Connections */

= Experiment: Transmit sensor data between an IoT device and a server =

== Aim ==
To develop an IoT application that uses the communication protocol to transmit sensor data between an IoT device and a server

== Objectives ==
* To understand the concept of IoT-based sensor data communication.
* To interface an DHT11 temperature sensor with an ESP32 development board.
* To read temperature data from the DHT11 sensor using the ESP32.
* To connect the ESP32 to a Wi-Fi network and transmit sensor data to a cloud server.
* To store and log the transmitted sensor data in CSV format.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer with Arduino IDE
| 1
|-
| 7
| Cloud IoT platform / server (Cognifront IoT Cloud)
| 1 account per user/student
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT enables sensor data to be transmitted to a remote server or cloud platform for storage and monitoring.

An IoT-based sensor data transmission system generally consists of:
* '''Sensor:''' Measures physical parameters and provides the measured data to the IoT device. In this experiment, the DHT11 is used to measure temperature and humidity.
* '''IoT device / Controller:''' Reads the sensor data, processes it and provides network connectivity. In this experiment, the ESP32 acts as the IoT device.
* '''Communication network:''' Provides connectivity between the IoT device and the server or cloud platform. The ESP32 uses Wi-Fi for communication.
* '''Cloud server:''' Receives and stores the sensor data transmitted by the ESP32. The cloud platform used in this experiment provides facilities for storing the sensor data.
* '''Data storage:''' The collected sensor data can be stored on the server and exported in CSV format for further use.

'''DHT11''' is a digital temperature and humidity sensor that measures temperature and relative humidity. Unlike an analog temperature sensor such as the LM35, the DHT11 provides digital sensor data through its data pin. The sensor contains temperature and humidity sensing elements along with internal signal-processing circuitry.

The ESP32 communicates with the DHT11 through its digital data pin. It reads the temperature and humidity values from the sensor and processes the received data. The ESP32 then connects to a Wi-Fi network and transmits the sensor data to the cloud server using the configured cloud communication mechanism.

The cloud server receives the temperature and humidity readings and stores them as data records. In this experiment, the sensor readings are collected at regular intervals and stored on the server. The stored data can be exported as a '''CSV (Comma-Separated Values)''' file, allowing the collected sensor data to be saved in a standard tabular format.

The overall data flow of the system is:

<pre>
DHT11 Temperature & Humidity Sensor
↓
ESP32
↓
Wi-Fi
↓
Cloud Server
↓
Data Storage / CSV
</pre>

This type of IoT-based data logging system can be used for applications such as environmental monitoring, indoor temperature and humidity monitoring, weather monitoring and other systems where sensor measurements need to be collected remotely and stored for later use.

== Actions: ==
# Write ESP32 code to read temperature data from the DHT11 sensor and send it to a cloud server using Wi-Fi.
# Display this reading on a web-based dashboard in real-time.
# Download readings data in CSV format.

== Setting Up Cloud ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 15px; text-align: center;">

<div>
[[File:cloud-01.png|frameless|300px|alt=Step 1]]
<br /><b>Step 1</b><br />Visit [https://www.cognifront.com www.cognifront.com] and scroll down to the footer section.
</div>

<div>
[[File:cloud-02.png|frameless|300px|alt=Step 2]]
<br /><b>Step 2</b><br />Click on the <b>IoT Cloud</b> option.
</div>

<div>
[[File:cloud-03.png|frameless|300px|alt=Step 3]]
<br /><b>Step 3</b><br />Click on <i>Login</i> or <i>Sign Up / Registration</i> to access your account.
</div>

<div>
[[File:cloud-04.png|frameless|300px|alt=Step 4]]
<br /><b>Step 4</b><br />After logging in, navigate to the <b>Dashboard</b> section.
</div>

<div>
[[File:cloud-05.png|frameless|300px|alt=Step 5]]
<br /><b>Step 5</b><br />Click on <b>Create New App</b> to start a new cloud application.
</div>

<div>
[[File:cloud-06.png|frameless|300px|alt=Step 6]]
<br /><b>Step 6</b><br />Enter your app name — for example, <b>Data Logger</b>.
</div>

<div>
[[File:cloud-07.png|frameless|300px|alt=Step 7]]
<br /><b>Step 7</b><br />Your dashboard will update and display the newly created app.
</div>

<div>
[[File:cloud-08.png|frameless|300px|alt=Step 8]]
<br /><b>Step 8</b><br />Each app shows buttons for <i>Edit</i>, <i>Delete</i>, <i>Launch</i>, and <i>API Key</i>.
</div>

<div>
[[File:cloud-09.png|frameless|300px|alt=Step 9]]
<br /><b>Step 9</b><br />Click <b>Edit App</b> to open your app and create variables.
</div>

<div>
[[File:cloud-10.png|frameless|300px|alt=Step 10]]
<br /><b>Step 10</b><br />Click on <b>Create Variable</b> to define a new data variable.
</div>

<div>
[[File:cloud-11.png|frameless|300px|alt=Step 11]]
<br /><b>Step 11</b><br />Enter a variable name and select its type (defines input/output behavior).
</div>

<div>
[[File:cloud-12.png|frameless|300px|alt=Step 12]]
<br /><b>Step 12</b><br />For example: Name – <b>LM35</b>, Type – <b>Continuous</b>.
</div>

<div>
[[File:cloud-13.png|frameless|300px|alt=Step 13]]
<br /><b>Step 13</b><br />Return to the home page and click <b>View App</b> to launch your application.
Congratulations! Your cloud app is now ready.
</div>

<div>
[[File:cloud-14.png|frameless|400px|alt=Step 14]]
<br /><b>Step 14</b><br />Open the program folder — you will find two files:
<i>eecit-exp-06-data-logger.ino</i> (main program) and <i>cogcloudesp.h</i> (library header file).
Open the <b>.ino</b> file in Arduino IDE.
</div>

<div>
[[File:cloud-15.png|frameless|400px|alt=Step 15]]
<br /><b>Step 15</b><br />Ensure the <b>cogcloudesp.h</b> header file is included properly in your project.
</div>

<div>
[[File:cloud-16.png|frameless|300px|alt=Step 16]]
<br /><b>Step 16</b><br />Update your code with your Wi-Fi SSID, password, and API key.
A stable internet connection is required.
</div>

<div>
[[File:cloud-17.png|frameless|300px|alt=Step 17]]
<br /><b>Step 17</b><br />Change the variable name in your code to match the one you created in the cloud app.
</div>

<div>
[[File:code-esp32-upload-settings.png|frameless|300px|alt=Step 18]]
<br /><b>Step 18</b><br />Connect your ESP32 to your computer and upload the code.
</div>

<div>
[[File:cloud-19.png|frameless|300px|alt=Step 19]]
<br /><b>Step 19</b><br />Open or launch your cloud app to visualize real-time sensor data from the <b>LM35</b>.
</div>

<div>
[[File:cloud-20.png|frameless|300px|alt=Step 20]]
<br /><b>Step 20</b><br />In the app settings, click the <b>Download .CSV</b> button to export data.
</div>

<div>
[[File:cloud-21.png|frameless|300px|alt=Step 21]]
<br /><b>Step 21</b><br />Set the desired time range for data export, or leave it blank to download all records.
</div>

<div>
[[File:cloud-22.png|frameless|300px|alt=Step 22]]
<br /><b>Step 22</b><br />Open the downloaded <b>.CSV</b> file in Microsoft Excel to view the logged data.
</div>

</div>

== Circuit & Board Connections ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; text-align: center; align-items: start;">

<div>
[[File:eecit-esp32-06.png|frameless|400px|alt=Circuit Diagram]]
<br /><b>Circuit Diagram</b><br />
The complete connection diagram of ESP32-based setup.
</div>

<div>
[[File:eecit-kit-esp32-06.png|frameless|400px|alt=Board Connections]]
<br /><b>Board Connections</b><br />
Actual board wiring layout showing sensor and module connections.
</div>

</div>

== Pin Connections ==

The following connections are based on the ESP32 and DHT11 configuration used in the program.

{| class="wikitable"
|-
! DHT11 Pin
! ESP32 Pin
! Description
|-
| GND
| GND
| Ground connection
|-
| VCC
| 3.3V
| Power supply
|-
| DATA / VOUT
| GPIO4
| Analog temperature output
|}

The USB cable connects the ESP32 to the computer. The computer runs the Arduino IDE and uploads your code to ESP32.
<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your ESP32 from the computer while making or removing component connections.
</span>

== ESP32 Code ==
<pre>
// © 2026, Cognifront. Member of The IoT Kits Family.
//Experiment 6: Data Logging Using ESP32 and Excel (Cloud Communication)

#include "cogcloudesp.h"

//int cogLed = 15;
const int lm35_pin = 34;

String ssid = "********"; // wifi/hotspot name
String pass = "********"; // wifi/hotspot password 2.4 hz band only

String apikey = "YOUR_API_KEY_HERE"; // API key from app. Keep the "" (quotes)

void setup ()
{
// pinMode (cogLed,OUTPUT);
pinMode (lm35_pin, INPUT);

Serial.begin(115200);
while (!Serial)
delay(100);
cogInitCloud (ssid,pass,apikey);

// cogBindPin (cogLed, "LED");
}

void loop ()
{
cogAppLoop();

int voltage_mv = analogReadMilliVolts(lm35_pin);
float temp_val = voltage_mv / 10.0; // LM35 = 10 mV per °C

// Send value to cloud
cogStoreCloudVariable("LM35", String(temp_val, 2));

delay(2000);
}

</pre>

<div style="text-align: center; margin-top: 25px;">
[[:Media:eecit-exp-06-data-logger.zip|<span style="background-color:#007BFF;color:white;padding:10px 20px;border-radius:8px;text-decoration:none;font-weight:bold;">⬇ Click Here to Download Code File</span>]]
<br />
<span style="font-size: 90%;">(Contains ESP32 source code)</span>
<br />
[[File:Code-esp32-upload-settings.png|frameless|400px|alt=Board Connections]]
<br />
Connect your ESP32 to your computer and upload the code make sure right port selected.
</div>

== Observation ==
* The ESP32 successfully reads temperature data from the LM35 sensor.

== Conclusion ==
This experiment demonstrates how to log real-time sensor data from ESP32 to a computer using cloud communication.



== Real Life Example ==
Condition Monitoring in Machines and Data Logging: Sensors collect data such as vibration, temperature, or pressure from mechanical systems, which is logged and analysed in Excel for predictive maintenance and fault diagnosis. Also this data can be fed for training a machine learning model.

MDM331AID/Experiment 8

2026-10-07T05:27:37Z

CogWikiEditor: /* Actions: */

= Experiment: Transmit sensor data between an IoT device and a server =

== Aim ==
To develop an IoT application that uses the communication protocol to transmit sensor data between an IoT device and a server

== Objectives ==
* To understand the concept of IoT-based sensor data communication.
* To interface an DHT11 temperature sensor with an ESP32 development board.
* To read temperature data from the DHT11 sensor using the ESP32.
* To connect the ESP32 to a Wi-Fi network and transmit sensor data to a cloud server.
* To store and log the transmitted sensor data in CSV format.

== Components Required ==

{| class="wikitable"
|-
! Sr. No.
! Component
! Quantity
|-
| 1
| ESP32 development board
| 1
|-
| 2
| DHT11 temperature sensor
| 1
|-
| 3
| USB cable
| 1
|-
| 4
| Patch cords / jumper wires
| As required
|-
| 5
| Wi-Fi network / Internet connection
| 1
|-
| 6
| Computer with Arduino IDE
| 1
|-
| 7
| Cloud IoT platform / server (Cognifront IoT Cloud)
| 1 account per user/student
|}

== Theory ==

'''Internet of Things (IoT)''' is a technology in which physical devices equipped with sensors, processing units and communication capabilities collect and exchange data over a network. IoT enables sensor data to be transmitted to a remote server or cloud platform for storage and monitoring.

An IoT-based sensor data transmission system generally consists of:
* '''Sensor:''' Measures physical parameters and provides the measured data to the IoT device. In this experiment, the DHT11 is used to measure temperature and humidity.
* '''IoT device / Controller:''' Reads the sensor data, processes it and provides network connectivity. In this experiment, the ESP32 acts as the IoT device.
* '''Communication network:''' Provides connectivity between the IoT device and the server or cloud platform. The ESP32 uses Wi-Fi for communication.
* '''Cloud server:''' Receives and stores the sensor data transmitted by the ESP32. The cloud platform used in this experiment provides facilities for storing the sensor data.
* '''Data storage:''' The collected sensor data can be stored on the server and exported in CSV format for further use.

'''DHT11''' is a digital temperature and humidity sensor that measures temperature and relative humidity. Unlike an analog temperature sensor such as the LM35, the DHT11 provides digital sensor data through its data pin. The sensor contains temperature and humidity sensing elements along with internal signal-processing circuitry.

The ESP32 communicates with the DHT11 through its digital data pin. It reads the temperature and humidity values from the sensor and processes the received data. The ESP32 then connects to a Wi-Fi network and transmits the sensor data to the cloud server using the configured cloud communication mechanism.

The cloud server receives the temperature and humidity readings and stores them as data records. In this experiment, the sensor readings are collected at regular intervals and stored on the server. The stored data can be exported as a '''CSV (Comma-Separated Values)''' file, allowing the collected sensor data to be saved in a standard tabular format.

The overall data flow of the system is:

<pre>
DHT11 Temperature & Humidity Sensor
↓
ESP32
↓
Wi-Fi
↓
Cloud Server
↓
Data Storage / CSV
</pre>

This type of IoT-based data logging system can be used for applications such as environmental monitoring, indoor temperature and humidity monitoring, weather monitoring and other systems where sensor measurements need to be collected remotely and stored for later use.

== Actions: ==
# Write ESP32 code to read temperature data from the DHT11 sensor and send it to a cloud server using Wi-Fi.
# Display this reading on a web-based dashboard in real-time.
# Download readings data in CSV format.

== Setting Up Cloud ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 15px; text-align: center;">

<div>
[[File:cloud-01.png|frameless|300px|alt=Step 1]]
<br /><b>Step 1</b><br />Visit [https://www.cognifront.com www.cognifront.com] and scroll down to the footer section.
</div>

<div>
[[File:cloud-02.png|frameless|300px|alt=Step 2]]
<br /><b>Step 2</b><br />Click on the <b>IoT Cloud</b> option.
</div>

<div>
[[File:cloud-03.png|frameless|300px|alt=Step 3]]
<br /><b>Step 3</b><br />Click on <i>Login</i> or <i>Sign Up / Registration</i> to access your account.
</div>

<div>
[[File:cloud-04.png|frameless|300px|alt=Step 4]]
<br /><b>Step 4</b><br />After logging in, navigate to the <b>Dashboard</b> section.
</div>

<div>
[[File:cloud-05.png|frameless|300px|alt=Step 5]]
<br /><b>Step 5</b><br />Click on <b>Create New App</b> to start a new cloud application.
</div>

<div>
[[File:cloud-06.png|frameless|300px|alt=Step 6]]
<br /><b>Step 6</b><br />Enter your app name — for example, <b>Data Logger</b>.
</div>

<div>
[[File:cloud-07.png|frameless|300px|alt=Step 7]]
<br /><b>Step 7</b><br />Your dashboard will update and display the newly created app.
</div>

<div>
[[File:cloud-08.png|frameless|300px|alt=Step 8]]
<br /><b>Step 8</b><br />Each app shows buttons for <i>Edit</i>, <i>Delete</i>, <i>Launch</i>, and <i>API Key</i>.
</div>

<div>
[[File:cloud-09.png|frameless|300px|alt=Step 9]]
<br /><b>Step 9</b><br />Click <b>Edit App</b> to open your app and create variables.
</div>

<div>
[[File:cloud-10.png|frameless|300px|alt=Step 10]]
<br /><b>Step 10</b><br />Click on <b>Create Variable</b> to define a new data variable.
</div>

<div>
[[File:cloud-11.png|frameless|300px|alt=Step 11]]
<br /><b>Step 11</b><br />Enter a variable name and select its type (defines input/output behavior).
</div>

<div>
[[File:cloud-12.png|frameless|300px|alt=Step 12]]
<br /><b>Step 12</b><br />For example: Name – <b>LM35</b>, Type – <b>Continuous</b>.
</div>

<div>
[[File:cloud-13.png|frameless|300px|alt=Step 13]]
<br /><b>Step 13</b><br />Return to the home page and click <b>View App</b> to launch your application.
Congratulations! Your cloud app is now ready.
</div>

<div>
[[File:cloud-14.png|frameless|400px|alt=Step 14]]
<br /><b>Step 14</b><br />Open the program folder — you will find two files:
<i>eecit-exp-06-data-logger.ino</i> (main program) and <i>cogcloudesp.h</i> (library header file).
Open the <b>.ino</b> file in Arduino IDE.
</div>

<div>
[[File:cloud-15.png|frameless|400px|alt=Step 15]]
<br /><b>Step 15</b><br />Ensure the <b>cogcloudesp.h</b> header file is included properly in your project.
</div>

<div>
[[File:cloud-16.png|frameless|300px|alt=Step 16]]
<br /><b>Step 16</b><br />Update your code with your Wi-Fi SSID, password, and API key.
A stable internet connection is required.
</div>

<div>
[[File:cloud-17.png|frameless|300px|alt=Step 17]]
<br /><b>Step 17</b><br />Change the variable name in your code to match the one you created in the cloud app.
</div>

<div>
[[File:code-esp32-upload-settings.png|frameless|300px|alt=Step 18]]
<br /><b>Step 18</b><br />Connect your ESP32 to your computer and upload the code.
</div>

<div>
[[File:cloud-19.png|frameless|300px|alt=Step 19]]
<br /><b>Step 19</b><br />Open or launch your cloud app to visualize real-time sensor data from the <b>LM35</b>.
</div>

<div>
[[File:cloud-20.png|frameless|300px|alt=Step 20]]
<br /><b>Step 20</b><br />In the app settings, click the <b>Download .CSV</b> button to export data.
</div>

<div>
[[File:cloud-21.png|frameless|300px|alt=Step 21]]
<br /><b>Step 21</b><br />Set the desired time range for data export, or leave it blank to download all records.
</div>

<div>
[[File:cloud-22.png|frameless|300px|alt=Step 22]]
<br /><b>Step 22</b><br />Open the downloaded <b>.CSV</b> file in Microsoft Excel to view the logged data.
</div>

</div>

== Circuit & Board Connections ==

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; text-align: center; align-items: start;">

<div>
[[File:eecit-esp32-06.png|frameless|400px|alt=Circuit Diagram]]
<br /><b>Circuit Diagram</b><br />
The complete connection diagram of ESP32-based setup.
</div>

<div>
[[File:eecit-kit-esp32-06.png|frameless|400px|alt=Board Connections]]
<br /><b>Board Connections</b><br />
Actual board wiring layout showing sensor and module connections.
</div>

</div>

== Pin Connections ==

The following connections are based on the ESP32 and LM35 configuration used in the program.

{| class="wikitable"
|-
! LM35 Pin
! ESP32 Pin
! Description
|-
| GND
| GND
| Ground connection
|-
| VCC
| 3.3V
| Power supply
|-
| DATA / VOUT
| GPIO34
| Analog temperature output
|}

The USB cable connects the ESP32 to the computer. The computer runs the Arduino IDE and uploads your code to ESP32.
<span style="background-color: #ffcccc; display: inline-block; padding: 5px; border-radius: 5px; font-weight: bold;">
⚠️ Disconnect your ESP32 from the computer while making or removing component connections.
</span>

== ESP32 Code ==
<pre>
// © 2026, Cognifront. Member of The IoT Kits Family.
//Experiment 6: Data Logging Using ESP32 and Excel (Cloud Communication)

#include "cogcloudesp.h"

//int cogLed = 15;
const int lm35_pin = 34;

String ssid = "********"; // wifi/hotspot name
String pass = "********"; // wifi/hotspot password 2.4 hz band only

String apikey = "YOUR_API_KEY_HERE"; // API key from app. Keep the "" (quotes)

void setup ()
{
// pinMode (cogLed,OUTPUT);
pinMode (lm35_pin, INPUT);

Serial.begin(115200);
while (!Serial)
delay(100);
cogInitCloud (ssid,pass,apikey);

// cogBindPin (cogLed, "LED");
}

void loop ()
{
cogAppLoop();

int voltage_mv = analogReadMilliVolts(lm35_pin);
float temp_val = voltage_mv / 10.0; // LM35 = 10 mV per °C

// Send value to cloud
cogStoreCloudVariable("LM35", String(temp_val, 2));

delay(2000);
}

</pre>

<div style="text-align: center; margin-top: 25px;">
[[:Media:eecit-exp-06-data-logger.zip|<span style="background-color:#007BFF;color:white;padding:10px 20px;border-radius:8px;text-decoration:none;font-weight:bold;">⬇ Click Here to Download Code File</span>]]
<br />
<span style="font-size: 90%;">(Contains ESP32 source code)</span>
<br />
[[File:Code-esp32-upload-settings.png|frameless|400px|alt=Board Connections]]
<br />
Connect your ESP32 to your computer and upload the code make sure right port selected.
</div>

== Observation ==
* The ESP32 successfully reads temperature data from the LM35 sensor.

== Conclusion ==
This experiment demonstrates how to log real-time sensor data from ESP32 to a computer using cloud communication.



== Real Life Example ==
Condition Monitoring in Machines and Data Logging: Sensors collect data such as vibration, temperature, or pressure from mechanical systems, which is logged and analysed in Excel for predictive maintenance and fault diagnosis. Also this data can be fed for training a machine learning model.