Fingerprints of humans are practically unique that’s why these are very successful in recognizing individuals. Fingerprints of individuals are collected & maintained by law enforcement agencies and also other occupations for certification or professional licensing like stockbrokers, financial advisors, teachers, real estate agents, security, doctors or nurses, contractors, and many more. At present, advancements in technologies use these scanners as an additional security feature. So these are becoming one of the latest and ever-growing security systems. This article discusses brief information on a fingerprint sensor – working with applications.
What is a Fingerprint Sensor?
A fingerprint sensor definition is a security system that is used to identify as well as authenticate an individual’s fingerprints to allow or reject access to a physical facility or a computer system. This sensor uses hardware & software combination techniques to recognize an individual’s fingerprint scans. These are safety systems of biometrics, so that used in smartphones, security industries, police stations, etc.
Working Principle of Fingerprint Sensor
The fingerprint sensor works on the principle of processing which includes two elements like enrollment & matching. In enrollment, each individual has to put the finger on the sensor device, so that the device checks the fingerprints to process & generate the finger pattern & it will be stored. In matching, once an individual places the finger then the system will generate a pattern of the finger & compares it with the stored data. So a fingerprint sensor is used to authenticate and recognize the fingerprints of a person. These sensors are very reliable and secure devices used for any security authentication.
In the fingerprint sensor working, first authorized persons’ fingerprint scans are recorded for a specific system and these scans are saved within a database. Whenever an individual needs to access the system then he places a finger on a hardware scanner, then the scanner scans & copies the input from the person & verifies with the previously stored scans for any similarity. If it matches, then the individual gets access. These sensors normally use the thumbprint of an individual as an identification.
Types of Fingerprint Sensor
There are different types of fingerprint sensors optical, capacitive, ultrasonic, and thermal which are discussed below. But these sensors considerably vary in both price & security. These sensors provide several benefits & are simple for companies to execute & use.
Optical Fingerprint Scanners
Optical fingerprint sensors are the first models which are used to simply capture the optical image of individuals’ fingerprints with CMOS or CCD image sensors. These sensors are related to camera sensors, although they are mainly designed to take high-contrast images as compared to any usual camera. This sensor includes a set of LEDs that the CMOS or CCD/ sensors light up the areas of fingers as well as the replicated light waves. The present sensor models are available in 1mm size in dimensions & they can scan wet fingers also.
Optical Fingerprint Scanner
Capacitive Fingerprint Scanner
These scanners use several small capacitors for detecting capacitance in between the ridges & valleys of fingers for capacitor plates. Once there is an edge, its distance by the plate of the capacitor is very small, resulting in somewhat less capacitance. Once there is a valley, then its distance through the capacitor plate is higher so it results in higher capacitance. From every capacitor, the capacitance is passed to the op-amp & is recorded simply with ADC. So this generates a fingerprint’s digital scan based on the sensing of capacitive touch.
Capacitive Fingerprint Scanner
These scanners are not easy to forge and they can even notice a live finger also. The only method to forge a fingerprint by using this scanner is to hack the hardware/software of the controller or else, these types of scanner will be fooled through a print image because a print image will have consequential capacitive effects, and a prosthetic can not exactly mimic a live finger’s touch capacitance.
Ultrasonic Fingerprint Scanner
The latest & most sophisticated scanners are ultrasonic fingerprint scanners which are capable of generating fingerprints 3D scans. Now, this is used only in some high-end smartphones. This scanner includes a set of ultrasonic transmitters & receivers where the transmitters generate ultrasonic signals which are reflected within the ridges, valleys & fingerprint pores and receivers detect the reflected signals.
Ultrasonic Scanner
These scanners need some time to efficiently capture the fingerprint’s 3D map. These scanners are very simple to implement, so frequently used in smartphones for in-display scanners. It is not possible to copy ultrasonic scanners and the scanned fingerprint 3D feature will make the technology extra robust. Similar to capacitive scanners, these scanners are forged simply by hacking the software & hardware. So, by the operation principle, these are approximately impeccable.
Thermal Fingerprint Scanner
These sensors are very helpful in determining the least temperature differences among the finger lines & generate the finger’s thermal image when we are placed on the scanner. Similar to other types of sensors, these are active and passive.
Thermal Fingerprint Scanner
Fingerprint Sensor Interfacing with Microcontroller
Interfacing fingerprint sensors with a microcontroller like Arduino is shown below. Here, the fingerprint sensor used is the R503 capacitive fingerprint sensor module. The main function of this module is to simply capture, match & store the fingerprint of a user.
Pin Configuration
The pin configuration of R503 capacitive fingerprint sensor is shown below. This sensor includes six pins which are discussed below.
R503 Capacitive Fingerprint Sensor
- Pin1 (Power supply): This is a power supply (DC 3.3V) pin.
- Pin2 (GND): This is a GND pin.
- Pin3 (TXD): This is a data output.
- Pin4 (RXD): This is data input.
- Pin5 (WAKEUP): This is a finger detection signal.
- Pin6 (3.3 VT): This is a touch induction power supply.
Features and Specifications
The features and specifications of the R503 capacitive fingerprint sensor include the following.
- The interface used is RS232.
- It has a 508 DPI resolution.
- The voltage used is DC 3.3V.
- The required current supply is 18mA.
- Standby voltage for typical touch is 3.3V
- The average current is 2uA
- The capacity of the fingerprint is 200
- The sensing array is 192 x 192 pixel
- LED color is red or blue.
- The speed of scanning is below 0.2 Sec.
- The speed of verification is below 0.3 Sec.
- The matching method is 1:1; 1:N.
- The false Rejection Ratio or FRR is ≤0.01%.
- False Acceptance Ratio or FAR is ≤0.00001%.
- UART communications baud rate is 9600N bps.
Now let us see how to interface the R503 capacitive fingerprint sensor with Arduino. So, the interfacing diagram is shown below which is very simple. The connections of this fingerprint sensor circuit diagram follow as;
R503 Capacitive Fingerprint Sensor with Arduino
Here, the R503 capacitive fingerprint sensor is a UART Module.
- Connect the VCC and GND pins of the fingerprint sensor to the 3.3V and GND pins of Arduino.
- Likewise, connect the yellow wire (Tx) and green wire (R2) to both D2 and D3 pins of Arduino respectively.
- Here, the blue color wire is an interrupt wire which remains unconnected.
- Connect the white color wire to 3.3V.
- Here, jumper wires are used for connecting the module with Arduino directly.
Source Code
For a capacitive fingerprint sensor, an Arduino library is available from Adafruit. So, you can simply download the Adafruit Library for fingerprint sensors from the Github repository.
For fingerprint data enrolling as well as reading, there are two separate codes are available. The code for enrolling will save the fingerprint data within EEPROM memory whereas the fingerprint read code simply reads the fingerprint data stored within EEPROM memory & match with the examined one.
#include <Adafruit_Fingerprint.h>
#if (defined(__AVR__) || defined(ESP8266)) && !defined(__AVR_ATmega2560__)
// For UNO and others without hardware serial, we must use software serial…
// pin #2 is IN from sensor (GREEN wire)
// pin #3 is OUT from arduino (WHITE wire)
// Set up the serial port to use softwareserial..
SoftwareSerial mySerial(2, 3);
#else
// On Leonardo/M0/etc, others with hardware serial, use hardware serial!
// #0 is green wire, #1 is white
#define mySerial Serial1
#endif
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
uint8_t id;
void setup()
{
Serial.begin(9600);
while (!Serial); // For Yun/Leo/Micro/Zero/…
delay(100);
Serial.println(“\n\nAdafruit Fingerprint sensor enrollment”);
// set the data rate for the sensor serial port
finger.begin(57600);
if (finger.verifyPassword()) {
Serial.println(“Found fingerprint sensor!”);
} else {
Serial.println(“Did not find fingerprint sensor :(“);
while (1) { delay(1); }
}
Serial.println(F(“Reading sensor parameters”));
finger.getParameters();
Serial.print(F(“Status: 0x”)); Serial.println(finger.status_reg, HEX);
Serial.print(F(“Sys ID: 0x”)); Serial.println(finger.system_id, HEX);
Serial.print(F(“Capacity: “)); Serial.println(finger.capacity);
Serial.print(F(“Security level: “)); Serial.println(finger.security_level);
Serial.print(F(“Device address: “)); Serial.println(finger.device_addr, HEX);
Serial.print(F(“Packet len: “)); Serial.println(finger.packet_len);
Serial.print(F(“Baud rate: “)); Serial.println(finger.baud_rate);
}
uint8_t readnumber(void) {
uint8_t num = 0;
while (num == 0) {
while (! Serial.available());
num = Serial.parseInt();
}
return num;
}
void loop() // run over and over again
{
Serial.println(“Ready to enroll a fingerprint!”);
Serial.println(“Please type in the ID # (from 1 to 127) you want to save this finger as…”);
id = readnumber();
if (id == 0) {// ID #0 not allowed, try again!
return;
}
Serial.print(“Enrolling ID #”);
Serial.println(id);
while (! getFingerprintEnroll() );
}
uint8_t getFingerprintEnroll() {
int p = -1;
Serial.print(“Waiting for valid finger to enroll as #”); Serial.println(id);
while (p != FINGERPRINT_OK) {
p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println(“Image taken”);
break;
case FINGERPRINT_NOFINGER:
Serial.println(“.”);
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println(“Communication error”);
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println(“Imaging error”);
break;
default:
Serial.println(“Unknown error”);
break;
}
}
// OK success!
p = finger.image2Tz(1);
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;
}
Serial.println(“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”);
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”);
break;
}
}
// 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;
}
Serial.print(“ID “); Serial.println(id);
p = finger.storeModel(id);
if (p == FINGERPRINT_OK) {
Serial.println(“Stored!”);
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println(“Communication error”);
return p;
} else if (p == FINGERPRINT_BADLOCATION) {
Serial.println(“Could not store in that location”);
return p;
} else if (p == FINGERPRINT_FLASHERR) {
Serial.println(“Error writing to flash”);
return p;
} else {
Serial.println(“Unknown error”);
return p;
}
return true;
}
Advantages and Disadvantages
The advantages of fingerprint sensors include the following.
- Fingerprint sensors are much more secure because they are not easy to forge.
- These are very easy to use.
- No need to remember passwords because fingerprints are with you always.
- These are non-transferable.
- Fingerprint identification provides a higher stage of responsibility at work.
- These are economical.
- These are highly accurate in recognizing fingerprints.
- These are stable for a long time.
- It needs less space and it decreases the memory requirement of the database.
- For every individual finger, these are unique & the arrangement of the ridge stays permanent during everyone’s lifetime.
- Fingerprint patterns are very hard to guess than passwords.
- Fingerprints cannot be misplaced like physical access cards.
- Fake identity cannot be created based on the image.
The disadvantages of fingerprint sensors include the following.
- Some technical failures occur.
- The system has an inability to enroll some users.
- The system’s accuracy & its working can be affected by the skin state of people.
- The gathering of high-quality images requires training & particular skills.
- This is associated with legal applications.
- Health issues may occur because of touching a single scanning sensor device with a number of individuals.
Fingerprint Sensor Applications
The applications of fingerprint sensors include the following.
- Fingerprint scanners are very helpful in authenticating & identifying an individual’s fingerprint.
- These are reliable & safe devices, so they are used for security authentication.
- These are used in security industries, police stations, mobile devices, and many more.
- These are used to provide biometric security
- These sensors are used in current IoT applications to add security and also identify the users easily.
- These are used in smartphones, wearables, smart industry & smart home applications for data security & entry identification.
Know more about Ultrasonic Sensor.
Know more about MB1240 Ultrasonic Sensor Datasheet.
Thus, this is an overview of a fingerprint sensor – working with applications. This sensor scans and also analyzes the fingerprint of an individual and checks the identity of the person. So this is mainly used for safety purposes and also verifications of employees, ID verification of the government, biometric authentication for approving transactions & grants the access of the user to some private data. Here is a question for you, what is the biometric sensor?