Fingeravtrykksbasert biometrisk oppmøtesystem ved bruk av atmega32 mikrokontroller

Ifølge forskere fra Pen State University er det mer sannsynlig at mennesker stoler på maskiner over mennesker, noe som sannsynligvis er tydelig fra at vi avslører min ATM-pin til en maskin så lett. I dag, i verden der AI, maskinlæring, chatbots, smarte høyttalere, roboter osv. Utvikler seg aktivt, vil denne synergien mellom mennesker og roboter bare øke. I dag erstattes alt rundt oss av broavgiftsoppkrevere til utsjekkasserer for maskiner for å få arbeidet gjort enklere og mer effektivt. For å holde tritt med fasen, vil vi i dette prosjektet bygge et biometrisk deltakingssystem ved hjelp av AVR-mikrokontrollere for å erstatte den manuelle prosedyren for å delta. Dette systemet vil være mer pålitelig og effektivt siden det vil spare tid og unngå dodgers.

Fingeravtrykk-fremmøtesystemer er allerede tilgjengelige direkte fra markedet, men hva er morsommere enn å bygge et? Vi har også bygget et bredt utvalg av Attendance Systems tidligere fra et enkelt RFID-basert Attendance-system til et IoT-basert biometrisk Attendance-system ved hjelp av Arduino og Raspberry Pi. I dette prosjektet har vi brukt fingeravtrykkmodul og AVR (atmega32) til å registrere oppmøte. Ved å bruke fingeravtrykkssensor vil systemet bli sikrere for brukerne. Følgende seksjoner forklarer tekniske detaljer for å lage et fingeravtrykksbasert biometrisk oppmøtingssystem ved hjelp av AVR.

Nødvendige komponenter

1. Atmega32 -1
2. Fingeravtrykkmodul (r305) -1
3. Trykknapp eller membranknapper - 4
4. Lysdioder -2
5. 1K Motstand -2
6. 2,2K motstand -1
7. Strøm 12v adapter
8. Koble ledninger
9. Summer -1
10. 16x2 LCD -1
11. PCB eller brødbrett
12. RTC-modul (ds1307 eller ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf kondensator -1
15. Burgstips hannkvinne
16. DC JACK (valgfritt)
17. BC547 Transistor -1

I denne systemkretsen for fingeravtrykk har vi brukt Fingeravtrykkssensormodulen til å autentisere en person eller ansattes identitet ved å ta fingeravtrykk-inngangen i systemet. Her bruker vi fire trykknapper for å registrere, slette, øke og redusere fingeravtrykkdata . Nøkkel 1 brukes til å registrere en ny person i systemet. Så når brukeren vil registrere en ny finger, så må han / hun trykke på tast 1, så ber LCD ham / henne om å plassere en finger på fingeravtrykkssensoren to ganger, så ber den om ansattes ID. På samme måte har nøkkel 2 dobbel funksjon, som når brukeren registrerer en ny finger, må han / hun velge fingeravtrykk-IDved å bruke to andre taster nemlig 3 og 4. Nå må brukeren trykke tast 1 (denne gangen oppfører denne tasten seg som OK) for å fortsette med valgt ID. Og nøkkel 2 brukes også til å tilbakestille eller slette data fra EEPROM til mikrokontroller.

Fingeravtrykkssensormodul fanger fingeravtrykk og konverterer det deretter til tilsvarende mal og lagrer dem i minnet i henhold til valgt ID av mikrokontroller. Hele prosessen er befalt av mikrokontrolleren, som å ta et bilde av fingeravtrykk; konvertere den til maler og lagre som ID osv. Du kan også sjekke ut disse andre fingeravtrykksensorprosjektene, hvor vi har bygget fingeravtrykkssensorsikkerhetssystem og fingeravtrykksstemmer.

Kretsdiagram

Det komplette kretsskjemaet for fingeravtrykksbasert oppmøte-systemprosjekt er vist nedenfor. Den har Atmega32 mikrokontroller for å kontrollere hele prosessen i prosjektet. Trykk- eller membranknappen brukes til å registrere, slette, velge ID-er for oppmøte, en summer brukes til indikasjon og en 16x2 LCD for å instruere brukeren om hvordan du bruker maskinen.

Som vist i kretsskjemaet, er trykk- eller membranknapper koblet direkte til pin PA2 (ENROLL-tast 1), PA3 (DEL-tast 2), PA0 (UP-tast 3), PA1 (NED-tast 4) til mikrokontrolleren i forhold til bakken eller PA4. Og en LED er koblet til pinnen PC2 på mikrokontrolleren i forhold til bakken gjennom en 1k motstand. Fingeravtrykksmodulens Rx og Tx direkte koblet til seriell pin PD1 og PD3 på mikrokontroller. 5v-forsyning brukes til å drive hele kretsen ved å bruke LM7805 spenningsregulatorsom drives av 12v likestrømsadapter. En summer er også koblet til på pin PC3. En 16x2 LCD er konfigurert i 4-bits modus, og dens RS, RW, EN, D4, D5, D6 og D7 er direkte koblet til pin PB0, PB1, PB2, PB4, PB5, PB6, PB7 til mikrokontroller. RTC-modulen er koblet til I2Cpin PC0 SCL og PC1 SDA. Og PD7 brukes som myk UART Tx-pinne for å få aktuell tid.

Hvordan Fingerprint Attendance System fungerer

Når brukeren plasserer fingeren over fingeravtrykkmodulen, tar fingeravtrykkmodulen et fingerbilde, og søk om ID er knyttet til dette fingeravtrykket i systemet. Hvis fingeravtrykks-ID oppdages, vil LCD-skjermen vise tilstedeværelsesregistrert, og samtidig vil en lyd pippe en gang.

Sammen med fingeravtrykkmodulen har vi også brukt en RTC-modul for tids- og datodata. Tid og dato kjører kontinuerlig i systemet, slik at Microcontroller kan ta tid og dato når en ekte bruker plasserer fingeren over fingeravtrykkssensoren og deretter lagrer dem i EEPROM på det tildelte minnesporet.

Brukeren kan laste ned oppmøtedataene ved å trykke og holde inne tast 4. Koble strømforsyningen til kretsen og vent, og etter en stund vil LCD-skjermen vise 'Nedlasting….'. Og brukeren kan se tilstedeværelsesdataene over seriell skjerm, her i denne kodeprogrammet er UART programmert på pin PD7-pin20 som Tx for å sende data til terminalen. Brukeren trenger også en TTL til USB-omformer for å se oppmøte data over seriell 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.