Skip to Content

FINGERPRINT DOOR LOCK

With the increasing need for advanced security measures, biometric authentication has become a crucial element in modern access control systems. Traditional locks, which rely on keys or passwords, often present security risks such as duplication, loss, or unauthorized access. To overcome these challenges, biometric systems leverage unique human characteristics, like fingerprints, to provide a more secure and efficient alternative.

One such innovative application is a fingerprint door lock, which offers a highly reliable and convenient method of restricting access. Unlike conventional locks that can be easily bypassed, this system ensures that only authorized individuals can unlock the door. It utilizes a fingerprint sensor to scan and authenticate users by comparing their fingerprint data against a stored database before granting access.

At the heart of this system is an Arduino Uno, which serves as the central processor, handling fingerprint data and sending commands to a servo motor that controls the locking mechanism. When a registered fingerprint is detected, the motor rotates to unlock the door, and after a brief delay, it returns to the locked position, ensuring continuous security.

By combining biometric authentication with microcontroller-based automation, this fingerprint door lock provides a secure, tamper-resistant, and user-friendly solution for homes, offices, and restricted areas. With its seamless operation and enhanced security features, this system represents a significant advancement in modern access control.

Components Required

  • Arduino Uno
  • Fingerprint Sensor Module
  • Servo Motor
  • LCD Display (Optional, for user feedback)
  • Push Button
  • Buzzer
  • Jumper Wires
  • Breadboard
  • Power Supply (5V)

Circuit Diagram

Component Connections

1. Connecting the Fingerprint Sensor to Arduino

A fingerprint sensor captures and stores fingerprint data, allowing the system to verify authorized users before granting access. It communicates with the Arduino using serial communication (TX and RX pins).

Wiring the Fingerprint Sensor to the Arduino:

  • VCC (Power Input) → Connect to 5V on the Arduino.
  • GND (Ground) → Connect to GND on the Arduino.
  • TX (Transmit) → Connect to D2 on the Arduino (Software Serial RX).
  • RX (Receive) → Connect to D3 on the Arduino (Software Serial TX).

2. Connecting the Servo Motor to Arduino

The servo motor is responsible for physically locking and unlocking the door by rotating a latch mechanism.

Wiring the Servo Motor to the Arduino:

  • VCC (Power) → Connect to 5V on the Arduino.
  • GND (Ground) → Connect to GND on the Arduino.
  • Signal (Control Pin) → Connect to D9 on the Arduino.

Why Use a Servo Motor?

A servo motor provides precise control over the locking mechanism, allowing the door to be securely locked or unlocked based on fingerprint authentication.

3. Powering the System

To ensure reliable operation, the power requirements must be managed effectively.

  • Powering the Fingerprint Sensor and Arduino: Use a 5V power source (either from the Arduino board or an external adapter).
  • Servo Motor Power: If the servo motor requires more power than the Arduino can provide, use an external power supply with a common ground connection.

4. Installing the Components on the Door Lock

  • Mounting the Fingerprint Sensor: Secure it near the door handle for easy access.
  • Positioning the Servo Motor: Attach it to the lock mechanism so that it rotates when activated.
  • Connecting the Arduino: Place it in a secure enclosure near the door to prevent tampering.

5. Uploading the Code to the Arduino

  • Open the Arduino IDE on your computer.
  • Install the Adafruit Fingerprint Sensor Library (if not already installed).
  • Paste the provided code into a new sketch.
  • Connect the Arduino to your computer via USB.
  • Select the correct board and port.
  • Click the Upload button.


CODE

#include <Adafruit_Fingerprint.h>
#include <Servo.h>
#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3); // RX, TX for the fingerprint sensor
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
Servo lockServo;

int lockPosition = 0;  // Locked position
int unlockPosition = 90;  // Unlocked position

void setup() {
  Serial.begin(9600);
  finger.begin(57600);
  lockServo.attach(9);
  lockServo.write(lockPosition); // Ensure the door starts locked

  if (finger.verifyPassword()) {
    Serial.println("Fingerprint sensor detected.");
  } 
  else {
    Serial.println("Fingerprint sensor not found.");
  }
}

void loop() {
  Serial.println("Place finger...");
  int id = getFingerprintID();

  if (id > 0) {
    Serial.print("Access Granted! User ID: ");
    Serial.println(id);
    unlockDoor();
    delay(5000);  // Keep unlocked for 5 seconds
    lockDoor();
  } 
  else {
    Serial.println("Access Denied.");
  }

  delay(1000);
}

int getFingerprintID() {
  int result = finger.getImage();
  if (result != FINGERPRINT_OK) return -1;

  result = finger.image2Tz();
  if (result != FINGERPRINT_OK) return -1;

  result = finger.fingerFastSearch();
  if (result != FINGERPRINT_OK) return -1;

  return finger.fingerID;
}

void unlockDoor() {
  Serial.println("Unlocking Door...");
  lockServo.write(unlockPosition);
}

void lockDoor() {
  Serial.println("Locking Door...");
  lockServo.write(lockPosition);
}


CODE EXPLANATION

1. Including Necessary Libraries

#include <Adafruit_Fingerprint.h>  
#include <Servo.h>  
#include <SoftwareSerial.h>
  • Adafruit_Fingerprint.h: Enables communication with the fingerprint sensor.
  • Servo.h: Controls the servo motor for locking and unlocking the door.
  • SoftwareSerial.h: Creates a software-based serial communication channel, allowing us to use other pins (not just the default RX/TX pins) for communication.

2. Setting Up Serial Communication and Initializing Components

SoftwareSerial mySerial(2, 3);  // RX, TX
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
Servo lockServo;
  • SoftwareSerial mySerial(2, 3); → Defines a software-based serial port using pins 2 (RX) and 3 (TX) for communication with the fingerprint sensor.
  • Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial); → Creates an instance of the fingerprint sensor to interact with it.
  • Servo lockServo; → Declares a servo motor object named lockServo, which will control the door lock mechanism.

3.Defining Pins

const int servoPin = 9;
const int buttonPin = 7;
  • servoPin = 9; → The servo motor is connected to pin 9 on the Arduino.
  • buttonPin = 7; → A push button for registering new fingerprints is connected to pin 7.

4. Setting Up the System in setup() Function

void setup() {
  Serial.begin(9600);
  finger.begin(57600);
  pinMode(buttonPin, INPUT_PULLUP);
  lockServo.attach(servoPin);
  • Serial.begin(9600); → Initializes serial communication at 9600 baud rate for debugging messages.
  • finger.begin(57600); → Initializes the fingerprint sensor at 57600 baud rate.
  • pinMode(buttonPin, INPUT_PULLUP); → Configures the push button as an input with an internal pull-up resistor to prevent floating states.
  • lockServo.attach(servoPin); → Assigns pin 9 to control the servo motor.

5. Checking Fingerprint Sensor Connectivity

if (finger.verifyPassword()) {
    Serial.println("Fingerprint sensor detected.");
} else {
    Serial.println("Fingerprint sensor not found.");
}
  • finger.verifyPassword(); → Checks if the fingerprint sensor is correctly connected and responding.
  • If true, it prints "Fingerprint sensor detected."
  • If false, it prints "Fingerprint sensor not found." (indicating a wiring or power issue).

6. Setting Initial Lock Position

lockServo.write(0); // Lock position
  • lockServo.write(0); → Positions the servo at 0 degrees (which represents the locked position of the door).

7. Continuous Loop for Fingerprint Authentication

void loop() {
  if (digitalRead(buttonPin) == LOW) {
    registerFingerprint();
  }
  int fingerprintID = getFingerprintID();
  if (fingerprintID > 0) {
    Serial.println("Access Granted!");
    unlockDoor();
    delay(5000); // Keep door open for 5 seconds
    lockDoor();
  }
}
  • if (digitalRead(buttonPin) == LOW) { registerFingerprint(); }
    • If the push button is pressed, the system enters fingerprint registration mode.
  • int fingerprintID = getFingerprintID();
    • Calls getFingerprintID() function to check if a fingerprint is scanned.
  • if (fingerprintID > 0) { ... }
    • If a valid fingerprint is detected, the door unlocks.
  • unlockDoor();
    • Calls the unlockDoor() function to rotate the servo and open the lock.
  • delay(5000);
    • Keeps the door unlocked for 5 seconds before relocking.
  • lockDoor();
    • Calls the lockDoor() function to return the servo to locked position.

8. Fingerprint Authentication Function

int getFingerprintID() {
  if (finger.getImage() != FINGERPRINT_OK) return -1;
  if (finger.image2Tz() != FINGERPRINT_OK) return -1;
  if (finger.fingerFastSearch() != FINGERPRINT_OK) return -1;
  return finger.fingerID;
}
  • finger.getImage();
    • Captures the fingerprint image.
    • If unsuccessful, returns -1 (indicating no fingerprint was scanned).
  • finger.image2Tz();
    • Converts the image into template data for processing.
  • finger.fingerFastSearch();
    • Searches the scanned fingerprint against the database of stored fingerprints.
    • If successful, returns a valid fingerprint ID.
    • If any step fails, the function returns -1 (meaning no fingerprint match was found).

9. Unlocking the Door

void unlockDoor() {
  lockServo.write(90); // Rotate to unlock position
  Serial.println("Door Unlocked!");
}
  • lockServo.write(90);
    • Moves the servo to 90 degrees to disengage the lock.
  • Serial.println("Door Unlocked!");
    • Displays a message in the serial monitor confirming that the door is unlocked.

10. Locking the Door

void lockDoor() {
  lockServo.write(0); // Rotate back to lock position
  Serial.println("Door Locked!");
}
  • lockServo.write(0);
    • Moves the servo back to 0 degrees, locking the door.
  • Serial.println("Door Locked!");
    • Displays a message confirming the door is locked.

11. Registering a New Fingerprint

void registerFingerprint() {
  Serial.println("Place finger to register...");
  delay(2000);
  finger.getImage();
  finger.image2Tz(1);
  finger.storeModel(1);
  Serial.println("Fingerprint stored successfully.");
}
  • Serial.println("Place finger to register...");
    • Displays a message instructing the user to place a finger on the sensor.
  • delay(2000);
    • Waits 2 seconds before scanning to allow the user time to position their finger.
  • finger.getImage();
    • Captures the fingerprint.
  • finger.image2Tz(1);
    • Converts the scanned fingerprint into template format for processing.
  • finger.storeModel(1);
    • Stores the fingerprint in memory with ID = 1.
  • Serial.println("Fingerprint stored successfully.");
    • Prints a message confirming successful fingerprint registration.

How It Works

  • The fingerprint sensor scans the user’s fingerprint.
  • If the fingerprint is recognized, the servo motor unlocks the door.
  • After 5 seconds, the door automatically locks again.

OBSERVING FUNCTIONALITY

To observe and test how the fingerprint door lock system functions, follow these steps:

1. System Initialization

  • Power on the Arduino board.
  • Check the serial monitor for a message confirming the fingerprint sensor is detected.
  • Ensure the servo motor starts in the locked position (0°).

2. Fingerprint Authentication

  • Place a registered fingerprint on the sensor.
  • Observe if:
    • The fingerprint is detected and authenticated.
    • The servo moves to 90°, unlocking the door.
    • The serial monitor displays "Access Granted!".
  • Wait for 5 seconds and check if:
    • The servo moves back to 0°, locking the door again.
    • The serial monitor displays "Door Locked!".

3. Unregistered Fingerprint Test

  • Place an unregistered fingerprint on the sensor.
  • Observe if:
    • The door remains locked.
    • The serial monitor does not display "Access Granted!".

4. Registering a New Fingerprint

  • Press the button (pin 7) to enter registration mode.
  • Check if:
    • The serial monitor displays "Place finger to register...".
    • The fingerprint sensor captures the fingerprint.
    • The serial monitor displays "Fingerprint stored successfully.".
  • After registration, test the new fingerprint to verify it unlocks the door.

5. Locking and Unlocking Mechanism

  • Manually test if the servo correctly rotates:
    • 0° → Locked Position.
    • 90° → Unlocked Position.
  • Observe the physical movement of the lock to ensure smooth operation.

6. Handling Errors

  • Disconnect the fingerprint sensor and restart the system.
    • Observe if the serial monitor displays "Fingerprint sensor not found.".
  • Place a damaged or unclear fingerprint and check if authentication fails.
  • Try registering the same fingerprint twice to test the system’s response.

COMMON PROBLEMS AND SOLUTIONS

1. Fingerprint Sensor Not Responding

  • Cause: Incorrect wiring.
  • Solution: Ensure TX and RX are correctly connected.

2. Door Not Locking/Unlocking

  • Cause: Servo motor power issues.
  • Solution: Use an external power source for the servo.

Conclusion

This fingerprint door lock system combines biometric authentication with microcontroller automation, enhancing security while maintaining user convenience. By integrating an Arduino Uno, a fingerprint sensor, and a servo motor, the system ensures controlled access, making it ideal for home and office security.

Comments

TOUCH-ACTIVATED FAN SWITCH