Fingerprint Scanner

A fingerprint scanner can add encoded fingerprint images to a database and then read a fingerprint to compare it against the stored fingerprints for identification purposes.

The GT-511C3 fingerprint scanner can store up to 200 different fingerprints in its onboard database.

This fingerprint scanner comes with a 4-wire connector (1 black wire + 3 white wires). Insert the wires into different numbered rows on a breadboard. Then use jumper wires to connect these rows to the Photon.

If the fingerprint scanner wires were numbered left to right as 1-4 (with the black wire being Wire 1), the jumper wire connections would be:

The fingerprint scanner will transfer data with the Photon board over a serial data connection using the Photon RX and TX pins.

NOTE: For serial data connections, the RX pin of one device connects to the TX pin of the other device. (RX = receive, TX = transmit)

TIP: The fingerprint scanner has a small built-in green LED. If the Photon device is powered on and you have correctly wired the fingerprint scanner, this green LED should be on.

Code for Fingerprint Reader

#Include Library

Your Photon app must include a code library with special functions that will allow you to control the fingerprint reader.

1. In Particle Build, click on the bookmark icon to open the Libraries sidebar.

2. Type "fingerprint" into the search field. Select the result called: FINGERPRINT_FPS_GT511C3

3. Click the button to "Include in Project"

4. Select the name of your Photon app, and then click the "Confirm" button

5. Particle Build will automatically insert an #include statement at the top of your app code

// This #include statement was automatically added by the Particle IDE.
#include <Fingerprint_FPS_GT511C3.h>

Global Variables

In your global variables, you need to declare an FPS_GT511C3 object variable that you will use to run the special functions in the library. The example below declares an object variable called "fps" (but you could use a different variable name).

// declare FPS_GT511C3 object variable called "fps"
FPS_GT511C3 fps;

You will probably also want to declare an integer variable to store a fingerprint ID number (such as the ID of the detected fingerprint, etc.). This will make it easier to do something with this ID. The example below declares a variable called "fingerprintID" (but you could use a different variable name).

// global variable
int fingerprintID;

setup( ) function

You need to include a statement within the setup() function to start a serial data connection (which will activate both the RX and TX pins on the Photon). This will allow the Photon and the fingerprint scanner to send and receive data between each other. The fingerprint scanner communicates at a baud rate of 9600 bps.

You also need to include statements to start ("open") the fingerprint scanner and to turn on the LED inside the scanner.

Serial1.begin(9600);
fps.Open();
fps.SetLED(true);

Test Fingerprint Scanner

You can use the following temporary code to test whether your fingerprint scanner is wired correctly and able to communicate with your Photon. It will simply turn the scanner's internal LED on and off in a blinking pattern. Once you've verified this works, you can remove this code from the loop() function.

void loop() {
    // FPS Blink LED Test
    fps.SetLED(true); // turn on the LED inside the fps
    delay(1000);
    fps.SetLED(false);// turn off the LED inside the fps
    delay(1000);
}

FINGERPRINT SCANNER TASKS

You can do the following tasks with the fingerprint scanner:

• Check If Finger Pressed

• Add Fingerprint

• Delete Fingerprint

• Verify Fingerprint Against Specific ID

• Verify Fingerprint Against All Stored IDs

This code will most likely be placed within the loop() function or within custom functions.

RECOMMENDATION: Use the speaker and/or LEDs to provide feedback on whether a fingerprint was verified or not. For example, if the fingerprint is verified, you could turn on a green LED and/or play a short medium-pitched sound. If the fingerprint is not recognized, you could turn on a red LED and/or play a longer low-pitched sound.

Check If Finger Pressed

You can check whether a finger is being pressed against the scanner using a fps.IsPressFinger() statement, which will return either true or false.

if(fps.IsPressFinger() == true) {

    // insert code to do something if finger press detected

}

For example, if a finger is pressed against the scanner, you could have your code verify whether the fingerprint is already stored in the database, etc.

Before you can verify a fingerprint, you will obviously need to have at least one fingerprint added to the scanner database.

Add Fingerprint

The fingerprint scanner can store up to 200 different fingerprints in its onboard database. Each fingerprint is given a unique ID number from 0-199. The fingerprints stored in the database will be retained even when the scanner is powered off.

Adding a new fingerprint is a process called "enrollment" which consists of capturing high-quality images of the same fingerprint 3 times in a row for comparison. This 3-step enrollment verifies the scanner is able to read and identify the fingerprint accurately and consistently.

During fingerprint enrollment, the person presses their finger on the scanner for the first capture, and then lifts the finger. The same finger is pressed down again for a second capture, and lifted again. Finally, the finger is pressed for a third capture, which will ideally complete the process. However, the enrollment process can fail at any of these 3 steps.

TIP: Be patient, as enrollment may take more than one try. However, once a fingerprint is successfully enrolled, verifying that fingerprint in the future is usually fast and accurate.

It is important to have some type of clear feedback during the enrollment process to know when to press and lift the finger, as well as to know whether the enrollment steps were successful or failed. This feedback could be provided through the OLED display screen, red & green LED lights, the web app, etc.

IMPORTANT: The code example below uses the Micro OLED display screen. You will need to wire the OLED screen to your Photon, and include other necessary code (library, global variables, etc.) for the OLED display.

You could use this code to enroll one or more fingerprints. Then you could remove the addFingerprint() statement from the loop() function, and replace it with your primary app code (to verify a fingerprint against the database and then do something with the result).

TIP: Once you are done enrolling fingerprints, you can still keep the code for the addFingerprint() custom function in your app, even if you are no longer calling it in the loop(). This will make it easier for you to add more fingerprints later, if necessary.

RECOMMENDATION: If you will need your Photon app (or web app) to know which fingerprint ID is assigned to which person, it may be easier to record this ID number immediately after successfully enrolling the finger. If a person (such as yourself) is going to register multiple fingers, then record the ID number for each specific finger (right index, left thumb, etc.) that you enroll. Then later, you can use this information to have your Photon app (or web app) make different decisions based on which specific fingerprint ID is detected by the scanner.

void setup() {
    oled.begin();
    Serial1.begin(9600);
    fps.Open();
    fps.SetLED(true);
}

void loop() {
    addFingerprint();
}

// custom function to display messages on OLED screen
void displayOLED(String message) {
    oled.clear(PAGE);
    oled.setFontType(0);
    oled.setCursor(0,0);
    oled.println(message);
    oled.display();
}

// custom function to enroll new fingerprint
void addFingerprint() {
    // find next available fingerprint ID
    int enrollID = 0;
    bool usedID = true;
    String message;
    while (usedID == true) {
        usedID = fps.CheckEnrolled(enrollID);
        if (usedID == true) enrollID++;
        if (enrollID == 200) {
            message = "Fingerprint\nDatabase\nFull";
            displayOLED(message);
            return;
        }
    }
    // start enrollment for new fingerprint ID
    fps.EnrollStart(enrollID);
    message = "Add ID ";
    message += String(enrollID);
    message += "\n\nPRESS\nFINGER";
    displayOLED(message);
    while(fps.IsPressFinger() == false) {
        delay(100);
        Particle.process();
    }
    // capture fingerprint (true = slower high-res image)
    bool bret = fps.CaptureFinger(true);
    int iret = 0;
    if (bret != false) {
        message = "REMOVE\nFINGER";
        displayOLED(message);
        // save fingerprint image 1
        fps.Enroll1();
        while(fps.IsPressFinger() == true) {
            delay(100);
            Particle.process();
        }
        message = "Confirm\n\nPRESS\nSAME\nFINGER";
        displayOLED(message);
        while(fps.IsPressFinger() == false) {
            delay(100);
            Particle.process();
        }
        bret = fps.CaptureFinger(true);
        if (bret != false) {
            message = "REMOVE\nFINGER";
            displayOLED(message);
            // verify fingerprint image 2
            fps.Enroll2();
            while(fps.IsPressFinger() == true) {
                delay(100);
                Particle.process();
            }
            message = "Final\nConfirm\n\nPRESS\nSAME\nFINGER";
            displayOLED(message);
            while(fps.IsPressFinger() == false) {
                delay(100);
                Particle.process();
            }
            bret = fps.CaptureFinger(true);
            if (bret != false) {
                message = "REMOVE\nFINGER";
                displayOLED(message);
                delay(1000);
                // verify fingerprint image 3
                iret = fps.Enroll3();
                if (iret == 0) {
                    message = "SUCCESS\n\nAdded\nFinger\nID ";
                    message += String(enrollID);
                    displayOLED(message);
                } else {
                    message = "FAILED\n\nError\nCode\n";
                    message += String(iret);
                    displayOLED(message);
                }
            } else {
                message = "3rd Press\nFAILED";
                displayOLED(message);
            }
        } else {
            message = "2nd Press\nFAILED";
            displayOLED(message);
        }
    } else {
        message = "1st Press\nFAILED";
        displayOLED(message);
    }
    // wait to allow final message to be read
    delay(5000);
}

That's a lot of code compared to what's been needed for other parts. Luckily, the other fingerprint scanner tasks only require a few lines of code at most.

Delete Fingerprint

If necessary, you can delete a specific fingerprint from the scanner database by providing its ID (0-199) either as a number or as an integer variable.

// ID number to delete - change as needed
fingerprintID = 13;

fps.DeleteID(fingerprintID);

If necessary, you can also delete all the fingerprint images from the scanner database. Be careful using this statement – there is no "undo" if you delete all the stored fingerprints.

fps.DeleteAll(); // caution - cannot undo

Verify Fingerprint Against Specific ID

You can use the fps.Verify1_1() statement to verify whether a finger matches a specific fingerprint ID by providing the ID (0-199) to check against. The ID can be provided as a number or as an integer variable.

First, you need to capture an image of the finger being pressed. For faster identification, a lower-resolution image is captured.

If the captured fingerprint matches the specific fingerprint ID stored in the database, the fps.Verify1_1() statement will return true. Otherwise, it will return false.

// ID number to check against - change as needed
fingerprintID = 7;

if(fps.IsPressFinger() == true) {

    // capture fingerprint (false = faster low-res image)
    fps.CaptureFinger(false);

    if(fps.Verify1_1(fingerprintID)) {

        // insert code to do something if fingerprint matches specific ID

    } else {

        // optional: do something else if it does not match specific ID
    }
}

Verify Fingerprint Against All Stored IDs

In most cases, you will want to use the fps.Identify1_N() statement to verify whether a fingerprint matches any of the fingerprints stored in the database – and if so, identify which fingerprint ID matches.

First, you need to capture an image of the finger being pressed. For faster identification, a lower-resolution image is captured.

If the fingerprint matches an ID stored in the database, the fps.Identify1_N() statement will return the matching ID number (0-199). Otherwise, it returns a value of 200 if the fingerprint isn't in the database.

if(fps.IsPressFinger() == true) {

    // capture fingerprint (false = faster low-res image)
    fps.CaptureFinger(false);

    fingerprintID = fps.Identify1_N();

    if(fingerprintID == 200) {

        // insert code to do something if fingerprint is NOT in database

    } else {

        // insert code to do something with matching fingerprint ID
    }
}