Fingeraftryksbaseret biometrisk tilstedeværelsessystem ved hjælp af atmega32 mikrokontroller

Ifølge forskere fra Pen State University er mennesker mere tilbøjelige til at stole på maskiner over mennesker, hvilket sandsynligvis fremgår af os, der afslører vores ATM-pin til en maskine så let. I dag, i verden hvor AI, maskinindlæring, chatbots, smarte højttalere, robotter osv. Udvikler sig aktivt, er denne synergi mellem mennesker og robotter kun indstillet til at øges. I dag erstattes alt omkring os fra broafgiftsopkrævere til check-out kasserer for maskiner for at få arbejdet gjort lettere og mere effektivt. For at holde trit med fasen vil vi i dette projekt opbygge et biometrisk tilstedeværelsessystem ved hjælp af AVR-mikrocontrollere til at erstatte den manuelle procedure for at deltage. Dette system vil være mere pålideligt og effektivt, da det ville spare tid og undgå dodgers.

Fingerprint-tilstedeværelsessystemer er allerede tilgængelige direkte fra markedet, men hvad er sjovere end at bygge et? Vi har også bygget en bred vifte af fremmøde-systemer tidligere fra et simpelt RFID-baseret fremmøde-system til et IoT-baseret biometrisk fremmøde-system ved hjælp af Arduino og Raspberry Pi. I dette projekt har vi brugt fingeraftryksmodul og AVR (atmega32) til at registrere deltagelse. Ved at bruge fingeraftrykssensor bliver systemet mere sikkert for brugerne. I de følgende afsnit forklares tekniske detaljer i oprettelse af et fingeraftryksbaseret biometrisk tilstedeværelsessystem ved hjælp af AVR.

Nødvendige komponenter

1. Atmega32 -1
2. Fingeraftryksmodul (r305) -1
3. Trykknap eller membranknapper - 4
4. Lysdioder -2
5. 1K modstand -2
6. 2,2K modstand -1
7. Strøm 12v adapter
8. Tilslutning af ledninger
9. Summer -1
10. 16x2 LCD -1
11. PCB eller brødbræt
12. RTC-modul (ds1307 eller ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf kondensator -1
15. Burgstips mandlig kvinde
16. DC JACK (valgfri)
17. BC547 Transistor -1

I dette systemkredsløb med fingeraftryk har vi brugt fingeraftrykssensormodulet til at godkende en persons eller medarbejders identitet ved at tage deres fingerprint-input i systemet. Her bruger vi 4 trykknapper til at tilmelde, Slet, forøg og reducer fingeraftryksdata . Nøgle 1 bruges til tilmelding af en ny person til systemet. Så når brugeren vil tilmelde en ny finger, skal han / hun trykke på tast 1, så beder LCD ham / hende om at placere en finger på fingeraftrykssensoren to gange, så beder den om et medarbejder-id. På samme måde har tast 2 dobbelt funktion, som når brugeren tilmelder ny finger, så skal han / hun vælge finger-print-idved at bruge yderligere to taster, nemlig 3 og 4. Nu skal brugeren trykke på tast 1 (denne gang opfører denne tast sig som OK) for at fortsætte med det valgte ID. Og nøgle 2 bruges også til nulstilling eller sletning af data fra EEPROM på mikrocontroller.

Fingeraftrykssensormodul fanger fingeraftryksbillede og konverterer det derefter til den tilsvarende skabelon og gemmer dem i hukommelsen som valgt ID af mikrokontroller. Al processen styres af mikrokontrolleren, som at tage et billede af fingeraftryk; konvertere det til skabeloner og gemme som ID osv. Du kan også tjekke disse andre fingeraftrykssensorprojekter, hvor vi har bygget fingeraftrykssensorsikkerhedssystem og fingeraftrykssensorstemmemaskine.

Kredsløbsdiagram

Det komplette kredsløbsdiagram for fingeraftryksbaseret tilstedeværelsessystemprojekt er vist nedenfor. Den har Atmega32 mikrokontroller til styring af hele projektets proces. Tryk- eller membranknappen bruges til tilmelding, sletning, valg af id'er til deltagelse, en summer bruges til indikation og et 16x2 LCD til at instruere brugeren om, hvordan man bruger maskinen.

Som vist i kredsløbsdiagrammet er trykknap- eller membranknapper direkte forbundet til pin PA2 (ENROLL-tast 1), PA3 (DEL-tast 2), PA0 (UP-tast 3), PA1 (DOWN-tast 4) af mikrocontroller i forhold til jorden eller PA4. Og en LED er tilsluttet ved pin PC2 på mikrocontroller i forhold til jord gennem en 1k modstand. Fingeraftryksmodulets Rx og Tx direkte forbundet med seriel pin PD1 og PD3 på mikrocontroller. 5v forsyning bruges til at drive hele kredsløbet ved hjælp af LM7805 spændingsregulatorsom drives af 12v jævnstrømsadapter. En summer er også tilsluttet på pin PC3. En 16x2 LCD er konfigureret i 4-bit-tilstand, og dens RS, RW, EN, D4, D5, D6 og D7 er direkte tilsluttet ved pin PB0, PB1, PB2, PB4, PB5, PB6, PB7 i mikrokontroller. RTC-modulet er forbundet med I2Cpin PC0 SCL og PC1 SDA. Og PD7 bruges som blød UART Tx-pin til at få den aktuelle tid.

Sådan fungerer Fingerprint Attendance System

Hver gang brugeren placerer sin finger over fingeraftryksmodulet, fanger fingeraftryksmodulet fingeraftrykket og søger efter, om der er noget ID forbundet med dette fingeraftryk i systemet. Hvis der registreres fingeraftryks-ID, vil LCD-displayet vise tilstedeværelsesregistreret, og samtidig bipper en summer.

Sammen med fingeraftryksmodulet har vi også brugt et RTC-modul til data om tid og dato. Tid og dato kører kontinuerligt i systemet, så Microcontroller kan tage tid og dato, når en ægte bruger placerer fingeren over fingeraftrykssensoren og derefter gemmer dem i EEPROM i den tildelte hukommelsesplads.

Brugeren kan downloade fremmødedataene ved at trykke på og holde nede på tast 4. Tilslut strømforsyningen til kredsløbet, og vent, og efter et stykke tid viser LCD 'Downloading….'. Og brugeren kan se tilstedeværelsesdataene over seriel skærm, her i denne kodesoftware er UART programmeret ved pin PD7-pin20 som Tx til at sende data til terminal. Brugeren har også brug for en TTL til USB-konverter for at se tilstedeværelsesdata over seriel terminal.

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.