- Materiais requisitados
- Módulo do sensor de impressão digital GT511C3 (FPS)
- Conectando o sensor de impressão digital GT511C3 ao Arduino
- Arduino com GT511C3
- Programando Arduino para sensor de impressão digital GT511C3
- Trabalhando com o sensor de impressão digital GT511C3 com Arduino
A biometria tem sido usada como um sistema de autenticação confiável há muito tempo. Hoje existem sistemas biométricos complexos que podem identificar uma pessoa pelo ritmo dos batimentos cardíacos ou mesmo por seu DNA. Outros métodos viáveis incluem reconhecimento de voz, reconhecimento facial, digitalização da íris e digitalização de impressão digital. Dentre os quais o reconhecimento de impressão digital é o método mais utilizado, podemos encontrá-lo desde um simples sistema de atendimento a smartphones, verificações de segurança e muito mais.
Neste tutorial, aprenderemos como usar o popular Sensor de impressão digital GT511C3 (FPS) com o Arduino. Existem muitos FPS disponíveis e já aprendemos como usá-los para construir projetos como sistema de atendimento, máquina de votação, sistema de segurança etc. Mas o GT511C3 é mais avançado com alta precisão e tempo de resposta mais rápido, por isso vamos aprender como usá-lo com Arduino para registrar impressões digitais nele e, em seguida, detectar as impressões digitais sempre que necessário. Então vamos começar.
Materiais requisitados
- Arduino Nano / UNO
- Sensor de impressão digital GT511C3
- Tela LCD 16x2
- Pot - resistores de 10k e 1k, 10k, 22k
- Botão de apertar
- Fios de conexão
- Tábua de pão
Módulo do sensor de impressão digital GT511C3 (FPS)
Antes de mergulhar no projeto, vamos entender sobre o módulo sensor de impressão digital GT511C3 e como ele funciona. Este sensor é muito diferente do sensor Capacitivo e Ultrassônico de Impressão Digital que são comumente usados em nossos smartphones. O GT511C3 é um sensor óptico de impressão digital, o que significa que ele depende de imagens de sua impressão digital para reconhecer seu padrão. Sim, você leu certo, o sensor na verdade tem uma câmera dentro dele que tira fotos de sua impressão digital e depois processa essas imagens usando o poderoso ARM Cortex M3 IC embutido. A imagem abaixo mostra a parte frontal e posterior do sensor com pinagem.
Como você pode ver, o sensor possui uma câmera (ponto preto) rodeada por LEDs azuis, esses LEDs devem estar acesos para obter uma imagem nítida da impressão digital. Essas imagens são então processadas e convertidas em valor binário usando o microcontrolador ARM acoplado com EEPROM. O módulo também possui um LED SMD de cor verde para indicar alimentação. Cada imagem de impressão digital é de 202x258 pixels com resolução de 450 dpi. O sensor pode registrar até 200 impressões digitais e para cada modelo de impressão digital ele atribui um formulário de identificação de 0 a 199. Então, durante a detecção, ele pode comparar automaticamente a impressão digital digitalizada com todos os 200 modelos e se uma correspondência for encontrada, ele fornece o número de identificação dessa impressão digital em particular usando o Smack Finger 3.0Algoritmo no microcontrolador ARM. O sensor pode operar de 3,3 V a 6 V e se comunica através da comunicação serial em 9600. Os pinos de comunicação (Rx e Tx) são considerados tolerantes a apenas 3,3 V, no entanto, a ficha técnica não especifica muito sobre isso. A pinagem de um GT511C3 FPS é mostrada abaixo.
Além da comunicação serial, o módulo também pode ser conectado diretamente ao computador através da conexão USB usando os pinos mostrados na imagem anterior. Uma vez conectado ao computador, o módulo pode ser controlado usando o aplicativo SDK_DEMO.exe, que pode ser baixado do link. Este aplicativo permite ao usuário registrar / verificar / excluir impressões digitais e também reconhecer impressões digitais. O software também pode ajudá-lo a ler a imagem capturada pelo sensor, o que vale a pena experimentar. Alternativamente, você também pode usar este software mesmo se o sensor estiver conectado ao Arduino, discutiremos sobre isso mais tarde neste artigo.
Outra característica interessante sobre o sensor é a carcaça de metal ao redor da região de detecção. Como eu disse antes, o LED azul precisa estar ligado para que o sensor funcione. Porém, em aplicações em que o sensor deve aguardar ativamente por uma impressão digital, não é possível manter o LED sempre aceso, pois isso aquecerá o sensor e, assim, danificará. Portanto, nesses casos, o invólucro de metal pode ser conectado a um pino de entrada de toque capacitivo de um MCU para detectar se ele está sendo tocado. Se sim, o LED pode ser ligado e o processo de detecção pode ser iniciado. Este método não é demonstrado aqui, pois está fora do escopo deste artigo.
Ao operar a 3,3 V, o sensor consome cerca de 130 mA. São necessários quase 3 segundos para registrar um dedo e 1 segundo para identificá-lo. No entanto, se a contagem de modelos inscritos for menor, a velocidade de reconhecimento será alta. Para obter mais detalhes sobre o sensor, você pode consultar esta folha de dados da ADH-Tech, que é o fabricante oficial do módulo.
Conectando o sensor de impressão digital GT511C3 ao Arduino
O GT511C3 FPS tem dois pinos de alimentação que podem ser alimentados pelo pino de + 5V do Arduino e dois pinos de comunicação Rx e Tx que podem ser conectados a qualquer pino digital do Arduino para comunicação serial. Além disso, também adicionamos um botão de pressão e um LCD para exibir o status do sensor. O diagrama de circuito completo para a interface do GT511C3 FPS com o Arduino pode ser encontrado abaixo.
Como os pinos Rx e Tx são tolerantes a 3,3 V, usamos um divisor de potencial no lado Rx para converter 5 V em 3,3 V. O resistor de 10k e o resistor de 22k converte o sinal de 5 V do pino Arduino Tx para 3,3 V antes de atingir o pino Rx do FPS. O sensor também pode ser alimentado por 3,3 V, mas certifique-se de que seu Arduino possa fornecer corrente suficiente para o sensor. Conectamos o LCD em modo de 4 bits alimentado por pino de 5 V do Arduino. Um botão de pressão é conectado ao pino D2 que, quando pressionado , colocará o programa no modo de registro, onde o usuário pode registrar um novo dedo. Depois de inscrever-se, o programa permanecerá no modo de digitalização para procurar qualquer dedo tocando o sensor.
Arduino com GT511C3
Conforme mencionado anteriormente, o GT511C3 FPS se comunica por meio de comunicação serial, o sensor entende o código hexadecimal e para cada código hexadecimal uma operação específica é executada. Você pode verificar a folha de dados para saber todos os valores hexadecimais e sua função correspondente se estiver interessado. Mas, para nossa sorte, o bboyho já criou uma biblioteca que pode ser usada diretamente com o Arduino para registrar e detectar impressões digitais. A biblioteca Github para GT511C3 FPS pode ser baixada do link abaixo
Biblioteca GT511C3 Arduino
O link fará o download de um arquivo ZIP, você deverá adicioná-lo ao seu IDE Arduino, seguindo o comando Sketch -> Incluir Biblioteca -> Adicionar Biblioteca.ZIP. Depois de adicionar a biblioteca, reinicie seu IDE e você deve ser capaz de encontrar os programas de exemplo para GT511C3 FSP em Arquivo -> Exemplo -> Scanner de impressão digital TTL como mostrado abaixo
Você deve ver quatro programas de exemplo, o programa de piscar piscará o led azul no FPS, o programa de registro e identificação de dedo pode ser usado para registrar e identificar os dedos de acordo. Observe que um dedo, uma vez cadastrado, sempre será lembrado pelo módulo, mesmo se estiver desligado.
O programa Serial Pass-through pode ser carregado no Arduino para usar o aplicativo Demo_SDK.exe que discutimos anteriormente neste artigo. Para excluir qualquer modelo de impressão digital ou salvar uma cópia em seu computador, este aplicativo SDK pode ser usado.
Programando Arduino para sensor de impressão digital GT511C3
Nosso objetivo aqui é escrever um programa que registrará um dedo quando um botão for pressionado e exibirá o número de identificação do dedo que já está registrado. Também devemos ser capazes de exibir todas as informações no LCD para permitir que o projeto seja independente. O código completo para fazer o mesmo é fornecido na parte inferior desta página. Aqui estou dividindo o mesmo em pequenos trechos para ajudá-lo a entender melhor.
Como sempre, começamos o programa incluindo as bibliotecas necessárias, aqui precisaremos da biblioteca FPS_GT511C3 para nosso módulo FPS, Software serial para usar D4 e D5 em comunicação serial e cristal líquido para interface de LCD. Então, precisamos mencionar a quais pinos o FPS e o LCD estão conectados. Se você seguiu o diagrama de circuito como tal, então é 4 e 5 para FPS e D6 a D11 para LCD. O código para o mesmo é mostrado abaixo
#include "FPS_GT511C3.h" // Obter biblioteca em https://github.com/sparkfun/Fingerprint_Scanner-TTL #include "SoftwareSerial.h" // Biblioteca serial de software #include
Dentro da função de configuração , exibimos algumas mensagens introdutórias no LCD e, em seguida, inicializamos o módulo FPS. O comando fps.SetLED (true) acenderá o LED azul no sensor, você pode desligá-lo por fps.SetLED (false) quando não for necessário, pois aqueceria o sensor se deixado ligado continuamente. Também criamos o pino D2 como pino de entrada e o conectamos ao resistor pull-up interno para conectar um botão de pressão ao pino.
void setup () { Serial.begin (9600); lcd.begin (16, 2); // Inicializar 16 * 2 LCD lcd.print ("GT511C3 FPS"); // Linha 1 da mensagem de introdução lcd.setCursor (0, 1); lcd.print ("com Arduino"); // Mensagem de introdução linha 2 delay (2000); lcd.clear (); fps.Open (); // envia o comando serial para inicializar fp fps.SetLED (true); // liga o LED para que o fps possa ver a impressão digital pinMode (2, INPUT_PULLUP); // Conecte ao resistor pull up interno como pino de entrada }
Dentro da função void loop , temos que verificar se o botão está pressionado, se pressionado registraremos um novo dedo e salvaremos seu modelo com um número de ID usando a função registrar. Do contrário, ficaremos esperando que um dedo seja pressionado no sensor. Se pressionado, iremos identificar a impressão digital comparando-a com todos os modelos de impressões digitais registrados usando o método 1: N. Assim que o número de identificação for descoberto, exibiremos welcome seguido do número de identificação. Se a impressão digital não coincidir com nenhum dos dedos registrados, a contagem de id será 200, nesse caso exibiremos bem-vindo desconhecido.
if (digitalRead (2)) // If botão pressionado { Enroll (); // Registra uma impressão digital } // Identifica o teste de impressão digital if (fps.IsPressFinger ()) { fps.CaptureFinger (false); id int = fps.Identify1_N (); lcd.clear (); lcd.print ("Bem-vindo:"); if (id == 200) lcd.print ("Desconhecido"); // Se não for reconhecido lcd.print (id); atraso (1000); }
A função de registro teria que pegar três entradas de amostra para registrar um dedo com sucesso. Uma vez inscrito, um modelo para aquele dedo em particular será criado e não será excluído a menos que o usuário o force por meio de comandos HEX. O código para registrar um dedo é mostrado abaixo. O método IsPressFinger é usado para verificar se um dedo foi detectado, em caso afirmativo, a imagem é capturada usando CaptureFinger e, finalmente, Enroll1, Enroll2 e Enroll3 são usados para três amostras diferentes para registrar com êxito um dedo. O LCD exibe o número de identificação do dedo se registrado com sucesso, caso contrário, exibiria uma mensagem de falha com o código. O código 1 significa que a impressão digital não foi capturada com clareza e, portanto, você deve tentar novamente. O código 2 é uma indicação de falha de memória e o código 3 é para indicar que o dedo já foi registrado.
void Enroll () // Inscrever a função do programa de exemplo da biblioteca { int matriculado = 0; bool usedid = true; while (usedid == true) { usedid = fps.CheckEnrolled (matriculado); if (usedid == true) matriculado ++; } fps.EnrollStart (matricula); // inscrever lcd.print ("Inscrever #"); lcd.print (matricula); while (fps.IsPressFinger () == false) delay (100); bool bret = fps.CaptureFinger (true); int iret = 0; if (bret! = false) { lcd.clear (); lcd.print ("Remover dedo"); fps.Enroll1 (); while (fps.IsPressFinger () == true) delay (100); lcd.clear (); lcd.print ("Pressione novamente"); while (fps.IsPressFinger () == false) delay (100); bret = fps.CaptureFinger (true); if (bret! = false) { lcd.clear (); lcd.print ("Remover dedo"); fps.Enroll2 (); while (fps.IsPressFinger () == true) delay (100); lcd.clear (); lcd.print ("Pressione novamente"); while (fps.IsPressFinger () == false) delay (100); bret = fps.CaptureFinger (true); if (bret! = false) { lcd.clear (); lcd.print ("Remover dedo"); iret = fps.Enroll3 (); if (iret == 0) { lcd.clear (); lcd.print ("Sucesso na inscrição"); } else { lcd.clear (); lcd.print ("Falha na inscrição:"); lcd.print (iret); } } else lcd.print ("Falha 1"); } else lcd.print ("Falha 2"); } else lcd.print ("Falha 3"); }
Trabalhando com o sensor de impressão digital GT511C3 com Arduino
Agora que nosso hardware e código estão prontos, é hora de testar nosso projeto. Faça o upload do código para o Arduino e ligue-o, estou apenas usando a porta micro-usb para alimentar o projeto. Na inicialização, devemos ver a mensagem de introdução no LCD e, em seguida, deve exibir “Hi!..”. Isso significa que o FPS está pronto para escanear o dedo, se qualquer dedo registrado for pressionado, dirá “Bem-vindo” seguido do número de identificação desse dedo, conforme mostrado abaixo.
Se for necessário registrar um novo dedo, podemos usar o botão de pressão para entrar no modo de registro e seguir as instruções do LCD para registrar um dedo. Após a conclusão do processo de registro, o LCD exibirá “Hi!..” novamente para indicar que foi lido para identificar os dedos novamente. O trabalho completo pode ser encontrado no vídeo no link abaixo.
A partir daqui, você pode desenvolver muitas coisas interessantes sobre isso usando o módulo sensor de impressão digital. Espero que você tenha entendido o tutorial e gostado de construir algo útil, se você tiver alguma dúvida, deixe-a na seção de comentários ou use os fóruns para outras questões técnicas.