Raspberry Pi Pico

Raspberry Pi Pico Fingerprint Door Lock Project

Biometric Door Lock project using Raspberry Pi Pico

Raspberry Pi Pico Fingerprint:

Raspberry Pi Pico Fingerprint Door Lock Project- Nowadays I have started a complete series on the R557 Biometric/Fingerprint Sensor Module. And in this series, I have already covered Arduino and Nodemcu ESP8266 WiFi module.

In the first tutorial, I used the R557 fingerprint module with Arduino to control an electronic door lock. This was a getting started tutorial; so I explained all the technical specifications, how to install the Arduino Library, how to enroll fingers, and how to control an electronic door lock using a registered finger ID.

 In the 2nd tutorial, I used the R557 Fingerprint module with the Nodemcu ESP8266 WiFi module and Google Sheet. This was an intermediate level IoT based project in which I practically demonstrated how to send the students or employee’s attendance information to the Google Sheet.

Raspberry Pi Pico Fingerprint

Now the 3rd tutorial, in this series is based on the Raspberry Pi Pico, R557 Biometric Fingerprint module, and an electronic door lock. As you know, there are two variants of the Raspberry Pi Pico the normal one and the one that comes with the WiFi. So, it doesn’t matter if you want to use Raspberry Pi Pico or the Raspberry Pi Pico W.

So, without any further delay, let’s get started!!!




Amazon Links:

Raspberry Pi Pico

Raspberry Pi Pico W

Raspberry Pi Pico W Ultimate Kit

R557 Capacitive Fingerprint Module

12V Electronic Door Lock

One-channel Relay module

Other Tools and Components:

Top Arduino Sensors:

Super Starter kit for Beginners

Digital Oscilloscopes

Variable Supply

Digital Multimeter

Soldering iron kits

PCB small portable drill machines

*Please Note: These are affiliate links. I may make a commission if you buy the components through these links. I would appreciate your support in this way!



Capacitive Fingerprint R557:

biometric r557 capacitive sensor module with Raspberry Pi Pico Fingerprint

The R557 Fingerprint Sensor module is a compact and reliable biometric Sensor that can be used to secure doors or other access points. It can also be used in students and employees attendance systems. It’s a low-cost and low-power Fingerprint sensor.  It operates on a low voltage of 3.3V, making it ideal for battery-powered systems. It can be used with 5v and 3.3V compatible controller boards like Arduino, ESP32, STM32, ESP8266, Raspberry Pi Pico, and so on. With this Capacitive Fingerprint sensor, you can easily integrate biometric authentication into your projects.

Technical specifications:

Technical parameter:

Supply voltage: DC 3.3V
Supply current:
Working current: 30mA (typ.)
Peak current: 40mA
Fingerprint image entry time: <0.3 seconds
Collection window area: 12.8mm in diameter
Image pixel: 160*160 pixel
Image Resolution: 508dpi
Match method:
Comparison method (1:1)
Search method (1:N)
Storage capacity: 120 pieces
Security level: five (from low to high: 1, 2, 3, 4, 5)
False Recognition Rate (FAR): <0.0001%
Authentic rejection rate (FRR): <1.0%
Search time: <0.3 seconds (1:1000, average)
Host computer interface: RS232 (TTL logic level, 3.3V)
Communication baud rate: (9600?N)bps where N=1~12 (default value N=6, ie 57600bps)

Working environment:

Temperature: -20 to +45?
Relative humidity: 10%RH-85%RH (non-condensing)

There is an RGB Led inside this module. So, when the fingerprint sensor is ON it shows Blue light. When the Fingerprint scanning operation is successful it shows Green Light, and when the operation is failed, it shows Red light.

It includes a storage capacity of up to 120 fingerprints, a fast recognition speed of under 1 second, and a high resolution image sensor that captures clear and accurate fingerprints.



R557 Capacitive Fingerprint Sensor Pinout:

Wiring

1 VT Finger detection

2 Out IRQ

3 VCC 3.3

4 TX 3.3 Logic level

5 RX 3.3 Logic level

6 GND

Raspberry Pi Pico Fingerprint sensor r557 sensor specification

1st wire is the VT. This is the Finger Detection power and this wire is connected with the 3.3V.

2nd wire is the IRQ. This is the Finger detection signal wire. When there is a finger, it outputs a high signal.

3rd wire is the VCC and it should be connected with 3.3V.

4th and 5th wires are TXD and RXD, both are 3.3V TTL logical level. And

6th wire is the GND and it should be connected with the ground.

Now, let’s go ahead and take a look at the circuit diagram.



R557 Fingerprint Sensor with Raspberry Pi Pico:

r557 sensor module circuit Raspberry Pi Pico Fingerprint

The Red and Yellow wires of the R557 Fingerprint module are connected with the Raspberry pi Pico W 3.3V pin. Red wire is the VT and Yellow wire is the VCC. This black wire is the IRQ wire and as you can see its left unconnected. But if you want you can use this wire. Anyway, for now I don’t need this.

The Green and Blue wires are the TXD and RXD wires and these are connected with the GP1 and GP0. GP1 is the RX and GP0 is the TX. The White wire is the GND wire and it’s connected with the Raspberry Pi Pico GND pin.

You can see a 12V SPDT type relay module. Its input wire is connected with the Raspberry Pi Pico GP26 pin and its ground is connected with the Raspberry Pi Pico GND pin.

You see the 12V electronic Door lock. Its ground wire is directly connected with the GND wire of the 12V power supply. Whereas, the 12V wire of the Electronic Door lock is connected with the 12V power supply through this relay.As you can clearly see the Red wire is connected with the Common contact of the relay and the 12v wire from the power supply is connected with the Normally open contact of the relay. So, by turning ON and turning OFF this relay, we can Open and Close this electronic Door lock. So, that’s all about the connections.

Raspberry Pi Pico Fingerprint practical testing

Now, let’s go ahead and install the fingerprint library.




Fingerprint Library Installation:

Now, the next step is to install the Arduino Library for the R557 Capacitive Fingerprint Sensor.

For this, open the Arduino IDE. Click on the sketch Menu, go to Include Library, and then click on manage libraries.

Raspberry Pi Pico Fingerprint R557 modulue library

Search for the Adafruit Fingerprint.

 

Raspberry Pi Pico Fingerprint R557 modulue library

Click on the install button.

Raspberry Pi Pico Fingerprint R557 modulue library

You can see my Adafruit Fingerprint Sensor Library is now installed.

Next, for the Fingerprint enrollment connect your Raspberry Pi Pico with the Laptop/PC and Upload this sketch.



Fingerprint Enrollment Code:

#include <Adafruit_Fingerprint.h>
#include <HardwareSerial.h>

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&Serial1);
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;
}

After uploading this code; next open the serial monitor and follow the instructions. If you find it difficult to enroll your fingers then you can follow my video tutorial given at the end of this article. Anyway, I enrolled my forefinger and I assigned 3 as an ID to the forefinger.



Altium Designer + Altium 365 + Octopart:

Arduino LoRa Free SMS

Altium 365 lets you hold the fastest design reviews ever. Share your designs from anywhere and with anyone with a single click. it’s easy, leave a comment tagging your teammate and they’ll instantly receive an email with a link to the design. Anyone you invite can open the design using a web browser. Using the browser interface, you’re able to comment, markup, cross probe, inspect, and more. Comments are attached directly to the project, making them viewable within Altium designer as well as through the browser interface. Design, share, and manufacture, all in the same space with nothing extra to install or configure. Connect to the platform directly from Altium Designer without changing how you already design electronics. Altium 365 requires no additional licenses and comes included with your subscription plan.

Get real-time component insights as you design with Octopart built into Altium 365. Octopart is the fastest search engine for electronic parts and gives you the most up-to-date part data like specs, datasheets, cad models, and how much the part costs at different amounts etc. Right in the design environment so you can focus on your designs. Start with Altium Designer and Activate Altium 365. Search for electronic parts on Octopart.

After, enrolling your finger. Next, upload the following code, and replace my finger id with yours.

Raspberry Pi Pico Fingerprint Code:

#include <Adafruit_Fingerprint.h>
#include <HardwareSerial.h>
int relay1=26; 
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&Serial1); 
void setup()
{
  pinMode(relay1,OUTPUT);

  digitalWrite(relay1, LOW);

  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");
      finger.LEDcontrol(FINGERPRINT_LED_OFF, 0, FINGERPRINT_LED_BLUE);
      finger.LEDcontrol(FINGERPRINT_LED_OFF, 0, FINGERPRINT_LED_RED);
      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!");
    finger.LEDcontrol(FINGERPRINT_LED_FLASHING, 25, FINGERPRINT_LED_PURPLE, 10);
    delay(1000);
    
     if(finger.fingerID==3)
  {
  digitalWrite(relay1,!digitalRead(relay1));
  delay(1000);
  }
      

 
  
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_NOTFOUND) {
    finger.LEDcontrol(FINGERPRINT_LED_FLASHING, 25, FINGERPRINT_LED_RED, 10);
  delay(1000);
  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;
}

This is the Final Code that I use to lock and unlock the Electronic Door Lock. If this is your first time using the Raspberry Pi Pico then you will also need to install the Raspberry Pi Pico board in the Arduino IDE. And for this, you can read my article on Raspberry Pi Pico and Adafruit IO.



Practical Demonstration:

When there is no finger placed on the sensor, then you will see a blue color, and if you see the Red color it means an un-registered finger is placed on the sensor. When you see the Green color it means the finger is successfully scanned; as you can see in the image given below.

Raspberry-Pi-Pico-Biometric fingerprint door lock project r557

I was able to successfully lock and unlock the Electronic Door lock using Raspberry Pi Pico and Fingerprint/Biometric module. For the practical demonstration, watch the video tutorial given below.

Watch Video Tutorial:

 

Engr Fahad

My name is Shahzada Fahad and I am an Electrical Engineer. I have been doing Job in UAE as a site engineer in an Electrical Construction Company. Currently, I am running my own YouTube channel "Electronic Clinic", and managing this Website. My Hobbies are * Watching Movies * Music * Martial Arts * Photography * Travelling * Make Sketches and so on...

Leave a Reply

Your email address will not be published. Required fields are marked *

Back to top button