Interfaz del sensor de huellas dactilares (fps) gt511c3 con arduino

La biometría se ha utilizado como un sistema de autenticación confiable durante mucho tiempo. Hoy en día existen complejos sistemas biométricos que pueden identificar a una persona por su ritmo cardíaco o incluso por su ADN. Otros métodos factibles incluyen reconocimiento de voz, reconocimiento facial, escaneo de iris y escaneo de huellas dactilares. De los cuales el reconocimiento de huellas dactilares es el método más utilizado, podemos encontrarlo desde un simple sistema de asistencia hasta teléfonos inteligentes, controles de seguridad y mucho más.

En este tutorial aprenderemos cómo usar el popular sensor de huellas dactilares (FPS) GT511C3 con Arduino. Hay muchos FPS disponibles y ya hemos aprendido a usarlos para crear diseños como el sistema de asistencia, la máquina de votación, el sistema de seguridad, etc. Pero el GT511C3 es más avanzado con alta precisión y tiempo de respuesta más rápido, por lo que aprenderemos a usarlo. con Arduino para registrar huellas digitales en él y luego detectar las huellas digitales cuando sea necesario. Entonces empecemos.

Materiales necesarios

Arduino Nano / UNO
Sensor de huellas dactilares GT511C3
Pantalla LCD 16x2
Pot - resistencias de 10k y 1k, 10k, 22k
Presionar el botón
Conexión de cables
Tabla de pan

Módulo de sensor de huellas dactilares (FPS) GT511C3

Antes de sumergirnos en el proyecto, comprendamos sobre el módulo sensor de huellas dactilares GT511C3 y cómo funciona. Este sensor es muy diferente al sensor de huellas dactilares capacitivo y ultrasónico que se utilizan comúnmente en nuestros teléfonos inteligentes. El GT511C3 es un sensor óptico de huellas dactilares, lo que significa que se basa en imágenes de su huella dactilar para reconocer su patrón. Sí, leíste bien, el sensor en realidad tiene una cámara en su interior que toma fotografías de tu huella dactilar y luego procesa estas imágenes usando un poderoso ARM Cortex M3 IC incorporado. La siguiente imagen muestra la parte frontal y posterior del sensor con pines.

Como puede ver, el sensor tiene una cámara (punto negro) rodeada de LED azules, estos LED deben estar encendidos para tomar una imagen clara de la huella digital. Estas imágenes luego se procesan y se convierten en valor binario usando el microcontrolador ARM acoplado con EEPROM. El módulo también tiene un LED SMD de color verde para indicar alimentación. Cada imagen de huella digital es de 202x258 píxeles con una resolución de 450 ppp. El sensor puede registrar hasta 200 huellas dactilares y para cada plantilla de huellas dactilares asigna un formulario de identificación de 0 a 199. Luego, durante la detección, puede comparar automáticamente la huella digital escaneada con las 200 plantillas y, si se encuentra una coincidencia, proporciona el número de identificación de esa huella digital en particular utilizando el Smack Finger 3.0.Algoritmo en el microcontrolador ARM. El sensor puede operar de 3.3V a 6V y se comunica a través de comunicación serial en 9600. Se dice que los pines de comunicación (Rx y Tx) son tolerantes a solo 3.3V, sin embargo, la hoja de datos no especifica mucho al respecto. El pin-out de un GT511C3 FPS se muestra a continuación.

Además de la comunicación en serie, el módulo también se puede conectar directamente a la computadora a través de una conexión USB utilizando los pines que se muestran en la imagen anterior. Una vez conectado a la computadora, el módulo se puede controlar mediante la aplicación SDK_DEMO.exe que se puede descargar desde el enlace. Esta aplicación permite al usuario registrar / verificar / eliminar huellas dactilares y también reconocer huellas dactilares. El software también puede ayudarlo a leer la imagen capturada por el sensor, por lo que vale la pena intentarlo. Alternativamente, también puede usar este software incluso si el sensor está conectado con Arduino, lo discutiremos más adelante en este artículo.

Otra característica interesante del sensor es la carcasa de metal alrededor de la región de detección. Como dije anteriormente, el LED azul debe estar encendido para que el sensor funcione. Pero en aplicaciones donde el sensor debe esperar activamente una huella dactilar no es posible mantener el LED encendido siempre ya que calentará el sensor y así lo dañará. Por lo tanto, en esos casos, la carcasa de metal se puede conectar a un pin de entrada táctil capacitiva de un MCU para detectar si se está tocando. En caso afirmativo, el LED se puede encender y se puede iniciar el proceso de detección. Este método no se demuestra aquí ya que está fuera del alcance de este artículo.

Cuando funciona a 3,3 V, el sensor consume aproximadamente 130 mA. Se necesitan casi 3 segundos para registrar un dedo y 1 segundo para identificarlo. Sin embargo, si el recuento de plantillas inscritas es menor, la velocidad de reconocimiento será alta. Para obtener más detalles sobre el sensor, puede consultar esta hoja de datos de ADH-Tech, que es el fabricante oficial del módulo.

Conexión del sensor de huellas dactilares GT511C3 con Arduino

El GT511C3 FPS tiene dos pines de alimentación que pueden ser alimentados por el pin + 5V de Arduino y dos pines de comunicación Rx y Tx que pueden conectarse a cualquier pin digital de Arduino para comunicación en serie. Además, también hemos agregado un botón pulsador y una pantalla LCD para mostrar el estado del sensor. El diagrama de circuito completo para la interfaz GT511C3 FPS con Arduino se puede encontrar a continuación.

Dado que los pines Rx y Tx son tolerantes a 3.3V, hemos utilizado un divisor de potencial en el lado Rx para convertir 5V a 3.3V. La resistencia de 10k y la resistencia de 22k convierten la señal de 5V del pin Arduino Tx a 3.3V antes de que alcance el pin Rx del FPS. El sensor también puede funcionar con 3.3V, pero asegúrese de que su Arduino pueda generar suficiente corriente para el sensor. Hemos conectado el LCD en modo de 4 bits alimentado por el pin 5V de Arduino. Un botón está conectado al pin D2 que cuando se presiona pondrá el programa en modo de registro donde el usuario puede registrar un nuevo dedo. Después de inscribirse, el programa permanecerá en modo de escaneo para buscar algún dedo que toque el sensor.

Arduino con GT511C3

Como se mencionó anteriormente, el GT511C3 FPS se comunica a través de la comunicación en serie, el sensor comprende el código hexadecimal y para cada código hexadecimal se realiza una operación particular. Puede consultar la hoja de datos para conocer todos los valores hexadecimales y su función correspondiente si está interesado. Pero, por suerte para nosotros, bboyho ya ha creado una biblioteca que se puede usar directamente con Arduino para inscribirse y detectar huellas dactilares. La biblioteca Github para GT511C3 FPS se puede descargar desde el siguiente enlace

Biblioteca Arduino GT511C3

El enlace descargará un archivo ZIP, luego deberá agregarlo a su IDE de Arduino siguiendo el comando Sketch -> Incluir biblioteca -> Agregar biblioteca.ZIP. Una vez que haya agregado la biblioteca, reinicie su IDE y debería poder encontrar los programas de ejemplo para GT511C3 FSP en Archivo -> Ejemplo -> Escáner de huellas digitales TTL como se muestra a continuación.

Debería ver cuatro programas de ejemplo, el programa de parpadeo parpadeará con el LED azul en el FPS, el programa de registro e identificación de dedos se puede utilizar para registrar e identificar los dedos en consecuencia. Tenga en cuenta que el módulo siempre recordará un dedo una vez registrado, incluso si está apagado.

El programa Serial Pass-through se puede cargar en Arduino para usar la aplicación Demo_SDK.exe que discutimos anteriormente en este artículo. Para eliminar cualquier plantilla de huellas digitales o para guardar una copia en su computadora, se puede utilizar esta aplicación SDK.

Programación de Arduino para el sensor de huellas dactilares GT511C3

Nuestro objetivo aquí es escribir un programa que registre un dedo cuando se presione un botón y muestre el número de identificación del dedo que ya está registrado. También deberíamos poder mostrar toda la información en la pantalla LCD para permitir que el proyecto sea independiente. El código completo para hacer lo mismo se encuentra al final de esta página. Aquí estoy dividiendo lo mismo en pequeños fragmentos para ayudarlo a comprender mejor.

Como siempre, comenzamos el programa incluyendo las bibliotecas requeridas, aquí necesitaremos la biblioteca FPS_GT511C3 para nuestro módulo FPS, la serie de software para usar D4 y D5 en la comunicación en serie y el cristal líquido para la interfaz LCD. Luego debemos mencionar a qué pines están conectados el FPS y el LCD. Si ha seguido el diagrama de circuito como tal, entonces es 4 y 5 para FPS y D6 a D11 para LCD. El código para el mismo se muestra a continuación.

#include "FPS_GT511C3.h" // Obtenga la biblioteca de https://github.com/sparkfun/Fingerprint_Scanner-TTL #include "SoftwareSerial.h" // Biblioteca de serie de software #include // Biblioteca para LCD FPS_GT511C3 fps (4, 5); // FPS conectado a D4 y D5 const int rs = 6, en = 7, d4 = 8, d5 = 9, d6 = 10, d7 = 11; // Mencione el número de pin para la conexión LCD LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Inicialice el método LCD

Dentro de la función de configuración , mostramos un mensaje introductorio en la pantalla LCD y luego inicializamos el módulo FPS. El comando fps.SetLED (verdadero) encenderá el LED azul en el sensor, puede apagarlo por fps.SetLED (falso) cuando no sea necesario, ya que calentaría el sensor si se deja encendido continuamente. También hemos creado el pin D2 como pin de entrada y lo hemos conectado a la resistencia pull-up interna para conectar un botón pulsador al pin.

configuración vacía () { Serial.begin (9600); lcd. comienzo (16, 2); // Inicializar 16 * 2 LCD lcd.print ("GT511C3 FPS"); // Mensaje de introducción, línea 1 lcd.setCursor (0, 1); lcd.print ("con Arduino"); // Retraso de la línea 2 del mensaje de introducción (2000); lcd.clear (); fps.Open (); // envía un comando en serie para inicializar fp fps.SetLED (true); // enciende el LED para que los fps puedan ver la huella digital pinMode (2, INPUT_PULLUP); // Conectar a la resistencia pull up interna como pin de entrada }

Dentro de la función de bucle void tenemos que comprobar si el botón está presionado, si lo presionamos registraremos un nuevo dedo y guardaremos su plantilla con un número de identificación usando la función de registro. Si no, seguiremos esperando a que se presione un dedo en el sensor. Si se presiona, identificaremos la huella digital comparándola con todas las plantillas de huellas digitales registradas utilizando el método 1: N. Una vez que se descubre el número de identificación, mostraremos la bienvenida seguido del número de identificación. Si la huella dactilar no coincide con ninguno de los dedos inscritos, el número de identificación será 200, en ese caso mostraremos la bienvenida desconocida.

if (digitalRead (2)) // Si se presiona el botón { Enroll (); // Registrar una huella digital } // Identificar la prueba de huellas digitales if (fps.IsPressFinger ()) { fps.CaptureFinger (false); int id = fps.Identify1_N (); lcd.clear (); lcd.print ("Bienvenido:"); if (id == 200) lcd.print ("Desconocido"); // Si no se reconoce lcd.print (id); retraso (1000); }

La función de registro tendría que tomar tres entradas de muestra para registrar un dedo con éxito. Una vez inscrito, se creará una plantilla para ese dedo en particular que no se eliminará a menos que el usuario lo fuerce a través de los comandos HEX. El código para registrar un dedo se muestra a continuación. El método IsPressFinger se usa para verificar si se detecta un dedo, si es así, la imagen se captura usando CaptureFinger y finalmente Enroll1, Enroll2 y Enroll3 se utiliza para tres muestras diferentes para registrar correctamente un dedo. La pantalla LCD muestra el número de identificación del dedo si se inscribió correctamente, de lo contrario, mostraría un mensaje de falla con el código. El código 1 significa que la huella digital no se capturó con claridad y, por lo tanto, debe intentarlo de nuevo. El código 2 es una indicación de falla de memoria y el código 3 es para indicar que el dedo ya se ha registrado.

void Enroll () // Función de inscripción del programa de ejemplo de la biblioteca { int enrollid = 0; bool usedid = verdadero; while (usedid == true) { usedid = fps.CheckEnrolled (enrollid); if (usedid == true) enrollid ++; } fps.EnrollStart (enrollid); // inscribir lcd.print ("Inscribir #"); lcd.print (enrollid); while (fps.IsPressFinger () == falso) delay (100); bool bret = fps.CaptureFinger (verdadero); int iret = 0; si (bret! = falso) { lcd.clear (); lcd.print ("Quitar dedo"); fps.Enroll1 (); while (fps.IsPressFinger () == true) delay (100); lcd.clear (); lcd.print ("Pulsar de nuevo"); while (fps.IsPressFinger () == falso) delay (100); bret = fps.CaptureFinger (verdadero); si (bret! = falso) { lcd.clear (); lcd.print ("Quitar dedo"); fps.Enroll2 (); while (fps.IsPressFinger () == true) delay (100); lcd.clear (); lcd.print ("Pulsar de nuevo"); while (fps.IsPressFinger () == falso) delay (100); bret = fps.CaptureFinger (verdadero); si (bret! = falso) { lcd.clear (); lcd.print ("Quitar dedo"); iret = fps.Enroll3 (); if (iret == 0) { lcd.clear (); lcd.print ("Inscripción exitosa"); } else { lcd.clear (); lcd.print ("Inscripción fallida:"); lcd.print (iret); } } else lcd.print ("Falló 1"); } else lcd.print ("Falló 2"); } else lcd.print ("Falló 3"); }

Funcionamiento del sensor de huellas dactilares GT511C3 con Arduino

Ahora que nuestro hardware y código están listos, es hora de probar nuestro proyecto. Sube el código a Arduino y enciéndelo, solo estoy usando el puerto micro-usb para alimentar el proyecto. Al arrancar, deberíamos ver el mensaje de introducción en la pantalla LCD y luego debería mostrar "¡Hola!…". Esto significa que FPS está listo para escanear el dedo, si se presiona cualquier dedo registrado, dirá "Bienvenido" seguido del número de identificación de ese dedo como se muestra a continuación.

Si se debe registrar un nuevo dedo, podemos usar el botón pulsador para entrar en el modo de registro y seguir las instrucciones de la pantalla LCD para registrar un dedo. Una vez finalizado el proceso de registro, la pantalla LCD mostrará "¡Hola!…" nuevamente para indicar que se lee para identificar nuevamente los dedos. El trabajo completo se puede encontrar en el video vinculado a continuación.

Desde aquí, puede desarrollar muchas cosas interesantes además de esto utilizando el módulo del sensor de huellas dactilares. Espero que haya entendido el tutorial y haya disfrutado construyendo algo útil, si tiene alguna pregunta déjela en la sección de comentarios o use los foros para otras preguntas técnicas.