Como criar um sistema de atendimento baseado em impressão digital com Arduino e Sensor Leitor Biométrico

Tempo de leitura: 9 minutes

Aprenda a criar um sistema de gerenciamento de presença biométrico que leva a impressão digital do usuário para marcar presença!

É amplamente aceito que um sistema adequado de gerenciamento de presenças é crucial para qualquer tipo de instituição. Como existem muitas questões práticas envolvidas nos métodos de atendimento manual em papel, hoje em dia quase todas as empresas automatizam seu processo de gerenciamento de atendimento.

 Ao longo do artigo, mostrarei como criar seu próprio sistema de gerenciamento de presença usando o Arduino, sensor de impressão digital e módulo de cartão SD. Este projeto pode ser a melhor escolha para o projeto do ano final se você for um estudante de engenharia.

E é surpreendentemente fácil criar isso em menos tempo, com um orçamento acessível. Além disso, este será um produto muito útil que podemos usar em nossa vida diária.

Vamos dar uma olhada nos componentes necessários.

 

Componentes Necessários

  • Arduino Uno ou Mega
  • Sensor Leitor Biométrico Impressão Digital Dy50 (ou equivalente)
  • Módulo LCD 16×2 com I2C
  • Módulo SD Card
  • Cartão SD Card
  • Dois Pushbuttons
  • Dois Leds
  • Dois Resistores de 10K Ohm
  • ProtoBoard e Fios

 

Bibliotecas necessárias

Ligação do hardware

 

 

Esquema

Para obter informações do usuário, o scanner de impressões digitais faz interface diretamente com o Arduino. O módulo LCD e os LEDs indicam a saída ou o resultado. O módulo do cartão SD salva o relatório de presença em um cartão SD. Dois ou mais botões podem ser usados ​​para controlar diferentes processos.

Foto Projeto

Vamos ver como cada módulo faz interface com a versão maior para criar nosso projeto.

Sensor Leitor Biométrico Impressão Digital para o Arduino

O Sensor de Digitais é um sensor biométrico desenvolvido para auxiliar hobistas e projetistas no desenvolvimento de projetos de automação residencial, por exemplo, tornando possível a leitura das impressões digitais dos dedos através de um chip DSP de alta potência e precisão, o que torna a utilização deste produto ainda mais prática e simplificada.

Quando utilizado em projetos dos mais diversificados, o Leitor Biométrico possui a capacidade de armazenar uma diversidade consideravelmente grande de digitais dentro da sua memória flash onboard, gravando aproximadamente 120 impressões digitais.

Através do seu fácil sistema de utilização e sua compatibilidade extremamente grande com diversos tipos de microcontroladores, o Sensor de Digitais pode ser utilizado para sistematizar diversos projetos estudantis, inclusive projetos de uso profissional para controle de acesso de empresas e residências, por exemplo.

Constituído por seis fios, o Leitor Biométrico utiliza somente quatro destes para realizar o seu funcionamento, no qual temos um fio que corresponde ao GND, VCC, TX e RX, observe a relação de cores:

– Preto: GND;
– Branco: RX;
– Verde: TX;
– Vermelho: VCC.

A Ligação dele para Uno e Mega descrito abaixo.

Sensor Leitor Biometrico

Módulo de cartão SD para o Arduino

O módulo do cartão SD se comunica com o Arduino através do protocolo de comunicação da interface periférica serial (SPI). Ele pode ser simplesmente conectado aos pinos SPI do hardware do Arduino.

 

 

SD Card

LCD com módulo I2C para o Arduino

Como o nome indica, o módulo LCD se comunica com o Arduino através da comunicação I2C.

LCD I2C

Por fim, dois LEDs e botões de pressão podem ser conectados como mostrado na imagem abaixo.

Foto Ligacao

 

Visão geral do sistema do scanner de impressão digital

Bloco de Ligacao

O sensor de impressão digital e os botões de pressão atuam como módulos de entrada. Aqui, estou usando dois botões para os processos de inscrição e identificação. Quando queremos registrar um novo usuário, o botão de registro deve ser pressionado para iniciar o processo de registro. Depois de pressionar o botão de presença, o dedo será verificado para marcar presença. Os módulos de LCD e LEDs atuam como módulos de saída. Eles imprimirão mensagens e erros para fornecer a saída visível do processo.

As impressões digitais são salvas na memória flash do sensor de impressão digital. O próprio módulo R305 realiza coleta, comparação e pesquisa de impressões digitais. O ID da impressão digital verificada é salvo em um arquivo de texto no cartão SD. Podemos usar esse relatório de presença removendo o cartão microSD do módulo.

 

Código Arduino

#include <Wire.h> 
#include <LiquidCrystal_I2C.h> // Usando o driver da NewLiquidCrystal 
#include <SPI.h>
#include <SD.h>
#include <Adafruit_Fingerprint.h> 

#define switchReg 4    // botão de registro
#define switchAtten 5  // Botão de presença
#define ledBlue 6
#define ledRed 7 

// descomentar por uno
//#include <SoftwareSerial.h>  
//SoftwareSerial mySerial(2, 3);  

// descomente para Mega
#define mySerial Serial1

//LiquidCrystal_I2C lcd(0x27,16,2);  // se for o outro verfique se os parametros são estes.
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
  
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial); 
 
uint8_t id;
File myFile;
int Status = 0;
const int chipSelect = 53;

void setup() {
  
  pinMode(switchAtten, INPUT);
  pinMode(switchReg, INPUT);
  pinMode(ledBlue, OUTPUT); 
  pinMode(ledRed, OUTPUT); 
  pinMode(chipSelect,OUTPUT);

  lcd.begin(16,2);         // Ative o LCD para ver o resultado.
  lcd.setBacklight(HIGH);  // Liga a luz de fundo do LCD
  //lcd.init();
  //lcd.backlight();
  lcd.clear();             // Limpa o LCD
    
  Serial.begin(9600);

  while (!Serial);  
  delay(100);  
  Serial.println("\n\nTeste de detecção de dedo Adafruit");  
  
  finger.begin(57600);  
        
  if (finger.verifyPassword()) {  
    Serial.println("Sensor de impressão digital encontrado!");  
  } else {  
    Serial.println("Não encontrou o sensor de impressão digital :(");  
    while (1) { delay(1); }  
  }   

  Serial.print("Inicializando o SD Card...");

  if (!SD.begin(chipSelect)) {
    Serial.println("O Card falhou ou não foi apresentadot");
    while (1);
  }
  Serial.println("Card Iniciado.");

}

void loop() {
  
  Status = 0;
  lcd.setCursor(1,0);
  lcd.print("Comparecer. Sistema");
  lcd.setCursor(3,1);
  lcd.print("CapSistema");
  
  int buttonStateP1 = 0; // Rastreamento do botão de presença
  int buttonStateP2 = 0; // Rastreamento do botão de registro
    
  digitalWrite(ledBlue,LOW);
  digitalWrite(ledRed,LOW);
    
  buttonStateP1 = digitalRead(switchReg); // Ouça o botão Iniciar a ser pressionado
  buttonStateP2 = digitalRead(switchAtten);
    
  // se o botão de registro foi pressionado
  if (buttonStateP1 == HIGH ){
    
    digitalWrite(ledBlue,HIGH);
    digitalWrite(ledRed,HIGH);

    lcd.setCursor(3,0);
    lcd.print("Processo de Registro");

    finger.getTemplateCount();  
    Serial.print("O sensor contém "); 
    Serial.print(finger.templateCount); 
    Serial.println(" modelos");  
    id = finger.templateCount + 1;
    Serial.println(id); 
    getFingerprintEnroll();
    
    buttonStateP1 = 0;
    
  // se o botão de atendimento foi pressionado
  }else if(buttonStateP2 == HIGH){

    uint8_t userId = -1;
    lcd.print("Processo de Atendimento");
    digitalWrite(ledBlue,LOW);
    digitalWrite(ledRed,LOW);

    Serial.println("Aguardando dedo válido...");
    for(int i=0;i<1;i++)
    {
      Status = 0;
      lcd.clear();
      lcd.print("Coloque o dedo");
      delay(2000);

      userId = getFingerprintIDez();
      if(userId >=1 && Status != 1)
      {
        digitalWrite(ledBlue,HIGH);
        lcd.clear();
        lcd.setCursor(3,0);
        lcd.print("Present");
        delay(2000);

        // Armazenando dados no cartão SD
        String ID = String(userId);
 
        myFile = SD.open("test.txt", FILE_WRITE);

        // se o arquivo foi aberto corretamente, escreva para ele:
        if (myFile) {
          
          myFile.print("ID do usuário ");
          myFile.println(ID);
          // fecha o arquivo:
          myFile.close();
          Serial.println("Feito.");
        } else {
          // if the file didn't open, print an error:
          Serial.println("erro ao abrir test.txt");
        } 
      }        
    }   
    buttonStateP2 = 0;
  }
}
  

// #################### Função de registro de impressão digital ########################## ###
uint8_t getFingerprintEnroll() {
 
  int p = -1;
  Serial.print("Aguardando o dedo válido se inscrever como #");
  Serial.println(id);
  lcd.clear();
  lcd.setCursor(4,0);
  lcd.print("Coloque o"); 
  lcd.setCursor(5,1);
  lcd.print("dedo "); 
  
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagem tirada");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.println(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Erro na comunicação");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Erro na imagem");
      break;
    default:
      Serial.println("Erro desconhecido");
      break;
    }
  }

  // OK Sucesso!

  p = finger.image2Tz(1);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagem Convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Imagem muito bagunçada");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Erro de comunicação");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Não foi possível encontrar os recursos de impressão digital");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Não foi possível encontrar os recursos de impressão digital");
      return p;
    default:
      Serial.println("Erro desconhecido");
      return p;
  }
  
  Serial.println("Remover dedo");
  lcd.clear();
  lcd.print(" Remover dedo "); 
  delay(2000);
  p = 0;
  while (p != FINGERPRINT_NOFINGER) {
    p = finger.getImage();
  }
  Serial.print("ID "); Serial.println(id);
  p = -1;
  Serial.println("Coloque o mesmo dedo novamente");
  lcd.clear();
  lcd.setCursor(3,0);
  lcd.print("Coloque o mesmo"); 
  lcd.setCursor(3,1);
  lcd.print("dedo de novo"); 
  
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagem tirada");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.print(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Erro de Comunicação");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Erro de imagem");
      break;
    default:
      Serial.println("Erro desconhecido");
      break;
    }
  }

  // OK succeso!

  p = finger.image2Tz(2);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagem convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Imagem muito bagunçada");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Erro de Comunicação");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Não foi possível encontrar os recursos de impressão digital");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Não foi possível encontrar os recursos de impressão digital");
      return p;
    default:
      Serial.println("Erro desconhecido");
      return p;
  }
  
  // OK converida!
  Serial.print("Criando modelo para #");  Serial.println(id);
  
  p = finger.createModel();
  if (p == FINGERPRINT_OK) {
    Serial.println("Impressões correspondentes!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Erro de Comunicação");
    return p;
  } else if (p == FINGERPRINT_ENROLLMISMATCH) {
    Serial.println("As impressões digitais não coincidem");
    return p;
  } else {
    Serial.println("Erro desconhecido");
    return p;
  }   
  
  Serial.print("ID "); Serial.println(id);
  p = finger.storeModel(id);
  if (p == FINGERPRINT_OK) {
    Serial.println("Gravado!");
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Gravado!"); 
    lcd.setCursor(0,1);
    lcd.print("ID ");lcd.print(id); 
    delay(3000);
    
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Erro de Comunicação");
    return p;
  } else if (p == FINGERPRINT_BADLOCATION) {
    Serial.println("Não foi possível armazenar nesse local");
    return p;
  } else if (p == FINGERPRINT_FLASHERR) {
    Serial.println("Erro ao gravar no flash");
    return p;
  } else {
    Serial.println("Erro desconhecido");
    return p;
  }
  lcd.clear();   
}

// ################## Pesquisa de impressão digital ###########################

int getFingerprintIDez() {
    
    uint8_t p = finger.getImage();
    if (p != FINGERPRINT_OK){
      lcd.clear();
      lcd.setCursor(3,0);
      lcd.print("Sem dedo ");
      lcd.setCursor(3,1);
      lcd.print("encontrado");
      delay(2000);
      Status = 1;
      return -1;  
    }
        
    p = finger.image2Tz();
    if (p != FINGERPRINT_OK){
      lcd.clear();
      lcd.setCursor(3,0);
      lcd.print("Sem dedo ");
      lcd.setCursor(3,1);
      lcd.print("econtrado");
      delay(2000);      
      Status = 1;
      return -1;
    }

    p = finger.fingerFastSearch();
    if (p != FINGERPRINT_OK){
      Serial.println("Dedo de erro");
      digitalWrite(ledBlue,LOW);
      digitalWrite(ledRed,HIGH);
      lcd.clear();
      lcd.setCursor(3,0);
      lcd.print("Sem dedo ");
      lcd.setCursor(3,1);
      lcd.print("encontrado");
      delay(2000);
      Status = 1;
      return -1;
    }

  Serial.print("Encontrada ID #"); Serial.print(finger.fingerID); 
  Serial.print(" com confiança de "); Serial.println(finger.confidence);
  return finger.fingerID; 
}

Vou explicar o código com base nos dois processos principais:

  1.  Registro de impressão digital
  2.  Reconhecimento de impressões digitais e presença de marcação

 

O processo de registro de impressões digitais

Todas as funções do sensor de impressão digital são controladas pela biblioteca de sensores de impressão digital Adafruit. A biblioteca contém os métodos e funções para dirigir o scanner de impressão digital.

Aqui, criei uma função chamada getFingerprintEnroll () para registrar novas impressões digitais. Ao chamar esta função, o sensor recebe duas digitalizações de impressão digital (fotos da impressão digital). Em seguida, a imagem da impressão digital é salva mesclando essas duas verificações em uma das 256 entradas no banco de dados interno. Você sempre receberá uma mensagem de erro se a imagem não for capturada corretamente devido a erros de posicionamento dos dedos.

Ao armazenar a impressão digital, temos que decidir a posição do banco de dados enquanto consideramos o armazenamento do sensor.

Foto 2

Como você pode ver, primeiro precisamos encontrar o número de impressões digitais que já estão armazenadas no sensor. Podemos obter esse número usando a função getTemplateCount(). Como a numeração da posição de armazenamento começa em 0, defina o ID aumentando o número em 1. O número do ID é uma variável global. Portanto, o número de ID atribuído será usado na função getFingerprintEnroll() ao armazenar a impressão digital.

 

O processo de reconhecimento de impressões digitais e presença de marcação

No processo de marcação de presença, a função getFingerprintIDez() é chamada. Essa função recebe a impressão digital de um usuário e a verifica com as impressões digitais já armazenadas.

Se o dedo não estiver no banco de dados, um código de erro será retornado pelo scanner. Se o dedo corresponder, ele retornará o número de identificação do usuário.

Eu converti os números de identificação em uma variável de string para armazená-los no SD Card. Por fim, você terá um relatório de presença como este:

Foto 3

Demonstração do sistema

Como você pode ver, o produto final deste projeto pode ser construído como um dispositivo portátil. No processo de registro, o usuário deve fornecer sua impressão digital duas vezes. Isso significa que cada usuário precisa tirar o dedo do scanner e colocá-lo novamente para poder gravar.

Durante o processo de participação, precisamos pressionar o botão Iniciar (botão azul) para iniciar o processo. O visor LCD exibe a mensagem “Coloque o dedo” para nos informar que o processo foi iniciado. Em seguida, o usuário deve colocar o dedo no scanner para marcar presença. Assim que a impressão digital for correspondida, a mensagem “Presente” será exibida e o LED azul acenderá. Se não houver correspondência, o LED vermelho piscará e o visor exibirá a mensagem de erro “Dedo não encontrado”.

 

Leitura e informações adicionais

Embora este seja um projeto completo, sempre há espaço para melhorias. Aqui estão outras melhorias que outras pessoas aplicaram a este projeto.

  • Sensor Leitor Biométrico Impressão Digital Dy50 tem a capacidade de armazenar até 256 modelos de impressão digital em sua memória. Se o seu projeto precisar de mais armazenamento do que isso, existem outras alternativas, como o scanner de impressão digital SparkFun GT521F52.
  • Neste projeto, o relatório de presença é um documento de texto com o número de identificação do usuário. No entanto, a interface de um módulo RTC também fornecerá a hora de chegada do usuário.
  • Se você deseja uma solução IoT para armazenamento de dados, pode substituir a placa Arduino por uma ESP32 ou Raspberry Pi e usar armazenamento baseado em nuvem, como o banco de dados MySQL.
Visits: 0 Visits: 772291