Fingerprint attendance system with R503

R503 is a popular capacitive fingerprint sensor. We can use this sensor for industrial purposes. In this article, we’ll make a fingerprint attendance system with R503 capacitive sensor with Arduino. I hope this project will help many people make their own attendance system. So, let’s start!

Disclaimer:

Working with electricity involves serious risk. Ensure you have the necessary skills and take proper safety precautions before attempting any electrical projects. Proceed at your own risk — the author assumes no responsibility for any damage, injury, or issues resulting from the use or misuse of the information provided.

All content on this website is original and protected by copyright. Please do not copy or reproduce content without permission. While most of the resources shared here are open-source and freely accessible for your learning and benefit, your respect for our intellectual effort is appreciated.

If you find our tutorials helpful, consider supporting us by purchasing related materials or sharing our work — it helps keep the content flowing.

Need help or have questions? Leave a comment below — the author is always happy to assist!

About R503 Capacitive fingerprint sensor:

These modules are typically used in safes – a high-powered DSP chip does the image rendering, calculation, feature-finding, and searching. Connect to any microcontroller or system with TTL serial, and send data packets to take photos, detect prints, hash, and search. You can also enroll new fingers directly – up to 200 (or even more in some models) fingerprints can be stored in the onboard FLASH memory.

Technical Details of R503

Specifications:

• Model: R503
• Capacitive Fingerprint Module
• Interface: TTL UART
• Resolution: 508 DPI
• Voltage: 3.3VDC or 5V [two different models]
• Capacity: 200 fingerprints
• Sensing array: 192×192 pixels
• Working current: 20mA
• Standby current: Typical touch standby voltage: 3.3V, Average current: 2uA
• Module size: 28mm (external diameter) / 23.5mm (inner diameter)
• Module height: 15.5mm
• Sensor area: 15.5mm
• LED Colors: Blue and Red
• Scanning speed: < 0.2 second
• Verification speed: < 0.3 second
• Matching method: 1:1; 1:N
• FRR: ≤1%
• FAR: ≤0.001%
• Work environment: -20ºC – 60ºC
• Work humidity: 10-85%
• Anti-static capacity: 15KV
• Abrasive resistance intensity: 1 million times
• Communications baud rate (UART): (9600 × N) bps where N = 1 ~ 12 (default is 57600bps)

Product Weight: 35.0g / 1.2oz

You can find more on the Adafrut site or directly buy on amazon.com.

Pin configuration:

The pin configuration is as follows:

Note: For the 5V module, the power supply(1) and touch power supply (6) are 5V rated.

Datasheet:

Communication:

R503 uses the UART protocol for communication. Simply Rx, Tx just like a common serial terminal will work fine.

Note: Even with the 3.3V version, the Tx & Rx pins are 5V tolerable. So, you can directly connect with 5V MCU. But it also works with 3.3V MCUs which is also available for the 5V module version. Only the VDD must be chosen carefully.

Circuit diagram for the attendance system:

For the complete system, it depends on how many features are being used. As this one is for tutorials purpose, so, the diagram will be very simple. So that, you can add other features on your demand.

Here, you can use the Atmega2560 MCU standalone if you want to design for more space-saving. But for the prototype, it’s enough to use Arduino Mega.

Also for the display, you can use different types such as OLED, or Graphics LCD. And for the keypad, you can use different types of keypads according to your requirement.

So, there are some customization options for your requirement or choice. Now, let’s go ahead.

Programming:

Now, the setup is ready, and we need to do the programming part. But before that, we need to gather the library function for the sensor. We will use the adafruit-fingerprint library for this project which is very common and well-organized for the Arduino platform.

After installing this library, we can start our coding section.

Library definition part:

#include <LiquidCrystal.h>
LiquidCrystal lcd(31, 33, 43, 45, 49, 51);

#define buzzer 10

//keyboard
#include "Adafruit_Keypad.h"

const byte ROWS = 4;  // rows
const byte COLS = 4;  // columns
//define the symbols on the buttons of the keypads
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 };  //connect to the row pinouts of the keypad
byte colPins[COLS] = { 5, 4, 3, 2 };  //connect to the column pinouts of the keypad
char key_value = 0;
int key_cnt = 0;
//initialize an instance of class NewKeypad
Adafruit_Keypad customKeypad = Adafruit_Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

Explanation:

First, we are using a LCD display, so we declared that with the corresponding pins. The pin pattern is RW, EN, D4~D7. Then one pin for the buzzer. And finally for the keypad, after including “Adafruit_Keypad.h”, simply sets the ROW, COL, and the layout of the keypad. Although in the circuit diagram, you have seen a default keypad of proteus ISIS but in reality, we’ll use just like the pattern we gave in the

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

And then set the pins for the keypad and call the customKeypad.

Setting up Fingerprint library:

After LCD and Keypad, now need to include “Adafruit_Fingerprint.h” library.

//finger print sensor
#include <Adafruit_Fingerprint.h>
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&Serial3);
uint8_t id;

We will use the id later on in the code.

Here, if you want to use soft serial, then use:

SoftwareSerial mySerial(rx, tx); Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

now, we can add other codes.

#include <LiquidCrystal.h>
LiquidCrystal lcd(31, 33, 43, 45, 49, 51);

#define buzzer 10

//keyboard
#include "Adafruit_Keypad.h"

const byte ROWS = 4;  // rows
const byte COLS = 4;  // columns
//define the symbols on the buttons of the keypads
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 };  //connect to the row pinouts of the keypad
byte colPins[COLS] = { 5, 4, 3, 2 };  //connect to the column pinouts of the keypad
char key_value = 0;
int key_cnt = 0;
//initialize an instance of class NewKeypad
Adafruit_Keypad customKeypad = Adafruit_Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

 
//finger print sensor
#include <Adafruit_Fingerprint.h>
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&Serial3);
uint8_t id;
byte find_a_finger = 0;
char roll_no[3];

void beep() {
  digitalWrite(buzzer, HIGH);
  delay(50);
  digitalWrite(buzzer, LOW);
}


void dly(unsigned int d) {
  for (unsigned int dly = 0; dly < d; dly++) {
    delay(1);
  }
}

byte operation_mode = 0;  //scan mode

void setup() {
  pinMode(buzzer, OUTPUT);
  digitalWrite(buzzer, LOW);
  Serial.begin(115200);
  finger.begin(57600);
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Finger Print");
  lcd.setCursor(0, 1);
  lcd.print("Sensor Test");
  delay(2000);
  beep();
  lcd.clear();
  customKeypad.begin();
  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);

  finger.getTemplateCount();
  if (finger.templateCount == 0) {
    Serial.print("Sensor doesn't contain any fingerprint data. Please run the 'enroll' example.");
  } else {
    Serial.println("Waiting for valid finger...");
    Serial.print("Sensor contains ");
    Serial.print(finger.templateCount);
    Serial.println(" templates");
  }
}

void loop() {
  keyboard_check();
  delay(200);

  if (operation_mode == 1)  //enroll mode
  {
    lcd.setCursor(0, 0);
    lcd.print("Enrol, Enter    ");
    lcd.setCursor(0, 1);
    lcd.print("ID:");
    Serial.println(F("Enrolling..."));
  } else  // scan mode
  {
    lcd.setCursor(0, 0);
    lcd.print("Scan Your Finger");
    digitalWrite(buzzer, LOW);
    find_a_finger = 0;
    finger.LEDcontrol(FINGERPRINT_LED_FLASHING, 25, FINGERPRINT_LED_PURPLE, 10);
    id = getFingerprintID();
    if (find_a_finger > 0) {
      beep();
      lcd.setCursor(0, 0);
      lcd.print("ID:");
      lcd.print(id);
      lcd.print("  Matched");
      finger.LEDcontrol(FINGERPRINT_LED_OFF, 0, FINGERPRINT_LED_RED);
      finger.LEDcontrol(FINGERPRINT_LED_ON, 0, FINGERPRINT_LED_BLUE);
      finger.LEDcontrol(FINGERPRINT_LED_OFF, 0, FINGERPRINT_LED_PURPLE);
      dly(2000);

      //add your function here, such as driving a relay to open the door. 

      finger.LEDcontrol(FINGERPRINT_LED_OFF, 0, FINGERPRINT_LED_RED);
      finger.LEDcontrol(FINGERPRINT_LED_OFF, 0, FINGERPRINT_LED_BLUE);
      finger.LEDcontrol(FINGERPRINT_LED_OFF, 0, FINGERPRINT_LED_PURPLE);
      lcd.clear();
      id = 0;
    }
  }
}

//end

so there is the full main code where you can see, I’ve done some extra lines just to check the sensor details.

Solving range problem:

You may find that you can not enroll more than 127 fingerprints and at the same time, the sensor can not detect over 60 fingerprint IDs. This is a common problem people fetch.

We can solve this issue very simply. Note that, unless you read the template of the module, the module can not allow you to go further to the full range rather than keeping a short range. So, a simple line can solve this issue.

finger.getTemplateCount();

And the other features you can skip are:

  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);

These are just some detailed information about the sensor.

Sensor Function Explanation:

The fingerprint sensor or module has two operating modes. One is for enrolling the fingerprints and the other one is for identifying the ID. In the library, we have several different functions to perform different tasks and among them, Enroll and GetfingerprintID are the main ones. Usually, the library offers you to use these two functions separately and individually. But you can combine all of these in your project with no worries.

Enroll default function:

/***************************************************
  This is an example sketch for our optical Fingerprint sensor

  Designed specifically to work with the Adafruit BMP085 Breakout
  ----> http://www.adafruit.com/products/751

  These displays use TTL Serial to communicate, 2 pins are required to
  interface
  Adafruit invests time and resources providing this open source code,
  please support Adafruit and open-source hardware by purchasing
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#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;
}

This is the default enroll function of the library. Definitely, you can customize it. Such as, for LEDs, you can add

  finger.LEDcontrol(FINGERPRINT_LED_GRADUAL_ON, 200, FINGERPRINT_LED_PURPLE);

or, similar commands which make the project more interactive.

Limitation of default library:

If you made only a small test project, then there are no worries to do about limitations. But if you need to use the sensor to store many IDs, then this will make you limited. Because when I was working, had a similar issue. We made a project for UNICEF, the quantity was big. And suddenly found that the module can not identify if the fingerprint is stored over 50/60 ID no.

The sensor can not store IDs over 50/60 while the full capacity was 200 and it shows that the ID is stored, but in practice, it can not detect IDs over 60. Why? very simple. If you do not call for the template by the following line:

finger.templateCount;

The sensor will not store the IDs over 50/60 in practice Althouse it shows that it stored the ID successfully.

Scan Fingerprint Function:

/***************************************************
  This is an example sketch for our optical Fingerprint sensor

  Designed specifically to work with the Adafruit BMP085 Breakout
  ----> http://www.adafruit.com/products/751

  These displays use TTL Serial to communicate, 2 pins are required to
  interface
  Adafruit invests time and resources providing this open source code,
  please support Adafruit and open-source hardware by purchasing
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.
  BSD license, all text above must be included in any redistribution
 ****************************************************/


#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);

void setup()
{
  Serial.begin(9600);
  while (!Serial);  // For Yun/Leo/Micro/Zero/...
  delay(100);
  Serial.println("\n\nAdafruit finger detect test");

  // set the data rate for the sensor serial port
  finger.begin(57600);
  delay(5);
  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);

  finger.getTemplateCount();

  if (finger.templateCount == 0) {
    Serial.print("Sensor doesn't contain any fingerprint data. Please run the 'enroll' example.");
  }
  else {
    Serial.println("Waiting for valid finger...");
      Serial.print("Sensor contains "); Serial.print(finger.templateCount); Serial.println(" templates");
  }
}

void loop()                     // run over and over again
{
  getFingerprintID();
  delay(50);            //don't ned to run this at full speed.
}

uint8_t getFingerprintID() {
  uint8_t p = finger.getImage();
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.println("No finger detected");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }

  // OK success!

  p = finger.image2Tz();
  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!
  p = finger.fingerSearch();
  if (p == FINGERPRINT_OK) {
    Serial.println("Found a print match!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_NOTFOUND) {
    Serial.println("Did not find a match");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }

  // found a match!
  Serial.print("Found ID #"); Serial.print(finger.fingerID);
  Serial.print(" with confidence of "); Serial.println(finger.confidence);

  return finger.fingerID;
}

// returns -1 if failed, otherwise returns ID #
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)  return -1;

  // found a match!
  Serial.print("Found ID #"); Serial.print(finger.fingerID);
  Serial.print(" with confidence of "); Serial.println(finger.confidence);
  return finger.fingerID;
}

There is no limitation found here but for practical work/design, some parts can be modified to make it less memory-consuming and at the same time-saving.

Keypad function:

Previous functions were from the library. But this one is customized. What the functions doing is:

1. Pressing * will set it to enroll mode which will allow you to put an ID of range 0-199 and store the template; after enrolling it will automatically set to scan mode.
2. Pressing # will return to default scan mode from enroll mode.
3. There is an option to erase all the data stored in the sensor template. Pressing B will erase all the IDs. so the sensor becomes empty.

Overall project operation:

The operation is shown in the video:

PCB Design for this test project:

As this one is not a final product, just before designing something like this:

I made a small test PCB to test the fingerprint sensor separately. Which is:

You can use this PDF file to make the test PCB.

In the end:

In this article, both the default program and the customized program are given. If you want to learn about the sensor and want to use it within a limit, then you can use the default programs. And if you need a little bit of customization, then use the custom one. This allows you to make a small attendance system which is very helpful. See you soon with the next article. Thanks.

You may read my other articles which may help you:

• PWM Generation with STM32
• Reading ADC with DMA in STM32 MCU
• Adafruit_FONA Library with ESP32
• Pure sine wave inverter using PIC16F76
• Arduino based egg incubator
• Make an MPPT Solar charge Controller with Synchronous Buck Converter

Liked this article? Subscribe to our newsletter:

Email*

or,

WhatsApp Me Follow on Pinterest Facebook Page LinkedIn Profile YouTube Channel

Visit LabProjectsBD.com for more inspiring projects and tutorials.

Thank you!