Unit 5: Actuators & Motors

What are Actuators?

Types of Actuators in IoT

In this unit, we'll focus on the three most important actuators for IoT beginners: DC Motors, Servo Motors, and Relay Modules. These three cover 90% of all student IoT projects.

DC Motor Basics — How It Works

The Science Inside a DC Motor

A DC motor converts electrical energy into mechanical rotational energy. Inside, it has a coil of wire (armature) sitting inside a magnetic field. When current flows through the coil, it creates a force (Lorentz force) that makes the coil spin. The direction of spin depends on the direction of current.

Why You CANNOT Connect a DC Motor Directly to Arduino

This is the #1 mistake every beginner makes. Let's understand why:

The Solution? Use a motor driver IC like the L293D. The motor driver acts as a middleman — it takes the small control signal from Arduino and uses a separate power supply to drive the motor with the current it needs.

Analogy
Think of it like this:

Arduino Pin  =  TV Remote      (sends signal, tiny power)
Motor Driver =  AC Power Socket (provides actual power)
DC Motor     =  Television      (needs real power to work)

You use the remote to CONTROL what happens,
but the TV gets its POWER from the wall socket.
The motor driver is that wall socket for your motor.

L293D Motor Driver — Dual H-Bridge IC

What is an H-Bridge?

An H-bridge is a circuit that allows you to control the direction of a DC motor. It uses 4 switches arranged in an "H" shape. By toggling different pairs of switches, current flows through the motor in either direction:

ASCII
         H-Bridge Circuit
    ┌─────────────────────────┐
    │                         │
    │   S1 ──┐     ┌── S3    │
    │        │     │          │
  +V ━━━━━━━┫     ┣━━━━━━━ +V
    │        │     │          │
    │     ┌──┴─────┴──┐       │
    │     │   MOTOR   │       │
    │     │  ⟲  or  ⟳ │       │
    │     └──┬─────┬──┘       │
    │        │     │          │
  GND ━━━━━━┫     ┣━━━━━━ GND
    │        │     │          │
    │   S2 ──┘     └── S4    │
    │                         │
    └─────────────────────────┘

  FORWARD:  S1=ON, S4=ON, S2=OFF, S3=OFF  →  Current: Left to Right
  REVERSE:  S3=ON, S2=ON, S1=OFF, S4=OFF  →  Current: Right to Left
  BRAKE:    S1=ON, S3=ON (or S2+S4)       →  Motor shorts, stops quickly
  COAST:    All OFF                        →  Motor spins freely to stop

The L293D IC contains two complete H-bridges in a single 16-pin DIP package, meaning it can control 2 motors independently.

L293D Pin Diagram (16-Pin DIP)

ASCII
                    L293D — Top View
              ┌────────┐  ┌────────┐
    Enable1 ──┤ 1    16 ├── Vss (+5V Logic)
     Input1 ──┤ 2    15 ├── Input4
    Output1 ──┤ 3    14 ├── Output4
        GND ──┤ 4    13 ├── GND
        GND ──┤ 5    12 ├── GND
    Output2 ──┤ 6    11 ├── Output3
     Input2 ──┤ 7    10 ├── Input3
  Vs (Motor) ─┤ 8     9 ├── Enable2
              └─────────────────────┘

    Pin 16 (Vss) = +5V (Logic supply from Arduino)
    Pin  8 (Vs)  = Motor supply voltage (6V–12V from battery)
    Pins 4,5,12,13 = GND (also act as heat sinks)

L293D Pin Functions

L293D Truth Table — Direction Control

Interfacing DC Motor with Arduino via L293D

Circuit Diagram

ASCII Circuit
    ┌─────────────────────────────────────────────┐
    │              ARDUINO UNO                     │
    │                                              │
    │  Pin 9  (PWM) ─────────── Enable1 (Pin 1)   │
    │  Pin 2  ────────────────── Input1  (Pin 2)   │
    │  Pin 3  ────────────────── Input2  (Pin 7)   │
    │  5V     ────────────────── Vss     (Pin 16)  │
    │  GND    ──┬─────────────── GND  (Pin 4,5,    │
    │           │                       12,13)     │
    └───────────┼──────────────────────────────────┘
                │
    ┌───────────┼──────────────────────────────────┐
    │  L293D    │                                   │
    │           │                                   │
    │  Output1 (Pin 3) ────── Motor Terminal A      │
    │  Output2 (Pin 6) ────── Motor Terminal B      │
    │                                               │
    │  Vs (Pin 8) ─────────── Battery + (6V–9V)    │
    │  GND (Pin 4,5,12,13) ── Battery GND ── Ard GND│
    └───────────────────────────────────────────────┘

    ⚡ Battery Pack: 4×AA (6V) or 9V battery
    ⚠️ Common GND between Arduino and Battery is CRITICAL!

Connection Table

Arduino Code: Forward, Reverse, Stop

Arduino
// DC Motor Control with L293D
// Forward → Reverse → Stop (repeat)

const int enablePin = 9;   // PWM pin for speed
const int in1 = 2;         // Input1 of L293D
const int in2 = 3;         // Input2 of L293D

void setup() {
  pinMode(enablePin, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  analogWrite(enablePin, 200);  // ~78% speed
}

void loop() {
  // ── FORWARD ──
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  delay(3000);  // Run forward for 3 seconds

  // ── STOP ──
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
  delay(1000);  // Pause 1 second

  // ── REVERSE ──
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
  delay(3000);  // Run reverse for 3 seconds

  // ── STOP ──
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
  delay(1000);
}

Speed Control with analogWrite

Arduino
// Gradually increase speed, then decrease

void loop() {
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);

  // Ramp UP: 0 → 255
  for (int speed = 0; speed <= 255; speed += 5) {
    analogWrite(enablePin, speed);
    delay(50);
  }

  // Ramp DOWN: 255 → 0
  for (int speed = 255; speed >= 0; speed -= 5) {
    analogWrite(enablePin, speed);
    delay(50);
  }

  delay(1000);
}

Controlling Direction & Speed via Serial Monitor

Let's build an interactive motor controller. You type a command in the Serial Monitor, and the motor responds:

Arduino
// Interactive DC Motor Control via Serial
// Commands: F = Forward, B = Backward, S = Stop
// Speed: 0-9 (0=off, 9=max)

const int enablePin = 9;
const int in1 = 2;
const int in2 = 3;
int motorSpeed = 200;

void setup() {
  Serial.begin(9600);
  pinMode(enablePin, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);

  Serial.println("=== DC Motor Controller ===");
  Serial.println("Commands:");
  Serial.println("  F = Forward");
  Serial.println("  B = Backward");
  Serial.println("  S = Stop");
  Serial.println("  0-9 = Speed (0=off, 9=max)");
}

void loop() {
  if (Serial.available() > 0) {
    char cmd = Serial.read();

    switch (cmd) {
      case 'F':
      case 'f':
        digitalWrite(in1, HIGH);
        digitalWrite(in2, LOW);
        analogWrite(enablePin, motorSpeed);
        Serial.print("▶ Forward at speed: ");
        Serial.println(motorSpeed);
        break;

      case 'B':
      case 'b':
        digitalWrite(in1, LOW);
        digitalWrite(in2, HIGH);
        analogWrite(enablePin, motorSpeed);
        Serial.print("◀ Backward at speed: ");
        Serial.println(motorSpeed);
        break;

      case 'S':
      case 's':
        digitalWrite(in1, LOW);
        digitalWrite(in2, LOW);
        analogWrite(enablePin, 0);
        Serial.println("⏹ Motor STOPPED");
        break;

      default:
        // Check if it's a speed digit 0-9
        if (cmd >= '0' && cmd <= '9') {
          motorSpeed = map(cmd - '0', 0, 9, 0, 255);
          analogWrite(enablePin, motorSpeed);
          Serial.print("🔧 Speed set to: ");
          Serial.println(motorSpeed);
        }
        break;
    }
  }
}

Multiple DC Motors — Robot Car Concept

The L293D can drive 2 DC motors simultaneously — perfect for a 2-wheel drive (2WD) robot car. Motor A controls the left wheel, Motor B controls the right wheel.

Robot Car Movement Logic

Arduino
// 2WD Robot Car — Full Motor Control

// Motor A (Left)
const int enA = 9;
const int in1 = 2;
const int in2 = 3;

// Motor B (Right)
const int enB = 10;
const int in3 = 4;
const int in4 = 5;

int speed = 200;

void setup() {
  pinMode(enA, OUTPUT);  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);  pinMode(in4, OUTPUT);
}

void moveForward() {
  analogWrite(enA, speed); analogWrite(enB, speed);
  digitalWrite(in1, HIGH); digitalWrite(in2, LOW);
  digitalWrite(in3, HIGH); digitalWrite(in4, LOW);
}

void moveBackward() {
  analogWrite(enA, speed); analogWrite(enB, speed);
  digitalWrite(in1, LOW);  digitalWrite(in2, HIGH);
  digitalWrite(in3, LOW);  digitalWrite(in4, HIGH);
}

void turnLeft() {
  analogWrite(enA, 0);     analogWrite(enB, speed);
  digitalWrite(in1, LOW);  digitalWrite(in2, LOW);
  digitalWrite(in3, HIGH); digitalWrite(in4, LOW);
}

void turnRight() {
  analogWrite(enA, speed); analogWrite(enB, 0);
  digitalWrite(in1, HIGH); digitalWrite(in2, LOW);
  digitalWrite(in3, LOW);  digitalWrite(in4, LOW);
}

void stopMotors() {
  analogWrite(enA, 0); analogWrite(enB, 0);
  digitalWrite(in1, LOW); digitalWrite(in2, LOW);
  digitalWrite(in3, LOW); digitalWrite(in4, LOW);
}

void loop() {
  moveForward();   delay(2000);
  turnRight();     delay(800);
  moveForward();   delay(2000);
  turnLeft();      delay(800);
  moveBackward(); delay(1000);
  stopMotors();    delay(2000);
}

Servo Motor — Precise Angle Control

How a Servo Motor Works

A servo motor is NOT like a DC motor. It doesn't just spin continuously. Instead, it moves to a specific angle and holds that position. It contains:

 ┌───────────────────────────────────────────────┐
 │                SERVO MOTOR                     │
 │                                                │
 │  ┌──────────┐    ┌──────────┐    ┌──────────┐ │
 │  │ CONTROL  │───▶│   DC     │───▶│  GEAR    │ │
 │  │ CIRCUIT  │    │  MOTOR   │    │  TRAIN   │──── OUTPUT
 │  │          │    │          │    │          │ │   SHAFT
 │  └────▲─────┘    └──────────┘    └────┬─────┘ │
 │       │                               │       │
 │       │         ┌──────────┐          │       │
 │       └─────────│ POSITION │◀─────────┘       │
 │                 │ SENSOR   │  (Potentiometer)  │
 │                 │ (Feedback)│                   │
 │                 └──────────┘                   │
 └───────────────────────────────────────────────┘

 1. Arduino sends PWM signal (pulse width = desired angle)
 2. Control circuit compares desired angle vs actual angle
 3. If there's a difference, motor rotates to correct it
 4. Potentiometer on shaft reports actual position
 5. When desired = actual → motor stops → holds position
 THIS IS A CLOSED-LOOP FEEDBACK SYSTEM!

Types of Servo Motors

SG90 Micro Servo — The IoT Workhorse

ASCII
  Servo PWM Signal (50Hz = 20ms period)

  0°  (1.0ms pulse):  ┃████┃                    ┃████┃
  90° (1.5ms pulse):  ┃██████┃                  ┃██████┃
  180°(2.0ms pulse):  ┃████████┃                ┃████████┃
                      ├── 20ms (1 period) ──────┤

  Pulse Width  →  Servo Position
  1.0 ms       →  0° (full left)
  1.5 ms       →  90° (centre)
  2.0 ms       →  180° (full right)

Interfacing Servo Motor with Arduino

Circuit Diagram

ASCII Circuit
    ┌────────────────────┐
    │   ARDUINO UNO      │
    │                    │
    │   Pin 9  ──────────┼────── Orange/Yellow (Signal)
    │   5V     ──────────┼────── Red    (VCC)
    │   GND    ──────────┼────── Brown  (GND)
    │                    │
    └────────────────────┘        ┌──────────┐
                                  │  SG90    │
         Signal ──────────────────│  SERVO   │
         VCC    ──────────────────│  MOTOR   │
         GND    ──────────────────│          │
                                  └──────────┘

    ⚠️ SG90 has 3 wires:
       🟤 Brown  = GND
       🔴 Red    = VCC (+5V)
       🟠 Orange = Signal (PWM)

    💡 For 1–2 servos, Arduino 5V is fine.
    ⚡ For 3+ servos, use external 5V power supply!

Connection Table

Arduino Code — Servo Sweep

Arduino
// Servo Sweep: 0° → 180° → 0° continuously
// Uses the built-in Servo library

#include <Servo.h>

Servo myServo;  // Create servo object

void setup() {
  myServo.attach(9);  // Attach servo to Pin 9
  Serial.begin(9600);
}

void loop() {
  // Sweep from 0° to 180°
  for (int angle = 0; angle <= 180; angle++) {
    myServo.write(angle);
    Serial.print("Angle: ");
    Serial.println(angle);
    delay(15);  // 15ms for smooth motion
  }

  // Sweep from 180° to 0°
  for (int angle = 180; angle >= 0; angle--) {
    myServo.write(angle);
    Serial.print("Angle: ");
    Serial.println(angle);
    delay(15);
  }
}

Key Servo Library Functions

Potentiometer-Controlled Servo

This is one of the most satisfying IoT circuits to build — turn a knob and watch the servo follow your hand in real-time!

Circuit Diagram

ASCII Circuit
    ┌────────────────────────────────────────────┐
    │              ARDUINO UNO                    │
    │                                             │
    │   A0 ──────────── Potentiometer WIPER       │
    │   Pin 9 ───────── Servo Signal (Orange)     │
    │   5V ──┬───────── Servo VCC (Red)           │
    │        └───────── Pot Pin 1 (VCC)           │
    │   GND ─┬───────── Servo GND (Brown)         │
    │        └───────── Pot Pin 3 (GND)           │
    └────────────────────────────────────────────┘

    POTENTIOMETER (10KΩ)
    ┌─────────────────┐
    │   1     2     3 │
    │  VCC  WIPER  GND│
    │  (+5V) (A0)     │
    └─────────────────┘

    Turn the knob → Voltage at A0 changes (0V–5V)
    Arduino reads: 0–1023 → maps to 0°–180°
    Servo follows the knob position!

Connection Table

Arduino Code

Arduino
// Potentiometer-Controlled Servo Motor
// Turn the knob → servo follows

#include <Servo.h>

Servo myServo;
const int potPin = A0;  // Analog input

void setup() {
  myServo.attach(9);
  Serial.begin(9600);
}

void loop() {
  int potValue = analogRead(potPin);  // Read: 0–1023
  int angle = map(potValue, 0, 1023, 0, 180);  // Map to 0°–180°

  myServo.write(angle);  // Move servo

  Serial.print("Pot: ");
  Serial.print(potValue);
  Serial.print(" → Angle: ");
  Serial.println(angle);

  delay(15);  // Small delay for stability
}

Relay Module — Controlling AC Appliances

How a Relay Works

A relay is an electrically operated switch. It uses a small DC signal (from Arduino) to control a much larger AC circuit (like a tube light, fan, or water pump). Think of it as a tiny servant — Arduino whispers "turn on," and the relay flips a heavy switch that your Arduino could never handle alone.

      DC Control Side           AC Load Side
      (Arduino)                 (Appliance)
    ┌─────────────────────────────────────────┐
    │                                         │
    │  ┌──────────┐        ┌─── COM (Common)  │
    │  │   COIL   │        │                  │
    │  │ (5V DC)  │   ┌────┤─── NO (Normally  │
    │  │          │   │    │    Open)          │
    │  └──┬───┬───┘   │    │                  │
    │     │   │    ┌──┴──┐ └─── NC (Normally  │
    │     │   │    │SWITCH│     Closed)        │
    │     │   │    │(Reed)│                    │
    │  Signal GND  └─────┘                    │
    │                                         │
    └─────────────────────────────────────────┘

    When Arduino sends HIGH to Signal pin:
    → Coil energises → creates magnetic field
    → Switch moves from NC to NO
    → Circuit through COM-NO closes → Appliance turns ON

    When Arduino sends LOW:
    → Coil de-energises → spring pulls switch back
    → Switch returns to NC position
    → COM-NO opens → Appliance turns OFF

Relay Module Circuit (DC Side — Safe for Students)

ASCII Circuit
    ┌────────────────────────────────────────────┐
    │              ARDUINO UNO                    │
    │                                             │
    │   Pin 7  ──────── IN  (Relay Signal)        │
    │   5V     ──────── VCC (Relay Power)         │
    │   GND    ──────── GND (Relay Ground)        │
    └────────────────────────────────────────────┘

    ┌────────────────────────────────────────────┐
    │         RELAY MODULE (DC Side)              │
    │                                             │
    │   IN   ← Signal from Arduino (Pin 7)       │
    │   VCC  ← 5V from Arduino                   │
    │   GND  ← GND from Arduino                  │
    │                                             │
    │   LED  ← Indicates relay state (ON/OFF)     │
    │                                             │
    │   ─── AC Side (COM, NO, NC) ───             │
    │   ⚡ DO NOT TOUCH AC SIDE                    │
    │   ⚡ TEACHER SUPERVISION REQUIRED            │
    └────────────────────────────────────────────┘

Arduino Code — Relay ON/OFF

Arduino
// Relay Module Control
// Toggle relay every 3 seconds

const int relayPin = 7;

void setup() {
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);  // Start with relay OFF
  Serial.begin(9600);
  Serial.println("Relay Controller Ready");
}

void loop() {
  // Turn relay ON
  digitalWrite(relayPin, HIGH);
  Serial.println("💡 Relay ON  — Appliance is running");
  delay(3000);

  // Turn relay OFF
  digitalWrite(relayPin, LOW);
  Serial.println("⚫ Relay OFF — Appliance is stopped");
  delay(3000);
}

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

Remember / Identify (Q1–Q8)

Understand / Explain (Q9–Q15)

Apply / Implement (Q16–Q21)

Analyze / Compare (Q22–Q25)

Evaluate / Justify (Q26–Q28)

Create / Design (Q29–Q30)

Short Answer & Long Answer Questions

Short Answer Questions (2–3 marks each)

int potValue = analogRead(A0);          // Read: 0–1023
int angle = map(potValue, 0, 1023, 0, 180);  // Convert to 0–180
myServo.write(angle);                   // Move servo

Long Answer Questions (5–8 marks each)

const int enablePin = 9;  // PWM for speed
const int in1 = 2;        // Direction
const int in2 = 3;        // Direction

void setup() {
  pinMode(enablePin, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
}

void loop() {
  // Forward at 75% speed
  analogWrite(enablePin, 191);
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  delay(3000);

  // Stop
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
  delay(1000);

  // Reverse at 50% speed
  analogWrite(enablePin, 127);
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
  delay(3000);

  // Stop
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
  delay(1000);
}

#include <Servo.h>

Servo lockServo;
const int trigPin = 6;
const int echoPin = 7;
bool isLocked = true;

void setup() {
  lockServo.attach(9);
  lockServo.write(0);    // Start locked
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
  Serial.println("Smart Door Lock Ready");
}

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

void loop() {
  float distance = getDistance();
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  if (distance < 20 && isLocked) {
    // Unlock
    lockServo.write(90);
    isLocked = false;
    Serial.println("🔓 DOOR UNLOCKED");
    delay(5000);  // Keep open 5 seconds

    // Lock again
    lockServo.write(0);
    isLocked = true;
    Serial.println("🔒 DOOR LOCKED");
  }

  delay(100);
}

Chapter Summary & Earning Checkpoint

Earning Checkpoint — What Can You Build & Earn?

✅ Unit 5 complete. Ready for Unit 6: IoT Communication Protocols!

[QR: Link to EduArtha video tutorial — Actuators & Motors]