Pirštų atspaudų pagrindu veikianti biometrinė lankomumo sistema, naudojant atmega32 mikrovaldiklį

Pasak Peno valstijos universiteto mokslininkų, žmonės labiau pasitiki mašinomis, o ne tikėtina, kad akivaizdu, jog mes taip lengvai atskleidžiame savo bankomato kaištį mašinai. Šiandien pasaulyje, kur AI, mašininis mokymasis, pokalbių robotai, išmanieji garsiakalbiai, robotai ir kt. Aktyviai progresuoja, ši sinergija tarp žmonių ir robotų tik didės. Šiandien, pradedant tiltų rinkliavų surinkėjais ir baigiant kasomis, viską, kas mus supa, keičia mašinos, kad darbas būtų atliktas lengviau ir efektyviau. Kad neatsiliktume nuo šio etapo, šiame projekte sukursime „ Bio-metric Attendance“ sistemą, naudodami AVR mikrovaldiklius, kad pakeistume rankinę dalyvavimo procedūrą. Ši sistema bus patikimesnė ir efektyvesnė, nes ji sutaupytų laiko ir išvengtų gudruolių.

Pirštų antspaudų lankomumo sistemas jau galima lengvai įsigyti tiesiogiai iš rinkos, bet kas yra smagiau nei sukurti? Mes taip pat anksčiau sukūrėme įvairias dalyvavimo sistemas, nuo paprastos RFID pagrįstos lankomumo sistemos iki daiktų internetine biometrine lankomumo sistema, naudojant „Arduino“ ir „Raspberry Pi“. Šiame projekte registravome lankomumą naudodami pirštų atspaudų modulį ir AVR (atmega32). Naudojant pirštų atspaudų jutiklį, sistema taps saugesnė vartotojams. Tolesniuose skyriuose paaiškinama techninė išsami informacija apie pirštų atspaudais pagrįstos biometrinės lankomumo sistemos naudojimą naudojant AVR.

Reikalingi komponentai

1. „Atmega32 -1“
2. Pirštų atspaudų modulis (r305) -1
3. Mygtukas arba membranos mygtukai - 4
4. Šviesos diodai -2
5. 1K rezistorius -2
6. 2.2K rezistorius -1
7. Maitinimo 12v adapteris
8. Jungiamieji laidai
9. Buzzer -1
10. 16x2 LCD -1
11. PCB arba duonos lenta
12. RTC modulis (ds1307 arba ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf kondensatorius -1
15. Burgstipso patelė
16. DC JACK (pasirinktinai)
17. BC547 tranzistorius -1

Šioje pirštų atspaudų lankymo sistemos grandinėje mes naudojome „ Pirštų atspaudų jutiklio“ modulį, kad patvirtintume asmens ar darbuotojo tapatybę, imant pirštų atspaudus sistemoje. Čia naudojame 4 mygtukus, kad užregistruotume, ištrintumėte, padidintumėte ir sumažintumėte pirštų duomenis . 1 raktas naudojamas įrašyti naują asmenį į sistemą. Taigi, kai vartotojas nori užregistruoti naują pirštą, jis / ji turi paspausti 1 klavišą, tada LCD paprašo jo du kartus uždėti pirštą ant pirštų atspaudų jutiklio, tada paprašo darbuotojo pažymėjimo. Panašiai 2 klavišas turi dvigubą funkciją, pvz., Kai vartotojas užregistruoja naują pirštą, tada jis / ji turi pasirinkti piršto atspaudo IDnaudodamiesi dar dviem klavišais, būtent 3 ir 4. Dabar vartotojas turi paspausti 1 klavišą (šį kartą šis klavišas elgiasi kaip gerai), kad galėtumėte tęsti pasirinktą ID. 2 raktas taip pat naudojamas atstatyti arba ištrinti duomenis iš mikrovaldiklio EEPROM.

Pirštų atspaudų jutiklio modulis užfiksuoja piršto atspaudo vaizdą, tada paverčia jį į lygiavertį šabloną ir išsaugo juos savo atmintyje pagal pasirinktą ID mikrovaldiklis. Visą procesą valdo mikrovaldiklis, pavyzdžiui, piršto atspaudo atvaizdo nuėmimas; paversti jį šablonais ir saugoti kaip asmens tapatybės dokumentą ir pan. Taip pat galite patikrinti šiuos kitus pirštų atspaudų jutiklių projektus, kur mes sukūrėme pirštų atspaudų jutiklių apsaugos sistemą ir pirštų atspaudų jutiklių balsavimo mašiną.

Grandinės schema

Visa grandinės schema, skirta pirštų atspaudais pagrįstai lankomumo sistemos projektui, parodyta žemiau. Jis turi „Atmega32“ mikrovaldiklį, skirtą valdyti visą projekto procesą. Mygtukas arba membraninis mygtukas naudojamas registruoti, ištrinti, pasirinkti dalyvaujančių asmenų ID, indikatorius naudojamas garsiniu signalu ir 16x2 skystųjų kristalų ekranu, nurodančiu vartotojui, kaip naudotis mašina.

Kaip parodyta grandinės schemoje, mygtukai arba membraniniai mygtukai yra tiesiogiai prijungti prie mikrovaldiklio kaiščių PA2 (1 mygtukas ENROLL), PA3 (DEL mygtukas 2), PA0 (3 mygtukas aukštyn), PA1 (žemyn mygtukas 4) žemės atžvilgiu. arba PA4. Šviesos diodas yra prijungtas prie mikrovaldiklio kaiščio PC2 žemės atžvilgiu per 1k rezistorių. Pirštų atspaudų modulio Rx ir Tx tiesiogiai prijungti prie mikrovaldiklio nuoseklių PD1 ir PD3 kontaktų. 5v maitinimas naudojamas visai grandinei maitinti naudojant LM7805 įtampos reguliatoriųkurį maitina 12v nuolatinės srovės adapteris. Prie kaiščio PC3 taip pat prijungtas garsinis signalas. 16x2 skystųjų kristalų ekranas sukonfigūruotas 4 bitų režimu, o jo RS, RW, EN, D4, D5, D6 ir D7 yra tiesiogiai prijungti prie mikrovaldiklio kaiščių PB0, PB1, PB2, PB4, PB5, PB6, PB7. RTC modulis prijungtas prie I2Cpin PC0 SCL ir PC1 SDA. PD7 naudojamas kaip minkštas UART Tx kaištis dabartiniam laikui gauti.

Kaip veikia pirštų atspaudų lankomumo sistema

Kai vartotojas uždeda pirštą ant pirštų atspaudų modulio, pirštų atspaudų modulis užfiksuoja piršto atvaizdą ir ieško, ar sistemoje su šiuo piršto antspaudu yra susietas koks nors ID. Jei aptinkamas piršto antspaudo ID, LCD ekrane rodoma registracija „Dalyvavimas“ ir tuo pačiu metu garsinis signalas pypsės vieną kartą.

Kartu su pirštų atspaudų moduliu laiko ir datos duomenims taip pat naudojome RTC modulį. Laikas ir data sistemoje nuolat veikia, todėl mikrovaldiklis gali užtrukti laiką ir datą, kai tikrasis vartotojas uždeda pirštą ant pirštų atspaudų jutiklio ir tada išsaugo juos EEPROM skirtoje atminties vietoje.

Vartotojas gali atsisiųsti lankomumo duomenis paspausdamas ir palaikydamas 4 klavišą. Prijunkite maitinimą prie grandinės ir palaukite, o po kurio laiko LCD bus rodoma „Atsisiunčiama….“. Ir vartotojas gali matyti lankomumo duomenis per nuoseklųjį monitorių, čia šiame kode programinė įranga UART yra užprogramuota kaiščiu PD7-pin20 kaip Tx siųsti duomenis į terminalą. Vartotojui taip pat reikia TTL į USB keitiklį, kad jis galėtų matyti lankomumo duomenis per nuoseklų 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.