- Componenti richiesti
- Schema del circuito e spiegazione
- Funzionamento del sensore di impronte digitali con microcontrollore PIC
- Spiegazione della programmazione
Il sensore di impronte digitali, che qualche anno fa vedevamo nei film di fantascienza, è diventato molto comune per verificare l'identità di una persona per vari scopi. Al giorno d'oggi possiamo vedere sistemi basati sulle impronte digitali ovunque nella nostra vita quotidiana come per la presenza negli uffici, la verifica dei dipendenti nelle banche, per il prelievo di contanti o depositi negli sportelli automatici, per la verifica dell'identità negli uffici governativi ecc. Lo abbiamo già interfacciato con Arduino e con Raspberry Pi, oggi interfacciamo il sensore di impronte digitali con il microcontrollore PIC. Utilizzando questo microcontrollore PIC PIC16f877A Finger Print System, possiamo registrare nuove impronte nel sistema e possiamo eliminare le impronte già alimentate. Il funzionamento completo del sistema è stato mostrato nel video riportato alla fine dell'articolo.
Componenti richiesti
- Microcontrollore PIC16f877A
- Modulo impronte digitali
- Pulsanti o tastiera
- LCD 16x2
- Pentola da 10k
- Oscillatore in cristallo da 18,432000 MHz
- Bread Board o PCB (ordinato da JLCPCB)
- Cavi jumper
- LED (opzionale)
- Resistenza 150 ohm -1 k ohm (opzionale)
- 5v di alimentazione
Schema del circuito e spiegazione
In questo progetto di interfacciamento del sensore di impronte digitali del microcontrollore PIC, abbiamo utilizzato 4 pulsanti: questi pulsanti sono usati per il multifunzione. Il tasto 1 viene utilizzato per abbinare l'impronta digitale e incrementare l'ID dell'impronta digitale durante la memorizzazione o l'eliminazione dell'impronta digitale nel sistema. La chiave 2 viene utilizzata per registrare la nuova impronta digitale e per diminuire l'ID dell'impronta digitale durante l'archiviazione o l'eliminazione dell'impronta digitale nel sistema. Il tasto 3 viene utilizzato per eliminare il dito memorizzato dal sistema e il tasto 4 viene utilizzato per OK. Un LED viene utilizzato per indicare che l'impronta digitale viene rilevata o abbinata. Qui abbiamo utilizzato un modulo di impronte digitali che funziona su UART. Quindi qui abbiamo interfacciato questo modulo di impronte digitali con il microcontrollore PIC alla sua velocità di trasmissione predefinita che è 57600.
Quindi, prima di tutto, dobbiamo effettuare tutte le connessioni richieste come mostrato nello schema del circuito di seguito. Le connessioni sono semplici, abbiamo appena collegato il modulo di impronte digitali all'UART del microcontrollore PIC. Un LCD 16x2 viene utilizzato per visualizzare tutti i messaggi. Un potenziometro da 10k viene utilizzato anche con LCD per controllare il contrasto dello stesso. I pin dati LCD 16x2 sono collegati ai pin PORTA. I pin d4, d5, d6 e d7 dell'LCD sono collegati rispettivamente ai pin RA0, RA1, RA2 e RA3 del microcontrollore PIC. Quattro pulsanti (o tastiera) sono collegati ai pin RD0, RD1, RD2 e RD di PORTD. Il LED è anche collegato al pin RC3 della porta PORTC. Qui abbiamo utilizzato un oscillatore a cristallo esterno da 18,432000 MHz per sincronizzare il microcontrollore.
Funzionamento del sensore di impronte digitali con microcontrollore PIC
Il funzionamento di questo progetto è semplice, basta caricare il file esadecimale, generato dal codice sorgente, nel microcontrollore PIC con l'aiuto del programmatore o del masterizzatore PIC (PIckit2 o Pickit3 o altri) e poi vedrai alcuni messaggi di introduzione su LCD e quindi l'utente verrà chiesto di inserire una scelta per le operazioni. Per abbinare l'impronta digitale, l'utente deve premere il tasto 1, quindi il display LCD chiederà di posizionare il dito sul sensore di impronte digitali. Ora, mettendo un dito sul modulo delle impronte digitali, possiamo verificare se le nostre impronte sono già memorizzate o meno. Se la tua impronta digitale è memorizzata, il display LCD mostrerà il messaggio con l'ID di memorizzazione di " ID: 2" simile a un'impronta digitale , altrimenti mostrerà "Non trovato" .
Ora per registrare un'impronta digitale, l' utente deve premere il pulsante di registrazione o il tasto 2 e seguire i messaggi di istruzioni sullo schermo LCD.
Se l'utente vuole cancellare qualsiasi delle impronte digitali, allora l'utente deve premere il cancellazione tasto o il tasto 3. Dopo di che, display chiede per l'ID dell'impronta digitale che deve essere cancellato. Ora utilizzando il pulsante di incremento o il tasto 1 (abbina il pulsante o il tasto 1) e il pulsante di decremento o il tasto 2 (pulsante di registrazione o tasto 2) per l'incremento e il decremento, l'utente può selezionare l'ID dell'impronta digitale salvata e premere OK pulsante per eliminare l'impronta digitale. Per una maggiore comprensione, guarda il video fornito alla fine del progetto.
Interfacciamento con FingerPrint Nota: il programma di questo progetto è un po 'complesso per un principiante. Ma il suo semplice codice di interfacciamento realizzato utilizzando la lettura della scheda tecnica del modulo di impronte digitali r305. Tutte le istruzioni di funzionamento di questo modulo per impronte digitali sono riportate nel datasheet.
Qui abbiamo usato un formato frame per parlare con il modulo fingerprint. Ogni volta che inviamo un comando o un frame di richiesta dati al modulo di impronte digitali, ci risponde con lo stesso formato di frame contenente dati o informazioni relative al comando applicato. Tutti i dati e il formato dei frame di comando sono stati forniti nel manuale utente o nella scheda tecnica del modulo impronte digitali R305.
Spiegazione della programmazione
Nella programmazione abbiamo utilizzato il formato del frame sottostante.
Iniziamo il programma impostando i bit di configurazione e definendo macro e pin per LCD, Pulsanti e LED, che potete verificare nel codice completo fornito alla fine di questo progetto. Se non conosci PIC Microcontroller, inizia con Getting started with PIC Microcontroller Project.
Quindi abbiamo dichiarato e inizializzato alcune variabili e array e abbiamo creato un frame che dobbiamo utilizzare in questo progetto per interfacciare il modulo di impronte digitali con il microcontrollore PIC.
uchar buf; uchar buf1; indice uint volatile = 0; flag int volatile = 0; uint msCount = 0; uint g_timerflag = 1; conteggio uint volatile = 0; dati uchar; uint id = 1; enumerazione { CMD, DATA, SBIT_CREN = 4, SBIT_TXEN, SBIT_SPEN, }; const char passPack = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x7, 0x13, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1B}; const char f_detect = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x3, 0x1, 0x0, 0x5}; const char f_imz2ch1 = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x4, 0x2, 0x1, 0x0, 0x8}; const char f_imz2ch2 = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x4, 0x2, 0x2, 0x0, 0x9}; const char f_createModel = {0xEF, 0x1,0xFF, 0xFF, 0xFF, 0xFF, 0x1,0x0,0x3,0x5,0x0,0x9}; char f_storeModel = {0xEF, 0x1,0xFF, 0xFF, 0xFF, 0xFF, 0x1,0x0,0x6,0x6,0x1,0x0,0x1,0x0,0xE}; const char f_search = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x8, 0x1B, 0x1, 0x0, 0x0, 0x0, 0xA3, 0x0, 0xC8}; char f_delete = {0xEF, 0x1,0xFF, 0xFF, 0xFF, 0xFF, 0x1,0x0,0x7,0xC, 0x0,0x0,0x0,0x1,0x0,0x15};
Dopo di ciò, abbiamo creato la funzione LCD per guidare LCD.
void lcdwrite (uchar ch, uchar rw) { LCDPORT = ch >> 4 & 0x0F; RS = rw; EN = 1; __delay_ms (5); EN = 0; LCDPORT = ch & 0x0F; EN = 1; __delay_ms (5); EN = 0; } Lcdprint (char * str) { while (* str) { lcdwrite (* str ++, DATA); // __ delay_ms (20); } } lcdbegin () { uchar lcdcmd = {0x02,0x28,0x0E, 0x06,0x01}; uint i = 0; per (i = 0; i <5; i ++) lcdwrite (lcdcmd, CMD); }
La funzione data viene utilizzata per inizializzare UART
void serialbegin (uint baudrate) { SPBRG = (18432000UL / (long) (64UL * baudrate)) - 1; // baud rate @ 18.432000Mhz Clock TXSTAbits.SYNC = 0; // Impostazione della modalità asincrona, ovvero UART RCSTAbits.SPEN = 1; // Abilita la porta seriale TRISC7 = 1; // Come prescritto nella scheda tecnica TRISC6 = 0; // Come prescritto nella scheda tecnica RCSTAbits.CREN = 1; // Abilita la ricezione continua TXSTAbits.TXEN = 1; // Abilita la trasmissione GIE = 1; // ENABLE interrompe INTCONbits.PEIE = 1; // Abilita gli interrupt periferici. PIE1bits.RCIE = 1; // ENABLE USART riceve l'interrupt PIE1bits.TXIE = 0; // disabilita l'interrupt TX USART PIR1bits.RCIF = 0; }
Le funzioni fornite vengono utilizzate per trasferire i comandi al modulo impronte digitali e ricevere dati dal modulo impronte digitali.
void serialwrite (char ch) { while (TXIF == 0); // Attendere che il registro del trasmettitore diventi vuoto TXIF = 0; // Cancella flag trasmettitore TXREG = ch; // carica il carattere da trasmettere nel registro di trasmissione } serialprint (char * str) { while (* str) { serialwrite (* str ++); } } void interrupt SerialRxPinInterrupt (void) { if ((PIR1bits.RCIF == 1) && (PIE1bits.RCIE == 1)) { uchar ch = RCREG; buf = ch; if (indice> 0) flag = 1; RCIF = 0; // cancella flag rx } } void serialFlush () { for (int i = 0; i
Dopodiché dobbiamo realizzare una funzione che prepari i dati da trasmettere all'impronta digitale e decodifichi i dati provenienti dal modulo impronta.
int sendcmd2fp (char * pack, int len) { uint res = ERROR; serialFlush (); indice = 0; __delay_ms (100); for (int i = 0; i
Ora, ci sono quattro funzioni disponibili nel codice per quattro diverse attività:
- Funzione per inserire l'ID dell'impronta digitale - unit getId ()
- Funzione per la corrispondenza del dito - void matchFinger ()
- Funzione per la registrazione di un nuovo dito - void enrolFinger ()
- Funzione per eliminare un dito - void deleteFinger ()
Alla fine viene fornito il codice completo con tutte e quattro le funzioni.
Ora nella funzione principale, inizializziamo GPIO, LCD, UART e controlliamo se il modulo di impronte digitali è collegato o meno a un microcontrollore. Quindi mostra alcuni messaggi introduttivi sul display LCD. Infine nel ciclo while leggiamo tutti i tasti o pulsanti per azionare il progetto.
int main () { void (* FP) (); ADCON1 = 0b00000110; LEDdir = 0; SWPORTdir = 0xF0; SWPORT = 0x0F; serialbegin (57600); LCDPORTDIR = 0x00; TRISE = 0; lcdbegin (); lcdprint ("Impronta digitale"); lcdwrite (192, CMD); lcdprint ("Interfacciamento"); __delay_ms (2000); lcdwrite (1, CMD); lcdprint ("Utilizzo di PIC16F877A"); lcdwrite (192, CMD); lcdprint ("Circuit Digest"); __delay_ms (2000); indice = 0; while (sendcmd2fp (& passPack, sizeof (passPack))) { lcdwrite (1, CMD); lcdprint ("FP non trovato"); __delay_ms (2000); indice = 0; } lcdwrite (1, CMD); lcdprint ("FP Found"); __delay_ms (1000); lcdinst (); while (1) { FP = match
Di seguito vengono forniti il codice PIC completo e un video funzionante. Controlla anche i nostri altri progetti che utilizzano il modulo sensore di impronte digitali:
- Macchina per il voto biometrico basata su impronte digitali che utilizza Arduino
- Sistema di sicurezza biometrico che utilizza Arduino e sensore di impronte digitali
- Sistema di rilevazione presenze biometrico basato su impronte digitali utilizzando Arduino
- Sensore di impronte digitali che si interfaccia con Raspberry Pi