Unit 4: Visual Output & Sensors

Opening Hook — Making Machines See, Sense, and Respond

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — Visual Output & Sensors from Scratch

1. LED Interfacing — The Hello World of Hardware

Every electronics journey begins with blinking an LED. An LED (Light Emitting Diode) is a semiconductor device that emits light when current flows through it in the forward direction. Unlike a regular bulb, an LED only allows current in one direction — from the Anode (+) to the Cathode (−).

ASCII Circuit Diagram — LED with Arduino

Circuit
    Arduino Uno
   ┌──────────────┐
   │              │
   │   Pin 13  ●──┼──── [220Ω Resistor] ────┐
   │              │                          │
   │              │                     LED (Anode +)
   │              │                          │
   │              │                     LED (Cathode -)
   │              │                          │
   │      GND  ●──┼──────────────────────────┘
   │              │
   └──────────────┘

   Schematic:
   Pin 13 ──[220Ω]──►|── GND
                     LED
   (►| = LED symbol: triangle is anode, line is cathode)

Connection Table

Complete Arduino Code — Blink LED

Arduino
// LED Blink Program — The Hello World of IoT
// Blinks an LED connected to Pin 13 every second

const int ledPin = 13;  // LED connected to digital pin 13

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

void loop() {
  digitalWrite(ledPin, HIGH);  // Turn LED ON (5V)
  delay(1000);                  // Wait 1 second
  digitalWrite(ledPin, LOW);   // Turn LED OFF (0V)
  delay(1000);                  // Wait 1 second
}

2. LED Brightness Control with PWM

Digital pins can only output HIGH (5V) or LOW (0V) — so how do we get intermediate brightness? The answer is PWM (Pulse Width Modulation). PWM rapidly switches the pin ON and OFF at varying ratios, creating the illusion of analog voltage.

ASCII PWM Waveform Diagram

PWM Waveforms
  25% Duty Cycle (analogWrite = 64):
  5V ┤ ██                          ██                          ██
     │ ██                          ██                          ██
  0V ┤ ██ ████████████████████████ ██ ████████████████████████ ██
     └──────────── Time ────────────────────────────────────────

  50% Duty Cycle (analogWrite = 127):
  5V ┤ ██████████████              ██████████████
     │ ██████████████              ██████████████
  0V ┤ ██████████████ ████████████ ██████████████ ████████████
     └──────────── Time ────────────────────────────────────────

  75% Duty Cycle (analogWrite = 191):
  5V ┤ ██████████████████████████  ██████████████████████████
     │ ██████████████████████████  ██████████████████████████
  0V ┤ ██████████████████████████ ███████████████████████████
     └──────────── Time ────────────────────────────────────────

Connection Table

Complete Arduino Code — Fading LED

Arduino
// LED Fading with PWM — Smooth brightness control
// LED connected to PWM pin 9

const int ledPin = 9;  // PWM pin (marked ~)

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

void loop() {
  // Fade IN: brightness 0 → 255
  for (int brightness = 0; brightness <= 255; brightness++) {
    analogWrite(ledPin, brightness);
    delay(10);  // 10ms per step = ~2.5 sec total fade
  }

  // Fade OUT: brightness 255 → 0
  for (int brightness = 255; brightness >= 0; brightness--) {
    analogWrite(ledPin, brightness);
    delay(10);
  }
}

3. 7-Segment Display — Displaying Digits

A 7-segment display is made up of 7 LEDs (segments a through g) arranged in a figure-8 pattern, plus an optional decimal point (dp). By turning specific segments ON/OFF, you can display digits 0–9 and some letters.

ASCII Pin Diagram — 7-Segment Display

Pin Layout
         ─── a ───
        │         │
        f         b
        │         │
         ─── g ───
        │         │
        e         c
        │         │
         ─── d ───   ● dp

  Physical Pin Layout (top view):
  ┌──────────────────────┐
  │  a   b   COM  d   e  │    (Top row: pins 1-5 left to right)
  │                      │
  │  f   g   COM  c   dp │    (Bottom row: pins 6-10 left to right)
  └──────────────────────┘

  Note: Pin numbering may vary by manufacturer.
  COM = Common pin (connect to GND for CC, 5V for CA)

Segment Truth Table — Digits 0-9 (Common Cathode, HIGH = ON)

Connection Table — 7-Segment to Arduino

ASCII Circuit Diagram

Circuit
    Arduino Uno                    7-Segment (Common Cathode)
   ┌──────────┐                   ┌─────────────┐
   │ Pin 2  ●─┼──[220Ω]──────────┤ a           │
   │ Pin 3  ●─┼──[220Ω]──────────┤ b           │
   │ Pin 4  ●─┼──[220Ω]──────────┤ c           │
   │ Pin 5  ●─┼──[220Ω]──────────┤ d           │
   │ Pin 6  ●─┼──[220Ω]──────────┤ e           │
   │ Pin 7  ●─┼──[220Ω]──────────┤ f           │
   │ Pin 8  ●─┼──[220Ω]──────────┤ g           │
   │   GND  ●─┼──────────────────┤ COM (GND)   │
   └──────────┘                   └─────────────┘

Complete Arduino Code — Display 0 to 9

Arduino
// 7-Segment Display: Digits 0-9 (Common Cathode)
// Segments a-g connected to Arduino pins 2-8

const int segPins[] = {2, 3, 4, 5, 6, 7, 8};
//                     a   b   c   d   e   f   g

// Segment patterns for digits 0-9 (1=ON, 0=OFF)
const byte digits[10][7] = {
  {1,1,1,1,1,1,0},  // 0
  {0,1,1,0,0,0,0},  // 1
  {1,1,0,1,1,0,1},  // 2
  {1,1,1,1,0,0,1},  // 3
  {0,1,1,0,0,1,1},  // 4
  {1,0,1,1,0,1,1},  // 5
  {1,0,1,1,1,1,1},  // 6
  {1,1,1,0,0,0,0},  // 7
  {1,1,1,1,1,1,1},  // 8
  {1,1,1,1,0,1,1}   // 9
};

void displayDigit(int digit) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(segPins[i], digits[digit][i]);
  }
}

void setup() {
  for (int i = 0; i < 7; i++) {
    pinMode(segPins[i], OUTPUT);
  }
}

void loop() {
  for (int d = 0; d <= 9; d++) {
    displayDigit(d);
    delay(1000);  // Show each digit for 1 second
  }
}

4. LCD Display (16×2) — Text Output

The 16×2 LCD is the most popular text display in embedded systems. It can show 16 characters per line across 2 lines = 32 characters total. It uses the HD44780 controller and communicates via parallel data pins.

LCD Pin Details — All 16 Pins

ASCII Circuit Diagram — LCD with Arduino

Circuit
    Arduino Uno                    LCD 16x2 (HD44780)
   ┌──────────┐                   ┌──────────────────────┐
   │   5V   ●─┼──────────────────┤ VDD (Pin 2)          │
   │   GND  ●─┼──┬───────────────┤ VSS (Pin 1)          │
   │          │  ├───────────────┤ RW  (Pin 5)          │
   │          │  │               │                      │
   │          │  │  ┌─[10kΩ POT]─┤ V0  (Pin 3)          │
   │          │  │  │            │                      │
   │ Pin 12 ●─┼──┼──┼────────────┤ RS  (Pin 4)          │
   │ Pin 11 ●─┼──┼──┼────────────┤ E   (Pin 6)          │
   │ Pin  5 ●─┼──┼──┼────────────┤ D4  (Pin 11)         │
   │ Pin  4 ●─┼──┼──┼────────────┤ D5  (Pin 12)         │
   │ Pin  3 ●─┼──┼──┼────────────┤ D6  (Pin 13)         │
   │ Pin  2 ●─┼──┼──┼────────────┤ D7  (Pin 14)         │
   │   5V   ●─┼──┼──┼──[220Ω]───┤ A   (Pin 15)         │
   │   GND  ●─┼──┘  │           ┤ K   (Pin 16)         │
   └──────────┘     │            └──────────────────────┘
                    │
              POT: One end → 5V, Other end → GND, Wiper → V0

Complete Arduino Code — LCD Display Text

Arduino
// LCD 16x2 Display — Hello World with LiquidCrystal Library
// Uses 4-bit mode (D4-D7 only, saves Arduino pins)

#include <LiquidCrystal.h>

// Initialize: LiquidCrystal(RS, E, D4, D5, D6, D7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  lcd.begin(16, 2);          // 16 columns, 2 rows
  lcd.setCursor(0, 0);       // Column 0, Row 0 (top line)
  lcd.print("Hello, World!");
  lcd.setCursor(0, 1);       // Column 0, Row 1 (bottom line)
  lcd.print("IoT Unit 4");
}

void loop() {
  // Scrolling text demonstration
  lcd.scrollDisplayLeft();
  delay(500);
}

5. Ultrasonic Sensor HC-SR04 — Distance Measurement

The HC-SR04 ultrasonic sensor measures distance by sending out a sound pulse and timing how long it takes to bounce back — just like a bat uses echolocation. It can measure distances from 2 cm to 400 cm with an accuracy of ±3mm.

HC-SR04 Pin Details

ASCII Circuit Diagram

Circuit
    Arduino Uno                    HC-SR04
   ┌──────────┐                   ┌────────────┐
   │    5V  ●─┼───────────────────┤ VCC        │
   │ Pin  9 ●─┼───────────────────┤ Trig       │    )))  →  Object  →  (((
   │ Pin 10 ●─┼───────────────────┤ Echo       │    Ultrasonic waves
   │   GND  ●─┼───────────────────┤ GND        │
   └──────────┘                   └────────────┘

   Timing Diagram:
   Trig:  _____|‾‾‾|_____________    (10µs pulse)
   Echo:  _________|‾‾‾‾‾‾‾‾|___    (width = round-trip time)
                   |←── t ──→|

Connection Table

Complete Arduino Code — Distance Measurement

Arduino
// HC-SR04 Ultrasonic Distance Measurement
// Measures distance and displays on Serial Monitor

const int trigPin = 9;
const int echoPin = 10;

long duration;
float distance;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
  Serial.println("HC-SR04 Distance Sensor Ready");
}

void loop() {
  // Step 1: Send 10µs trigger pulse
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Step 2: Read echo pulse duration
  duration = pulseIn(echoPin, HIGH);

  // Step 3: Calculate distance
  distance = (duration * 0.034) / 2;

  // Step 4: Display result
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(500);  // Measure every 500ms
}

6. Temperature & Humidity Sensor — DHT22/DHT11

The DHT series sensors are the most popular temperature and humidity sensors in the IoT world. They're cheap, easy to use, and give both temperature and humidity readings from a single data pin.

DHT11 vs DHT22 — Comparison

Pin Diagram — DHT11/DHT22

Pin Layout
   Front View (grid side facing you):
   ┌─────────────────┐
   │  ░░░░░░░░░░░░░  │
   │  ░░░░░░░░░░░░░  │
   │  ░░ DHT 11  ░░  │
   │  ░░░░░░░░░░░░░  │
   │  ░░░░░░░░░░░░░  │
   └─┬───┬───┬───┬─┘
     │   │   │   │
    VCC DATA NC  GND
    (1) (2) (3) (4)

   Pin 1: VCC  → 3.3V or 5V
   Pin 2: DATA → Arduino digital pin (with 10kΩ pull-up to VCC)
   Pin 3: NC   → Not Connected
   Pin 4: GND  → GND

ASCII Circuit Diagram

Circuit
    Arduino Uno                      DHT11/DHT22
   ┌──────────┐                     ┌─────────┐
   │    5V  ●─┼─────┬──────────────┤ VCC (1) │
   │          │     │              │         │
   │          │    [10kΩ]          │         │
   │          │     │              │         │
   │  Pin 7 ●─┼─────┴──────────────┤ DATA(2) │
   │          │                    │         │
   │          │         (NC)───────┤ NC  (3) │
   │          │                    │         │
   │   GND  ●─┼────────────────────┤ GND (4) │
   └──────────┘                    └─────────┘

   The 10kΩ pull-up resistor goes between VCC and DATA.
   It keeps the DATA line HIGH when idle (required for protocol).

Connection Table

Complete Arduino Code — Weather Station

Arduino
// Weather Station — DHT11/DHT22 Temperature & Humidity
// Install DHT library: Sketch → Include Library → Manage → search "DHT sensor library"

#include <DHT.h>

#define DHTPIN 7       // Data pin connected to Arduino pin 7
#define DHTTYPE DHT11  // Change to DHT22 if using DHT22

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
  Serial.println("=== IoT Weather Station ===");
  Serial.println("Reading DHT sensor...");
  Serial.println();
}

void loop() {
  delay(2000);  // Wait 2 seconds between readings

  float humidity = dht.readHumidity();
  float tempC = dht.readTemperature();       // Celsius
  float tempF = dht.readTemperature(true);  // Fahrenheit

  // Check if readings are valid
  if (isnan(humidity) || isnan(tempC)) {
    Serial.println("ERROR: Failed to read from DHT sensor!");
    return;
  }

  // Calculate Heat Index
  float heatIndex = dht.computeHeatIndex(tempC, humidity, false);

  Serial.println("--- Weather Report ---");
  Serial.print("Temperature: ");
  Serial.print(tempC);
  Serial.print("°C / ");
  Serial.print(tempF);
  Serial.println("°F");
  Serial.print("Humidity: ");
  Serial.print(humidity);
  Serial.println("%");
  Serial.print("Heat Index: ");
  Serial.print(heatIndex);
  Serial.println("°C");
  Serial.println();
}

7. PIR Motion Sensor — Detecting Movement

The PIR (Passive Infrared) sensor detects motion by sensing changes in infrared radiation emitted by warm bodies (humans, animals). It's called "passive" because it doesn't emit anything — it only receives IR radiation.

PIR Pin Details

ASCII Circuit Diagram — Security Alarm System

Circuit
    Arduino Uno         PIR Sensor          Buzzer        LED (Red)
   ┌──────────┐        ┌──────────┐
   │    5V  ●─┼────────┤ VCC      │
   │  Pin 2 ●─┼────────┤ OUT      │
   │   GND  ●─┼────────┤ GND      │
   │          │        └──────────┘
   │          │
   │  Pin 8 ●─┼──────────────────────[Buzzer +]
   │   GND  ●─┼──────────────────────[Buzzer -]
   │          │
   │ Pin 13 ●─┼──[220Ω]──[LED Anode +]
   │   GND  ●─┼───────────[LED Cathode -]
   └──────────┘

   PIR Sensor (back view):
   ┌────────────────────┐
   │  ⊕ Sensitivity Pot │
   │  ⊕ Time Delay Pot  │
   │                    │
   │  ┌──┐  ┌──┐  ┌──┐ │
   │  │VCC│ │OUT│ │GND│ │
   └──┴──┴──┴──┴──┴──┴─┘

Connection Table

Complete Arduino Code — Security Alarm Project

Arduino
// PIR Security Alarm System
// Detects motion → Turns on LED + Buzzer + Serial alert

const int pirPin   = 2;   // PIR sensor output
const int buzzerPin = 8;  // Buzzer
const int ledPin   = 13;  // Red LED

int motionState = 0;

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  Serial.println("=== SECURITY SYSTEM ACTIVE ===");
  Serial.println("Warming up PIR sensor (30 sec)...");
  delay(30000);  // PIR needs 30 sec warm-up
  Serial.println("System ARMED. Monitoring...");
}

void loop() {
  motionState = digitalRead(pirPin);

  if (motionState == HIGH) {
    // INTRUDER DETECTED!
    digitalWrite(ledPin, HIGH);    // Red LED ON
    digitalWrite(buzzerPin, HIGH);  // Buzzer ON
    Serial.println("⚠️ ALERT: Motion Detected!");
    delay(3000);  // Keep alarm on for 3 seconds
  } else {
    // No motion — all clear
    digitalWrite(ledPin, LOW);
    digitalWrite(buzzerPin, LOW);
  }

  delay(100);
}

8. IR Sensor — Infrared Object Detection

An IR (Infrared) sensor consists of an IR transmitter (LED) that emits infrared light and an IR receiver (photodiode) that detects the reflected light. When an object is placed in front of the sensor, the IR light bounces back and is detected — triggering a response.

IR Sensor Module Pin Details

ASCII Circuit Diagram

Circuit
    Arduino Uno               IR Sensor Module (FC-51)
   ┌──────────┐              ┌──────────────────┐
   │    5V  ●─┼──────────────┤ VCC              │
   │  Pin 3 ●─┼──────────────┤ OUT              │   ┌─────┐
   │   GND  ●─┼──────────────┤ GND              │   │     │
   └──────────┘              │                  │   │ Obj │
                             │  [IR TX]→→→→→→→→→┼→→→│ ect │
                             │  [IR RX]←←←←←←←←┼←←←│     │
                             │                  │   └─────┘
                             │  ⊕ Range Pot     │
                             └──────────────────┘

   IR TX = Infrared transmitter LED (emits IR)
   IR RX = Photodiode receiver (detects reflected IR)

Connection Table

Complete Arduino Code — Object Detection

Arduino
// IR Sensor — Object Detection
// Detects objects and turns on LED indicator

const int irPin  = 3;   // IR sensor output
const int ledPin = 13;  // Indicator LED

void setup() {
  pinMode(irPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  Serial.println("IR Object Detection Ready");
}

void loop() {
  int irValue = digitalRead(irPin);

  if (irValue == LOW) {
    // Object detected (IR reflected back)
    digitalWrite(ledPin, HIGH);
    Serial.println("Object DETECTED!");
  } else {
    // No object
    digitalWrite(ledPin, LOW);
    Serial.println("No object.");
  }

  delay(200);
}

Line Follower Robot — The Classic IR Application

A line follower robot uses 2 or 3 IR sensors pointed downward at the surface. A black line on a white surface absorbs IR (no reflection → HIGH), while the white surface reflects IR (reflection → LOW). The robot's logic:

Learn by Doing — 3-Tier Lab Structure

Arduino
// Traffic Light Controller — Red → Yellow → Green cycle

const int redPin    = 4;
const int yellowPin = 3;
const int greenPin  = 2;

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(yellowPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
}

void loop() {
  // RED — Stop (5 seconds)
  digitalWrite(redPin, HIGH);
  digitalWrite(yellowPin, LOW);
  digitalWrite(greenPin, LOW);
  delay(5000);

  // YELLOW — Get Ready (2 seconds)
  digitalWrite(redPin, LOW);
  digitalWrite(yellowPin, HIGH);
  digitalWrite(greenPin, LOW);
  delay(2000);

  // GREEN — Go (5 seconds)
  digitalWrite(redPin, LOW);
  digitalWrite(yellowPin, LOW);
  digitalWrite(greenPin, HIGH);
  delay(5000);

  // YELLOW — Slow Down (2 seconds)
  digitalWrite(redPin, LOW);
  digitalWrite(yellowPin, HIGH);
  digitalWrite(greenPin, LOW);
  delay(2000);
}

Industry Spotlight — A Day in the Life

Earn With It — Freelance & Income Roadmap

⏱️ Time to First Earning: 1–2 weeks (offer to build Arduino mini-projects for juniors in your department)

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Calculate (Q11–Q15)

Analyze / Compare (Q16–Q20)

Evaluate / Justify (Q21–Q25)

Create / Design (Q26–Q30)

Short Answer Questions (8 Questions)

Q1. What is forward bias in an LED? Why does an LED need it to work?

Model Answer: Forward bias occurs when the anode (+) of an LED is connected to a higher voltage than the cathode (−). An LED is a diode — it only conducts current in one direction. In forward bias, the potential barrier across the P-N junction is reduced, allowing current to flow and the LED to emit light. In reverse bias (cathode to positive), the barrier increases and no current flows, so the LED remains off. The minimum voltage needed to achieve forward bias is called the forward voltage (V_f), typically 1.8V–3.3V depending on color.

Q2. Calculate the resistance needed for a blue LED (V_f = 3.2V, I_f = 20mA) connected to a 5V Arduino pin.

Model Answer: Using Ohm's law: R = (V_s − V_f) / I_f = (5V − 3.2V) / 0.020A = 1.8 / 0.020 = 90Ω. The nearest standard resistor value is 100Ω. Using 100Ω gives a current of 1.8/100 = 18mA, which is safe for the LED and within the Arduino's 40mA per-pin limit.

Q3. Explain the difference between Common Cathode and Common Anode 7-segment displays.

Model Answer: In a Common Cathode (CC) display, all cathodes of the 7 LED segments are connected together and tied to GND. To turn on a segment, you send HIGH (5V) to its anode pin. In a Common Anode (CA) display, all anodes are connected together and tied to VCC (5V). To turn on a segment, you send LOW (0V) to its cathode pin. The code logic is inverted: CC uses HIGH=ON, CA uses LOW=ON. CC displays are more common in Arduino projects because the logic matches Arduino's HIGH/LOW convention intuitively.

Q4. What is the purpose of the V0 pin on a 16×2 LCD, and how is it controlled?

Model Answer: The V0 pin controls the contrast of the LCD display. It determines how dark or light the text pixels appear against the background. V0 is connected to the wiper (middle terminal) of a 10kΩ potentiometer, with the other two terminals connected to VCC (5V) and GND. Turning the potentiometer varies the voltage on V0 between 0V and 5V, adjusting contrast. If contrast is wrong, the display may appear blank or show solid black blocks. Optimal contrast is usually around 0.3V–0.7V on V0.

Q5. Write the complete distance calculation formula for the HC-SR04 sensor and explain each component.

Model Answer: Distance (cm) = (Duration × 0.034) / 2. Where: Duration = time in microseconds measured by pulseIn(echoPin, HIGH) — the duration the Echo pin stays HIGH. 0.034 = speed of sound in cm/µs (340 m/s = 34,000 cm/s = 0.034 cm/µs). ÷ 2 = because the ultrasonic pulse travels to the object AND reflects back, so the measured duration is the round-trip time. We divide by 2 to get the one-way distance. Example: Duration = 588µs → Distance = (588 × 0.034) / 2 = 19.99 / 2 ≈ 10 cm.

Q6. Why does a DHT sensor need a 10kΩ pull-up resistor on its DATA pin?

Model Answer: The DHT sensor communicates using a single-wire bidirectional protocol. Both the sensor and the Arduino take turns pulling the DATA line LOW to send bits. When neither is actively driving the line, it needs to return to HIGH — this is the "idle" state. The 10kΩ pull-up resistor connected between VCC and DATA ensures the line defaults to HIGH when not actively driven LOW. Without it, the DATA line would "float" at an undefined voltage, causing communication errors and intermittent "Failed to read" errors. Some breakout boards have this resistor built-in.

Q7. How does a PIR sensor differentiate between a stationary warm object and a moving person?

Model Answer: A PIR sensor has two pyroelectric sensing elements side by side, covered by a Fresnel lens that divides the field of view into multiple zones. A stationary warm object (like a radiator) produces a constant IR level on both elements — no change, no trigger. When a person moves across the sensor's field of view, one element detects a change in IR level before the other, creating a differential voltage spike. This change is what triggers the output. This is why PIR sensors detect movement, not just heat presence. The Fresnel lens amplifies this effect by creating alternating sensitive and blind zones.

Q8. Explain why IR sensors are unsuitable for detecting black objects, and suggest an alternative.

Model Answer: IR sensors work by emitting infrared light and detecting the reflection. Black surfaces absorb most of the IR light instead of reflecting it. Since very little IR returns to the receiver, the sensor fails to detect the object — it "sees through" black objects as if they aren't there. This is a fundamental limitation based on the absorption/reflection properties of the surface. Alternative: Use an ultrasonic sensor (HC-SR04), which uses sound waves instead of light. Sound reflects off objects regardless of their color, surface texture, or material (as long as the surface isn't sound-absorbent like foam). For line-following robots on dark lines, this is actually an advantage — the IR sensor detects the black line as "no reflection."

Long Answer Questions (3 Questions)

Q1. Explain the working principle, circuit diagram, connection table, and complete Arduino code for interfacing an HC-SR04 ultrasonic sensor to measure distance and display it on a 16×2 LCD. (10 marks)

Model Answer:

Working Principle: The HC-SR04 ultrasonic sensor works on the principle of echolocation. A 10µs HIGH pulse is sent to the Trig pin, which causes the sensor to emit 8 ultrasonic pulses at 40kHz. These sound waves travel through the air, hit an object, and reflect back to the sensor. The Echo pin goes HIGH for a duration proportional to the round-trip travel time. Using the speed of sound (340 m/s), we calculate distance: Distance = (Time × 0.034) / 2 cm.

Connection Table:

Arduino
#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int trigPin = 9;
const int echoPin = 10;
long duration;
float distance;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  lcd.begin(16, 2);
  lcd.print("Distance Meter");
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  duration = pulseIn(echoPin, HIGH);
  distance = (duration * 0.034) / 2;

  lcd.setCursor(0, 1);
  lcd.print("Dist: ");
  lcd.print(distance);
  lcd.print(" cm   ");  // Extra spaces clear old chars

  delay(500);
}

Q2. Compare and contrast the four sensors covered in this unit (Ultrasonic HC-SR04, DHT11/DHT22, PIR, and IR) in terms of working principle, output type, detection range, use cases, and limitations. Present in tabular form. (10 marks)

Model Answer:

Key Insight: No single sensor is "best" — each excels in specific scenarios. Good IoT system design often combines multiple sensors. For example, a smart home security system might use PIR for room occupancy, ultrasonic for proximity-based triggers, and IR for doorway counting. Understanding the strengths and limitations of each sensor is critical for selecting the right tool for the job.

Q3. Design a complete "Smart Home Entry System" that uses a PIR sensor to detect someone approaching the door, an ultrasonic sensor to measure their distance, an LCD to display a welcome message, a green LED for "approach" status, a red LED for "too close" warning, and a buzzer for doorbell function. Draw the circuit diagram, provide the complete connection table, and write the full Arduino code. (15 marks)

Model Answer:

System Design:

• PIR detects person approaching → LCD shows "Welcome!"
• Ultrasonic measures distance: >50cm → Green LED | <50cm → Red LED + Buzzer rings (doorbell)
• When no one is around → LCD shows "Smart Home" on line 1, "System Ready" on line 2

Connection Table:

Arduino
#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int pirPin     = 6;
const int trigPin    = 9;
const int echoPin    = 10;
const int greenLED   = 7;
const int redLED     = 8;
const int buzzerPin  = 13;

long duration;
float distance;

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  pinMode(buzzerPin, OUTPUT);

  lcd.begin(16, 2);
  lcd.print("Smart Home");
  lcd.setCursor(0, 1);
  lcd.print("Initializing...");
  delay(30000);  // PIR warm-up
  lcd.clear();
  lcd.print("System Ready");
}

float getDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  return (duration * 0.034) / 2;
}

void loop() {
  int motion = digitalRead(pirPin);

  if (motion == HIGH) {
    distance = getDistance();

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Welcome!");
    lcd.setCursor(0, 1);
    lcd.print("Dist: ");
    lcd.print(distance);
    lcd.print("cm");

    if (distance < 50) {
      // Person at the door — ring doorbell
      digitalWrite(redLED, HIGH);
      digitalWrite(greenLED, LOW);
      tone(buzzerPin, 1000, 500);  // Doorbell tone
    } else {
      // Person approaching
      digitalWrite(greenLED, HIGH);
      digitalWrite(redLED, LOW);
      noTone(buzzerPin);
    }
  } else {
    // No one around — idle state
    digitalWrite(greenLED, LOW);
    digitalWrite(redLED, LOW);
    noTone(buzzerPin);

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Smart Home");
    lcd.setCursor(0, 1);
    lcd.print("System Ready");
  }

  delay(300);
}

Chapter Summary

Earning Checkpoint — Skills Inventory

Quick Reference Card — Pinouts & Formulas

Essential Formulas

Arduino PWM Pins (Uno)

Common LED Forward Voltages

Key Arduino Functions Used in This Unit

What's Next — Unit 5 Preview

✅ Unit 4 complete. Ready for Unit 5: Communication & IoT Connectivity!

[QR: Link to EduArtha video tutorial — Visual Output & Sensors]