Interfacciamento del sensore di impronte digitali (fps) gt511c3 con arduino

La biometria è stata utilizzata da molto tempo come un sistema di autenticazione affidabile. Oggi esistono sistemi biometrici complessi che possono identificare una persona dal ritmo del battito cardiaco o persino dal suo DNA. Altri metodi possibili includono il riconoscimento vocale, il riconoscimento facciale, la scansione dell'iride e la scansione delle impronte digitali. Di cui il riconoscimento dell'impronta digitale è il metodo più utilizzato, possiamo trovarlo da un semplice sistema di presenza agli smartphone, ai controlli di sicurezza e molto altro ancora.

In questo tutorial impareremo come utilizzare il popolare sensore di impronte digitali (FPS) GT511C3 con Arduino. Sono disponibili molti FPS e abbiamo già imparato a usarli per creare progetti come il sistema di presenza, la macchina per il voto, il sistema di sicurezza ecc. Ma il GT511C3 è più avanzato con elevata precisione e tempi di risposta più rapidi, quindi impareremo come usarlo con Arduino per registrare le impronte digitali su di esso e quindi rilevare le impronte digitali quando necessario. Quindi iniziamo.

Materiali richiesti

Arduino Nano / UNO
Sensore di impronte digitali GT511C3
Schermo LCD 16x2
Pot: resistori da 10k e 1k, 10k, 22k
Premi il bottone
Collegamento dei cavi
Tagliere per il pane

Modulo sensore di impronte digitali (FPS) GT511C3

Prima di immergerci nel progetto, facci capire il modulo del sensore di impronte digitali GT511C3 e come funziona. Questo sensore è molto diverso dal sensore di impronte digitali capacitivo e ultrasonico che sono comunemente utilizzati nei nostri smartphone. Il GT511C3 è un sensore di impronte digitali ottico, il che significa che si basa sulle immagini della tua impronta digitale per riconoscere il suo modello. Sì, hai letto bene, il sensore in realtà ha una fotocamera al suo interno che scatta foto della tua impronta digitale e quindi elabora queste immagini utilizzando il potente IC ARM Cortex M3 integrato. L'immagine sotto mostra il lato anteriore e posteriore del sensore con piedinatura.

Come puoi vedere il sensore ha una telecamera (punto nero) circondata da LED blu, questi LED devono essere accesi per acquisire un'immagine chiara dell'impronta digitale. Queste immagini vengono quindi elaborate e convertite in valore binario utilizzando il microcontrollore ARM accoppiato con EEPROM. Il modulo ha anche un LED SMD di colore verde per indicare l'alimentazione. Ogni immagine dell'impronta digitale è di 202x258 pixel con una risoluzione di 450 dpi. Il sensore può registrare fino a 200 impronte digitali e per ogni modello di impronte digitali assegna un modulo ID da 0 a 199. Quindi durante il rilevamento può confrontare automaticamente l'impronta digitale scansionata con tutti i 200 modelli e se viene trovata una corrispondenza fornisce il numero ID di quella particolare impronta digitale utilizzando Smack Finger 3.0Algoritmo sul microcontrollore ARM. Il sensore può funzionare da 3,3 V a 6 V e comunica tramite comunicazione seriale a 9600. Si dice che i pin di comunicazione (Rx e Tx) tollerino solo 3,3 V, tuttavia la scheda tecnica non ne specifica molto. Di seguito è mostrato il pin-out di un FPS GT511C3.

Oltre alla comunicazione seriale, il modulo può anche essere interfacciato direttamente al computer tramite connessione USB utilizzando i pin mostrati nell'immagine precedente. Una volta connesso al computer, il modulo può essere controllato tramite l'applicazione SDK_DEMO.exe che può essere scaricata dal link. Questa applicazione consente all'utente di registrare / verificare / eliminare le impronte digitali e anche di riconoscere le impronte digitali. Il software può anche aiutarti a leggere l'immagine catturata dal sensore che vale la pena provare. In alternativa puoi utilizzare anche questo Software anche se il sensore è connesso ad Arduino, ne parleremo più avanti in questo articolo.

Un'altra caratteristica interessante del sensore è l'involucro metallico attorno alla regione di rilevamento. Come ho detto prima, il LED blu deve essere acceso affinché il sensore funzioni. Ma nelle applicazioni in cui il sensore deve attendere attivamente un'impronta digitale, non è possibile mantenere il LED sempre acceso poiché riscalda il sensore e quindi lo danneggia. Quindi in questi casi l' involucro metallico può essere collegato a un pin di input tattile capacitivo di un MCU per rilevare se viene toccato. Se sì, il LED può essere acceso e il processo di rilevamento può essere avviato. Questo metodo non è illustrato qui poiché esula dall'ambito di questo articolo.

Quando funziona a 3,3 V, il sensore consuma circa 130 mA. Sono necessari quasi 3 secondi per registrare un dito e 1 secondo per identificarlo. Tuttavia, se il numero di modelli registrati è inferiore, la velocità di riconoscimento sarà elevata. Per maggiori dettagli sul sensore è possibile fare riferimento a questa scheda tecnica di ADH-Tech che è il produttore ufficiale del modulo.

Collegamento del sensore di impronte digitali GT511C3 con Arduino

L'FPS GT511C3 ha due pin di alimentazione che possono essere alimentati dal pin + 5V di Arduino e due pin di comunicazione Rx e Tx che possono essere collegati a qualsiasi pin digitale di Arduino per la comunicazione seriale. Inoltre abbiamo anche aggiunto un pulsante e un display LCD per visualizzare lo stato del sensore. Di seguito è riportato lo schema circuitale completo per l' interfacciamento di GT511C3 FPS con Arduino.

Poiché i pin Rx e Tx tollerano 3,3 V, abbiamo utilizzato un potenziale divisore sul lato Rx per convertire 5 V in 3,3 V. Il resistore da 10k e il resistore da 22k converte il segnale a 5V dal pin Tx di Arduino a 3,3V prima che raggiunga il pin Rx dell'FPS. Il sensore può anche essere alimentato a 3,3 V, ma assicurati che il tuo Arduino possa fornire corrente sufficiente per il sensore. Abbiamo collegato il display LCD in modalità 4 bit alimentato dal pin 5V di Arduino. Un pulsante è collegato al pin D2 che, se premuto , metterà il programma in modalità di registrazione in cui l'utente può registrare un nuovo dito. Dopo la registrazione, il programma rimarrà in modalità di scansione per rilevare eventuali dita che toccano il sensore.

Arduino con GT511C3

Come accennato in precedenza, l'FPS GT511C3 comunica tramite comunicazione seriale, il sensore comprende il codice esadecimale e per ogni codice esadecimale viene eseguita una particolare operazione. Puoi controllare il foglio dati per conoscere tutti i valori esadecimali e la sua funzione corrispondente se sei interessato. Ma, fortunatamente per noi, bboyho ha già creato una libreria che può essere utilizzata direttamente con Arduino per registrare e rilevare le impronte digitali. La libreria Github per GT511C3 FPS può essere scaricata dal collegamento sottostante

Libreria Arduino GT511C3

Il link scaricherà un file ZIP, dovrai quindi aggiungerlo al tuo IDE Arduino seguendo il comando Sketch -> Include Library -> Add.ZIP Library. Dopo aver aggiunto la libreria, riavvia il tuo IDE e dovresti essere in grado di trovare i programmi di esempio per GT511C3 FSP in File -> Example -> Fingerprint Scanner TTL come mostrato di seguito

Dovresti vedere quattro programmi di esempio, il programma blink lampeggerà il led blu sull'FPS, il programma di registrazione e ID finger può essere utilizzato per registrare e identificare le dita di conseguenza. Notare che un dito una volta registrato sarà sempre ricordato dal modulo anche se è spento.

Il programma Serial Pass-through può essere caricato su Arduino per utilizzare l' applicazione Demo_SDK.exe di cui abbiamo discusso in precedenza in questo articolo. Per eliminare qualsiasi modello di impronta digitale o per salvare una copia sul computer è possibile utilizzare questa applicazione SDK.

Programmazione di Arduino per sensore di impronte digitali GT511C3

Il nostro scopo qui è scrivere un programma che registri un dito quando viene premuto un pulsante e visualizzi il numero ID del dito che è già registrato. Dovremmo anche essere in grado di visualizzare tutte le informazioni sull'LCD per consentire al progetto di essere autonomo. Il codice completo per fare lo stesso è fornito in fondo a questa pagina. Qui sto suddividendo lo stesso in piccoli frammenti per aiutarti a capire meglio.

Come sempre iniziamo il programma includendo le librerie richieste, qui avremo bisogno della libreria FPS_GT511C3 per il nostro modulo FPS, Software seriale per utilizzare D4 e D5 sulla comunicazione seriale e Cristalli liquidi per l'interfacciamento LCD. Quindi dobbiamo menzionare a quali pin sono collegati l'FPS e l'LCD. Se hai seguito lo schema del circuito in quanto tale, è 4 e 5 per FPS e da D6 a D11 per LCD. Il codice per lo stesso è mostrato di seguito

#include "FPS_GT511C3.h" // Scarica la libreria da https://github.com/sparkfun/Fingerprint_Scanner-TTL #include "SoftwareSerial.h" // Libreria seriale del software #include // Libreria per LCD FPS_GT511C3 fps (4, 5); // FPS connesso a D4 e D5 const int rs = 6, en = 7, d4 = 8, d5 = 9, d6 = 10, d7 = 11; // Indica il numero di pin per la connessione LCD LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Inizializza il metodo LCD

All'interno della funzione di configurazione , visualizziamo alcuni messaggi introduttivi sul display LCD e quindi inizializziamo il modulo FPS. Il comando fps.SetLED (true) accenderà il led blu sul sensore, è possibile spegnerlo da fps.SetLED (false) quando non è richiesto in quanto riscalderebbe il sensore se lasciato acceso continuamente. Abbiamo anche realizzato il pin D2 come pin di ingresso e lo abbiamo collegato alla resistenza interna di pull-up in modo da collegare un pulsante al pin.

void setup () { Serial.begin (9600); lcd.begin (16, 2); // Inizializza 16 * 2 LCD lcd.print ("GT511C3 FPS"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("con Arduino"); // Ritardo riga 2 messaggio introduttivo (2000); lcd.clear (); fps.Open (); // invia un comando seriale per inizializzare fp fps.SetLED (true); // attiva il LED in modo che fps possa vedere l'impronta digitale pinMode (2, INPUT_PULLUP); // Collega al resistore di pull up interno come pin di ingresso }

All'interno della funzione void loop dobbiamo controllare se il pulsante è premuto, se premuto registreremo un nuovo dito e salveremo il suo modello con un numero ID utilizzando la funzione di registrazione. In caso contrario, continueremo ad aspettare che un dito venga premuto nel sensore. Se premuto identificheremo l'impronta digitale confrontandola con tutti i modelli di impronte digitali registrati utilizzando il metodo 1: N. Una volta individuato il numero ID, verrà visualizzato il benvenuto seguito dal numero ID. Se l'impronta digitale non corrisponde a nessuna delle dita registrate, il conteggio degli ID sarà 200, in tal caso verrà visualizzato il benvenuto sconosciuto.

if (digitalRead (2)) // Se il pulsante è stato premuto { Enroll (); // Registra un'impronta digitale } // Identifica il test dell'impronta digitale if (fps.IsPressFinger ()) { fps.CaptureFinger (false); int id = fps.Identify1_N (); lcd.clear (); lcd.print ("Benvenuto:"); if (id == 200) lcd.print ("Unkown"); // Se non riconosciuto lcd.print (id); ritardo (1000); }

La funzione di registrazione dovrebbe richiedere tre input di esempio per registrare correttamente un dito. Una volta registrato, verrà creato un modello per quel particolare dito che non verrà eliminato a meno che l'utente non lo abbia forzato tramite i comandi HEX. Il codice per registrare un dito è mostrato di seguito. Il metodo IsPressFinger viene utilizzato per verificare se viene rilevato un dito, in caso affermativo l'immagine viene acquisita utilizzando CaptureFinger e infine Enroll1, Enroll2 e Enroll3 vengono utilizzati per tre diversi campioni per registrare correttamente un dito. Il display LCD visualizza il numero ID del dito se registrato con successo, altrimenti visualizzerebbe un messaggio di errore con codice. Codice 1 significa che l'impronta digitale non è stata acquisita chiaramente e quindi devi riprovare. Il codice 2 è un'indicazione di errore di memoria e il codice 3 indica che il dito è già stato registrato.

void Enroll () // Funzione di registrazione dal programma exmaple della libreria { int register = 0; bool usedid = true; while (usedid == true) { usedid = fps.CheckEnrolled (registerid); if (usedid == true) registerid ++; } fps.EnrollStart (registerid); // registra lcd.print ("Enroll #"); lcd.print (registerid); while (fps.IsPressFinger () == false) ritardo (100); bool bret = fps.CaptureFinger (true); int iret = 0; if (bret! = false) { lcd.clear (); lcd.print ("Rimuovi dito"); fps.Enroll1 (); while (fps.IsPressFinger () == true) ritardo (100); lcd.clear (); lcd.print ("Premi ancora"); while (fps.IsPressFinger () == false) ritardo (100); bret = fps.CaptureFinger (true); if (bret! = false) { lcd.clear (); lcd.print ("Rimuovi dito"); fps.Enroll2 (); while (fps.IsPressFinger () == true) ritardo (100); lcd.clear (); lcd.print ("Premi ancora una volta"); while (fps.IsPressFinger () == false) ritardo (100); bret = fps.CaptureFinger (true); if (bret! = false) { lcd.clear (); lcd.print ("Rimuovi dito"); iret = fps.Enroll3 (); if (iret == 0) { lcd.clear (); lcd.print ("Iscrizione riuscita"); } altro { lcd.clear (); lcd.print ("Registrazione non riuscita:"); lcd.print (iret); } } else lcd.print ("Fallito 1"); } else lcd.print ("Failed 2"); } else lcd.print ("Fallito 3"); }

Funzionamento del sensore di impronte digitali GT511C3 con Arduino

Ora che il nostro hardware e il nostro codice sono pronti, è il momento di testare il nostro progetto. Carica il codice su Arduino e accendilo, sto solo usando la porta micro-usb per alimentare il progetto. All'avvio dovremmo vedere il messaggio di introduzione sul display LCD e quindi dovrebbe visualizzare "Ciao!..". Ciò significa che FPS è pronto per la scansione del dito, se viene premuto un dito registrato, verrà visualizzato "Benvenuto" seguito dal numero ID di quel dito come mostrato di seguito.

Se è necessario registrare un nuovo dito, è possibile utilizzare il pulsante per entrare in modalità di registrazione e seguire le istruzioni del display LCD per registrare un dito. Dopo che il processo di registrazione è completo, il display LCD visualizzerà nuovamente "Ciao!.." per indicare che è stato letto per identificare nuovamente le dita. La lavorazione completa si trova nel video linkato di seguito.

Da qui puoi sviluppare molte cose interessanti su questo utilizzando il modulo sensore di impronte digitali. Spero che tu abbia capito il tutorial e ti sia piaciuto costruire qualcosa di utile, se hai domande lasciale nella sezione commenti o usa i forum per altre domande tecniche.