Sistema di presenza biometrico basato su impronte digitali utilizzando il microcontrollore atmega32

Secondo i ricercatori della Pen State University, è più probabile che gli esseri umani si fidino delle macchine rispetto alle persone, il che è probabilmente evidente quando riveliamo il nostro pin ATM a una macchina così facilmente. Oggi, nel mondo in cui l'intelligenza artificiale, l'apprendimento automatico, i chat bot, gli altoparlanti intelligenti, i robot ecc. Stanno progredendo attivamente, questa sinergia tra esseri umani e robot è destinata ad aumentare. Oggi, dagli esattori dei pedaggi ai cassieri, tutto intorno a noi viene sostituito da macchine per svolgere il lavoro in modo più semplice ed efficiente. Per stare al passo con la fase, in questo progetto costruiremo un sistema di Presenza Biometrica utilizzando microcontrollori AVR per sostituire la procedura manuale di presa di presenza. Questo sistema sarà più affidabile ed efficiente poiché farebbe risparmiare tempo ed eviterebbe gli evasori.

I sistemi di rilevamento delle impronte digitali sono già prontamente disponibili direttamente dal mercato, ma cosa c'è di più divertente che costruirne uno? Abbiamo anche costruito una vasta gamma di sistemi di presenze in precedenza, da un semplice sistema di presenze basato su RFID a un sistema di presenze biometrico basato su IoT utilizzando Arduino e Raspberry Pi. In questo progetto, abbiamo utilizzato il modulo impronte digitali e l'AVR (atmega32) per registrare la partecipazione. Utilizzando il sensore di impronte digitali, il sistema diventerà più sicuro per gli utenti. Le sezioni seguenti spiegano i dettagli tecnici per creare un sistema di presenza biometrico basato sulle impronte digitali utilizzando AVR.

Componenti richiesti

1. Atmega32 -1
2. Modulo impronte digitali (r305) -1
3. Pulsante o pulsanti a membrana - 4
4. LED -2
5. Resistenza 1K -2
6. Resistenza da 2.2K -1
7. Adattatore di alimentazione 12v
8. Cavi di collegamento
9. Buzzer -1
10. LCD 16x2 -1
11. PCB o breadboard
12. Modulo RTC (ds1307 o ds3231) -1
13. LM7805 -1
14. Condensatore da 1000uf, 10uf -1
15. Burgstips maschio femmina
16. DC JACK (opzionale)
17. Transistor BC547 -1

In questo circuito del sistema di rilevamento delle impronte digitali, abbiamo utilizzato il modulo del sensore di impronte digitali per autenticare l'identità di una persona o di un dipendente prendendo l' impronta digitale nel sistema. Qui stiamo usando 4 pulsanti per registrare, cancellare, aumentare e diminuire i dati di impronte digitali . La chiave 1 viene utilizzata per l'iscrizione di una nuova persona nel sistema. Quindi, quando l'utente desidera registrare un nuovo dito, deve premere il tasto 1, quindi LCD gli chiede di posizionare un dito sul sensore di impronte digitali due volte, quindi chiede un ID dipendente. Allo stesso modo, il tasto 2 ha una doppia funzione, come quando l'utente registra un nuovo dito, quindi deve selezionare l'ID dell'impronta digitaleutilizzando altri due tasti 3 e 4. Ora l'utente deve premere il tasto 1 (questa volta questo tasto si comporta come OK) per procedere con l'ID selezionato. E la chiave 2 viene utilizzata anche per ripristinare o eliminare i dati dalla EEPROM del microcontrollore.

Il modulo del sensore di impronte digitali acquisisce l'immagine dell'impronta digitale, quindi la converte nel modello equivalente e la salva nella sua memoria secondo l'ID selezionato dal microcontrollore. Tutto il processo è comandato dal microcontrollore, come prendere un'immagine dell'impronta digitale; convertirlo in modelli e memorizzarlo come ID, ecc. Puoi anche controllare questi altri progetti di sensori di impronte digitali, dove abbiamo costruito un sistema di sicurezza del sensore di impronte digitali e una macchina per il voto del sensore di impronte digitali.

Schema elettrico

Di seguito è mostrato lo schema circuitale completo per il progetto del sistema di presenza basato sulle impronte digitali. Ha un microcontrollore Atmega32 per il controllo di tutto il processo del progetto. Il pulsante o il pulsante a membrana viene utilizzato per registrare, cancellare, selezionare gli ID per la presenza, un cicalino viene utilizzato per l'indicazione e un LCD 16x2 per istruire l'utente su come utilizzare la macchina.

Come mostrato nello schema elettrico, i pulsanti a pressione oa membrana sono collegati direttamente al pin PA2 (tasto ENROLL 1), PA3 (tasto DEL 2), PA0 (tasto UP 3), PA1 (tasto DOWN 4) del microcontrollore rispetto alla massa o PA4. E un LED è collegato al pin PC2 del microcontrollore rispetto alla massa tramite una resistenza da 1k. Rx e Tx del modulo di impronte digitali collegati direttamente al pin seriale PD1 e PD3 del microcontrollore. L'alimentazione 5v viene utilizzata per alimentare l'intero circuito utilizzando il regolatore di tensione LM7805che è alimentato da un adattatore da 12 V CC. Un buzzer è anche collegato al pin PC3. Un LCD 16x2 è configurato in modalità 4 bit e i suoi RS, RW, EN, D4, D5, D6 e D7 sono collegati direttamente al pin PB0, PB1, PB2, PB4, PB5, PB6, PB7 del microcontrollore. Il modulo RTC è collegato a I2Cpin PC0 SCL e PC1 SDA. E PD7 viene utilizzato come soft pin UART Tx per ottenere l'ora corrente.

Come funziona il sistema di rilevamento delle impronte digitali

Ogni volta che l'utente posiziona il dito sul modulo dell'impronta digitale, il modulo dell'impronta digitale acquisisce l'immagine del dito e cerca se un ID è associato a questa impronta digitale nel sistema. Se viene rilevata l'ID dell'impronta digitale, il display LCD mostrerà la presenza registrata e contemporaneamente il cicalino emetterà un segnale acustico.

Insieme al modulo delle impronte digitali, abbiamo anche utilizzato un modulo RTC per i dati di ora e data. Ora e data sono in esecuzione continuamente nel sistema, quindi il microcontrollore può prendere l'ora e la data ogni volta che un vero utente posiziona il dito sul sensore di impronte digitali e quindi salvarle nella EEPROM nello slot di memoria assegnato.

L'utente può scaricare i dati di presenza premendo e tenendo premuto il tasto 4. Collegare l'alimentazione al circuito e attendere e dopo un po 'di tempo, il display LCD mostrerà "Download in corso…". E l'utente può vedere i dati di presenza sul monitor seriale, qui in questo codice software l'UART è programmato sul pin PD7-pin20 come Tx per inviare i dati al terminale. L'utente necessita anche di un convertitore da TTL a USB per vedere i dati di presenza sul terminale seriale.

And if the user wants to delete all the data then he/she has to press and hold key 2 and then connect power and wait for some time. Now after some time LCD will show ‘Please wait…’ and then ‘Record Deleted successfully’. These two steps are not shown in demonstration video given in the end.

Code Explanation

Complete code along with the video for this biometric attendance system is given at the end. Code of this project is a little bit lengthy and complex for beginner. Hence we have tried to take descriptive variables to make good readability and understanding. First of all, we have included some necessary header file then written macros for different-different purpose.

#define F_CPU 8000000ul #include #include #include /***MACROS*/ #define USART_BAUDRATE 9600 #define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1) #define uchar unsigned char #define uint unsigned int #define LCDPORTDIR DDRB #define LCDPORT PORTB #define rs 0 #define rw 1 #define en 2 #define RSLow (LCDPORT&=~(1< #define KeyPORTdir DDRA #define key PINA #define KeyPORT PORTA

After this, we have declared some variables and arrays for fingerprint command and response. We have also added some functions for fetching and setting data to RTC.

void RTC_stp() { TWCR=(1< } void RTC_read() { TWCR=(1< while((TWCR&0x80)==0x00); TWDR=0xD0; //RTC write (slave address) TWCR=(1< while(!(TWCR&(1< TWDR=0x00; //RTC write (word address) TWCR=(1< while(!(TWCR&(1< TWCR=(1< while ((TWCR&0x80)==0x00); TWDR=0xD1; // RTC command to read TWCR=(1< while(!(TWCR&(1< }

Then we have some functions for LCD which are responsible to drive the LCD. LCD driver function is written for 4-bit mode drive. Followed by that we also have some UART driver functions which are responsible for initializing UART and exchanging data between fingerprint sensor and microcontroller.

void serialbegin() { UCSRC = (1 << URSEL) - (1 << UCSZ0) - (1 << UCSZ1); UBRRH = (BAUD_PRESCALE >> 8); UBRRL = BAUD_PRESCALE; UCSRB=(1< sei(); } ISR(USART_RXC_vect) { char ch=UDR; buf=ch; if(ind>0) flag=1; //serial1Write(ch); } void serialwrite(char ch) { while ((UCSRA & (1 << UDRE)) == 0); UDR = ch; } void serialprint(char *str) { while(*str) { serialwrite(*str++); } }

Now we have some more UART function but they are software UART. It is used for transferring saved data to the computer via serial terminal. These functions are delay-based and don’t use any type of interrupt. And for UART only tx signal will work and we have hardcoded baud rate for soft UART as 9600.

void SerialSoftWrite(char ch) { PORTD&=~(1<<7); _delay_us(104); for(int i=0;i<8;i++) { if(ch & 1) PORTD-=(1<<7); else PORTD&=~(1<<7); _delay_us(104); ch>>=1; } PORTD-=(1<<7); _delay_us(104); } void SerialSoftPrint(char *str) { while(*str) { SerialSoftWrite(*str); str++; } }

Followed by that we have functions that are responsible for displaying the RTC time in the LCD. The below given functions are used for writing attendance data to EEPROM and reading attendance data from EEPROM.

int eeprom_write(unsigned int add,unsigned char data) { while(EECR&(1< EEAR=add; EEDR=data; EECR-=(1< EECR-=(1< return 0; } char eeprom_read(unsigned int add) { while(EECR & (1< EEAR=add; EECR-=(1< return EEDR; }

The below function is responsible for reading fingerprint image and convert them in template and matching with already stored image and show result over LCD.

void matchFinger() { // lcdwrite(1,CMD); // lcdprint("Place Finger"); // lcdwrite(192,CMD); // _delay_ms(2000); if(!sendcmd2fp((char *)&f_detect,sizeof(f_detect))) { if(!sendcmd2fp((char *)&f_imz2ch1,sizeof(f_imz2ch1))) { if(!sendcmd2fp((char *)&f_search,sizeof(f_search))) { LEDHigh; buzzer(200); uint id= data; id<<=8; id+=data; uint score=data; score<<=8; score+=data; (void)sprintf((char *)buf1,"Id: %d",(int)id); lcdwrite(1,CMD); lcdprint((char *)buf1); saveData(id); _delay_ms(1000); lcdwrite(1,CMD); lcdprint("Attendance"); lcdwrite(192,CMD); lcdprint("Registered"); _delay_ms(2000); LEDLow; }

Followed by that we have a function that is used for enrolling a new finger and displaying the result or status on LCD. Then the below function is used for deleting stored fingerprint from the module by using id number and show status of the same.

void deleteFinger() { id=getId(); f_delete=id>>8 & 0xff; f_delete=id & 0xff; f_delete=(21+id)>>8 & 0xff; f_delete=(21+id) & 0xff; if(!sendcmd2fp(&f_delete,sizeof(f_delete))) { lcdwrite(1,CMD); sprintf((char *)buf1,"Finger ID %d ",id); lcdprint((char *)buf1); lcdwrite(192, CMD); lcdprint("Deleted Success"); } else { lcdwrite(1,CMD); lcdprint("Error"); } _delay_ms(2000); }

Below function is responsible for sending attendance data to serial terminal via soft UART pin PD7 and TTL to USB converter.

/*function to show attendence data on serial moinitor using softserial pin PD7*/ void ShowAttendance() { char buf; lcdwrite(1,CMD); lcdprint("Downloding…."); SerialSoftPrintln("Attendance Record"); SerialSoftPrintln(" "); SerialSoftPrintln("S.No ID1 ID2 Id3 ID4 ID5 "); //serialprintln("Attendance Record"); //serialprintln(" "); //serialprintln("S.No ID1 ID2 Id3 ID4 ID5"); for(int cIndex=1;cIndex<=8;cIndex++) { sprintf((char *)buf,"%d " "%d:%d:%d %d/%d/20%d " "%d:%d:%d %d/%d/20%d " "%d:%d:%d %d/%d/20%d " "%d:%d:%d %d/%d/20%d " "%d:%d:%d %d/%d/20%d ", cIndex, eeprom_read((cIndex*6)),eeprom_read((cIndex*6)+1),eeprom_read((cIndex*6)+2),eeprom_read((cIndex*6)+3),eeprom_read((cIndex*6)+4),eeprom_read((cIndex*6)+5), eeprom_read((cIndex*6)+48),eeprom_read((cIndex*6)+1+48),eeprom_read((cIndex*6)+2+48),eeprom_read((cIndex*6)+3+48),eeprom_read((cIndex*6)+4+48),eeprom_read((cIndex*6)+5+48), eeprom_read((cIndex*6)+96),eeprom_read((cIndex*6)+1+96),eeprom_read((cIndex*6)+2+96),eeprom_read((cIndex*6)+3+96),eeprom_read((cIndex*6)+4+96),eeprom_read((cIndex*6)+5+96), eeprom_read((cIndex*6)+144),eeprom_read((cIndex*6)+1+144),eeprom_read((cIndex*6)+2+144),eeprom_read((cIndex*6)+3+144),eeprom_read((cIndex*6)+4+144),eeprom_read((cIndex*6)+5+144), eeprom_read((cIndex*6)+192),eeprom_read((cIndex*6)+1+192),eeprom_read((cIndex*6)+2+192),eeprom_read((cIndex*6)+3+192),eeprom_read((cIndex*6)+4+192),eeprom_read((cIndex*6)+5+192)); SerialSoftPrintln(buf); //serialprintln(buf); } lcdwrite(192,CMD); lcdprint("Done"); _delay_ms(2000); }

Below function is used for deleting all the attendance data from the microcontroller’s EEPROM.

void DeleteRecord() { lcdwrite(1,CMD); lcdprint("Please Wait…"); for(int i=0;i<255;i++) eeprom_write(i,10); _delay_ms(2000); lcdwrite(1,CMD); lcdprint("Record Deleted"); lcdwrite(192,CMD); lcdprint("Successfully"); _delay_ms(2000); }

In the main function we will initialize all the used module and gpio pins. Finally, all-controlling event are performed in this as shown below

while(1) { RTC(); // if(match == LOW) // { matchFinger(); // } if(enrol == LOW) { buzzer(200); enrolFinger(); _delay_ms(2000); // lcdinst(); } else if(delet == LOW) { buzzer(200); getId(); deleteFinger(); _delay_ms(1000); } } return 0; }

The complete working set-up is shown in the video linked below. Hope you enjoyed the project and learnt something new. If you have any questions leave them in the comment section or use the forums for other technical questions.