Misra
Misra
Introduction
The fascinating world of IoT-based fingerprint attendance systems. These
innovative solutions combine biometrics, connectivity, and smart technology
to revolutionize attendance management. Here’s an overview:
IoT-Based Biometric Fingerprint Attendance System
1. Purpose and Objective
The IoT-based biometric fingerprint attendance system aims to automate
attendance tracking, enhance accuracy, and improve security. By leveraging
fingerprint recognition and internet connectivity, this system eliminates manual
processes and provides real-time data.
2. How It Works
Fingerprint Enrollment:
o Users’ fingerprints are enrolled and stored in the system.
o The enrollment process ensures unique identification for each
individual.
Attendance Marking:
o When users arrive at a specific location (e.g., classroom,
office), they place their finger on a fingerprint sensor.
o The system verifies their identity by comparing the live
fingerprint with stored templates.
o Real-time attendance records are generated.
Data Transmission:
o The IoT-enabled device (such as NodeMCU ESP8266)
collects attendance data.
o Data is transmitted over the internet to a central server or
cloud platform.
Database and Records:
o A website (coded in PHP) maintains attendance records.
o Users can log in to access their attendance history, including
personal details and timing.
o Data can be exported to Excel sheets for further analysis.
3. Advantages
4. Components
To build an IoT-based biometric fingerprint attendance system, you’ll need
the following components:
6. Conclusion
IoT-based fingerprint attendance systems enhance security, accuracy, and
efficiency. Whether in educational institutions or corporate settings, these
systems redefine how we manage attendance. By using biometrics, we create a
more secure and reliable environment for user. We can explore similar
projects like the Arduino Fingerprint Attendance System or consider using the
GT511C3 fingerprint sensor for better performance.
Problem Statement
The problem statement for an IoT-based fingerprint attendance system. This
system aims to address several challenges associated with traditional
attendance methods and enhance efficiency. Here’s the problem statement:
Problem Statement: Enhancing Attendance Management with IoT
and Biometrics
Background and Challenges
Objectives
Solution Approach
IoT-Based Fingerprint Attendance System:
o Utilize IoT (Internet of Things) technology for connectivity.
o Implement biometric fingerprint recognition for secure
identification.
o Collect attendance data from multiple users using Wi-Fi-
enabled modules (e.g., NodeMCU ESP8266).
o Transmit data over the internet to a central server or cloud
platform.
o Maintain attendance records on a website coded in PHP.
o Provide user-friendly access to attendance history, including
personal details and timing.
o Allow data export to Excel sheets for further analysis.
2. Workflow
1. Fingerprint Enrollment:
o Users’ fingerprints are enrolled during system setup.
o The fingerprint sensor captures unique features.
o Templates are stored securely.
2. Attendance Marking:
o When users arrive (e.g., students entering a classroom), they place
their finger on the sensor.
o The system verifies their identity by comparing the live
fingerprint with stored templates.
o Real-time attendance records are generated.
3. Data Transmission:
o The NodeMCU ESP8266 collects attendance data.
o Over Wi-Fi, it sends data to the central server or cloud.
4. Database and Records:
o The website displays attendance history.
o Users can view their own records.
o Administrators access overall attendance data.
o Data is organized and easily retrievable.
3. Benefits
4. Revenue Streams
5. Impact
Key Activities:
The key activities involved in an IoT-based fingerprint attendance
system. These systems leverage biometric technology to automate
attendance tracking and enhance efficiency. Here are the essential
activities:
1. Fingerprint Data Collection:
o Objective: To capture fingerprints of students or employees.
o How It Works:
A fingerprint sensor (such as the R305 or R307) scans the
user’s fingerprint.
The sensor processes the fingerprint data and extracts
unique features.
The system stores these features for future
comparison.
o Benefits:
Highly secure and personalized.
Eliminates the need for physical tokens (e.g., ID cards).
2. Authentication and Verification:
o Objective: To verify the identity of individuals during
attendance.
o How It Works:
When a user places their finger on the sensor, it
compares the live fingerprint with stored templates.
If a match is found, the system confirms the user’s
identity.
Real-time verification ensures accurate attendance
records.
o Benefits:
Prevents proxy attendance.
Provides reliable authentication.
3. Data Transmission and Storage:
o Objective: To record attendance data and make it
accessible.
o How It Works:
The system communicates with a central server or
cloud platform.
Attendance records are transmitted over the internet.
Data is securely stored and organized for further
analysis.
o Benefits:
Enables remote monitoring.
Facilitates data retrieval and reporting.
4. Attendance Processing:
o Objective: To generate attendance records.
o How It Works:
The system compiles attendance data for each user.
It calculates total hours, days present, and other
relevant metrics.
Records are updated in real time.
o Benefits:
Streamlines administrative tasks.
Provides accurate reports.
5. Integration with Other Systems:
o Objective: To seamlessly integrate attendance data with
existing infrastructure.
o How It Works:
The system can link attendance records to student
databases, payroll systems, or access control.
APIs or custom interfaces allow data exchange.
o Benefits:
Enhances overall efficiency.
Reduces manual data entry.
6. Maintenance and Troubleshooting:
o Objective: To ensure system reliability.
o How It Works:
Regular maintenance includes sensor calibration,
firmware updates, and hardware checks.
Troubleshooting resolves issues promptly.
o Benefits:
Minimizes downtime.
Sustains long-term functionality.
In summary, IoT-based attendance systems not only improve accuracy but also
open up various revenue opportunities for providers. Whether through
subscriptions, hardware sales, or customization services, these systems can be
both efficient and profitable.
Traction
The traction for IoT-based attendance systems is gaining momentum across
various sectors due to their efficiency, security, and convenience. Here’s a brief
overview:
1. Adoption in Multiple Sectors:
o IoT-based attendance systems are being adopted in sectors like
education, healthcare, transportation,
and agriculture.
o They offer solutions for contactless check-ins, which became
particularly relevant during the COVID-19 pandemic.
2. Benefits Driving Adoption:
o The systems provide a reliable and secure alternative to
manual attendance methods.
o They address shortcomings such as time theft and offer
features like temperature measurements for health
monitoring.
3. Target Audience:
o The primary target audience includes educational
institutions, corporate offices, and healthcare facilities.
o These systems are also suitable for any organization looking to
automate attendance tracking and enhance security measures.
4. Market Growth Factors:
o The demand for contactless and automated solutions has
increased due to health concerns.
o Organizations are seeking ways to improve efficiency and
accuracy in attendance management.
IOT based attendance system are well postioned for growth as they continue
to offer innovative solutions to traditional challenges in attendance tracking.
Competitive Landscape
Competitive landscape of IoT-based fingerprint attendance systems. These
systems leverage biometrics and connectivity to enhance attendance
management. Here are some notable projects and solutions:
1. IoT Biometric Fingerprint Attendance System with ESP8266:
o Overview: This project uses NodeMCU ESP8266, a 0.96"
OLED display, and the R305 or R307 fingerprint sensor.
o Workflow:
The ESP8266 collects fingerprint data from multiple
users.
Data is sent over the internet to a website coded in
PHP.
The website maintains attendance records, including
personal details and timing.
o Benefits:
Real-time tracking, security, and scalability.
o Application: : Schools, colleges, offices, and security
systems
2. IoT-Based Fingerprint Biometric Attendance System Using
NodeMCU:
o Overview: This system utilizes NodeMCU (ESP8266), a
0.96" OLED display, and the R-307 fingerprint sensor.
o Workflow:
Fingerprint enrollment occurs on the server using the R-
307 sensor.
Users’ fingerprints are verified on the client side.
Data is transmitted over the internet to a website.
o USP: Contactless experience, real-time tracking, and
security
3. IoT-Based Smart Attendance System Project Using NodeMCU
ESP8266:
o Overview: This project integrates NodeMCU with the R305
fingerprint module and an LCD display.
o Workflow:
Fingerprint data is collected.
Attendance logs are stored in a Google spreadsheet.
o Benefits: Real-time attendance tracking and easy log
maintenance
1. Security Concerns:
o Security is the primary weakness of any IoT device.
o Breaches, hacks, and unauthorized access pose significant risks.
o Ensuring robust security measures is crucial.
2. Complexity and Interoperability:
o Integrating various IoT devices and ensuring seamless
communication can be challenging.
o Compatibility issues may arise when different devices use
different protocols.
o Standardization efforts are ongoing.
1. Market Growth:
o The demand for attendance solutions is rising across sectors
(education, healthcare, corporate).
o IoT-based systems have ample growth opportunities.
2. Customization and Industry-Specific Solutions:
o Tailoring solutions to specific industry needs (e.g., education,
healthcare) can lead to success.
o Customized features enhance user experience and adoption.
3. Data Analytics and Insights:
o Beyond attendance tracking, IoT systems provide valuable data
for resource optimization.
o Organizations can make informed decisions based on real- time
insights.
Play music. In summary, IOT based attendance system offer immense potential.
But addressing security interoperability, and privacy challenges is critical for
long success.
Hardware Sales:
2. Expected Expenses:
Hardware Costs:
3. Turnaround Time:
Development Phase:
Revenue Generation:
4. Conclusion:
Remember that these projections are general estimates, and actual results
may vary based on market dynamics, competition, and other factors.
Hardware Components:
o NodeMCU ESP8266 Board: Typically priced around Rs(500 to
2000)
o R305/R307 Fingerprint Sensor: Costs approximately Rs (700 to
1800).
o 0.96" I2C OLED Display: Usually available for Rs 150to 400.
o Connecting Wires, Breadboard, and other components:
Budget around Rs1000.
Software Development:
o Hiring developers or allocating internal resources for coding and
testing.
o Costs vary based on expertise and project complexity.
Website Setup:
o Domain registration and hosting costs (if using an external
website).
o Alternatively, setting up a local server for testing and
deployment.
Database Configuration:
o Creating and maintaining a database for attendance records.
o Costs depend on the chosen database management system (e.g.,
MySQL, PostgreSQL).
Digital Marketing:
o Promoting the system through online channels (social media, ads,
etc.).
o Budget allocation for marketing campaigns.
Sales Efforts:
o Sales team salaries or commissions (if applicable).
Ongoing Expenses:
o Regular maintenance, bug fixes, and updates.
o Ensuring system reliability and security.
Customer Support:
o Providing assistance to users.
o Costs associated with support staff.
5. Revenue Generation:
Subscription Model:
o Recurring revenue from institutes using the system.
Hardware Sales:
o One-time revenue from selling fingerprint sensors and
related components.
Customization Fees:
o Charging for tailoring the system to specific requirements.
Maintenance Contracts:
o Generating revenue through ongoing support services.
Conclusion:
Manpower Requirement
1. Project Manager:
o Role: Oversees the entire project, including planning,
execution, and delivery.
o Responsibilities:
Define project scope, goals, and deliverables.
Allocate resources and manage timelines.
Coordinate communication among team members.
Monitor progress and address any issues.
2. Hardware Engineer:
o Role: Designs and implements the hardware components of the
system.
o Responsibilities:
Select appropriate sensors (e.g., fingerprint sensors,
OLED displays).
Design the circuit layout.
Prototype and test hardware configurations.
Ensure compatibility and reliability.
3. Software Developer/Programmer:
o Role: Develops the software components of the system.
o Responsibilities:
Write code for data collection, transmission, and
database management.
Implement the website or dashboard (coded in PHP or other
relevant languages).
Integrate hardware and software functionalities.
4. Database Administrator:
o Role: Manages the database where attendance records are stored.
o Responsibilities:
Set up the database (e.g., MySQL, PostgreSQL).
Optimize data storage and retrieval.
Ensure data security and backups.
5. Network Specialist:
o Role: Ensures seamless communication between devices and
the central server.
o Responsibilities:
Configure Wi-Fi connectivity for NodeMCU ESP8266.
Troubleshoot network issues.
Monitor data transmission.
6. Quality Assurance (QA) Tester:
o Role: Ensures the system functions correctly and meets
requirements.
o Responsibilities:
Test fingerprint enrollment, verification, and data
transmission.
Verify real-time updates and accuracy.
Identify and report any bugs or issues.
7. Technical Support/Help Desk:
o Role: Provides assistance to users and resolves queries.
o Responsibilities:
Address user inquiries related to the system.
Troubleshoot issues promptly.
Document common problems and solutions.
8. Sales and Marketing Team:
o Role: Promotes the system and secures clients.
o Responsibilities:
Market the solution to educational institutions,
businesses, and organizations.
Generate leads and close sales.
Communicate the system’s benefits to potential clients.
9. Maintenance and Upgrades Team:
o Role: Ensures ongoing system reliability.
o Responsibilities:
Perform regular maintenance (software updates, bug
fixes).
Implement system upgrades based on user feedback and
technological advancements.
10. Documentation Specialist:
o Role: Creates user manuals, technical documentation, and
training materials.
o Responsibilities:
Document system functionalities, installation
procedures, and troubleshooting steps.
Provide clear instructions for users.
Model
TX Blue wire
RX Green Wire
Resolution 500ppi
Host computer interface UART (TTL logic level)
Communication baud rate (UART) (9600XN) bps Where N = 1 ~ 6 (default value N = 6, namely 57600bps)
Arduino Uno
Power Vin, 3.3V, 5V, GND Vin: Input voltage to Arduino when using an external power
source.
Serial 0(Rx), 1(Tx) Used to receive and transmit TTL serial data.
Operating Voltage 5V
SRAM 2 KB
EEPROM 1 KB
33K This is the output pin which gives the compensated temperature as well as accurate reference clock.
This pin outputs a square wave at different frequencies of 1Hz, 4kHz, 8kHz, or 32kHz. It may also provide an interrupt
SQW
signal.
SCL This is the serial clock pin which is used in I2C communication.
SDA This is the serial data pin which is also used in I2C communication.
VCC This is the power supply pin of the module. Connect it with 3.3V or 5V
GND This is the ground pin used for providing common ground.
DS3231 RTC Schematic Diagram
The schematic of the module is provided to understand the connections which
may turn helpful while repairing the module:
2 Vdd (+5 Volt) Powers the LCD with +5V (4.7V – 5.3V)
5 Read/Write Used to read or write data. Normally grounded to write data to LCD
7 Data Pin 0
These LCD’s can also operate on 4-bit mode in such case Data pin 4,5,6
and 7 will be left free.
8 Data Pin 1
9 Data Pin 2
10 Data Pin 3
11 Data Pin 4
12 Data Pin 5
13 Data Pin 6
14 Data Pin 7
Block Diagram
In this Fingerprint Sensor Based Biometric Attendance System using
Arduino, we used a Fingerprint Sensor module to authenticate a true
person or employee by taking their finger input in the system. Here we
are using 4 push buttons to register new fingerprint or delete stored
fingerprint or match stored fingerprint. The 4 push buttons are used as
an input unit for these tasks. Similarly, RTC Module DS3231 is used for
registering scanning/entering/existing time of the user.
The LCD displays the time record and every function happening via push
button. Buzzer indicates different functions and happening whenever an
interrupt is detected. The LED is used for power indication.
Code:
#include "Adafruit_Fingerprint.h" //fingerprint library header file
#include<EEPROM.h> //command for storing data
#include<LiquidCrystal.h> //lcd header file
LiquidCrystal lcd(8,9,10,11,12,13);
#include <SoftwareSerial.h>
SoftwareSerial fingerPrint(2, 3); //for tx/rx communication between arduino & r305
fingerprint sensor
#include <Wire.h>
#include "RTClib.h" //library file for DS3231 RTC Module
RTC_DS3231 rtc;
uint8_t id;
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&fingerPrint);
#define register_back 14
#define delete_ok 15
#define forward 16
#define reverse 17
#define match 5
#define indFinger 7
#define buzzer 5
int user1,user2,user3,user4,user5,user6,user7,user8,user9,user10;
DateTime now;
void setup()
{
delay(1000);
lcd.begin(16,2);
Serial.begin(9600);
pinMode(register_back, INPUT_PULLUP);
pinMode(forward, INPUT_PULLUP);
pinMode(reverse, INPUT_PULLUP);
pinMode(delete_ok, INPUT_PULLUP);
pinMode(match, INPUT_PULLUP);
pinMode(buzzer, OUTPUT);
pinMode(indFinger, OUTPUT);
digitalWrite(buzzer, LOW);
if(digitalRead(register_back) == 0)
{
digitalWrite(buzzer, HIGH);
delay(500);
digitalWrite(buzzer, LOW);
lcd.clear();
lcd.print("Please wait !");
lcd.setCursor(0,1);
lcd.print("Downloding Data");
Serial.println("Please wait");
Serial.println("Downloding Data..");
Serial.println();
Serial.print("S.No. ");
for(int i=0;i<records;i++)
{
digitalWrite(buzzer, HIGH);
delay(500);
digitalWrite(buzzer, LOW);
Serial.print(" User ID");
Serial.print(i+1);
Serial.print(" ");
}
Serial.println();
int eepIndex=0;
for(int i=0;i<30;i++)
{
if(i+1<10)
Serial.print('0');
Serial.print(i+1);
Serial.print(" ");
eepIndex=(i*7);
download(eepIndex);
eepIndex=(i*7)+210;
download(eepIndex);
eepIndex=(i*7)+420;
download(eepIndex);
eepIndex=(i*7)+630;
download(eepIndex);
eepIndex=(i*7)+840;
download(eepIndex);
eepIndex=(i*7)+1050;
download(eepIndex);
eepIndex=(i*7)+1260;
download(eepIndex);
eepIndex=(i*7)+1470;
download(eepIndex);
eepIndex=(i*7)+1680;
download(eepIndex);
Serial.println();
}
}
if(digitalRead(delete_ok) == 0)
{
lcd.clear();
lcd.print("Please Wait");
lcd.setCursor(0,1);
lcd.print("Reseting.....");
for(int i=1000;i<1005;i++)
EEPROM.write(i,0);
for(int i=0;i<841;i++)
EEPROM.write(i, 0xff);
lcd.clear();
lcd.print("System Reset");
delay(1000);
}
lcd.clear();
lcd.print(" Fingerprint ");
lcd.setCursor(0,1);
lcd.print("Attendance System");
delay(2000);
lcd.clear();
digitalWrite(buzzer, HIGH);
delay(500);
digitalWrite(buzzer, LOW);
for(int i=1000;i<1000+records;i++)
{
if(EEPROM.read(i) == 0xff)
EEPROM.write(i,0);
}
finger.begin(57600);
Serial.begin(9600);
lcd.clear();
lcd.print("Finding Module..");
lcd.setCursor(0,1);
delay(2000);
if (finger.verifyPassword())
{
Serial.println("Found fingerprint sensor!");
lcd.clear();
lcd.print(" Module Found");
delay(2000);
}
else
{
Serial.println("Did not find fingerprint sensor :(");
lcd.clear();
lcd.print("Module Not Found");
lcd.setCursor(0,1);
lcd.print("Check Connections");
while (1);
}
if (! rtc.begin())
Serial.println("Couldn't find RTC");
user1=EEPROM.read(1000);
user2=EEPROM.read(1001);
user3=EEPROM.read(1002);
user4=EEPROM.read(1003);
user5=EEPROM.read(1004);
lcd.clear();
digitalWrite(indFinger, HIGH);
void loop()
{
now = rtc.now();
lcd.setCursor(0,0);
lcd.print("Time: ");
lcd.print(now.hour(), DEC);
lcd.print(':');
lcd.print(now.minute(), DEC);
lcd.print(':');
lcd.print(now.second(), DEC);
lcd.print(" ");
lcd.setCursor(0,1);
lcd.print("Date: ");
lcd.print(now.day(), DEC);
lcd.print('/');
lcd.print(now.month(), DEC);
lcd.print('/');
lcd.print(now.year(), DEC);
lcd.print(" ");
delay(500);
int result=getFingerprintIDez();
if(result>0)
{
digitalWrite(indFinger, LOW);
digitalWrite(buzzer, HIGH);
delay(100);
digitalWrite(buzzer, LOW);
lcd.clear();
lcd.print("ID:");
lcd.print(result);
lcd.setCursor(0,1);
lcd.print("Please Wait....");
delay(1000);
attendance(result);
lcd.clear();
lcd.print("Attendance ");
lcd.setCursor(0,1);
lcd.print("Registered");
delay(1000);
digitalWrite(indFinger, HIGH);
return;
}
checkKeys();
delay(300);
}
// dmyyhms - 7 bytes
void attendance(int id)
{
int user=0,eepLoc=0;
if(id == 1)
{
eepLoc=0;
user=user1++;
}
else if(id == 2)
{
eepLoc=210;
user=user2++;
}
else if(id == 3)
{
eepLoc=420;
user=user3++;
}
else if(id == 4)
{
eepLoc=630;
user=user4++;
}
else if(id == 5)
{
eepLoc=0;
user=user5++;
}
else if(id == 6)
{
eepLoc=840;
user=user5++;
}
else if(id == 7)
{
eepLoc=1050;
user=user7++;
}
else if(id == 8)
{
eepLoc=1260;
user=user8++;
}
else if(id == 9)
{
eepLoc=1470;
user=user9++;
}
else if(id == 10)
{
eepLoc=1680;
user=user8++;
}
/*else if(id == 5) // fifth user
{
eepLoc=840;
user=user5+
+;
}*/
else
return;
int eepIndex=(user*7)+eepLoc;
EEPROM.write(eepIndex++, now.hour());
EEPROM.write(eepIndex++, now.minute());
EEPROM.write(eepIndex++, now.second());
EEPROM.write(eepIndex++, now.day());
EEPROM.write(eepIndex++, now.month());
EEPROM.write(eepIndex++, now.year()>>8 );
EEPROM.write(eepIndex++, now.year());
EEPROM.write(1000,user1);
EEPROM.write(1001,user2);
EEPROM.write(1002,user3);
EEPROM.write(1003,user4);
// EEPROM.write(4,user5); // figth user
}
void checkKeys()
{
if(digitalRead(register_back) == 0)
{
lcd.clear();
lcd.print("Please Wait");
delay(1000);
while(digitalRead(register_back) == 0);
Enroll();
}
else if(digitalRead(delete_ok) == 0)
{
lcd.clear();
lcd.print("Please Wait");
delay(1000);
delet();
}
}
void Enroll()
{
int count=1;
lcd.clear();
lcd.print("Enter Finger ID:");
while(1)
{
lcd.setCursor(0,1);
lcd.print(count);
if(digitalRead(forward) == 0)
{
count++;
if(count>records)
count=1;
delay(500);
}
else if(digitalRead(reverse) == 0)
{
count--;
if(count<1)
count=records;
delay(500);
}
else if(digitalRead(delete_ok) == 0)
{
id=count;
getFingerprintEnroll();
for(int i=0;i<records;i++)
{
if(EEPROM.read(i) != 0xff)
{
EEPROM.write(i, id);
break;
}
}
return;
}
else if(digitalRead(register_back) == 0)
{
return;
}
}
}
void delet()
{
int count=1;
lcd.clear();
lcd.print("Enter Finger ID");
while(1)
{
lcd.setCursor(0,1);
lcd.print(count);
if(digitalRead(forward) == 0)
{
count++;
if(count>records)
count=1;
delay(500);
}
else if(digitalRead(reverse) == 0)
{
count--;
if(count<1)
count=records;
delay(500);
}
else if(digitalRead(delete_ok) == 0)
{
id=count;
deleteFingerprint(id);
for(int i=0;i<records;i++)
{
if(EEPROM.read(i) == id)
{
EEPROM.write(i, 0xff);
break;
}
}
return;
}
else if(digitalRead(register_back) == 0)
{
return;
}
}
}
uint8_t getFingerprintEnroll()
{
int p = -
1;
lcd.clear();
lcd.print("finger ID:");
lcd.print(id);
lcd.setCursor(0,1);
lcd.print("Place Finger");
delay(2000);
while (p != FINGERPRINT_OK)
{
p = finger.getImage();
switch (p)
{
case FINGERPRINT_OK:
Serial.println("Image taken");
lcd.clear();
lcd.print("Image taken");
break;
case FINGERPRINT_NOFINGER:
Serial.println("No Finger");
lcd.clear();
lcd.print("No Finger Found");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
lcd.clear();
lcd.print("Comm Error");
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
lcd.clear();
lcd.print("Imaging Error");
break;
default:
Serial.println("Unknown error");
lcd.clear();
lcd.print("Unknown Error");
break;
}
}
// OK success!
p = finger.image2Tz(1);
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
lcd.clear();
lcd.print("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
lcd.clear();
lcd.print("Image too messy");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
lcd.clear();
lcd.print("Comm Error");
return p;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
lcd.clear();
lcd.print("Feature Not Found");
return p;
case FINGERPRINT_INVALIDIMAGE:
Serial.println("Could not find fingerprint features");
lcd.clear();
lcd.print("Feature Not Found");
return p;
default:
Serial.println("Unknown error");
lcd.clear();
lcd.print("Unknown Error");
return p;
}
Serial.println("Remove finger");
lcd.clear();
lcd.print("Remove Finger");
delay(2000);
p = 0;
while (p != FINGERPRINT_NOFINGER) {
p = finger.getImage();
}
Serial.print("ID "); Serial.println(id);
p = -1;
Serial.println("Place same finger again");
lcd.clear();
lcd.print("Place Finger");
lcd.setCursor(0,1);
lcd.print(" Again");
while (p != FINGERPRINT_OK) {
p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image taken");
break;
case FINGERPRINT_NOFINGER:
Serial.print(".");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
break;
default:
Serial.println("Unknown error");
return;
}
}
// OK success!
p = finger.image2Tz(2);
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
return p;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
return p;
case FINGERPRINT_INVALIDIMAGE:
Serial.println("Could not find fingerprint features");
return p;
default:
Serial.println("Unknown error");
return p;
}
// OK converted!
Serial.print("Creating model for #"); Serial.println(id);
p = finger.createModel();
if (p == FINGERPRINT_OK) {
Serial.println("Prints matched!");
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println("Communication error");
return p;
} else if (p == FINGERPRINT_ENROLLMISMATCH) {
Serial.println("Fingerprints did not match");
return p;
} else {
Serial.println("Unknown error");
return p;
}
int getFingerprintIDez()
{
uint8_t p = finger.getImage();
if (p != FINGERPRINT_OK)
return -1;
p = finger.image2Tz();
if (p != FINGERPRINT_OK)
return -1;
p = finger.fingerFastSearch();
if (p != FINGERPRINT_OK)
{
lcd.clear();
lcd.print("Finger Not Found");
lcd.setCursor(0,1);
lcd.print("Try Later");
delay(2000);
return -1;
}
// found a match!
Serial.print("Found ID #");
Serial.print(finger.fingerID);
return finger.fingerID;
}
else
{
Serial.print("Something Wrong");
lcd.clear();
lcd.print("Something Wrong");
lcd.setCursor(0,1);
lcd.print("Try Again Later");
delay(2000);
return p;
}
}
Serial.print(" ");
}
Working Explanation:
The working of the Fingerprint Sensor Based Biometric Attendance
System. In this project, we have used a DS3231 RTC Module for time &
date display. We used 1 LED for power indication, and 1 buzzer for
different function indications. We have interfaced 16*2 LCD which
displays everything whenever the finger is placed or removed, or
registering attendance or downloading data.
We have used 4 push buttons which are used to control the entire
system. The functions of each button are:
1. Register/Back Button – Used for enrolling new fingerprints as well as
reversing the back process or going back
2. Delete/OK Button – This Button is used for deleting the earlier stored
fingerprint system as well as granting access as an OK selection.
3. Forward Button – Used for moving forward while selecting the
memory location for storing or deleting fingerprints.
4. Reverse Button – Used for moving backward while selecting memory
location for storing or deleting fingerprints.
Downloading data:
Simply click on Register/Back Button and reset the button together. At
this movement, the serial monitor should be opened.
References:
Santoso, Banu, and Marti Widya Sari. "Design of student attendance system
using Internet of Things (IoT) technology." In Journal of Physics:
Conference Series, vol. 1254, no. 1, p. 012064. IOP Publishing, 2019.