Explore Smart ThermostatBME280 SensorLine Following Robot49 Projects

Build Project

Home Automation

ESP32 Smart Door Lock

Build a safe smart lock prototype using ESP32, an access input, and a low-voltage lock actuator output.

IntermediateAges 12+90-150 minUnder $35Parent Safe
Project Mission

Build Your Smart Door Lock

The Story

ESP32 Smart Door Lock turns the ESP32 into a real object that senses something, decides what it means, and reacts in the physical world.

The important lesson is not only the finished door lock prototype. You learn how to separate input, decision logic, and output so a project stays debuggable instead of becoming a pile of wires and guesses.

Explain Like I'm 12

Think of the ESP32 as the brain. The RFID reader or keypad input is how it notices the world. The servo or relay lock is how it answers back. The code is the rule book that tells the brain what to do when the numbers change.

Safety Standards

  • Unplug USB before changing jumper wires. Recheck 3.3 V, 5 V, and GND before reconnecting power.
  • Do not power motors, pumps, LED strips, or servos from the ESP32 3.3 V pin. Use a suitable external supply and common ground.
  • Breadboards are for low-current prototypes. Move high-current or unattended builds to proper terminals, enclosure, strain relief, and fusing.
  • Relay and mains-voltage projects require isolation, correct relay ratings, enclosed wiring, and qualified adult supervision.

What You Will Build

A working door lock prototype with an ESP32, a real input, a controlled output, Serial Monitor diagnostics, and a wiring map you can expand into a more advanced version.

Learning Objectives

  • Wire and test the RFID reader or keypad input before connecting the rest of the circuit.
  • Map each signal to a named ESP32 GPIO and keep the code constants readable.
  • Control servo or relay lock using a clear threshold or command instead of hidden magic numbers.
  • Use Serial Monitor as an engineering tool, not only as a success message.
  • Identify power, wiring, and timing faults using a repeatable test checklist.

Components List

  • ESP32 DevKit boardMain controller
  • Rfid Reader Or Keypad InputPrimary input for the project
  • Servo Or Relay LockPhysical output controlled by ESP32
  • Breadboard and jumper wiresPrototype wiring
  • USB data cableProgramming and testing

Bill of Materials

PartQtyEstimated CostNotes
ESP32 DevKit1$6-$10USB board
Rfid Reader Or Keypad Input1$2-$10Project input
Servo Or Relay Lock1$3-$12Use low-voltage test hardware
Breadboard and wires1 set$3-$5Prototype wiring

Wiring

Wire the RFID reader or keypad input first, verify readings, then connect the servo or relay lock.

Wiring Diagram ESP32 Smart Door Lock wiring diagram
  1. 1

    Unplug USB before placing modules on the breadboard.

  2. 2

    Connect the RFID reader or keypad input power pins to the correct 3.3 V or 5 V rail according to its module label.

  3. 3

    Connect the RFID reader or keypad input signal line to GPIO5/GPIO22.

  4. 4

    Connect the servo or relay lock control input to GPIO26 and share ground with the ESP32.

  5. 5

    Power the ESP32 from USB and test the input reading before enabling the output.

GPIO Mapping

SignalESP32 PinDirectionNotes
RFID reader or keypad inputGPIO5/GPIO22InputRead before controlling output
servo or relay lockGPIO26OutputDrive through a module or driver
Status LEDGPIO2OutputOptional debug indicator
Serial MonitorUSBDebug115200 baud

Circuit Explanation

The circuit is split into an input side and an output side. The RFID reader or keypad input tells the ESP32 what is happening. The servo or relay lock receives a controlled signal from the ESP32, usually through a driver, relay, or module that can handle more current than a GPIO pin.

Engineering Explanation

A reliable door lock prototype is built in layers. First prove the input, then prove the output, then join them with simple state logic. This prevents a common beginner problem where the robot, lock, or automation fails and every wire looks suspicious at the same time.

Code

Copy into Arduino IDE. Install any libraries noted in the component guides first.

smart-door-lock.ino 
#include <SPI.h>
#include <MFRC522.h>
#include <ESP32Servo.h>

#define SS_PIN 5
#define RST_PIN 22
#define SERVO_PIN 26

MFRC522 rfid(SS_PIN, RST_PIN);
Servo lockServo;
byte allowedUid[] = {0xDE, 0xAD, 0xBE, 0xEF};

bool allowedCard() {
  if (rfid.uid.size != sizeof(allowedUid)) return false;
  for (byte i = 0; i < rfid.uid.size; i++) {
    if (rfid.uid.uidByte[i] != allowedUid[i]) return false;
  }
  return true;
}

void setup() {
  Serial.begin(115200);
  SPI.begin();
  rfid.PCD_Init();
  lockServo.attach(SERVO_PIN);
  lockServo.write(0);
  Serial.println("Door lock ready");
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
  if (allowedCard()) {
    Serial.println("Unlocked for 5 seconds");
    lockServo.write(90);
    delay(5000);
    lockServo.write(0);
  } else {
    Serial.println("Unknown card");
  }
  rfid.PICC_HaltA();
}

Code Explanation

The example uses named pins, reads the input, converts the reading into a true or false decision, and then updates the output and status LED. Replace the threshold with values measured from your own RFID reader or keypad input because modules vary.

Expected Output

Serial Monitor should show a changing reading. When the RFID reader or keypad input reaches the test condition, the status LED and servo or relay lock should switch state. If the reading changes but the output does not, debug the output wiring separately.

Build Photos

  • Breadboard overviewShow the ESP32, module placement, and power rails clearly.
  • Close-up wiringCapture each GPIO wire so beginners can compare their build.
  • Working outputShow the Serial Monitor, display, robot, pump, or lock state after the code runs.

Troubleshooting

  • RFID reader or keypad input never changes Check power, ground, signal pin, and whether the sensor is analog or digital.
  • servo or relay lock does not switch Test the output module with a simple blink-style sketch before using the full project.
  • ESP32 resets under load Use a separate supply for motors, pumps, or locks and keep only control signals connected to ESP32.
  • Behavior is reversed Your module may be active LOW; invert the output logic after confirming with Serial Monitor.

Common Mistakes

  • Testing input and output for the first time together.
  • Using a GPIO pin that does not match the code constant.
  • Expecting an ESP32 GPIO to power a motor, pump, or lock directly.
  • Forgetting the shared ground between modules.

Testing Checklist

  • ESP32 appears on the correct port and accepts a basic blink upload.
  • Ground is shared between every module that exchanges signals with the ESP32.
  • Each GPIO in the code matches the wire connected on the breadboard.
  • Serial Monitor prints startup text at 115200 baud.
  • The RFID reader or keypad input value changes when you create a real test condition.
  • The servo or relay lock changes only when the expected condition is reached.
  • The circuit still behaves correctly after power is removed and restored.

Upgrade Ideas

  • Add OLED status feedback.
  • Add Wi-Fi dashboard or mobile alerts.
  • Store event history in flash or a cloud service.
  • Add calibration settings instead of hard-coded thresholds.

Real-World Applications

  • Classroom door lock prototype trainer
  • STEM lab demonstration
  • Home automation prototype
  • Engineering debugging practice
  • IoT portfolio project

Downloads

  • ESP32 Smart Door Lock Arduino sketchUse the code section as the downloadable source until file downloads are published.
  • Wiring checklistMatch the GPIO table and wiring steps before powering the circuit.
  • Troubleshooting worksheetRecord symptoms, Serial output, voltage checks, and fixes.

FAQs

Why does my RFID reader or keypad input reading look wrong?

Check the input power, ground, and signal wiring before changing access logic. Keypads and RFID readers fail differently, so test the input alone first.

Why does servo or relay lock not respond?

Check the ground connection first. Then confirm the output pin, power supply capacity, and whether the output module uses active HIGH or active LOW logic.

Can this protect a real door?

No. Treat it as a low-voltage classroom prototype. Real locks need mechanical fail-safe planning, secure installation, and adult review.

Review, Testing, and References

Author: Abdul Mubeen and the ESP32 Engine editorial team. Last updated: 2026-06-29. Reviewed: wiring logic, Arduino code structure, beginner safety, and learning sequence.

Educational level: Intermediate. Estimated completion time: 90-150 min. This project is for learning and prototyping; production or unattended hardware needs additional engineering review.

Project Complete!

You built a real door lock prototype and learned how to connect sensing, decision logic, and output control in one ESP32 project.

  • Wire and test RFID reader or keypad input
  • Control servo or relay lock from ESP32
  • Debug hardware with Serial Monitor
  • Improve the project safely