Sistem de prezență biometric bazat pe amprentă digitală care utilizează microcontroler atmega32

Potrivit cercetătorilor de la Pen State University, oamenii sunt mai predispuși să aibă încredere în mașini decât în ​​oameni, ceea ce este evident din faptul că ne-am dezvăluit atât de ușor pinul ATM-ului către o mașină. Astăzi, în lumea în care AI, învățarea automată, robotii de chat, difuzoarele inteligente, roboții etc. progresează activ, această sinergie între oameni și roboți va crește. Astăzi, de la colectoarele de taxe de pod până la casierii de check-out, tot ceea ce ne înconjoară este înlocuit de mașini pentru a face munca mai ușoară și mai eficientă. Pentru a ține pasul cu faza, în acest proiect vom construi un sistem de prezență bio-metrică folosind microcontrolere AVR pentru a înlocui procedura manuală de participare. Acest sistem va fi mai fiabil și mai eficient, deoarece ar economisi timp și ar evita evitatorii.

Sistemele de prezență a amprentelor digitale sunt deja disponibile direct de pe piață, dar ce este mai distractiv decât construirea unuia? De asemenea, am construit o gamă largă de sisteme de prezență mai devreme de la un sistem simplu de prezență bazat pe RFID la un sistem de prezență biometric bazat pe IoT folosind Arduino și Raspberry Pi. În acest proiect, am folosit modulul de amprentă digitală și AVR (atmega32) pentru a înregistra prezența. Prin utilizarea senzorului de amprentă, sistemul va deveni mai sigur pentru utilizatori. Următoarele secțiuni explică detaliile tehnice ale realizării unui sistem de prezență biometrică bazat pe amprente digitale folosind AVR.

Componente necesare

1. Atmega32 -1
2. Modul de amprentă digitală (r305) -1
3. Buton de apăsare sau butoane cu membrană - 4
4. LED-uri -2
5. Rezistor 1K -2
6. 2.2K rezistor -1
7. Adaptor de alimentare 12v
8. Conectarea firelor
9. Buzzer -1
10. 16x2 LCD -1
11. PCB sau placa de pâine
12. Modul RTC (ds1307 sau ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf condensator -1
15. Burstips mascul de sex feminin
16. DC JACK (opțional)
17. BC547 Tranzistor -1

În acest circuit al sistemului de prezență a amprentelor digitale, am folosit modulul senzor de amprentă digitală pentru a autentifica identitatea unei persoane sau a unui angajat luând intrarea amprentelor digitale în sistem. Aici folosim 4 butoane pentru a înregistra, șterge, mări și micșora datele de amprentă digitală . Tasta 1 este utilizată pentru înscrierea unei persoane noi în sistem. Deci, atunci când utilizatorul dorește să înregistreze un deget nou, atunci el / ea trebuie să apese tasta 1, apoi LCD-ul îi cere să plaseze un deget pe senzorul de amprentă de două ori, apoi solicită un ID de angajat. În mod similar, tasta 2 are funcție dublă, ca atunci când utilizatorul înregistrează un deget nou, atunci el / ea trebuie să selecteze ID-ul amprentei digitalefolosind alte două taste și anume 3 și 4. Acum utilizatorul trebuie să apese tasta 1 (de data aceasta această tastă se comportă ca OK) pentru a continua cu ID-ul selectat. Și tasta 2 este, de asemenea, utilizată pentru resetarea sau ștergerea datelor din EEPROM a microcontrolerului.

Modulul senzorului de amprentă captează imaginea cu amprenta digitală și apoi o convertește în șablonul echivalent și le salvează în memoria sa conform ID-ului selectat de microcontroler. Tot procesul este comandat de microcontroler, cum ar fi luarea unei imagini a amprentei digitale; convertiți-l în șabloane și depozitați ca ID etc. Puteți verifica și aceste alte proiecte ale senzorului de amprentă digitală, unde am construit un sistem de securitate al senzorului de amprentă digitală și un aparat de vot pentru senzorul de amprentă digitală.

Diagrama circuitului

Schema completă a circuitului pentru proiectul sistemului de prezență bazat pe amprente digitale este prezentată mai jos. Are microcontroler Atmega32 pentru controlul întregului proces al proiectului. Butonul de apăsare sau membrană este utilizat pentru înscriere, ștergere, selectarea ID-urilor pentru prezență, un buzzer este utilizat pentru indicație și un ecran LCD de 16x2 pentru a instrui utilizatorul despre modul de utilizare a aparatului.

După cum se arată în schema circuitului, butoanele de apăsare sau de membrană sunt conectate direct la pinul PA2 (tasta ENROLL 1), PA3 (tasta DEL 2), PA0 (tasta UP 3), PA1 (tasta DOWN 4) ale microcontrolerului față de sol sau PA4. Și un LED este conectat la pinul PC2 al microcontrolerului față de masă printr-un rezistor de 1k. Rx și Tx ale modulului de amprentă digitală conectate direct la pinul serial PD1 și PD3 al microcontrolerului. Alimentarea cu 5V este utilizată pentru alimentarea întregului circuit utilizând regulatorul de tensiune LM7805care este alimentat de un adaptor de 12V c.c. Un buzzer este, de asemenea, conectat la pinul PC3. Un ecran LCD de 16x2 este configurat în modul 4 biți, iar RS, RW, EN, D4, D5, D6 și D7 sunt conectate direct la pinul PB0, PB1, PB2, PB4, PB5, PB6, PB7 al microcontrolerului. Modulul RTC este conectat la I2Cpin PC0 SCL și PC1 SDA. Iar PD7 este folosit ca pin UART Tx moale pentru a obține ora curentă.

Cum funcționează sistemul de asistență la amprentă digitală

Ori de câte ori utilizatorul plasează degetul peste modulul de amprentă, modulul de amprentă captează imaginea degetelor și caută dacă există vreun ID asociat cu această amprentă în sistem. Dacă este detectat ID-ul amprentei, LCD va afișa prezența înregistrată și, în același timp, buzzerul va emite o singură dată.

Împreună cu modulul de amprentă digitală, am folosit și un modul RTC pentru date privind ora și data. Ora și data rulează continuu în sistem, astfel încât microcontrolerul poate lua ora și data ori de câte ori un utilizator adevărat plasează degetul peste senzorul de amprentă și apoi le salvează în EEPROM în slotul de memorie alocat.

Utilizatorul poate descărca datele de prezență apăsând și menținând apăsată tasta 4. Conectați alimentarea la circuit și așteptați și după ceva timp, ecranul LCD va afișa „Descărcare….”. Și utilizatorul poate vedea datele de prezență pe monitorul serial, aici în acest cod software-ul UART este programat la pinul PD7-pin20 ca Tx pentru a trimite date la terminal. Utilizatorul are nevoie și de un convertor TTL în USB pentru a vedea datele de prezență prin terminalul serial.

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.