Biometrický dochádzkový systém založený na odtlačkoch prstov využívajúci mikrokontrolér atmega32

Podľa vedcov z Pen state University je pravdepodobnejšie, že ľudia budú viac dôverovať strojom ako ľuďom, čo je pravdepodobne zrejmé z toho, že sme náš strojový štít tak ľahko odhalili. Dnes, vo svete, kde AI, strojové učenie, chatovacie roboty, inteligentné reproduktory, roboty atď. Aktívne napredujú, sa táto synergia medzi ľuďmi a robotmi bude len zvyšovať. Dnes, od vyberačov mostov cez mýto až po pokladne, je všetko okolo nás nahradené strojmi, aby bola práca ľahšia a efektívnejšia. Aby sme udržali krok s fázou, v tomto projekte vybudujeme biometrický dochádzkový systém využívajúci mikrokontroléry AVR, ktorý nahradí manuálny postup účasti. Tento systém bude spoľahlivejší a efektívnejší, pretože by ušetril čas a predišiel podvodníkom.

Dochádzkové systémy s odtlačkami prstov sú už ľahko dostupné priamo z trhu, ale čo je zábavnejšie ako ich zostavenie? Tiež sme predtým vybudovali širokú škálu dochádzkových systémov, od jednoduchého dochádzkového systému založeného na RFID až po biometrický dochádzkový systém založený na IoT využívajúci Arduino a Raspberry Pi. V tomto projekte sme na registráciu dochádzky použili modul odtlačkov prstov a AVR (atmega32). Použitím snímača odtlačkov prstov sa systém stane pre používateľov bezpečnejším. Nasledujúca časť vysvetľuje technické podrobnosti výroby biometrického dochádzkového systému založeného na odtlačkoch prstov pomocou AVR.

Požadované komponenty

1. Atmega32 -1
2. Modul odtlačkov prstov (r305) -1
3. 4. Tlačidlo alebo membránové tlačidlá - 4
4. LED diódy -2
5. 1K rezistor -2
6. 2,2K rezistor -1
7. Napájací adaptér 12v
8. Pripojovacie vodiče
9. Bzučiak -1
10. 16 x 2 LCD -1
11. PCB alebo chlebová doska
12. Modul RTC (ds1307 alebo ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf kondenzátor -1
15. Burgstips mužskej ženy
16. DC JACK (voliteľné)
17. Tranzistor BC547 -1

V tomto obvode systému dochádzky na odtlačky prstov sme použili modul Snímač odtlačkov prstov na autentifikáciu totožnosti osoby alebo zamestnanca pomocou ich vstupu odtlačkov prstov do systému. Tu používame 4 tlačidlá na registráciu, mazanie, zvyšovanie a znižovanie údajov o odtlačkoch prstov . Kľúč 1 sa používa na registráciu novej osoby do systému. Takže keď chce užívateľ zaregistrovať nový prst, musí stlačiť kláves 1, potom ho LCD dvakrát vyzve, aby umiestnil prst na snímač odtlačkov prstov, potom požiada o ID zamestnanca. Kľúč 2 má takisto dvojitú funkciu, napríklad keď používateľ zaregistruje nový prst, potom musí zvoliť ID odtlačku prstapomocou ďalších dvoch klávesov, konkrétne 3 a 4. Teraz musí užívateľ stlačiť kláves 1 (tentokrát sa správa ako OK), aby mohol pokračovať s vybraným ID. Kľúč 2 sa tiež používa na resetovanie alebo odstránenie údajov z EEPROM mikrokontroléra.

Modul snímača odtlačkov prstov zachytáva tlačený obrázok prsta a potom ho prevádza na ekvivalentnú šablónu a ukladá ich do svojej pamäte podľa zvoleného ID mikrokontrolérom. Celý proces ovláda mikrokontrolér, napríklad snímanie odtlačkov prstov; previesť na šablóny a uložiť ich ako ID atď. Môžete sa tiež pozrieť na tieto ďalšie projekty snímačov odtlačkov prstov, kde sme vytvorili bezpečnostný systém snímača odtlačkov prstov a hlasovacie zariadenie na snímanie odtlačkov prstov.

Schéma zapojenia

Kompletná schéma zapojenia pre projekt dochádzkového systému založeného na odtlačkoch prstov je uvedená nižšie. Má mikrokontrolér Atmega32 na riadenie celého procesu projektu. Stlačovacie alebo membránové tlačidlo sa používa na prihlásenie, mazanie, výber ID pre dochádzku, na indikáciu sa používa bzučiak a 16x2 LCD, ktorý informuje používateľa o tom, ako stroj používať.

Ako je znázornené na schéme zapojenia, tlačidlá alebo membránové tlačidlá sú priamo spojené s pinom PA2 (klávesa ENROLL 1), PA3 (klávesa DEL 2), PA0 (klávesa UP 3), PA1 (klávesa DOWN 4) mikrokontroléra vzhľadom na zem alebo PA4. A LED je pripojená na pin PC2 mikrokontroléra vzhľadom na zem cez 1k odpor. Rx a Tx modulu odtlačkov prstov priamo pripojené na sériový pin PD1 a PD3 mikrokontroléra. Napájanie 5 V sa používa na napájanie celého obvodu pomocou regulátora napätia LM7805ktorý je napájaný 12v dc adaptérom. Na kolíku PC3 je tiež pripojený bzučiak. 16x2 LCD je nakonfigurovaný v 4-bitovom režime a jeho RS, RW, EN, D4, D5, D6 a D7 sú priamo pripojené na pin PB0, PB1, PB2, PB4, PB5, PB6, PB7 mikrokontroléra. RTC modul je pripojený na I2Cpin PC0 SCL a PC1 SDA. A PD7 sa ​​používa ako mäkký pin UART Tx na získanie aktuálneho času.

Ako funguje dochádzkový systém pre odtlačky prstov

Kedykoľvek používateľ položí prst na modul odtlačkov prstov, potom modul odtlačkov prstov zaznamená obrázok prsta a vyhľadá, či je s týmto odtlačkom prsta v systéme spojené nejaké ID. Ak je zistené ID odtlačku prsta, na LCD displeji sa zobrazí Attendance registered a súčasne raz zaznie pípnutie.

Spolu s modulom odtlačkov prstov sme pre dáta času a dátumu použili aj modul RTC. Čas a dátum v systéme bežia nepretržite, takže mikrokontrolér môže čas a dátum zobrať, kedykoľvek skutočný používateľ položí prst na snímač odtlačkov prstov, a potom ich uložiť do EEPROM v pridelenom slote pamäte.

Užívateľ si môže stiahnuť údaje o dochádzke stlačením a podržaním klávesu 4. Pripojte napájanie k okruhu a počkajte a po nejakom čase sa na LCD displeji zobrazí „Prebieha načítanie…“. A užívateľ môže vidieť údaje o dochádzke cez sériový monitor, tu v tomto kódovom softvéri je UART naprogramovaný na pin PD7-pin20 ako Tx na zasielanie dát do terminálu. Užívateľ tiež potrebuje prevodník TTL na USB, aby videl údaje o dochádzke cez sériový terminál.

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.