Enligt forskare från Pen State University är människor mer benägna att lita på maskiner över människor, vilket sannolikt framgår av att vi avslöjar vår ATM-stift till en maskin så lätt. I dag, i världen där AI, maskininlärning, chattbots, smarta högtalare, robotar osv utvecklas aktivt, kommer denna synergi mellan människor och robotar bara att öka. Idag, från broavgiftsuppköpare till utcheckningskassörer, ersätts allt runt omkring oss för maskiner för att få jobbet gjort enklare och effektivare. För att hålla jämna steg med fasen kommer vi i detta projekt att bygga ett biometriskt närvarosystem med AVR-mikrokontroller för att ersätta det manuella förfarandet för att delta. Detta system blir mer pålitligt och effektivt eftersom det skulle spara tid och undvika dodgers.
Fingeravtryckssystem är redan tillgängliga direkt från marknaden, men vad är roligare än att bygga ett? Vi har också byggt ett brett utbud av närvarasystem tidigare från ett enkelt RFID-baserat närvarosystem till ett IoT-baserat biometriskt närvarosystem med Arduino och Raspberry Pi. I detta projekt har vi använt fingeravtrycksmodul och AVR (atmega32) för att registrera närvaro. Genom att använda fingeravtryckssensorn blir systemet säkrare för användarna. Följande avsnitt förklarar tekniska detaljer för att skapa ett fingeravtrycksbaserat biometriskt närvarosystem med hjälp av AVR.
Nödvändiga komponenter
- Atmega32 -1
- Fingeravtrycksmodul (r305) -1
- Tryckknapp eller membranknappar - 4
- Lysdioder -2
- 1K Motstånd -2
- 2,2K motstånd -1
- Strömadapter 12v
- Anslutande ledningar
- Summer -1
- 16x2 LCD -1
- PCB eller brödbräda
- RTC-modul (ds1307 eller ds3231) -1
- LM7805 -1
- 1000uf, 10uf kondensator -1
- Burgstips manlig kvinna
- DC JACK (tillval)
- BC547 Transistor -1
I den här systemkretsen för fingeravtryck har vi använt Fingerprint Sensor-modulen för att autentisera en person eller anställds identitet genom att ta deras fingeravtrycksingång i systemet. Här använder vi fyra tryckknappar för att registrera, ta bort, öka och minska fingeravtrycksdata . Nyckel 1 används för registrering av en ny person i systemet. Så när användaren vill registrera ett nytt finger måste han / hon trycka på tangent 1 och LCD ber honom / henne att placera ett finger på fingeravtryckssensorn två gånger och sedan ber det om ett anställd ID. På samma sätt har tangent 2 dubbel funktion, som när användaren registrerar nytt finger, då måste han / hon välja finger-print-IDgenom att använda ytterligare två tangenter, nämligen 3 och 4. Nu måste användaren trycka på tangent 1 (den här gången fungerar denna tangent som OK) för att fortsätta med valt ID. Och nyckel 2 används också för att återställa eller radera data från EEPROM på mikrokontrollern.
Fingeravtryckssensormodulen fångar fingeravtrycksbilden och konverterar den sedan till motsvarande mall och sparar dem i sitt minne enligt valt ID av mikrokontroller. Hela processen styrs av mikrokontrollern, som att ta en bild av fingeravtryck; konvertera den till mallar och lagra som ID etc. Du kan också kolla in dessa andra fingeravtryckssensorprojekt, där vi har byggt fingeravtryckssensorsäkerhetssystem och fingeravtrycksgivares röstmaskin.
Kretsschema
Det fullständiga kretsschemat för fingeravtrycksbaserat närvarosystemsprojekt visas nedan. Den har Atmega32 mikrokontroller för att styra hela processen i projektet. Tryck- eller membranknappen används för att registrera, radera, välja ID för närvaro, en summer används för indikering och en 16x2 LCD för att instruera användaren om hur man använder maskinen.
Som visas i kretsschemat är tryck- eller membranknappar direkt anslutna till stift PA2 (ENROLL-tangent 1), PA3 (DEL-tangent 2), PA0 (UPP-tangent 3), PA1 (NED-tangent 4) på mikrokontrollern med avseende på mark eller PA4. Och en LED är ansluten vid stift PC2 på mikrokontroller med avseende på jord genom ett 1k-motstånd. Fingeravtrycksmodulens Rx och Tx direkt anslutna vid seriell stift PD1 och PD3 på mikrokontrollern. 5v-matning används för att driva hela kretsen med hjälp av LM7805 spänningsregulatorsom drivs av 12V likströmsadapter. En summer är också ansluten på stift PC3. En 16x2 LCD är konfigurerad i 4-bitars läge och dess RS, RW, EN, D4, D5, D6 och D7 är direktanslutna vid stift PB0, PB1, PB2, PB4, PB5, PB6, PB7 i mikrokontroller. RTC-modulen är ansluten till I2Cpin PC0 SCL och PC1 SDA. Och PD7 används som mjuk UART Tx-stift för att få aktuell tid.
Hur Fingerprint Attendance System fungerar
Närhelst användaren lägger fingret över fingeravtrycksmodulen så fångar fingeravtrycksmodulen fingerbild och söker om något ID är associerat med detta fingeravtryck i systemet. Om fingeravtrycks-ID upptäcks kommer LCD att visa registrerad närvaro och samtidigt piper en summer.
Along with the fingerprint module, we have also used an RTC module for Time and date data. Time and date are running continuously in the system, so Microcontroller can take time and date whenever a true user places his finger over fingerprint sensor and then save them in the EEPROM at the allotted slot of memory.
User may download the attendance data by pressing and holding key 4. Connect supply to circuit and wait and after some time, LCD will show ‘Downloading….’. And user can see the attendance data over serial monitor, here in this code software UART is programmed at pin PD7-pin20 as Tx to send data to terminal. User also needs a TTL to USB converter to see the attendance data over serial 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
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<
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<
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<
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.