Name: Aditya Vikram Pawar

MIS: 112101050
Batch: C

INTERNET OF THINGS AND APPLICATIONS

EXPERIMENT NO. 1
To study Arduino IDE and different types of Arduino Board

Aim:
To study Arduino IDE and different types of Arduino Board

Objective:
1. To introduce different types of Arduino boards and their specifications.
2. To understand the working principles of Arduino boards and their applications.
3. To write a simple program using the Arduino IDE for a specific Arduino board.

Hardware required:
1. Arduino Uno
2. Arduino Nano
3. Breadboard and jumper wires
4. LED (Light Emitting Diode)
5. Resistors (220 ohms)

Software required:
Arduino IDE (downloaded and installed)

Working principle:
The Arduino IDE is a software platform that allows users to write, compile, and upload code to Arduino
boards. Arduino boards are microcontroller-based platforms that execute the uploaded code to perform
various tasks.

Theory:
Arduino boards are equipped with microcontrollers, such as the AT Mega series, and a bootloader that
facilitates the programming process. The Arduino IDE provides an integrated development environment
for writing code in the Arduino programming language (based on C/C++).

Applications:
Arduino boards are widely used in prototyping, hobbyist projects, educational activities, and various
industrial applications. They serve as the brains of electronic projects, enabling the control of sensors,
actuators, and other components.

Conclusion:
This experiment successfully introduced the Arduino IDE and provided a basic understanding of different
types of Arduino boards. Exploring the IDE and working with simple code and hardware laid the
foundation for more complex projects involving sensors, actuators, and communication modules.
Understanding the versatility of Arduino boards and their applications is essential for anyone interested in
electronics, programming, and embedded systems.
 EXPERIMENT NO. 2
LED Blinking
Aim:
The aim of this experiment is to understand the basics of microcontroller programming and interfacing by
creating a simple LED blinking circuit. This experiment aims to introduce participants to the fundamental
concepts of hardware-software integration and real-time control.

Objective:
1. To set up a basic circuit for LED interfacing with a microcontroller.
2. To write a simple program to control the blinking of the LED.
3. To observe and analyse the behaviour of the LED under different program conditions.

Hardware required:
1. Microcontroller (e.g., Arduino Uno)
2. LED (Light Emitting Diode)
3. Resistor (220 ohms)
4. Breadboard and jumper wires

Software required:
Arduino IDE or any other microcontroller programming environment

Working principle:
The LED blinking circuit involves a microcontroller, which serves as the brain of the system. The
microcontroller is programmed to control the flow of electricity through the LED, causing it to alternate
between an on and off state. This control is achieved through the manipulation of digital output pins on
the microcontroller.

Theory:
LEDs are semiconductor devices that emit light when a current passes through them. In this experiment,
a microcontroller is used to control the flow of current through the LED, thereby controlling its
illumination. The program loaded onto the microcontroller dictates the on-off pattern of the LED.

Applications:
LED blinking experiments form the foundation for various electronic projects. The knowledge gained can
be applied to more complex applications such as display systems, lighting controls, and embedded
systems in diverse fields like robotics and automation.

Specification of sensors:
No external sensors are required for this introductory experiment. The focus is on the microcontroller
and LED interaction.
Circuit diagram:

Sketch:
// LED Blinking Program

const int ledPin = 13; // Pin number for the LED

void setup() {
pinMode(ledPin, OUTPUT); // Set the LED pin as output
}

void loop() {
digitalWrite(ledPin, HIGH); // Turn on the LED
delay(1000); // Wait for 1 second
digitalWrite(ledPin, LOW); // Turn off the LED
delay(1000); // Wait for 1 second
}
Result:
Upon uploading the program to the microcontroller, the LED will exhibit a blinking behavior with a one-
second on-off cycle. By modifying the program, participants can observe changes in the LED's behavior,
gaining insights into the direct relationship between code and hardware response.

Conclusion:
This experiment successfully achieved its objectives by providing a practical understanding of
microcontroller programming and hardware interfacing. We learned to construct a basic circuit, write a
program, and observe the direct impact of code changes on the LED's behavior. This foundational
knowledge is crucial for those venturing into the world of embedded systems and electronics.
 EXPERIMENT NO. 3
Calculating distance using Arduino
Aim:

To build an IoT project using Ultra Sonic HC-SR04 and Arduino (Arduino UNO) to calculate distance
between Ultra Sonic HC-SR04 device and an object.

Objective:

1. To write a program to calculate distance using Arduino.

2. Use a processing app to display the distance between Ultra Sonic device and object on the laptop’s
(Monitor) screen.

Hardware Requirements:
1. Arduino UNO board
2. USB cable connecter for Arduino UNO
3. Ultra Sonic HC-SR04
4. Power source (e.g., 9V battery)

Software requirements:
1. Arduino software

The working principle of Arduino-Bluetooth Module:

The Ultra Sonic HC-SR04 emits ultrasound at 40,000Hz that travels in the air. If there is an object or
obstacle in its path, then it collides and bounces back to the Ultra Sonic module.

The formula distance = speed*time is used to calculate the distance.

Suppose an object is placed at a distance of 10 cm away from the sensor, the speed of sound in air is 340
m/s or 0.034 cm/µs. It means the sound wave needs to travel in 294 µs. But the Echo pin double the
distance (forward and bounce backward distance). So, to get the distance in cm multiply the received
travel time value with echo pin by 0.034 and divide it by 2.

The distance between Ultra Sonic HC-SR04 and an object is:

Backward Skip 10sPlay Video

Theory:

The HC-SR04 ultrasonic sensor uses sonar to determine the distance to an object like bats do. It
offers excellent non-contact range detection with high accuracy and stable readings in an easy-
to-use package.

From 2cm to 400 cm or 1” to 13 feet. Its operation is not affected by sunlight or black material like sharp
rangefinders are (although acoustically soft materials like cloth can be difficult to detect). It comes
complete with the ultrasonic transmitter and a receiver module. A waterproof version of this Ultrasonic
Sensor is also available called JSN-SR04T/AJ-SR04M.

Specifications of sensors:
The specifications of the ultrasonic distance sensor HC-SR04 are below:

1. Minimum measuring range – 2 cm

2. Maximum measuring range: 400 cm or 4 meters
3. Accuracy: 3 mm
4. Operating Voltage: +5V
5. Operating Current: 15mA
6. Working Frequency: 40 KHz.
7. Trigger Input signal: 10us pulse
8. Measuring angle: 15 degrees

Pins:

1. VCC: +5VDC
2. Trig: Trigger (INPUT)
3. Echo: Echo (OUTPUT)
4. GND: GND
How Does it Work?

Ultrasonic sensors emit short, high-frequency sound pulses at regular intervals. These propagate
in the air at the velocity of sound. If they strike an object, then they are reflected back as echo
signals to the sensor, which itself computes the distance to the target based on the time-span
between emitting the signal and receiving the echo.

Circuit Diagram:
Sketch:
// define variables
#define trigPin 3
#define echoPin 2
long duration; // variable for duration of sound wave travel
int distance; // variable for the distance measurement
void setup () {
pinMode(trigPin, OUTPUT);// Sets the trigPin as an OUTPUT
pinMode(echoPin, INPUT);// Sets the ecoPin as INPUT
Serial.begin(9600); // Serial communication is starting with 9600 of baudrate speed
Serial.println("Ultrasonic sensor HC-SR04 Test ");// print some text in serial monitor
Serial.println("with Arduino UNO R3");
}
void loop () {
// clears the trig pin condition
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
//sets the trigpin high active for 10 microseconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// READS THE ECHO PIN , RETURNS THE SOUND WAVE TRAVEL TIME IN MICROSECONDS
duration=pulseIn(echoPin, HIGH );
// CALCULATING THE DISTANCE
distance=duration*0.034/ 2; //speed of sound wave divided by 2 (go and back)
// display the distance on the serial monitor
Serial.print("distance : ");
Serial.print(distance);
Serial.println(" cm");
}
Result:

Conclusion:
This experiment successfully demonstrated the process of interfacing an ultrasonic sensor with an
Arduino to measure distances accurately. We gained practical insights into the working principle of
ultrasonic sensors and the translation of sensor data into meaningful distance measurements.
Understanding and implementing such systems are crucial for various real-world applications, particularly
in robotics, automation, and sensor-based control systems.
 EXPERIMENT NO. 4
Monitor temperature and humidity using DHT11 sensor.

Aim:

To build an IoT project using DHT11 sensor and Arduino (Arduino UNO) to measure temperature and
humidity of surrounding environment.

Objectives:

1. To write a program to monitor temperature and humidity using Arduino.

2. Use a serial monitor to display the temperature in Celsius or Fahrenheit and humidity on the
laptop’s (Monitor) screen.

Hardware Requirements:

1. Arduino UNO board

2. USB cable connecter for Arduino UNO
3. DHT11 sensor
4. Jumper wires male to female

Software requirements:

1. Arduino software
2. DHT11 library for Arduino

Working principle:

 DHT11 sensor consists of a capacitive humidity sensing element and a thermistor for sensing
temperature.
 The humidity sensing capacitor has two electrodes with a moisture holding substrate as a
dielectric between them. Change in the capacitance value occurs with the change in humidity
levels. The IC measures and processes this changed capacitance values and change them into
digital form.
 For measuring temperature this sensor uses a Negative Temperature coefficient thermistor,
which causes a decrease in its resistance value with increase in temperature. To get larger
resistance value even for the smallest change in temperature, this sensor is usually made up of
semiconductor ceramics or polymer.

Theory:

 Humidity is the measure of water vapors present in the air. The level of humidity in the air affects
various physical, chemical, and biological processes.
 In industrial applications, humidity can affect the business cost of the products, health, and safety
of the employees. So, in semiconductor industries and control system industries measurement of
humidity is very important.
  Humidity measurement determines the amount of moisture present in the gas that can be a
mixture of water vapors, nitrogen, argon, or pure gas etc.... Humidity sensors are of two types
based on their measurement units. They are a relative humidity sensor and Absolute humidity
sensor. DHT11 is a digital temperature and relative humidity sensor.

Relative Humidity

 Relative humidity is defined as the ratio between the amount of moisture in the air at a particular
temperature to the maximum moisture air can withstand at the same temperature. The relative
humidity is 100% during rainy seasons.

Absolute Humidity

 Absolute humidity, which describes air’s water content, is used to measure the weight of water
vapour per unit volume of air. The absolute humidity unit is given as g.m-3 which is units of grams of
water vapours per cubic metre of air. Since other factors constantly affect absolute humidity, the
results are less useful.

Specific Humidity

 The specific humidity unit is the most reliable unit of measurement of humidity. This measures the
weight of water vapors per unit weight of air, and it is expressed as grams of water vapors per
kilogram of air g.kg-1 is the specific humidity unit.

Applications:

 This sensor is used in various applications such as measuring humidity and temperature values in
heating, ventilation, and air conditioning systems.
 Weather stations also use these sensors to predict weather conditions.
 The humidity sensor is used as a preventive measure in homes where people are affected by
humidity. Offices, cars, museums, greenhouses, and industries use this sensor for measuring
humidity values and as a safety measure.
 Its compact size and sampling rate made this sensor popular among hobbyists. Some of the
sensors which can be used as an alternative to DHT11 sensor are DHT22, AM2302, SHT71.
Specification of DHT11 sensor:
Circuit Diagram:

Sketch:

// Temperature and Humidity Monitoring Program

#include <DHT.h>

#define DHTPIN 2 // Digital pin connected to the DHT sensor

#define DHTTYPE DHT22 // Type of the DHT sensor (DHT22 or DHT11)

DHT dht(DHTPIN, DHTTYPE);

void setup() {

Serial.begin(9600);

dht.begin();

void loop() {

delay(2000); // Delay between readings

 float temperature = dht.readTemperature();

float humidity = dht.readHumidity();

Serial.print("Temperature: ");

Serial.print(temperature);

Serial.print(" °C, Humidity: ");

Serial.print(humidity);

Serial.println(" %");

Result:

Conclusion:

In conclusion, the experiment to monitor temperature and humidity using the DHT11 sensor has been
successful in achieving its objectives. The DHT11 sensor, with its straightforward interfacing and reliable
performance, proved to be an effective tool for real-time environmental data monitoring.
 EXPERIMENT NO. 5
Detection of motion using PIR sensor
Aim:

The aim of this experiment is to implement a motion detection system using a PIR sensor and Arduino.
The primary objective is to understand the principles behind PIR sensors, interface them with a
microcontroller, and develop a practical motion detection application.

Objective:

1. To comprehend the working principle of PIR sensors.

2. To interface a PIR sensor with an Arduino microcontroller.
3. To write a program that detects and responds to motion events.
4. To analyze the reliability and sensitivity of the motion detection system

Hardware required:

1. Arduino board (e.g., Arduino Uno)

2. PIR sensor (Passive Infrared Sensor)
3. Breadboard and jumper wires
4. LED (Light Emitting Diode)
5. Resistors (220 ohms)
6. Power source (e.g., 9V battery)

Software required:

Arduino IDE

Working principle:

PIR sensors detect changes in infrared radiation emitted by or reflected from objects in their field of view.
When a warm object, such as a person, enters the sensor's range, it triggers a motion event.

Theory:

The PIR sensor contains pyroelectric sensors that generate electrical charges in response to infrared
radiation changes. The sensor module amplifies and converts these charges into voltage variations,
triggering an output signal when motion is detected.

Applications:

Motion detection systems using PIR sensors are widely employed in security systems, lighting control,
home automation, and occupancy sensing applications.

Specification of sensors:

For this experiment, a generic PIR sensor with a range of approximately 5-7 meters and an adjustable
sensitivity and delay time is used.

Circuit diagram:
Sketch:

int sensor = 2;
int state = LOW;
int val = 0;
int led = 13;
void setup() {
// put your setup code here, to run once:
pinMode(led, OUTPUT);
pinMode(sensor, INPUT);
Serial.begin(9600);

void loop() {
val = digitalRead(sensor);
if (val == HIGH) {
digitalWrite(led, HIGH);
delay(500);

if (state == LOW) {
Serial.println("Motion detected!");
state = HIGH;
}
}
 else {
digitalWrite(led, LOW);
delay(500);
if(state == HIGH){
Serial.println("Motion stopped!");
state = LOW;

}
} // put your main code here, to run repeatedly:

Result:

Conclusion:
This experiment successfully demonstrated the practical implementation of a motion detection system
using a PIR sensor and Arduino. Participants gained insights into the working principles of PIR sensors,
their interface with microcontrollers, and the development of responsive applications. Motion detection
systems are integral to various fields, particularly in smart homes, security systems, and energy-efficient
lighting control.
 EXPERIMENT NO. 6
Determine the gas level/smoke using MQ2 Gas sensor.

Aim:
The aim of this experiment is to design a gas sensing system using a gas sensor and Arduino. The primary
goal is to understand the principles of gas sensors, interface them with a microcontroller, and develop a
practical application for gas detection.

Objective:
1. To comprehend the working principle of gas sensors.
2. To interface a gas sensor with an Arduino microcontroller.
3. To develop a program that reads and interprets gas concentration data.
4. To analyse the sensitivity and reliability of the gas sensing system.

Hardware required:
1. Arduino board (e.g., Arduino Uno)
2. Gas sensor (e.g., MQ series gas sensor)
3. Breadboard and jumper wires
4. Power source (e.g., USB power or battery)

Software required:
Arduino IDE

Working principle:
Gas sensors operate on the principle of detecting changes in electrical conductivity caused by the
presence of specific gases. When the target gas interacts with the sensor's surface, it alters the
conductivity, leading to measurable changes.

Theory:
MQ series gas sensors use a metal oxide semiconductor to detect gases. The sensor's resistance changes
when it comes into contact with a specific gas, and this change is translated into a voltage signal that can
be read and analyzed by a microcontroller.

Applications:
Gas sensors find applications in various fields, including air quality monitoring, industrial safety, and
detection of harmful gases in confined spaces.
Specification of sensors:
For this experiment, an MQ series gas sensor is used. The specifications vary depending on the specific
gas being detected. Common gases include methane, propane, carbon monoxide, and others.

Circuit diagram:

Sketch:
Result:

Conclusion:
This experiment successfully demonstrated the practical implementation of a gas sensing system using a
gas sensor and Arduino. We got insights into the working principles of gas sensors, their interface with
microcontrollers, and the interpretation of gas concentration data. Gas sensors are essential in various
applications, particularly in monitoring air quality and ensuring safety in environments where the
presence of specific gases poses a risk. Understanding and implementing such systems are crucial for
those involved in environmental monitoring and industrial safety.
 EXPERIMENT NO. 7
3-axis orientation using accelerometer

Aim:
The aim of this experiment is to design a vibration detection system using an accelerometer and Arduino.
The primary objective is to understand the principles of accelerometer sensors, interface them with a
microcontroller, and develop a practical application for vibration detection.

Objective:
 To comprehend the working principle of accelerometers.
 To interface an accelerometer with an Arduino microcontroller.
 To develop a program that detects and responds to vibrations.
 To analyze the sensitivity and reliability of the vibration detection system.

Hardware required:
1. Arduino board (e.g., Arduino Uno)
2. Accelerometer sensor (e.g., ADXL335)
3. Breadboard and jumper wires
4. LED (Light Emitting Diode)
5. Resistors (220 ohms)
6. Power source (e.g., 9V battery)

Software required:
Arduino IDE

Working principle:
Accelerometers measure acceleration, including the effects of gravity. When subjected to vibrations, the
accelerometer generates electrical signals proportional to the applied forces. These signals can be
analyzed to detect and quantify vibrations.

Theory:
The ADXL335 accelerometer, for example, consists of three-axis sensors that measure acceleration in
the x, y, and z directions. The sensor outputs analog voltage signals corresponding to the acceleration in
each axis. By monitoring these signals, vibrations in the environment can be identified.

Applications:
Vibration detection systems are essential in various industries, including structural health monitoring,
predictive maintenance, and transportation for monitoring vehicle vibrations.
Specification of sensors:
For this experiment, an ADXL335 accelerometer sensor is used. It has a sensing range of ±3g and
provides analog voltage outputs corresponding to acceleration along the x, y, and z axes.

Circuit diagram:

Sketch:
Result:
Conclusion:
This experiment successfully demonstrated the practical implementation of a vibration detection system
using an accelerometer and Arduino. Participants gained insights into the working principles of
accelerometers, their interface with microcontrollers, and the development of responsive applications.
Vibration detection systems play a crucial role in monitoring the integrity of structures and machinery,
making them valuable tools in fields such as engineering and industrial maintenance.
 EXPERIMENT NO. 8
3-axis orientation using gyroscope.

Aim:
The aim of this experiment is to implement a gyroscope measurement system using an Inertial
Measurement Unit (IMU) and Arduino. The primary objective is to gain hands-on experience with
gyroscope sensors, interface them with a microcontroller, and develop a practical application for
measuring angular motion.

Objective:
1. To understand the working principles of gyroscope sensors.
2. To interface an IMU with an Arduino microcontroller.
3. To develop a program that reads and interprets gyroscope data.
4. To analyse the accuracy and reliability of the gyroscope measurement system.

Hardware required:
1. Arduino board (e.g., Arduino Uno)
2. Inertial Measurement Unit (IMU) with gyroscope (e.g., MPU6050)
3. Breadboard and jumper wires
4. Power source (e.g., USB power or battery)

Software required:
1. Arduino IDE
2. MPU6050 library (for interfacing with the gyroscope)

Working principle:
Gyroscopes measure the rate of angular motion in degrees per second. In an IMU, a gyroscope detects
changes in orientation by sensing the Coriolis effect caused by the rotation of the device.

Theory:
The MPU6050 gyroscope, for example, uses a microelectromechanical system (MEMS) to sense angular
motion. The Coriolis force generated by the rotation of the device causes a displacement of the MEMS
structure, which is converted into electrical signals. These signals are then processed to determine the
angular velocity.

Applications:
Gyroscope sensors find applications in various fields, including robotics, navigation systems, virtual reality,
and motion tracking.
Specification of sensors:
For this experiment, an MPU6050 IMU is used. It has a gyroscope with a programmable full-scale range,
typically ±250, ±500, ±1000, or ±2000 degrees per second.

Circuit diagram:

Sketch:
Result:
Conclusion:
This experiment successfully demonstrated the practical implementation of a gyroscope measurement
system using an IMU and Arduino. Participants gained insights into the working principles of gyroscopes,
their interface with microcontrollers, and the interpretation of gyroscope data. Gyroscope sensors are
essential in various applications, particularly in robotics and motion sensing technologies. Understanding
and implementing such systems are crucial for those involved in developing devices that require precise
orientation tracking.
 EXPERIMENT NO. 9
LCD display with Arduino Uno
Aim:
The aim of this experiment is to interface an LCD (Liquid Crystal Display) with an Arduino to display
information. The primary goal is to understand the basics of connecting and programming an LCD for
practical applications.

Objective:
1. To learn how to connect and interface an LCD with an Arduino.
2. To understand the programming required to display information on the LCD.
3. To develop a simple application for displaying data on the LCD.
4. To explore the versatility of using an LCD for real-time information presentation.

Hardware required:
1. Arduino board (e.g., Arduino Uno)
2. LCD (16x2 or any other compatible with Arduino)
3. Potentiometer (for contrast adjustment)
4. Breadboard and jumper wires

Software required:
Arduino IDE

Working principle:
LCDs work on the principle of liquid crystal modulation to control the passage of light through pixels.
Arduino is used to send specific commands and data to the LCD, allowing the display of characters and
graphics.

Theory:
The LCD is a passive display technology that requires an external light source to be visible. In this
experiment, the LCD is connected to the Arduino, and characters or messages are sent to the LCD by
programming the Arduino microcontroller.

Applications:
LCDs are widely used in various applications, including digital devices, instrumentation, and DIY
electronics projects where visual information needs to be displayed.
Specification of sensors:
No external sensors are required for this experiment. The focus is on the Arduino and LCD interface

Circuit diagram:

Sketch:
#define DELEAY 2

#define EN 1

#define DATAMODE 0b0010 // 4 bit data mode

#define CLEAR_1 0b0000

#define CLEAR_2 0b0001

#define RET_1 0b0000

#define RET_2 0b0010

#define ON_1 0b0000

#define ON_2 0b1100

#define H_1 0b0100

#define H_2 0b1000

#define I_1 0b0100

#define I_2 0b1001

void setup()

DDRD = B11111111; // set PORTD (digital 7~0) to outputs

DDRB = B11111111; // set PORTD (digital 7~0) to outputs

DDRC = B11111111; // set PORTD (digital 7~0) to outputs

void loop()

command(DATAMODE);

command(ON_1);

command(ON_2);

while(1)

command(CLEAR_1);

command(CLEAR_2);

ch(H_1);
 ch(H_2);

ch(I_1);

ch(I_2);

void command(int command)

PORTC = B0;

PORTD = command;

PORTB = B1;

delay(DELEAY);

PORTB = B0;

void ch(int ch)

PORTD = ch;

PORTC = B1;

PORTB = B1;

delay(DELEAY);

PORTB = B0;

Result:
Conclusion:

This experiment successfully demonstrated the basics of interfacing an LCD with Arduino, allowing for the
display of information in a controlled manner. Participants gained insights into the programming and
circuitry required for incorporating an LCD into electronic projects. Understanding how to work with LCDs
is valuable for anyone involved in electronics and embedded systems, as it is a common component in
many applications requiring visual feedback.
 EXPERIMENT NO. 10
To Perform Arithmetic operation using python

Aim:
To Perform Arithmetic operation using python

Objective:
 To understand and implement common arithmetic operations in Python.
 To learn how to write and execute Python scripts for mathematical calculations.
 To gain proficiency in using variables and operators in Python programming.
 To visualize and interpret the results of arithmetic operations.

Software required:
Python interpreter or a Python IDE (Integrated Development Environment) installed on the computer.

Working principle:
The working principle involves using Python as a programming language to execute arithmetic operations.
Python provides a set of operators (e.g., +, -, *, /,%, **) that can be used to perform addition, subtraction,
multiplication, division, modulo (remainder), and exponentiation, respectively.

Theory:
Python is a versatile and expressive programming language that supports arithmetic operations natively.
Variables are used to store numeric values, and operators are used to perform operations on these
variables.

Applications:
While this experiment focuses on basic arithmetic operations, Python is widely used in various fields,
including web development, data science, machine learning, automation, and scientific computing.

Sketch:
# Arithmetic Operations in Python

# Addition

num1 = 10

num2 = 5

sum_result = num1 + num2

print(f"Addition: {num1} + {num2} = {sum_result}")

# Subtraction

difference = num1 - num2

print(f"Subtraction: {num1} - {num2} = {difference}")

# Multiplication

product = num1 * num2

print(f"Multiplication: {num1} * {num2} = {product}")

# Division

quotient = num1 / num2

print(f"Division: {num1} / {num2} = {quotient}")

# Modulo (Remainder)

remainder = num1 % num2

print(f"Modulo (Remainder): {num1} % {num2} = {remainder}")

# Exponentiation

power_result = num1 ** num2

print(f"Exponentiation: {num1} ^ {num2} = {power_result}")

Result:
Conclusion:
This experiment successfully introduced basic arithmetic operations in Python. Understanding and
mastering these fundamental concepts are essential for programming in Python and laying the
groundwork for more complex tasks in software development and data analysis. We have gained practical
experience in writing and executing Python scripts for mathematical computations.