Sebbene sia possibile accedere a sistemi sicuri tramite password e chiavi, entrambe le opzioni possono essere scomode e facili da dimenticare. In questo tutorial impareremo come utilizzare il modulo FPM10A con la libreria Adafruit Arduino per creare sistema biometrico impronte digitali.

Per tradizione, iniziamo con i componenti per la nostra lezione.

Dettagli

• Modulo impronte digitali FPM10A
• ArduinoUno

Librerie e software

• IDE Arduino
• Libreria di impronte digitali Adafruit

Schema di collegamento

Lo schema di connessione del modulo FPM10A e Arduino Uno deve essere collegato insieme come nella figura sopra. Entreremo più nel dettaglio nel passaggio successivo.

Colleghiamo i componenti

Iniziare con questo modulo è incredibilmente facile grazie al fatto che utilizza una porta seriale per la comunicazione. Tuttavia, poiché Arduino Uno ha solo una porta seriale hardware, è necessario utilizzare la porta seriale tramite Software utilizzando i pin 2 e 3 per comunicare con il modulo impronte digitali (la porta seriale hardware è riservata alla comunicazione con il PC).

Il cavo a nastro fornito con il modulo FPM10A non è molto adatto agli hobby, poiché i fili si trovano nel case a un passo di 1,27 mm, quindi abbiamo tagliato un lato e quindi collegato i fili ai ponticelli.

Installazione e utilizzo della libreria

Il primo passaggio nell'utilizzo dell'FPM10A consiste nell'installare la libreria Adafruit Fingerprint, che può essere eseguita utilizzando il Gestore libreria. Apri l'IDE di Arduino e vai a:

Schizzo → Includi libreria → Gestisci librerie

Quando il Library Manager carica una ricerca "Fingerprint", il primo risultato dovrebbe essere Adafruit Fingerprint Library. Installalo.

Dopo aver installato la libreria, è il momento di creare nuovo progetto Arduino. Clic File → Nuovo , quindi salva il progetto nella tua cartella. A questo punto, apri la cartella del progetto e copiaci dentro il file "fingerprint.h".

Questo fascicolo speciale intestazione scritta per semplificare l'utilizzo della libreria di impronte digitali. Il file di intestazione ha solo tre funzioni:

• fingerprint_setup () - configura la porta seriale per 9600 baud e si connette al modulo;
• readFingerprint() - funzione di polling che restituisce -1 se qualcosa è andato storto o restituisce informazioni che è stata trovata un'impronta digitale corretta
• enrollFingerprint (int id) - aggiunge un'impronta digitale al sistema con l'id assegnato "id".

Per includere questo file nel tuo progetto, usa semplicemente il comando include come mostrato di seguito:

#include "impronta.h"

La prima funzione che deve essere chiamata in setup() è fingerprint_setup(), che si connette automaticamente al modulo e conferma che tutto funziona.

Void setup() ( fingerprint_setup(); )

Per aggiungere una nuova impronta digitale, chiama la funzione enrollFingerprint(id).

Questo restituirà -1 se fallisce. In caso contrario, i valori indicano la corretta registrazione delle impronte digitali. L'identificatore passava a questa funzione un riferimento all'impronta digitale scansionata e ogni impronta digitale aveva un numero di identificazione univoco.

iscriviimpronta digitale(0x01);

Codice Arduino

Puoi copiare lo schizzo finale per la nostra scheda Arduino qui sotto:

#include "fingerprint.h" void setup() ( fingerprint_setup(); ) void loop() ( // Crea una nuova voce per l'impronta digitale enrollFingerprint(0x01); delay(1000); // Richiedi la voce Serial.println(" \nUSER RICHIESTA DI ACCESSO... POSIZIONA IL DITO SUL SENSORE \n"); while(readFingerprint() == -1); Serial.println(" \nACCESS GRANTED \n"); Serial.println(" \nFingerprint trust: " + String (confidenza) + "\n"); ritardo(3000); )

Principio di funzionamento

Quando abiliti questo progetto, ti chiederà prima di posizionare il dito sullo scanner. Se lo scanner è in grado di leggere le tue impronte digitali, ti chiederà di rimuovere e quindi sostituire il dito con lo scanner. Ciò dovrebbe far sì che lo scanner aggiunga correttamente l'impronta digitale all'ID 1 e posizionare il dito sullo scanner dovrebbe comportare l'accesso al sistema.

Questo design può essere facilmente esteso per includere elettroserrature e relè per consentire agli utenti autorizzati di apportare modifiche e sbloccare il sistema. Una volta che il tuo progetto è pronto, installa nuovo scanner in porte, armadi, casseforti, finestre, impianti elettrici, computer e molto altro!

Per creare un collegamento con il sensore di impronte digitali, ho utilizzato le istruzioni di Josh Hawley (istruzioni per il download diretto).

Per eseguire il debug del funzionamento dello scanner di impronte digitali con un display a lettere, è necessario eseguire la sincronizzazione.

Il sensore di impronte digitali dispone di una propria memoria per l'archiviazione delle immagini acquisite. Quindi, dopo che il sensore inizia a funzionare, scarica questo aggiungendolo al database delle impronte digitali all'indirizzo 0. Apri la console di gestione sul tuo computer e segui le istruzioni.

Codici - Lampeggio Esempio:

/* Esempio di libreria per il controllo del Finger Print Scanner (FPS) GT-511C3 */ #include "FPS_GT511C3.h" #include "SoftwareSerial.h" //Configurazione hardware - FPS connesso a: //pin digitale 10(arduino rx, fps tx) // pin digitale 11 (arduino tx - resistenza da 560 ohm fps tx - resistenza da 1000 ohm - terra) // questo porta la linea 5v tx a circa 3,2 v in modo da non friggere i nostri fps FPS_GT511C3 fps (10, 11); void setup()( Serial.begin(9600); fps.UseSerialDebug = true; // così puoi vedere i messaggi nella schermata di debug seriale fps.Open(); ) void loop()( // FPS Blink LED Test fps .SetLED(true); // accendi il LED all'interno del ritardo fps(1000); fps.SetLED(false);// spegnere il LED all'interno del ritardo fps (1000); )

Codici - Iscriviti Esempio:

/* FPS_Enroll.ino - Esempio di libreria per il controllo dello scanner per impronte digitali GT-511C3 (FPS) */ #include "FPS_GT511C3.h" #include "SoftwareSerial.h" //Configurazione hardware - FPS connesso a: //pin digitale 10 (arduino rx, fps tx) // pin digitale 11 (arduino tx - resistenza 560ohm fps tx - resistenza 1000ohm - terra) // questo porta la linea 5v tx a circa 3,2v in modo da non friggere i nostri fps FPS_GT511C3 fps(10, undici); void setup()( Serial.begin(9600); delay(100); fps.Open(); fps.SetLED(true); Enroll(); ) void Enroll()( // Test di registrazione // trova l'id di registrazione aperto int enrollid = 0; fps.EnrollStart(enrollid); // iscrivi Serial.print("Premi il dito per iscrivere #"); Serial.println(enrollid); while(fps.IsPressFinger() == false) delay(100) ; bool bret = fps.CaptureFinger(true); int iret = 0; if (bret != false) ( Serial.println("Rimuovi dito"); fps.Enroll1(); while(fps.IsPressFinger() == true ) delay(100); Serial.println("Premi di nuovo lo stesso dito"); while(fps.IsPressFinger() == false) delay(100); bret = fps.CaptureFinger(true); if (bret != false) ( Serial.println("Rimuovi dito"); fps.Enroll2(); while(fps.IsPressFinger() == true) delay(100); Serial.println("Premi di nuovo lo stesso dito"); while(fps. IsPressFinger() == false) delay(100); bret = fps.CaptureFinger(true); if (bret != false) ( Serial.println("Rimuovi dito"); iret = fps.Enroll3(); if (iret == 0) ( Serial.println("Registrazione riuscita"); ) else ( Serial.print("Registrazione Fallito con codice di errore:"); Serial.println(iret); ) ) else Serial.println("Impossibile acquisire il terzo dito"); ) else Serial.println("Impossibile acquisire il secondo dito"); ) else Serial.println( "Impossibile acquisire il primo dito"); ) void loop()( delay(100000); )

File di sincronizzazione:

File di registrazione delle miniature:

Passaggio 7: programmazione del processore ATtiny85

Il microchip ATtiny85 è economico e completamente compatibile con la scheda Arduino, probabilmente la migliore parte elettrica mai realizzata!

Il programmatore Arduino è necessario anche per eseguire il flashing del chip ATmega328 che controlla il funzionamento dell'LCD.

Nel dispositivo assemblato, il processore ATtiny eseguirà comandi molto semplici: verifica la presenza di un segnale dall'ATmega e apri la porta del garage quando il segnale viene confermato.

Per programmare il funzionamento del processore, deve essere collegato utilizzando tagliere al programmatore insieme a un condensatore da 10uF come mostrato nell'immagine qui sotto.

E poi carica codice finale e seguire le raccomandazioni istruzioni da High-Low Tech.

Successivamente, l'uscita 13 sulla scheda Arduino, collegata al LED, deve essere impostata sullo stato HIGH per tenere traccia del lavoro sull'indicazione luminosa.

Codice finale per ATminuscolo :

//fpsAttiny di Nodcah //Riceve un breve segnale dal modulo principale per chiudere un relè void setup()( pinMode(2,OUTPUT); //indicatore led tramite resistore da 10K pinMode(4,OUTPUT); //trasistor pin che apre il garage pinMode(0,INPUT); //input delay(500); //dà alle cose il tempo di avviarsi digitalWrite(2, HIGH); //indicatore LED ) void loop()( if(digitalRead(0)) ( //semplice schema per attivare il transistor delay(125); if(digitalRead(0)==false)( delay(55); //i tempi sono disattivati ​​perché il timer di ATtiny non è perfetto if(digitalRead( 0))( delay(55); if(digitalRead(0)==false)( delay(55); if(digitalRead(0))( delay(55); if(digitalRead(0)==false)( digitalWrite (4, HIGH); //il transistor "preme" il pulsante delay(1000); digitalWrite(4,LOW); digitalWrite(2,LOW); delay(1000); digitalWrite(2, HIGH); ) ) ) ) ) ) )

Serratura biometrica - codice finale, taglio copertura, predisposizione garage Orologio GPS su Arduino Serratura biometrica - Layout e assemblaggio LCD

Dal momento che non ho una macchina, non devo portare le mie chiavi con me ovunque. Per questo motivo, mi sono ritrovato più volte senza chiavi fuori casa e ho dovuto aspettare che uno dei parenti tornasse a casa e mi facesse entrare, e ad un certo punto ho deciso che dovevo fare qualcosa al riguardo e ha progettato una serratura da garage fatta in casa.

In questo progetto, ti mostrerò come realizzare un blocco delle impronte digitali sulla porta d'ingresso.

Passaggio 1: materiali

Ecco un elenco di materiali e strumenti necessari.

Elettronica:

• Scanner di impronte digitali (e connettore JST)
• Kit LCD (con ATmega328)
• ATtiny85
• Transistor NPN
• Altoparlante-tweeter
• filo dell'altoparlante
• Caso (nel passaggio 9 ci saranno i file per la stampa 3D)
• Pellicola di rame
• Regolatore di tensione 5V
• Batteria 9V
• Connettore batteria 9V
• Interruttore SPDT

Per comodità, allegherò una lista dei desideri già pronta sul sito web di Sparkfun.

Attrezzo:

• Saldatore e saldatura
• Nastro isolante
• Fili e ponticelli
• Tronchesi / spogliarellista
• scheda di prototipazione
• Vari resistori
• viti
• Trapano
• Diversi LED per il test
• Scheda FTDI 5V
• pistola per colla a caldo
• Accesso a una stampante 3D
• Opzionale: presa IC (8 pin per ATtiny e 28 pin per ATmega)
• Opzionale: un'altra scheda Arduino / condensatore da 10uF (dettagli al punto 5)

Passaggio 2: schema del dispositivo

Il kit LCD acquistato da Sparkfun veniva fornito con un ATmega328 che guidava il display. L'ATmega328 è piuttosto potente e può essere utilizzato non solo per il controllo del display, ma anche per altre attività. In considerazione di ciò, possiamo usarlo al posto di Arduino per comunicare con lo scanner di impronte digitali e inviare comandi all'ATtiny85, controllare il display e il cicalino.

Per evitare che la serratura biometrica della porta funzioni sempre, ho integrato un interruttore che funziona nel momento in cui la valigia si chiude. Se la custodia è chiusa, il dispositivo non è alimentato e risparmiamo le risorse della batteria.

Nota importante: lo scanner di impronte digitali funziona a 3,3 V, quindi consiglio di utilizzare un partitore di tensione che convertirà i segnali dall'ATmega a 3,2 V. Il partitore di tensione è costituito da una resistenza da 560 ohm tra D10 / pin 2 dello scanner e una resistenza da 1 kΩ tra GND / pin 2 dello scanner.

Piedinatura LCD:

• D10 - pin 1 dello scanner (filo nero)
• D11 - pin 2 dello scanner (tramite partitore di tensione)
• D12-ATtiny85
• D13 - Squittio

Piedinatura ATtiny85:

• Pin 5 (0 nel codice del programma) - input da ATmega
• Pin 3 (4 nel codice del programma) - transistor / LED giallo
• Pin 7 (2 nel codice del programma) - LED di indicazione

Passaggio 3: assemblaggio dei componenti dal kit LCD

Il nome del passaggio parla da solo: guida rapida/guida all'assemblaggio pratica e pratica

Passaggio 4: assemblaggio del circuito sulla scheda di prototipazione

Il posizionamento dei componenti sulla scheda dipende da te, prova solo a saldare i fili in modo che guardino in una direzione e non si rompano.

Dopo l'assemblaggio, ho coperto la parte superiore e inferiore della scheda con colla a caldo, che ha fissato e isolato gli elementi del circuito. La colla a caldo non danneggerà il chip.

Come con la scheda principale, salda tutto alla scheda ATtiny e applica la colla a caldo per fissare e isolare i componenti. Il regolatore di tensione può diventare molto caldo, quindi è una buona idea non applicare colla a caldo su di esso o su superfici vicine. È anche meglio non incollare a caldo la scheda ATtiny, poiché potresti volerla rimuovere e riprogrammare.

Passaggio 5: programmazione dell'ATmega328

Come accennato nel passaggio 2, l'ATmega328 ha un processore sufficientemente potente e pin sufficienti per pilotare l'LCD mentre pilota altri componenti aggiuntivi. Per raggiungere questo obiettivo, è necessario programmare il chip.

Se hai un Arduino Uno o Duemilanove, puoi semplicemente rimuovere il chip da loro e sostituirlo con quello fornito con il kit. In alternativa, puoi trovare una scheda FTDI Basic Breakout (5V) e le intestazioni di saldatura su un lato (vedi le immagini nel passaggio 3)

Dovrai inoltre inserire il codice nella modalità "Duemilanove con ATmega328".

Codice qui sotto - programma di lavoro per verificare la funzionalità del dispositivo.

#include "LiquidCrystal.h" LiquidCrystal lcd(2,3,4,5,6,7,8); void setup() ( pinMode(9, OUTPUT); // retroilluminazione pinMode(13, OUTPUT); // tweeter lcd.begin(16, 2); // 16 caratteri di larghezza, 2 caratteri di altezza digitalWrite(9, HIGH) ; //attiva la retroilluminazione lcd.print(" Hello world!"); //centra il testo con spazi delay(2000); ) void loop() ( //il tweeter si accende e si spegne, il suo stato viene visualizzato sul display lcd.clear( ); lcd.print(" Buzzer attivo "); tone(13, 262, 1000); delay(1000); lcd.clear(); lcd.print(" Buzzer spento "); ritardo (1000); ) File

Passaggio 6: configurare il lettore di impronte digitali

Per comunicare con lo scanner, ho usato questa libreria. Link per il download diretto.

Per verificare se il codice funziona, scarica questo programma di lampeggio.

Lo scanner di impronte digitali dispone di una propria memoria integrata per l'archiviazione dei dati. Quindi, dopo esserti assicurato che lo scanner funzioni, scarica questo programma per aggiungere la tua impronta digitale al database con l'id #0. Apri la console seriale e segui semplicemente le istruzioni.

Programma di lampeggio del LED del test dello scanner

/* Questo semplice codice accende e spegne il LED. Serve per capire se la comunicazione sta funzionando. */ #include "FPS_GT511C3.h" #include "SoftwareSerial.h" //Configurazione hardware - lettore d'impronte collegato a: //pin digitale 10(arduino rx, fps tx) //pin digitale 11(arduino tx - resistore 560ohm fps tx - resistenza 1000ohm - GND) //questo abbassa 5v tx a circa 3.2v e non masterizzeremo il nostro scanner FPS_GT511C3 fps(10, 11); void setup()( Serial.begin(9600); fps.UseSerialDebug = true; // sarai in grado di vedere i messaggi sulla schermata di debug seriale fps.Open(); ) void loop()( // prova il fps.SetLED(true); // accende il LED all'interno dello scanner delay(1000); fps.SetLED(false);// spegne il LED all'interno dello scanner delay(1000); )

Software di registrazione dei dati dello scanner

#include "FPS_GT511C3.h" #include "SoftwareSerial.h" //Configurazione hardware - lettore d'impronte collegato a: //pin digitale 10(arduino rx, fps tx) //pin digitale 11(arduino tx - resistenza 560ohm fps tx - resistenza 1000ohm - GND) //questo abbassa 5v tx a circa 3.2v e non bruceremo il nostro scanner FPS_GT511C3 fps(10, 11); void setup()( Serial.begin(9600); delay(100); fps.Open(); fps.SetLED(true); Enroll(); ) void Enroll()( // Test di registrazione // cerca l'id aperto int idiscrizione = 0; fps.EnrollStart(idiscrizione); // registrazione Serial.print("Premi il dito per iscrivere #"); Serial.println(idiscrizione); while(fps.IsPressFinger() == false) delay(100) ; bool bret = fps.CaptureFinger(true); int iret = 0; if (bret != false) ( Serial.println("Rimuovi dito"); fps.Enroll1(); while(fps.IsPressFinger() == true ) delay(100); Serial.println("Premi di nuovo lo stesso dito"); while(fps.IsPressFinger() == false) delay(100); bret = fps.CaptureFinger(true); if (bret != false) ( Serial.println("Rimuovi dito"); fps.Enroll2(); while(fps.IsPressFinger() == true) delay(100); Serial.println("Premi di nuovo lo stesso dito"); while(fps. IsPressFinger () == false) delay(100); bret = fps.CaptureFinger(true); if (bret != false) ( Serial.println("Rimuovi dito"); iret = fps.Enroll3(); if (iret = = 0) ( Serial.println("Registrazione riuscita"); ) else ( Serial.print("Registrazione non riuscita con codice di errore:"); Serial.println(iret); ) ) else Serial.println("Impossibile acquisire il terzo dito"); ) else Serial.println("Impossibile acquisire il secondo dito"); ) else Serial.println("Impossibile acquisire il primo dito"); ) void loop()( delay(100000); ) File

Passaggio 7: programma ATtiny85

ATtiny85 è qualcosa come un Arduino economico assemblato in un chip. L'ATtiny85 può essere programmato con altri Arduino, incluso l'ATmega328 che si trova nel nostro kit LCD. Il progetto lo utilizza per eseguire comandi molto semplici: controlla il segnale dall'ATmega e apri il gate se il segnale è corretto.

Per programmarlo collegare il tutto secondo le foto allegate. Quindi scarica i file necessari e segui queste istruzioni.

Una volta caricato il codice, il pin 13 di Arduino (LED integrato) dovrebbe accendersi, indicando che il codice è stato caricato.

Codice finale:

//Riceve un breve segnale dal modulo principale per chiudere il relè void setup()( pinMode(2,OUTPUT); //Indicazione LED attraverso una resistenza da 10K pinMode(4,OUTPUT); //pin transistor che apre il garage pinMode (0,INPUT ); // inserisci delay(500); // dai al dispositivo il tempo di avviare digitalWrite(2, HIGH); // LED di indicazione ) void loop()( if(digitalRead(0))( // simple modello per la commutazione del ritardo del transistor (125); if(digitalRead(0)==false)( delay(55); //aspetta perché ATtiny timer non è perfetto if(digitalRead(0))( delay(55); if(digitalRead (0)= =false)( delay(55); if(digitalRead(0))( delay(55); if(digitalRead(0)==false)( digitalWrite(4, HIGH); //transistor "preme" pulsante delay(1000 ); digitalWrite(4,LOW); digitalWrite(2,LOW); delay(1000); digitalWrite(2, HIGH); ) ) ) ) ) ) ) File

Passaggio 8: codice finale

Di seguito è riportato un programma Arduino che ho scritto utilizzando le librerie dello scanner e del display. Per far capire cosa sta succedendo in ogni parte del programma, ho cercato di commentare tutto nel miglior modo possibile. Dopo aver scaricato questo codice, tutto dovrebbe funzionare e non resta che integrare il sistema nella porta.

Attenzione: se la libreria dello scanner non funziona, prova a utilizzare vecchia versione IDE Arduino.

Codice per ATmega238:

#include "LiquidCrystal.h" //libreria del display #include "FPS_GT511C3.h" //libreria fps (scanner di impronte digitali) #include "SoftwareSerial.h" //utilizzato dalla libreria dello scanner //Configura il display e i pin dello scanner LiquidCrystal lcd (2, 3, 4, 5, 6, 7, 8); //mostra la piedinatura FPS_GT511C3 fps(10, 11); //RX, TX booleano isFinger = falso; //true se la libreria fps rileva un dito sullo scanner //output pins const int buzzerPin = 13; const int retroilluminazionePin = 9; const int attinyPin = 12; const String idNames = ( "self","Fratello", "Ryan", "Mamma", "Papà", "Zietta", "Nonna", "Zeide", "Persona", "persona", "Pollice"); void setup()( //imposta le uscite pinMode(buzzerPin, OUTPUT); pinMode(backlightPin, OUTPUT); pinMode(attinyPin, OUTPUT); //per il debug //Serial.begin(9600); fps.UseSerialDebug = false; //diventa vero per il debug fps tramite porta seriale //inizializzazione delle librerie lcd.begin(16,2);digitalWrite(backlightPin, HIGH); // retroilluminazione LCD fps.Open(); fps SetLED(vero); //LED su fps //caricamento suono for(int i=0; i<30; i++){ tone(buzzerPin, 50+10*i, 30); delay(30); } tone(buzzerPin, 350); //вывод стартового сообщения lcd.print("Put your finger "); //команда вывода на экран lcd.setCursor(0, 1); //устанавливаем курсор на нулевую колонку первой строки lcd.print(" on the scanner "); delay(150); noTone(buzzerPin); //останавливаем стартовый звук } void loop(){ //сканируем и распознаём отпечаток, когда приложен палец waitForFinger(); lcd.clear(); //очищаем экран и устанавливаем курсов в положение 0,0 fps.CaptureFinger(false); //захватываем отпечаток для идентификации int id = fps.Identify1_N(); //идентифицируем отпечаток и сохраняем id if(id <= 10){ lcd.print(" Access granted "); //сообщение об успехе lcd.setCursor(0,1); //выводим на экран имя когда дверь открывается String message = " Hey " + idNames + "!"; lcd.print(message); tone(buzzerPin, 262, 1000); delay(1500); //отправляем сигнал для открытия двери digitalWrite(attinyPin, HIGH); //первый импульс синхронизирует задержку (10ms) delay(5); digitalWrite(attinyPin, LOW); delay(3); digitalWrite(attinyPin, HIGH); //следующие два - открывают дверь delay(15); digitalWrite(attinyPin, LOW); delay(5); digitalWrite(attinyPin, HIGH); delay(10); digitalWrite(attinyPin, LOW); delay(1000); lcd.clear(); lcd.print("Don"t forget to "); lcd.setCursor(0,1); lcd.print(" shut me off! "); delay(2000); waitForFinger(); //нажмите чтобы продолжить запись while(true){ //сохраняет новый отпечаток //выводит сообщение на экран lcd.clear(); lcd.print(centerText("So you want to")); lcd.setCursor(0,1); lcd.print(centerText("scan a new one?")); delay(2000); //Скопировано и слегка модифицировано из примера регистрации данных: int enrollid = 11; //выбираете какой id переписать\создать //отпустите палец, когда хотите записать id/имя, напечатанное на экране waitForFinger(); //ждёт, когда будет нажат fps while(enrollid==11){ for (int i = 1; i1){ lcd.print(i); enrollid = i-1; break; } } } //предупреждение, если в данном слоте уже есть данные if(fps.CheckEnrolled(enrollid)){ lcd.clear(); lcd.print(" Warning! ID #"); lcd.print(enrollid); lcd.setCursor(0,1); lcd.print(" has data. OK? "); delay(2500); waitForFinger(); //ждёт, когда будет нажат fps fps.DeleteID(enrollid); //удаляет данные delay(100); } //Enroll fps.EnrollStart(enrollid); lcd.clear(); lcd.print("Place finger to "); lcd.setCursor(0,1); lcd.print("enroll #"); lcd.print(enrollid); //выводит id, который был добавлен waitForFinger(); //ждёт, когда будет нажат fps //захватывает отпечаток и сохраняет его в память трижды для точности данных bool bret = fps.CaptureFinger(true); //картинка высокого качества для записи int iret = 0; //в случае ошибки if (bret != false){ //первая регистрация lcd.clear(); lcd.print(" Remove finger "); fps.Enroll1(); while(fps.IsPressFinger() == true) delay(100); //ждёт пока уберут палец lcd.clear(); lcd.print(" Press again "); waitForFinger(); //ждёт, когда будет нажат fps bret = fps.CaptureFinger(true); if (bret != false){ //вторая регистрация lcd.clear(); lcd.print(" Remove finger "); fps.Enroll2(); while(fps.IsPressFinger() == true) delay(100); lcd.clear(); lcd.print("Press yet again "); waitForFinger(); bret = fps.CaptureFinger(true); if (bret != false){ //третья регистрация iret = fps.Enroll3(); if (iret == 0){ //проверяет, были ли какие-нибудь ошибки lcd.clear(); lcd.print(" Success! "); delay(2000); beep(); //выключает Ардуино } else{ //запускает этот код в случае любой ошибки lcd.clear(); lcd.print("Fail. Try again "); delay(1000); } } lcd.clear(); lcd.print(" Failed 3rd "); //ошибка на третьей записи delay(1000); } lcd.clear(); lcd.print(" Failed 2nd "); //ошибка на второй записи delay(1000); } lcd.clear(); lcd.print(" Failed 1st "); //ошибка на первой записи delay(1000); } } else{ lcd.print("Fingerprint is"); //если отпечаток не распознан lcd.setCursor(0,1); lcd.print(" unverified "); delay(2000); lcd.clear(); lcd.print("Please try again"); lcd.setCursor(0,1); lcd.print("Use your pointer"); //pointer - указательный палец (можете использовать любой и заменить это слово) delay(500); } delay(250); } void beep(){ //издаёт звуки, чтобы кто-нибудь закрыл кейс lcd.clear(); lcd.print("Please close the"); lcd.setCursor(0,1); lcd.print(" case! "); for(int i=0;i=80 && !fps.IsPressFinger()){ beep(); } } timer = 0; //обнуляет таймер как только функция завершится } String centerText(String s) { //центрует текст на дисплее, чтобы он лучше смотрелся while(16-s.length()>1)( //se il testo deve essere centrato s = " " + s + " "; //aggiunge spazi uniformemente su entrambi i lati ) return s; ) File

Per creare un semplice sistema di sicurezza biometrico per proteggere la tua auto da accessi non autorizzati, abbiamo bisogno di un sensore di impronte digitali e di un microcontrollore Arduino. Questo progetto utilizza il tutorial Adafruit. Per facilità di ripetizione, viene utilizzato il codice completo di questo materiale, con piccole modifiche.

Per prima cosa modifichiamo il sistema di lancio del veicolo. La connessione principale è il filo IG dall'interruttore di accensione, che fornisce alimentazione al regolatore di tensione, quindi al microcontrollore Arduino per accenderlo e spegnerlo e scansionare il dito sul sensore per 10 secondi. Quando l'impronta digitale corrisponde, il sistema attiva una scatola relè che controlla il relè di avviamento. Ora puoi avviare il motore. Dopo 10 secondi, il sensore di impronte digitali si spegne. Puoi riaccenderlo ripetendo il ciclo di avvio dell'accensione. Se entro 10 secondi il sensore non rileva un'impronta digitale o l'impronta digitale non corrisponde al riferimento, il sistema di avviamento viene disabilitato e il motore non si avvia.

Poiché ogni veicolo ha un diverso sistema di configurazione di avviamento, è necessario consultare un elettricista del veicolo o rivedere lo schema elettrico prima di modificare il sistema di avviamento del motore.

Si prega di notare che il sensore di impronte digitali non avvia il motore. Attiva e disattiva solo il relè di avviamento, che impedisce o consente l'avviamento del motore.

In questo progetto, l'antifurto è installato su una coupé Mitsubishi Lancer 2000 a 2 porte.

Passaggio 1: componenti utilizzati

Passaggio 4: download del programma principale

Collegare il sensore di impronte digitali come mostrato nello schema e scaricare il programma principale. Collegare un LED e una resistenza al pin 12 per verificare se il funzionamento è corretto.

Il programma funziona secondo il principio del materiale di formazione Adafruit Fingerprint. Tuttavia, ho modificato leggermente il codice di programmazione e ho aggiunto un timer per spegnere il sensore dopo 10 secondi per evitare distrazioni dovute al lampeggiamento del LED del sensore.

Passaggio 5: assemblaggio parte 1

Rimuovere le viti sotto il cruscotto. Allentare la leva di rilascio del fermo del cofano. Rimuovere la parte inferiore del cruscotto. Posizionare il sensore in uno spazio libero.

Passaggio 6: assemblaggio parte 2

Misurare la distanza richiesta e ritagliare una piccola area per installare saldamente il sensore.

Passaggio 7: assemblaggio parte 3

L'Arduino Uno è meglio posizionato dietro il sensore di impronte digitali. Ho tagliato un po' l'impronta per portare la scheda Arduino Uno nella posizione corretta.

Per creare un tale progetto, l'autore ha dovuto modificare il sistema di lancio del suo veicolo. La connessione principale è il conduttore IG dall'interruttore di accensione, attraverso il quale la tensione viene fornita al regolatore di tensione, quindi all'Arduino stesso per accenderlo, nonché accendere il sensore di scansione delle dita. Se la scansione delle dita ha esito positivo, il sistema attiva la scatola relè e controlla il relè di avviamento. Ora puoi avviare la macchina. Il sensore funziona per 10 secondi e può essere riavviato ripetendo il ciclo di avvio dell'accensione. Se, nel tempo assegnato, il sensore non ha rilevato un'impronta digitale o non corrisponde a quella specificata, il sistema di avviamento verrà disabilitato e il motore non si avvierà.

Poiché ogni auto ha il proprio sistema di configurazione dell'avviamento, è necessario esaminare il circuito elettrico prima di modificare il sistema di avviamento del motore.

Questo articolo descrive come collegare un dispositivo antifurto a una coupé a 2 porte Mitsubishi Lancer 2000.

Materiali:
-Arduino Uno.
- Sensore di impronte digitali.
- Alimentazione elettrica.
- Blocco relè.
- Transistore NPN BC547B
- Resistenza 1 kOhm

Schema elettrico:
Il circuito è leggermente modificato in base ai componenti utilizzati. Si prega di notare che questo è valido solo per questo modello di veicolo.

Passaggio 1 Preparazione dei componenti software:
L'IDE di Arduino scarica e aggiunge il file .
Il file dalla libreria blank.ino viene caricato in Arduino, che fungerà da interfaccia tra il sensore e il microcontrollore.
Il programma è installato e il sensore è collegato ad Arduino come mostrato nel diagramma. Quindi l'impronta digitale viene caricata tramite il programma installato.

Il sensore è ora collegato come mostrato nello schema seguente. Successivamente, l'autore procede al download del programma principale. Un LED con un resistore è collegato al pin 12.

Il programma funzionerà principalmente sul tutorial Adafruit Fingerprint. Al codice del programma è stato aggiunto solo un timer di spegnimento del sensore di 10 secondi. Puoi scaricare il codice sotto l'articolo.

Passaggio 3 assemblaggio:
Parte 1:
Per cominciare, le viti sotto il cruscotto sono svitate. La parte inferiore del pannello viene rimossa e il sensore può essere posizionato nello spazio libero.

Parte 2:
Nella posizione selezionata per il sensore, viene tagliata una zona per la sua installazione affidabile.

parte 3:
La scheda Arduino è installata dietro il sensore di impronte digitali. Il punto in cui installare Arduino è stato leggermente minato in modo che la scheda potesse assumere la posizione corretta.

parte 4:
L'alimentatore regolato è installato dietro il cruscotto sul lato del conducente.

parte 5:
I restanti componenti dell'apparecchiatura sono collegati secondo lo schema all'inizio dell'articolo.

Fase 4 installazione:
I cavi necessari sono collegati e il dispositivo è installato sotto il cruscotto. L'autore si assicura che non ci siano cortocircuiti.