Como criar um sistema de atendimento baseado em impressão digital com Arduino e Sensor Leitor Biométrico - Cap Sistema
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.
Arduino Uno ou Mega
Sensor Leitor Biométrico Impressão Digital Dy50 (ou equivalente)
Módulo LCD 16×2 com I2C
Dois Pushbuttons
Dois Resistores de 10K Ohm
Biblioteca de sensores de impressão digital Adafruit
Biblioteca LiquidCrystal I2C
Biblioteca SD Arduino
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.
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:
A Ligação dele para Uno e Mega descrito abaixo.
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.
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.
Por fim, dois LEDs e botões de pressão podem ser conectados como mostrado na imagem abaixo.
Visão geral do sistema do scanner de impressão digital
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.
#include <LiquidCrystal_I2C.h> // Usando o driver da NewLiquidCrystal
#define switchReg 4    // botão de registro
#define switchAtten 5  // Botão de presença
// descomentar por uno
// descomente para Mega
//LiquidCrystal_I2C lcd(0x27,16,2);  // se for o outro verfique se os parametros são estes.
pinMode(switchAtten, INPUT);
pinMode(switchReg, INPUT);
lcd.begin(16,2);         // Ative o LCD para ver o resultado.
lcd.setBacklight(HIGH);  // Liga a luz de fundo do LCD
lcd.clear();             // Limpa o LCD
Serial.println("\n\nTeste de detecção de dedo Adafruit");
Serial.println("Sensor de impressão digital encontrado!");
Serial.println("Não encontrou o sensor de impressão digital :(");
Serial.println("O Card falhou ou não foi apresentadot");
Serial.println("Card Iniciado.");
lcd.print("Comparecer. Sistema");
lcd.print("CapSistema");
int buttonStateP1 = 0; // Rastreamento do botão de presença
int buttonStateP2 = 0; // Rastreamento do botão de registro
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 ){
lcd.print("Processo de Registro");
Serial.print("O sensor contém ");
Serial.println(" modelos");
id = finger.templateCount + 1;
// se o botão de atendimento foi pressionado
}else if(buttonStateP2 == HIGH){
uint8_t userId = -1;
lcd.print("Processo de Atendimento");
Serial.println("Aguardando dedo válido...");
lcd.print("Coloque o dedo");
userId = getFingerprintIDez();
if(userId >=1 && Status != 1)
lcd.print("Present");
// Armazenando dados no cartão SD
String ID = String(userId);
// se o arquivo foi aberto corretamente, escreva para ele:
myFile.print("ID do usuário ");
// #################### Função de registro de impressão digital ########################## ###
Serial.print("Aguardando o dedo válido se inscrever como #");
lcd.print("Coloque o");
lcd.print("dedo ");
Serial.println("Imagem tirada");
Serial.println("Erro na comunicação");
Serial.println("Erro na imagem");
// OK Sucesso!
Serial.println("Imagem muito bagunçada");
Serial.println("Erro de comunicação");
Serial.println("Não foi possível encontrar os recursos de impressão digital");
Serial.println("Remover dedo");
lcd.print(" Remover dedo ");
lcd.print("Coloque o mesmo");
lcd.print("dedo de novo");
// OK succeso!
// OK converida!
Serial.print("Criando modelo para #");  Serial.println(id);
Serial.println("Impressões correspondentes!");
Serial.println("As impressões digitais não coincidem");
Serial.println("Gravado!");
lcd.print("Gravado!");
lcd.print("ID ");lcd.print(id);
Serial.println("Não foi possível armazenar nesse local");
Serial.println("Erro ao gravar no flash");
// ################## Pesquisa de impressão digital ###########################
lcd.print("Sem dedo ");
lcd.print("encontrado");
lcd.print("econtrado");
Serial.println("Dedo de erro");
Serial.print("Encontrada ID #"); Serial.print(finger.fingerID);
Vou explicar o código com base nos dois processos principais:
Registro de impressão digital
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.
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:
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
Arduino, Arduino IDE, Arduino Uno, Fios, LCD 16x2 I2C, Leds, Module SD Card, ProtoBoard, Push Botton, Resistores, SD Card, Sensor Leitor Biométrico Impressão Digital Dy50, Sketch
Conexão LED RGB usando Arduino Uno
Um comentário sobre "Como criar um sistema de atendimento baseado em impressão digital com Arduino e Sensor Leitor Biométrico"
Parabéns pela explicação, está muito clara e muito bem explicada!
Compreendi que, apesar de utilizarmos o cartão SD para gravar os registros, não é possível utilizá-lo durante o processo de autenticação. Esta compreensão está correta?
Pergunto, pois gostaria de criar um sistema capaz de armazenar um número bem maior que o limite de armazenamento do sensor, mas estou sempre esbarrando nisto. Há algo a ser feito, em sua opinião?