VISVESVARAYA TECHNOLOGICAL UNIVERSITY

Jnana Sangama, Santhibastawad Road, Machhe, Belagavi - 590018, Karnataka, India

Internet of Things (18CS81) Practical Report

Submitted in the partial fulfillment of requirements for the award of the degree of

BACHELOR OF ENGINEERING
IN
INFORMATION SCIENCE AND ENGINEERING
For the Academic Year 2023-2024
Submitted by

AKASH N 1JS20IS010

Under the Guidance of

DR D.V ASHOK
Professor
Dept. of ISE, JSSATE

2023-2024
DEPARTMENT OF INFORMATION SCIENCE AND ENGINEERING
JSS ACADEMY OF TECHNICAL EDUCATION
JSS Campus, Dr. Vishnuvardhan Road, Bengaluru-560060
 JSS MAHAVIDYAPEETHA, MYSURU
JSS ACADEMY OF TECHNICAL EDUCATION
JSS Campus, [Link] Road, Bengaluru-560060

DEPARTMENT OF INFORMATION SCIENCE & ENGINEERING

CERTIFICATE

This is to certify that Internet of Things (18CS81) report is a bonafide work carried out
by Akash N [1JS20IS010] in partial fulfillment for the award of degree of Bachelor of
Engineering in Information Science and Engineering of Visvesvaraya Technological
University Belagavi during the year 2023- 2024.

Signature of the Guide Signature of the HOD

DR D.V Ashok Dr Rekha PM

Professor Professor and Head
Dept. of ISE Dept. of ISE
JSSATE, Bengaluru JSSATE, Bengaluru
 ACKNOWLEDGEMENT

The satisfaction and euphoria that accompany the successful completion of any
task would be incomplete without the mention of the people who made it possible.
So, with gratitude, we acknowledge all those whose guidance and encouragement
crowned my effort with success.

First and foremost, we would like to thank his Holiness Jagadguru Sri
Shivarathri Deshikendra Mahaswamiji and Dr Bhimasen Soragaon., Principal,
JSSATE, Bangalore for providing an opportunity to carry out the Internet of
Things (18CS81) pratical report as a part of our curriculum in the partial
fulfillment of the degree course.

We express our sincere gratitude for our beloved Professor & Head of the
department, Dr. Rekha P M, for her co-operation and encouragement at all the
moments of our approach. We are thankful to our department Coordinator
Internet of Things (18CS81) DR D.V Ashok , Professor, Dept. of ISE, for his
continuous cooperation and support.

We would like to thank all Teaching and non-teaching Faculty for providing us
with their valuable guidance and for being there at all stages of our work.

Akash N
1JS20IS010
 ABSTRACT

This IoT practical report explores various aspects of communication protocols and sensor interfacing in
embedded systems. The report covers four distinct experiments: UART communication, point-to-point RF
communication, multi-point to single-point RF communication using LAN sub-netting, and I2C protocol
study. Additionally, it includes a detailed demonstration of reading temperature and relative humidity
values from the DHT11 sensor.

Each experiment is accompanied by a clear aim, introduction, procedure, circuit diagrams (where
applicable), program codes, and results. For example, in the UART communication experiment, the aim
was to transmit a string using UART communication on a microcontroller. The procedure involved
initializing UART, transmitting a string, and observing the results on a receiving device. Similarly, other
experiments follow a structured approach to achieve their respective objectives.

The report demonstrates the versatility and applicability of various communication protocols such as
UART, RF, and I2C, in addition to showcasing the capabilities of sensors like the DHT11. Real-time
monitoring and troubleshooting aspects are emphasized throughout the experiments, ensuring practical
insights into system behavior and reliability.

Overall, this IoT practical report provides a comprehensive understanding of communication protocols and
sensor integration in embedded systems, offering valuable insights for students and practitioners alike in
the field of IoT and embedded electronics.

Dept of ISE, JSSATEB 4

 TABLE OF CONTENTS

CHAPTER TITLE PAGE NO

Problem 1 Transmit a string using UART 6
Problem 2 Point-to-Point communication of two Motes over the 9
radio frequency.
Problem 3 Multi-point to single-point communication of Motes 12
over the radio [Link] (Sub-netting).
Problem 4 I2C protocol study 15

Problem 5 Reading Temperature and Relative Humidity value 18

from the sensor

Dept of ISE, JSSATEB 5

 Problem 1: Transmit a string using UART

1.1 Aim:
Transmit a string using UART communication on a microcontroller.

1.2 Introduction:
UART (Universal Asynchronous Receiver-Transmitter) is a fundamental serial communication protocol
widely employed in microcontrollers and embedded systems. Unlike synchronous protocols like SPI or I2C,
UART operates asynchronously, meaning it doesn't necessitate a shared clock signal. Instead, it utilizes
predefined baud rates to synchronize data transmission and reception between devices. Typically
employing two pins—TX (transmit) and RX (receive)—UART facilitates bidirectional data transfer,
making it versatile for various applications. Its simplicity, low hardware requirements, and full-duplex
communication capability make it ideal for interfacing with peripherals, sensors, and external devices.
UART plays a vital role in enabling seamless data exchange between microcontrollers, computers, and
other electronic devices, serving as a cornerstone of modern communication protocols.

1.3 Procedure:
The circuit setup is crucial for establishing communication between the microcontroller and the receiving
device. Physically connecting the microcontroller's UART transmit pin (TX) to the receive pin (RX) of the
receiving device forms the basis of the communication link. This direct connection enables data
transmission from the microcontroller to the receiving device. Additionally, ensuring a common ground
connection between both devices is essential to maintain a stable reference voltage level and ensure reliable
communication.
UART Initialization (UART_Init): This function initializes the microcontroller's UART module with
specific settings such as baud rate, parity, and data format. These settings determine the speed and format
of data transmission. The initialization process prepares the UART module for communication according to
the desired configuration.
Transmitting a String (UART_TransmitString): This function is responsible for transmitting a string of
characters over UART. It iterates through each character of the string and sends them sequentially over the
UART interface. Inside the function, each character is transmitted individually until the null terminator ('\0')
is encountered, indicating the end of the string. This ensures that the entire string is transmitted reliably.
Transmitting the String:
String Definition: We define a string variable named "message" containing the message we want to
transmit. In this case, the message is "Hello, World!". This string serves as the data payload to be
transmitted over UART.
Dept of ISE, JSSATEB 6
Function Call: After defining the string to transmit, we call the UART transmission function
(UART_TransmitString) with the "message" string as an argument. This initiates the transmission of the
string over UART. The function handles the process of transmitting each character of the string over the
UART interface.

1.4 Circuit Diagram:

1.5 Program :

#include <avr/io.h>
#include <util/delay.h>
// Define baud rate
#define BAUD 9600
#define F_CPU 16000000UL // MCU operating frequency
#include <util/setbaud.h>

Dept of ISE, JSSATEB 7

// Initialize UART with desired settings
void UART_Init() {
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
UCSR0B = (1 << TXEN0) | (1 << RXEN0);
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}
void UART_TransmitChar(char c) {
// Wait for empty transmit buffer
while (!(UCSR0A & (1 << UDRE0)));
UDR0 = c;
}
void UART_TransmitString(const char* str) {
while (*str != '\0') {
UART_TransmitChar(*str);
str++;
}
}
int main() {
// Initialize UART
UART_Init();
const char message[] = "Hello, World!\r\n";
UART_TransmitString(message);
return 0;
}

1.6 Results:
Upon executing the code, the microcontroller will transmit the string "Hello, World!" over UART. The
transmitted string can be observed on the receiving device, confirming successful UART communication.
By comparing the received string with the transmitted one, we can ensure the integrity of the
communication.

Dept of ISE, JSSATEB 8

 Problem 2: Point-to-Point communication of two Motes over radio frequency.

2.1 Aim:
Establish point-to-point communication between two Motes (microcontroller-based wireless devices) using
radio frequency.

2.2 Introduction:
Point-to-Point communication of two Motes over radio frequency involves establishing a direct wireless
link between two microcontroller-based devices using RF technology. It enables bidirectional data
transmission without the need for intermediate network infrastructure, making it ideal for applications
where wired connections are impractical. This method allows for reliable data exchange between remote
devices, facilitating tasks such as remote sensing, telemetry, and data logging. RF communication offers
advantages such as flexibility, scalability, and mobility, making it suitable for various applications in
remote monitoring and control systems.

2.3 Procedure:
In this experiment, we utilize radio frequency (RF) communication to establish a wireless link between two
Motes. RF communication enables devices to transmit and receive data over the airwaves, making it
suitable for applications where wired connections are impractical or not feasible. By establishing a point-
to-point RF link between two Motes, we aim to demonstrate the capability of wireless communication for
data exchange between remote devices.
Hardware Setup:Place two Motes within the communication range of each other. Ensure that both Motes
are powered and properly configured for RF communication. Connect any necessary peripherals or sensors
to the Motes if required.
Initialization: Initialize the RF module on both Motes with compatible settings for communication.
Configure the RF parameters such as frequency, modulation scheme, data rate, and addressing mode to
ensure compatibility between the Motes.
Transmitting Data: Choose one Mote as the transmitter and the other as the receiver. Prepare the data to
be transmitted, such as a string or sensor readings. On the transmitter Mote, initiate the transmission of data
using the RF communication API or library. Encode the data into packets suitable for RF transmission and
send them periodically or upon trigger events.
Receiving Data: On the receiver Mote, configure the RF module to listen for incoming transmissions.
Implement a data reception routine to process and decode incoming RF packets. Upon receiving data
packets, extract the payload and process it accordingly, such as displaying messages or storing sensor data.

Dept of ISE, JSSATEB 9

Verification: Monitor the communication status and data exchange between the Motes. Verify the integrity
and correctness of the received data to ensure reliable communication. Test the communication link under
various conditions, such as distance, interference, and environmental factors.

2.4 Circuit Diagram

2.5 Program :
Transmittor code
#include <SPI.h>
#include <RF24.h>
RF24 radio(9, 10); // CE, CSN pins
const uint64_t pipe = 0xE8E8F0F0E1LL; // Pipe address for communication
void setup() {
[Link](9600);
[Link]();
[Link](pipe);
}
void loop() {
const char data[] = "Hello, Mote!";
[Link]("Transmitting: " + String(data));

Dept of ISE, JSSATEB 10

 [Link](&data, sizeof(data));
delay(1000); // Delay between transmissions
}
Receive code:
#include <SPI.h>
#include <RF24.h>
RF24 radio(9, 10); // CE, CSN pins
const uint64_t pipe = 0xE8E8F0F0E1LL; // Pipe address for communication
void setup() {
[Link](9600);
[Link]();
[Link](1, pipe); // Set the pipe address for receiving
[Link](); // Start listening for incoming messages
}
void loop() {
if ([Link]()) { // Check if there is incoming data
char data[32]; // Define a buffer to hold the received data
[Link](&data, sizeof(data)); // Read the incoming data into the buffer
[Link]("Received: ");
[Link](data); // Print the received data to the serial monitor
}
}
The output on the serial monitor of the receiver Arduino would look something like this:
Received: Hello, Mote!
Received: Hello, Mote!
...

2.6 Results:
Established Communication: Motes successfully established wireless communication link using RF.
Data Transmission: Data such as messages or sensor readings, was transmitted from one Mote to the other
reliably. Data Reception: The receiving Mote received and processed the transmitted data accurately,
confirming the integrity of the communication. Robustness Testing: The communication link was tested
under various conditions to evaluate its robustness, including distance, interference, and environmental
factors. Validation: an effectiveness of point-to-point RF communication for wireless data exchange
between remote devices. Overall, the results affirm the practical utility of RF communication for enabling
wireless connectivity and data exchange in microcontroller-based systems.
Dept of ISE, JSSATEB 11
 Problem 3 : Multi-point to single-point communication of Motes over the
radio frequency LAN
3.1 Aim:
The aim of this experiment is to establish multi-point to single-point communication of Motes over radio
frequency using LAN (Local Area Network) sub-netting, and to verify the successful transmission and
reception of data packets between the Motes and the central receiver.

3.2 Introduction:
Multi-point to single-point communication involves multiple Motes transmitting data to a single-point
receiver over radio frequency. LAN sub-netting subdivides a larger network into smaller, more manageable
sub-networks, each with its own unique address range. By combining these concepts, we can create a
scenario where multiple Motes communicate with a central receiver using LAN sub-netting to organize the
network. This setup enables efficient data management and enhances the scalability and flexibility of the
communication system.

3.3 Procedure
Hardware Setup: Prepare two or more Motes and a central receiver, each equipped with compatible RF
modules (e.g., NRF24L01). Connect the RF modules to the Motes and the central receiver according to
their pinout specifications. Ensure all devices have a stable power source, either batteries or power adapters.
Software Setup: Install the necessary libraries for RF communication on the microcontrollers (e.g., RF24
library for Arduino). Develop or adapt the firmware for both the Motes and the central receiver to handle
RF communication and data processing.
Network Configuration:
Assign Unique Addresses: Assign unique addresses to each Mote within the network.
Define Subnet Masks: Determine subnet masks and address ranges for LAN sub-netting.
Configure Central Receiver: Configure the central receiver to recognize and receive data from all subnets.
Data Transmission (Motes):
Data Collection: Each Mote collects sensor data or messages to transmit.
Packet Formation: Formulate data packets like destination addresses corresponding to the central receiver.
Transmission: Motes transmit their data wirelessly using RF communication.
Data Reception (Central Receiver): Listen for Incoming Data: The central receiver continuously listens for
incoming data packets.
Address Filtering: Filter incoming packets based on their destination addresses to separate data from
different Motes.

Dept of ISE, JSSATEB 12

Data Processing: Process received data packets as required, such as storing data in memory or displaying it
on a screen.
3.4 Block diagram:

3.5 Program:
Transmittor code
#include <RF24.h>
RF24 radio(9, 10); // CE, CSN pins
const uint64_t centralReceiverAddress = 0xF0F0F0F0E1LL; // Address of the central receiver
void setup() {
[Link]();
[Link](centralReceiverAddress);
}
void loop() {
// Collect data to transmit
char data[] = "Sensor Data";
[Link](&data, sizeof(data));
delay(1000); // Delay between transmissions
}
Receiver code
#include <RF24.h>
RF24 radio(9, 10); // CE, CSN pins
const uint64_t centralReceiverAddress = 0xF0F0F0F0E1LL;
Dept of ISE, JSSATEB 13
void setup() {
[Link](9600);
[Link]();
[Link](1, centralReceiverAddress); // Set the pipe address for receiving
[Link](); // Start listening for incoming messages
}
void loop() {
if ([Link]()) { // Check if there is incoming data
char data[32]; // Define a buffer to hold the received data
[Link](&data, sizeof(data)); // Read the incoming data into the buffer
[Link]("Received: ");
[Link](data); // Print the received data to the serial monitor
}
}
Output
Received: Sensor Data
Received: Sensor Data
…
This output confirms that the central receiver is successfully receiving data packets from the Motes. If you
observe consistent reception of the message "Sensor Data" at regular intervals, it indicates that the
communication system is functioning as expected, demonstrating the multi-point to single-point
communication over radio frequency using LAN sub-netting.

3.6 Results:
 Motes transmit data wirelessly to the central receiver over radio frequency.
 LAN sub-netting effectively organizes the network into logical sub-networks, allowing for efficient
data management.
 The central receiver receives and processes data packets from all Motes, demonstrating multi-point to
single-point communication.
 Data integrity and reliability are verified through consistent data reception and processing by the
central receiver.

Dept of ISE, JSSATEB 14

 Problem 4 : I2C protocol study
4.1 Aim:
The aim of this experiment is to study and understand the operation of the I2C (Inter-Integrated Circuit)
protocol by interfacing two devices using I2C communication.

4.2 Introduction:
The I2C (Inter-Integrated Circuit) protocol is a widely used synchronous serial communication standard in
embedded systems, facilitating seamless communication between integrated circuits, offering a
straightforward and efficient means of data exchange. I2C employs a bus architecture consisting of two
bidirectional lines: Serial Data (SDA) and Serial Clock (SCL). These lines allow multiple devices to
communicate with each other using only two wires, making I2C a preferred choice for interconnecting
sensors, actuators, memory devices, and other peripherals within embedded systems.I2C supports multi-
master and multi-slave configurations, making it suitable for various applications such as sensor networks,
real-time clocks, EEPROMs, and LCD displays.

4.3 Procedure:
It uses only 2 bi-directional open-drain lines for data communication called SDA and SCL. Both these
lines are pulled high. Serial Data (SDA) – Transfer of data takes place through this pin and Serial Clock
(SCL) – It carries the clock signal. I2C operates in 2 modes –Master mode and Slave mode. Each data bit
transferred on SDA line is synchronized by a high to the low pulse of each clock on the SCL line.
According to I2C protocols, the data line can not change when the clock line is high, it can change only
when the clock line is low. The data is transmitted in the form of packets which comprises 9 bits. The
sequence of these bits are – Start Condition – 1 bit, Slave Address – 8 bit and Acknowledge – 1 bitStart and
Stop Conditions : START and STOP can be generated by keeping the SCL line high and changing the level
of SDA. To generate START condition the SDA is changed from high to low while keeping the SCL high.

Hardware Setup:
Connect the SDA and SCL lines of the two devices (e.g., microcontrollers, sensors) to establish the I2C bus.
Ensure both devices share common ground connection. Power the devices using appropriate power sources.
Software Configuration: Initialize the I2C interface on both devices by configuring the SDA and SCL
pins. Set the device addresses for communication. Each device on the I2C bus must have a unique 7-bit
address. Determine the roles of each device (master or slave) in the communication.
Master Device Operation: The master device initiates communication by sending start and stop
conditions on the bus. It controls the timing of data transfer by generating clock pulses on the SCL line.
The master device addresses the slave devices on the bus and sends commands or requests for data.
Dept of ISE, JSSATEB 15
Slave Device Operation: The slave device listens for its address on the bus and responds when addressed
by the master. It acknowledges its address and processes commands or responds with data as required.
Data Transfer: Data transfer occurs in byte-sized packets between the master and slave devices.
The master device sends data bytes to the slave, which may respond with data or acknowledge receipt of
data. Multiple data bytes can be transferred sequentially in a single transaction.

4.4 Block Diagram :

4.5 Program :
#include <Wire.h>
#define DEVICE_ADDRESS 0x12 // Define the address of the slave device
#define DATA_SIZE 4 // Define the size of the data to be sent
uint8_t data[DATA_SIZE] = {0x01, 0x02, 0x03, 0x04}; // Define the data to be sent
void setup() {
[Link]();
[Link](9600);
}
void loop() {
[Link](DEVICE_ADDRESS);
[Link](data, DATA_SIZE);
[Link]();
delay(1000);
}

Dept of ISE, JSSATEB 16

Output:
Sent data: 01 02 03 04
Sent data: 01 02 03 04
Sent data: 01 02 03 04
…
The Arduino (master device) will continuously send data packets to the slave device with the address 0x12
every second. The transmitted data packets contain the bytes {0x01, 0x02, 0x03, 0x04}. The serial monitor
will display debug messages indicating the transmission of data packets to the slave device.

4.6 Results
 Data Transmission: The experiment successfully transmitted data packets from the master device
(Arduino) to the slave device using the I2C protocol. This confirms the ability of the I2C protocol to
facilitate communication between devices.
 Slave Device Response: Upon receiving data packets, the slave device responded appropriately based
on the transmitted data. This indicates the slave device's capability to receive and process data from the
master device.
 Serial Monitor Output: Debug messages in the serial monitor provided real-time feedback on the
transmission process, confirming successful data transmission and facilitating troubleshooting in case
of communication errors.
 Observation and Analysis: By observing the behavior of the master and slave devices during the
experiment, participants gained insights into the operation and reliability of I2C communication, as
well as potential challenges encountered in practical implementations.

Dept of ISE, JSSATEB 17

 Problem 5: Reading Temperature and Relative Humidity value from the sensor

5.1 Aim:
The aim of this experiment is to utilize the DHT11 sensor to accurately measure temperature and relative
humidity values.

5.2 Introduction:
The DHT11 sensor is a widely-used digital temperature and humidity sensor capable of providing accurate
and reliable measurements in various applications. It features a calibrated digital signal output, making it
easy to interface with microcontrollers for data acquisition. In this experiment, we leverage the capabilities
of the DHT11 sensor to measure temperature and relative humidity values in real-time. The DHT11 sensor
operates based on capacitive sensing principles, where changes in temperature and relative humidity affect
the capacitance of a polymer capacitor integrated into the sensor. This capacitance change is then converted
into digital signals by the sensor's built-in analog-to-digital converter (ADC) circuitry. Interfacing the
DHT11 sensor with a microcontroller, such as an Arduino board, enables us to read these digital signals
and interpret them as temperature and relative humidity values.

5.3 Procedure:
Hardware Setup: Connect the DHT11 sensor to the microcontroller board. The DHT11 sensor typically
has three pins: VCC, DATA, and GND. Connect the VCC pin of the DHT11 sensor to the 5V pin of the
microcontroller. Connect the DATA pin of the DHT11 sensor to a digital pin of the microcontroller (e.g.,
pin 2). Connect the GND pin of the DHT11 sensor to the ground (GND) pin of the microcontroller.
Code Implementation: Include the DHT library for interfacing with the DHT11 sensor. This library
provides functions to read temperature and humidity values from the sensor. Initialize the DHT sensor with
the appropriate pin configuration (e.g., pin 2) and specify the sensor type (DHT11). Read temperature and
relative humidity values from the DHT11 sensor using the readTemperature() and readHumidity()
functions provided by the DHT library.
Data Processing:Process the raw sensor data obtained from the DHT11 sensor to obtain meaningful
temperature and relative humidity values. The DHT library automatically performs data processing and
returns temperature in Celsius (°C) and relative humidity as a percentage (%).
Display and Monitoring: Display temperature and relative humidity values on the serial monitor for real-
time monitoring and analysis. Continuously update and refresh the displayed values to provide ongoing
monitoring of environmental [Link] relative humidity values.

Dept of ISE, JSSATEB 18

5.4 Block Diagram:

5.5 Program :
#include <DHT.h>
#define DHTPIN 2 // Digital pin connected to the DHT11 sensor
#define DHTTYPE DHT11 // Type of DHT sensor (DHT11 or DHT22)
DHT dht(DHTPIN, DHTTYPE); // Initialize DHT sensor
void setup() {
[Link](9600); // Initialize serial communication
[Link](); // Initialize DHT sensor
}
void loop() {
float temperature = [Link]();
float humidity = [Link]();

Dept of ISE, JSSATEB 19

 if (isnan(temperature) || isnan(humidity)) {
[Link]("Failed to read from DHT sensor!");
return;
}
[Link]("Temperature: ");
[Link](temperature);
[Link](" °C\t");
[Link]("Humidity: ");
[Link](humidity);
[Link](" %");
delay(2000); // Wait for 2 seconds before the next reading
}
The output for the provided code will be displayed on the serial monitor of the Arduino IDE. It will
continuously show the temperature and relative humidity values read from the DHT11 sensor in real-time.
Temperature: 25.0 °C Humidity: 50.0 %
Temperature: 25.2 °C Humidity: 49.8 %
Temperature: 25.5 °C Humidity: 49.6 %

5.6 Results :
 Temperature Readings: The experiment successfully retrieves temperature values from the DHT11
sensor. These values represent the ambient temperature in degrees Celsius (°C) and are displayed on
the serial monitor.
 Relative Humidity Readings: This retrieves relative humidity values from the DHT11 sensor. These
values represent the percentage of water vapor present in the air relative to the maximum amount of
water vapor the air can hold at that temperature, and they are displayed alongside the temperature
readings on the serial monitor.
 Real-time Monitoring: The displayed temperature and humidity values provide real-time monitoring
of the environmental conditions surrounding the sensor. This allows users to observe changes in
temperature and humidity levels over time.
 Sensor Reliability: The consistency and accuracy of the temperature and humidity readings
demonstrate the reliability of the DHT11 sensor for environmental monitoring applications.
 Troubleshooting Capability: The code includes error-checking mechanisms to detect and handle any
failures in reading data from the DHT11 sensor. In case of communication errors or sensor
malfunctions, appropriate error messages are displayed on the serial monitor, enabling users to identify
and address issues effectively.
Dept of ISE, JSSATEB 20
 CONCLUSION

In conclusion, the series of experiments conducted in this IoT practical report have provided valuable
insights into communication protocols and sensor interfacing in embedded systems. Each experiment was
meticulously designed to achieve specific objectives, ranging from basic UART communication to more
complex multi-point to single-point RF communication using LAN sub-netting.

Through these experiments, we explored the fundamentals of UART, RF, and I2C protocols, understanding
their principles of operation, advantages, and limitations. We witnessed how UART facilitates
straightforward serial communication, RF enables wireless data exchange, and I2C streamlines
communication between multiple devices using only two wires. Additionally, we demonstrated the
practical application of these protocols in transmitting data reliably and efficiently.

Moreover, the integration of sensors such as the DHT11 added another layer of functionality to our
embedded systems. By accurately measuring temperature and relative humidity values, we showcased the
importance of sensor data in various IoT applications, including environmental monitoring and control.

Throughout the experiments, we emphasized real-time monitoring and troubleshooting, essential aspects of
IoT system development. By continuously monitoring output data and implementing error-checking
mechanisms, we ensured the integrity and reliability of our systems.

Overall, this IoT practical report serves as a comprehensive guide for understanding and implementing
communication protocols and sensor interfacing in embedded systems. It equips students and practitioners
with the knowledge and skills necessary to design and develop IoT applications effectively, contributing to
the advancement of technology in the field of embedded electronics.

Dept of ISE, JSSATEB 21