Practical No.

1
Program :
int led=8; void
setup()
{
pinMode(led, OUTPUT);
}

void loop()
{
digitalWrite(led, HIGH);
delay(500); digitalWrite(led,
LOW); delay(500);
}

Output :
 Practical No. 2
Program :

void setup()
{
pinMode(8, OUTPUT);
pinMode(7, OUTPUT);
}
void loop()
{
digitalWrite(8, HIGH);
delay(500); digitalWrite(8,
LOW); delay(1000);
digitalWrite(7, HIGH);
delay(500); digitalWrite(7,
LOW); delay(1000);
}

Output :
 Practical No. 3
Program :

int led=7; int i;

void setup()
{
pinMode(led,OUTPUT);
}

void loop()
{
for(i=0;i<=255;i++)
{
analogWrite(led,i);
delay(15);
}
}

Output :
 Practical No. 4
Program :
void setup()
{
pinMode(A0, INPUT); pinMode(13, OUTPUT); Serial.begin(9600);
}
void loop()
{
int ldr= analogRead(A0); Serial.println(ldr); if(ldr<500)
{
digitalWrite(13, HIGH);
}
else
{
digitalWrite(13, LOW);
}
delay(300);
}

Output :
 Practical No. 5
Program :
float temp;
int tempPin = A1;

void setup()
{
Serial.begin(9600);
}
void loop()
{
temp = analogRead(tempPin); temp = temp * 0.48828125;
Serial.print("TEMPERATURE = "); Serial.print(temp); Serial.print("*C");
Serial.println();
delay(1000);
}
Output :
 Practical No. 6
Program :
#define ctsPin 2 int ledPin = 13; void setup()
{
Serial.begin(9600); pinMode(ledPin, OUTPUT); pinMode(ctsPin, INPUT);
}
void loop() {
int ctsValue = digitalRead(ctsPin); if (ctsValue == HIGH) { digitalWrite(ledPin,
HIGH); Serial.println("TOUCHED");
}
else{ digitalWrite(ledPin,LOW); Serial.println("not touched");
}
delay(500);
}
Output :
 Practical No. 7
Program :
int IRSensor = 7; void setup()
{
pinMode (IRSensor, INPUT); Serial.begin(9600);
}

void loop()
{
int statusSensor = digitalRead (IRSensor);

if (statusSensor == 1)
{
Serial.println("obstacle detected");
}
else
{
Serial.println(" No obstacle detected");
}
}
Output :
 Practical No. 8
Program :
#define echoPin 12
#define trigPin 13 long duration;
int distance; void setup()
{
pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); Serial.begin(9600);
Serial.println("Distance measurement using Arduino Uno."); delay(500);
}
void loop()
{
digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH);
delayMicroseconds(10); digitalWrite(trigPin, LOW); duration =
pulseIn(echoPin, HIGH); distance = duration * 0.0344 / 2;
Serial.print("Distance: "); Serial.print(distance); Serial.println(" cm");
delay(100);
}

Output :
 Practical No. 9
Program :

int LED = 11; const

int gas = 0; int
MQ2pin = A0;
void setup() { Serial.begin(9600);
}
void loop() {
float sensorValue,MQ2pin; sensorValue =
analogRead(MQ2pin); if(sensorValue >=
470){ digitalWrite(LED,HIGH);
Serial.println(" |SMOKE DETECTED");
}
else{ digitalWrite(LED,LOW);
Serial.println("Sensor Value: ");
Serial.println(sensorValue);
}
delay(1000);
}
float getsensorValue(int pin){ return
(analogRead(pin));
}

Output :
 Practical No. 10
Program :
const int sensorPin = 4; const
int ledPin = 2; const int
buzzerPin = 3; void setup()
{
Serial.begin(9600);
pinMode(sensorPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(buzzerPin,
OUTPUT);
}
void loop()
{
if (digitalRead(sensorPin))
{
Serial.println("Detected
vibration...");
digitalWrite(ledPin, HIGH);
tone(buzzerPin, 1000);
}
else
{
Serial.println("...");
digitalWrite(ledPin, LOW);
noTone(buzzerPin);
}
delay(100);
}

Output :
 Practical No. 11
Program :
#define BUZZER 2
#define DELAYTIME 1000
void setup() { pinMode(2,
OUTPUT); digitalWrite(2,
LOW);
}
void loop(){ digitalWrite(2,
HIGH); delay(DELAYTIME);
digitalWrite(2, LOW);
delay(DELAYTIME);
}
Output :

\
 Practical No. 12
Program :
#include <LiquidCrystal_I2C.h>

#include"DHT.h"

#define DHTPIN 2 #define

DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup() { pinMode(DHTPIN,

INPUT);
lcd.init(); lcd.backlight();
dht.begin();
}

void loop() { delay(2000);

lcd.setCursor(1, 0);
float h = dht.readHumidity(); float t =
dht.readTemperature(); if (isnan(h) ||
isnan(t)) {
Serial.println(F("Failed to read from DHT sensor!")); return;
}
lcd.print("Humidity: "); lcd.print(h);
lcd.setCursor(1, 1);
lcd.print("Temperature: "); lcd.print(t);
delay(100);
}
Output :
 Practical No. 13
Program :
void setup()
{
pinMode(13,OUTPUT); pinMode(2,
INPUT); Serial.begin(9600);
}
void loop()
{
int x=digitalRead(2); if (x==1)
{
digitalWrite(13,HIGH);
Serial.println("Object Detected");
delay(500);
}
else{
digitalWrite(13,LOW);
Serial.println("NO Object Detected");
delay(500);
}
}
Output :
 Practical No. 14
Program :
#include <IRremote.h>

const int irReceiverPin = 2;

void setup()
{
Serial.begin(9600);
IrReceiver.begin(irReceiverPin);
pinMode(12, OUTPUT);
}
void loop() {
if (IrReceiver.decode())
{
Serial.println(IrReceiver.decodedIRData
.command); int a =
IrReceiver.decodedIRData.command;

if (a == 48)
{
digitalWrite(3, HIGH);
}

else
{
digitalWrite(3, LOW);
}

}
IrReceiver.resume();
}

Output :
 Practical No. 15
Program :
const int PIR_PIN = 4;
const int LDR_PIN = A0; const int
LED_PIN = 6;
int pirState = LOW; int ldrValue = 0;
int threshold = 500; void setup() {
pinMode(PIR_PIN, INPUT);
pinMode(LED_PIN, OUTPUT);
Serial.begin(9600);
}
void loop() {
pirState = digitalRead(PIR_PIN);
ldrValue = analogRead(LDR_PIN);
if (pirState == HIGH && ldrValue <
threshold) { digitalWrite(LED_PIN,
HIGH);
Serial.println("Motion detected and
ambient light level is low. Turning on
LED.");
} else {
digitalWrite(LED_PIN, LOW);
Serial.println("No motion detected or
ambient light level is high. Turning off
LED.");
}
delay(100);
}
Output :
 Practical No. 16
Program :
#include <Wire.h>
#include <LiquidCrystal_I2C.h> //343 m/s = 0.0001 * 343 = 0.0343 cm/μs
if (distance < 40) {
LiquidCrystal_I2C lcd(0x27, 16, 2); Serial.print("OBSTACLE DETECTED \n");
const int trigger = 9; tone(buzzer, 1000);
const int echo = 10; } else {
const int buzzer = 11; noTone(buzzer);
const int led = 13; }
void setup() { if(distance>40){
pinMode(trigger, OUTPUT); Serial.print("NO OBSTACLE DETECTED \n");
pinMode(echo, INPUT); digitalWrite(led, HIGH);
pinMode(buzzer, OUTPUT);
pinMode(led, OUTPUT); }
Serial.begin(9600); else{
lcd.init(); digitalWrite(led, LOW);
lcd.backlight();
} }
void loop() {
digitalWrite(trigger, LOW); lcd.setCursor(0, 0);
delayMicroseconds(5); lcd.print("OBJ DISTANCE ");
lcd.setCursor(0, 1);
digitalWrite(trigger, HIGH); lcd.print(distance);
delayMicroseconds(13); lcd.setCursor(4, 1);
digitalWrite(trigger, LOW); lcd.print("cm");

long duration = pulseIn(echo, HIGH);

int distance = (duration * 0.0343) / 2; delay(500);
Serial.print("Sensor Distance: "); }
Serial.println(distance);
Output :
 Practical No. 17
Program :
#include <LiquidCrystal.h>

const int mq2Pin = A0;

const int flamePin = 2;
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
const int speakerPin = 10;
const int smokeThreshold = 300;
const int flameThreshold = LOW;

void setup() {
lcd.begin(16, 2);
pinMode(mq2Pin, INPUT);
pinMode(flamePin, INPUT);
pinMode(speakerPin, OUTPUT);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Fire & Smoke");
lcd.setCursor(0, 1);
lcd.print("Detection");
}

void loop() {
int smokeValue = analogRead(mq2Pin);
int flameValue = digitalRead(flamePin);

if (smokeValue > smokeThreshold || flameValue == flameThreshold) {

lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Fire or Smoke");
lcd.setCursor(0, 1);
lcd.print("Detected");
tone(speakerPin, 1000);
} else {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("System Standby");
noTone(speakerPin);
}

delay(1000);
}
Output :
 Practical No. 18
Program :
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4); Output :
const int potentiometerPin = A0;
const int relayPin = 7;
const int ledPin = 3;
int moistureLevel = 0;
const int moistureThresholdLow = 50;
const int moistureThresholdHigh = 75;
unsigned long previousMillis = 0;
const long interval = 1000;
void setup() {
lcd.init();
lcd.backlight();
pinMode(relayPin, OUTPUT);
pinMode(ledPin, OUTPUT);
digitalWrite(relayPin, LOW);
digitalWrite(ledPin, LOW);
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
moistureLevel = analogRead(potentiometerPin);
int moisturePercentage = map(moistureLevel, 0, 1023, 0, 100);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Moisture: ");
lcd.print(moisturePercentage);
lcd.print("%");
if (moisturePercentage < moistureThresholdLow || moisturePercentage >
moistureThresholdHigh) {
lcd.setCursor(0, 1);
lcd.print("Sprinkler Activated!");
digitalWrite(relayPin, HIGH);
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(relayPin, LOW);
digitalWrite(ledPin, LOW);
}
}
}
 Practical No. 19
Program :
#include <LiquidCrystal.h> analogRead(mq2Pin);
const int mq2Pin = A0; int flameValue =
const int flamePin = 2; digitalRead(flamePin);
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); if (smokeValue > smokeThreshold
const int speakerPin = 10; || flameValue == flameThreshold) {
const int smokeThreshold = 300; lcd.clear();
const int flameThreshold = LOW; lcd.setCursor(0, 0);
void setup() { lcd.print("Fire detected");
lcd.begin(16, 2); tone(speakerPin, 1000);
pinMode(mq2Pin, INPUT); } else {
pinMode(flamePin, INPUT); lcd.clear();
pinMode(speakerPin, OUTPUT); lcd.setCursor(0, 0);
lcd.clear(); lcd.print("Standby");
lcd.setCursor(0, 0); noTone(speakerPin);
lcd.print("Fire Detection"); }
}
void loop() { delay(1000);
int smokeValue = }
Output :
 Practical No. 20
Program :
#include <DHT.h>
#include <LiquidCrystal_I2C.h>

#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 16, 2); Output :

int chk;
float hum;
float temp;

void setup() {
dht.begin();
lcd.init();
lcd.backlight();
}

void loop() {
delay(2000);
hum = dht.readHumidity();
temp = dht.readTemperature();
lcd.setCursor(0, 0);
lcd.print("Humidity: ");
lcd.print(hum);
lcd.print(" % ");
lcd.setCursor(0, 1);
lcd.print(" Temp: ");
lcd.print(temp);
lcd.println(" Celsius");
delay(10000);
}