This innovative project implements a secure, IOT-powered door unlocking system that uses advanced facial recognition technology combined with multi-factor authentication. Built with modern web technologies and Arduino hardware, it provides a seamless and secure access control solution.

• 🎯 FaceAPI-Powered Face Recognition - Advanced ML models with 75%+ accuracy
• 🔒 Multi-Factor Authentication - Face + PIN verification for enhanced security
• 👁️ Liveness Detection - Prevents spoofing with photo/video attacks
• 🔄 Auto-Lock System - Automatic door locking after timeout
• 📊 Access Logging - Complete audit trail of all access attempts
• ⚡ Real-time Processing - Fast recognition within 2 seconds
• 🌐 Modern Web Interface - Responsive ReactJS frontend
• 🔧 Hardware Integration - Seamless Arduino control

graph TB
    A[👤 User] --> B[📷 Webcam]
    B --> C[🧠 Face-API.js]
    C --> D[⚛️ React Frontend]
    D --> E[🔍 Face Recognition]
    E --> F{✅ Authorized?}
    F -->|Yes| G[🔢 PIN Entry]
    F -->|No| H[❌ Access Denied]
    G --> I[🖥️ Node.js Backend]
    I --> J[🗄️ MongoDB]
    I --> K[📡 Serial Communication]
    K --> L[🤖 Arduino]
    L --> M[🔓 Servo Motor]
    M --> N[🚪 Door Unlock]

1. 👁️ Face Detection

   • System activates webcam and detects user's face using advanced ML models
   • Real-time face tracking and positioning

2. 🔍 Face Recognition

   • Compares detected face with authorized users in database
   • Uses multiple facial feature points for accurate identification

3. 🛡️ Liveness Check

   • Analyzes facial expressions to ensure it's a real person
   • Prevents photo and video spoofing attacks

4. 🔢 PIN Verification

   • User enters PIN using physical 4x4 keypad
   • Multi-factor authentication for enhanced security

5. ✅ Access Granted

   • Backend sends unlock signal to Arduino
   • Servo motor rotates to unlock the door
   • Access logged with timestamp

6. 🔒 Auto-Lock

   • Door automatically locks after preset timeout
   • System returns to monitoring mode

Our system uses state-of-the-art machine learning models for optimal performance:

• ⚡ Recognition Speed: ~2 seconds average
• 🎯 Overall Accuracy: 73-75% under various conditions
• ❌ False Positive Rate: <15%
• 👁️ Liveness Detection: 78%+ success rate

Before you begin, ensure you have the following installed:

• ✅ Node.js (v14 or higher)
• ✅ MongoDB (for user data storage)
• ✅ Arduino IDE
• ✅ Webcam (USB or built-in)
• ✅ Hardware Components (Servo Motor, 4x4 Keypad)

git clone https://github.com/Adarsha59/Final-Year-Project.git
cd Final-Year-Project

# Install dependencies
npm install

# Start React development server
npm start

The frontend will be available at http://localhost:3000

# Navigate to backend directory
cd backend

# Install backend dependencies
npm install

# Start backend server
npm start
# or for development
nodemon index.js

The backend will run on http://localhost:3001

Download the required face-api.js models and place them in /public/models/:

# Create models directory
mkdir public/models

# Download models from official repository
# Place the following files in public/models/:
- ssdMobilenetv1_model-weights_manifest.json
- ssdMobilenetv1_model-shard1
- face_recognition_model-weights_manifest.json
- face_recognition_model-shard1
- face_landmark_68_model-weights_manifest.json
- face_landmark_68_model-shard1
- face_expression_model-weights_manifest.json
- face_expression_model-shard1

📥 Download Link: face-api.js Models

1. Install Arduino IDE from arduino.cc

2. Install Required Libraries:

   // In Arduino IDE, go to: Sketch > Include Library > Manage Libraries
   // Search and install:
   - Servo library
   - Keypad library (by Mark Stanley)

3. Hardware Connections:

   Arduino Uno Connections:
   ├── Servo Motor (SG90)
   │   ├── Red Wire    → 5V
   │   ├── Brown Wire  → GND
   │   └── Orange Wire → Pin 9
   ├── 4x4 Keypad
   │   ├── Row Pins    → Pins 6, 7, 8, 9
   │   └── Col Pins    → Pins 2, 3, 4, 5
   └── USB Cable       → Computer
   

4. Upload Arduino Code:

   • Copy the provided Arduino code
   • Select your board and port
   • Upload the code

# Start MongoDB service
# For Windows:
net start MongoDB

# For macOS:
brew services start mongodb-community

# For Linux:
sudo systemctl start mongod

// Load face-api.js models
await faceapi.nets.ssdMobilenetv1.loadFromUri("/models");
await faceapi.nets.faceRecognitionNet.loadFromUri("/models");
await faceapi.nets.faceLandmark68Net.loadFromUri("/models");
await faceapi.nets.faceExpressionNet.loadFromUri("/models");

// Face recognition with liveness detection
const detectionsWithExpressions = await faceapi
  .detectAllFaces(video)
  .withFaceLandmarks()
  .withFaceDescriptors()
  .withFaceExpressions();

const { SerialPort } = require("serialport");
const { ByteLengthParser } = require("@serialport/parser-byte-length");

const serialPort = new SerialPort({
  path: "/dev/ttyACM0", // Adjust for your system
  baudRate: 9600,
});

const parser = new ByteLengthParser({ length: 1 });
serialPort.pipe(parser);

// Handle keypad input
parser.on("data", (data) => {
  const key = data.toString().trim();
  console.log("Keypad Key Received:", key);

  if (key === "*" || key === "#") {
    inputBuffer = "";
  } else if (key.toUpperCase() === "D") {
    enterPressed = true;
  } else {
    inputBuffer += key;
  }
});

#include <Keypad.h>

const byte ROWS = 4;
const byte COLS = 4;

char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte rowPins[ROWS] = {9, 8, 7, 6};
byte colPins[COLS] = {5, 4, 3, 2};

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

void setup() {
  Serial.begin(9600);
}

void loop() {
  char key = keypad.getKey();
  if (key) {
    Serial.println(key);
  }
}

#include <Servo.h>

Servo myServo;
const int ledPin = 8;
const int servoPin = 9;

int targetPos = 0;
int currentPos = 0;
unsigned long lastMoveTime = 0;
const int stepDelay = 10;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
  myServo.attach(servoPin);
  myServo.write(currentPos);
}

void loop() {
  if (Serial.available() > 0) {
    char signal = Serial.read();
    if (signal == '1') {
      digitalWrite(ledPin, HIGH);
      targetPos = 180; // Unlock
      Serial.println("DOOR UNLOCKED");
    } else if (signal == '0') {
      digitalWrite(ledPin, LOW);
      targetPos = 0; // Lock
      Serial.println("DOOR LOCKED");
    }
  }

  // Smooth servo movement
  unsigned long now = millis();
  if (now - lastMoveTime >= stepDelay) {
    if (currentPos < targetPos) {
      currentPos++;
      myServo.write(currentPos);
    } else if (currentPos > targetPos) {
      currentPos--;
      myServo.write(currentPos);
    }
    lastMoveTime = now;
  }
}

face-recognition-door-system/
├── 📁 arduino_code/
│   ├── keypad_input_serial_communication.cpp
│   ├── smooth_servo_and_led_control_with_arduino.cpp
│   └── both_servo_and_keypad_serial_control.cpp
├── 📁 backend/
│   ├── 📁 config/
│   ├── 📁 models/
│   ├── 📁 routes/
│   ├── 📁 uploads/
│   ├── index.js
│   ├── help.js
│   └── package.json
├── 📁 src/
│   ├── 📁 components/
│   ├── 📁 pages/
│   ├── App.js
│   ├── App.css
│   └── index.js
├── 📁 public/
│   ├── 📁 models/          # AI models go here
│   ├── 📁 labels/
│   ├── index.html
│   └── favicon.ico
├── 📁 Docs/
│   └── Final_Reports_FRBDUS.pdf
├── Face Api.png
├── README.md
├── package.json
└── tailwind.config.js

1. 🚀 Start Backend Server

   cd backend
   npm start

2. ⚛️ Launch Frontend

   npm start

3. 🔌 Connect Arduino

   • Ensure Arduino is connected via USB
   • Check the correct COM port in backend configuration

4. 👤 Register Users

   • Navigate to registration page
   • Capture multiple face samples for better accuracy
   • Set a 5-digit PIN

5. 🧪 Test Recognition

   • Stand in front of webcam
   • Wait for face detection
   • Enter PIN when prompted

6. 🚪 Verify Door Operation

   • Servo motor should rotate to unlock position
   • LED indicator should light up
   • Door should auto-lock after timeout

• 👁️ Liveness Detection: Prevents photo/video spoofing attacks
• 🔢 Two-Factor Authentication: Face recognition + PIN verification
• 📊 Access Logging: Complete audit trail with timestamps
• ⏰ Auto-Lock System: Automatic door locking after preset time
• 🚨 Intrusion Detection: Alerts on repeated unauthorized attempts
• 🔄 Session Management: Secure user sessions with timeout

🔧 Arduino Not Detected

• ✅ Check USB cable connection
• ✅ Verify COM port settings
• ✅ Install Arduino drivers
• ✅ Test with Arduino IDE Serial Monitor

👁️ Face Recognition Fails

• ✅ Ensure adequate lighting (avoid backlight)
• ✅ Position face 1-2 feet from camera
• ✅ Check if models are loaded correctly
• ✅ Clear browser cache and reload

📡 Serial Communication Errors

• ✅ Verify baud rate (9600)
• ✅ Check port permissions (Linux/Mac)
• ✅ Ensure only one application accesses serial port
• ✅ Restart backend server

🔌 Hardware Issues

• ✅ Check all wire connections
• ✅ Verify power supply (5V for servo)
• ✅ Test components individually
• ✅ Check for loose connections

💾 Database Connection Issues

• ✅ Ensure MongoDB is running
• ✅ Check connection string
• ✅ Verify database permissions
• ✅ Test database connectivity

User Registration:

POST /api/register
{
  "name": "John Doe",
  "password": "12345",
  "imageData": "base64_encoded_image"
}

Response:
{
  "success": true,
  "message": "User registered successfully",
  "userId": "64a7b8c9d1e2f3g4h5i6"
}

• 📱 Mobile App Integration: iOS/Android companion app
• ☁️ Cloud Synchronization: Multi-device access management
• 🔊 Voice Commands: Voice-activated door control
• 📧 Email Notifications: Real-time access alerts
• 🌐 Web Dashboard: Remote monitoring and control
• 🤖 AI Improvements: Enhanced recognition accuracy
• 🔐 Blockchain Security: Immutable access logs

• 🏠 Smart Home Systems: Integration with Alexa, Google Home
• 🏢 Enterprise Systems: Active Directory integration
• 📹 CCTV Integration: Video recording on access events
• 🚨 Security Alarms: Integration with alarm systems

We welcome contributions from the community! Here's how you can help:

1. 🍴 Fork the Repository

   git fork https://github.com/Adarsha59/Final-Year-Project.git

2. 🌿 Create Feature Branch

   git checkout -b feature/amazing-feature

3. 💾 Commit Changes

   git commit -m "Add amazing feature"

4. 📤 Push to Branch

   git push origin feature/amazing-feature

5. 🔄 Open Pull Request

• Follow existing code style and conventions
• Add tests for new features
• Update documentation for any changes
• Ensure all tests pass before submitting
• Write clear commit messages

• Use GitHub Issues to report bugs
• Provide detailed reproduction steps
• Include system information and logs
• Add screenshots if applicable

This project is developed for academic purposes at Nepal College of Information Technology.

• ✅ Free for educational and research purposes
• ✅ Modification and distribution allowed with attribution
• ❌ Commercial use requires explicit permission
• ❌ No warranty provided - use at your own risk

• face-api.js: MIT License
• React.js: MIT License
• Node.js: MIT License
• Arduino Libraries: Various open-source licenses

• 🏫 Nepal College of Information Technology - For providing the platform and resources
• 👨‍🏫 Faculty Members - For guidance and supervision throughout the project
• 🤝 Open Source Community - For the amazing libraries and tools
• 📚 Research Papers - For insights into face recognition algorithms
• 💻 GitHub Community - For code examples and troubleshooting help
• 🤖 ChatGPT - For patiently explaining things 27 times and pretending not to judge my coding skills

• face-api.js Documentation
• Arduino Official Documentation
• React.js Best Practices
• MongoDB Query Optimization
• Computer Vision Research Papers