Biometrisches Anwesenheitssystem auf Fingerabdruckbasis mit atmega32-Mikrocontroller

Laut Forschern der Pen State University vertrauen Menschen eher Maschinen als Menschen, was wahrscheinlich daran zu erkennen ist, dass wir unseren Geldautomaten-Pin so einfach einem Automaten zeigen. In der Welt, in der KI, maschinelles Lernen, Chat-Bots, intelligente Lautsprecher, Roboter usw. aktiv Fortschritte machen, wird diese Synergie zwischen Menschen und Robotern nur noch zunehmen. Heute wird alles um uns herum durch Maschinen ersetzt, um die Arbeit einfacher und effizienter zu erledigen, von Brückenmautsammlern bis hin zu Kassierern an der Kasse. Um mit der Phase Schritt zu halten, werden wir in diesem Projekt ein biometrisches Anwesenheitssystem mit AVR-Mikrocontrollern bauen, um das manuelle Verfahren zur Teilnahme zu ersetzen. Dieses System ist zuverlässiger und effizienter, da es Zeit spart und Ausweichmanöver vermeidet.

Fingerabdruck-Anwesenheitssysteme sind bereits direkt vom Markt erhältlich, aber was macht mehr Spaß, als eines zu erstellen ? Wir haben auch früher eine Vielzahl von Anwesenheitssystemen gebaut, von einem einfachen RFID-basierten Anwesenheitssystem bis zu einem IoT-basierten biometrischen Anwesenheitssystem mit Arduino und Raspberry Pi. In diesem Projekt haben wir das Fingerabdruckmodul und AVR (atmega32) verwendet, um die Teilnahme zu registrieren. Durch die Verwendung eines Fingerabdrucksensors wird das System für die Benutzer sicherer. In den folgenden Abschnitten werden technische Details zur Erstellung eines Fingerabdruck-basierten biometrischen Anwesenheitssystems mit AVR erläutert.

Erforderliche Komponenten

1. Atmega32 -1
2. Fingerabdruckmodul (r305) -1
3. Druckknopf oder Membrantasten - 4
4. LEDs -2
5. 1K Widerstand -2
6. 2,2 K Widerstand -1
7. Netzteil 12V Adapter
8. Kabel anschließen
9. Summer -1
10. 16x2 LCD -1
11. PCB oder Brotplatte
12. RTC-Modul (ds1307 oder ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf Kondensator -1
15. Burgstips männlich weiblich
16. DC JACK (optional)
17. BC547 Transistor -1

In dieser Schaltung des Fingerabdruck-Anwesenheitssystems haben wir das Fingerabdruck-Sensormodul verwendet, um die Identität einer Person oder eines Mitarbeiters zu authentifizieren, indem deren Fingerabdruck-Eingabe in das System übernommen wird. Hier verwenden wir 4 Drucktasten, um Fingerabdruckdaten zu registrieren, zu löschen, zu erhöhen und zu verringern . Schlüssel 1 wird für die Registrierung einer neuen Person im System verwendet. Wenn der Benutzer einen neuen Finger registrieren möchte, muss er die Taste 1 drücken. Das LCD fordert ihn auf, zweimal einen Finger auf den Fingerabdrucksensor zu legen, und fragt dann nach einer Mitarbeiter-ID. In ähnlicher Weise hat Taste 2 eine Doppelfunktion, z. B. wenn der Benutzer einen neuen Finger anmeldet, muss er die Fingerabdruck-ID auswählenVerwenden Sie zwei weitere Tasten, nämlich 3 und 4. Jetzt muss der Benutzer die Taste 1 drücken (diesmal verhält sich diese Taste wie OK), um mit der ausgewählten ID fortzufahren. Die Taste 2 wird auch zum Zurücksetzen oder Löschen von Daten aus dem EEPROM des Mikrocontrollers verwendet.

Das Fingerabdrucksensormodul erfasst das Fingerabdruckbild, konvertiert es dann in die entsprechende Vorlage und speichert sie gemäß der vom Mikrocontroller ausgewählten ID in seinem Speicher. Der gesamte Vorgang wird vom Mikrocontroller gesteuert, z. B. das Aufnehmen eines Fingerabdrucks. Konvertieren Sie es in Vorlagen und speichern Sie es als ID usw. Sie können sich auch diese anderen Projekte für Fingerabdrucksensoren ansehen, in denen wir ein Sicherheitssystem für Fingerabdrucksensoren und ein Abstimmungsgerät für Fingerabdrucksensoren entwickelt haben.

Schaltplan

Das vollständige Schaltbild für ein auf Fingerabdrücken basierendes Anwesenheitssystem ist unten dargestellt. Es verfügt über einen Atmega32-Mikrocontroller zur Steuerung des gesamten Projektprozesses. Der Druck- oder Membrantaster dient zum Registrieren, Löschen, Auswählen von IDs für die Teilnahme, ein Summer zur Anzeige und ein 16x2-LCD, um den Benutzer in die Verwendung des Geräts einzuweisen.

Wie im Schaltplan gezeigt, sind Druck- oder Membrantasten direkt mit Pin PA2 (ENROLL-Taste 1), PA3 (DEL-Taste 2), PA0 (UP-Taste 3), PA1 (DOWN-Taste 4) des Mikrocontrollers in Bezug auf Masse verbunden oder PA4. Und eine LED ist an Pin PC2 des Mikrocontrollers in Bezug auf Masse über einen 1k-Widerstand angeschlossen. Rx und Tx des Fingerabdruckmoduls sind direkt an den seriellen Pins PD1 und PD3 des Mikrocontrollers angeschlossen. Die 5-V-Versorgung dient zur Stromversorgung des gesamten Stromkreises mithilfe des Spannungsreglers LM7805welches von 12V Gleichstromadapter gespeist wird. Ein Summer ist ebenfalls an Pin PC3 angeschlossen. Ein 16x2-LCD ist im 4-Bit-Modus konfiguriert und seine RS, RW, EN, D4, D5, D6 und D7 sind direkt an Pin PB0, PB1, PB2, PB4, PB5, PB6, PB7 des Mikrocontrollers angeschlossen. Das RTC-Modul ist an I2Cpin PC0 SCL und PC1 SDA angeschlossen. Und PD7 wird als weicher UART Tx-Pin verwendet, um die aktuelle Zeit abzurufen.

Funktionsweise des Fingerabdruck-Anwesenheitssystems

Immer wenn der Benutzer seinen Finger über das Fingerabdruckmodul legt, erfasst das Fingerabdruckmodul das Fingerbild und sucht, ob diesem Fingerabdruck im System eine ID zugeordnet ist. Wenn eine Fingerabdruck-ID erkannt wird, zeigt das LCD die registrierte Anwesenheit an und gleichzeitig piept der Summer einmal.

Neben dem Fingerabdruckmodul haben wir auch ein RTC-Modul für Zeit- und Datumsdaten verwendet. Uhrzeit und Datum werden kontinuierlich im System ausgeführt, sodass der Mikrocontroller Zeit und Datum erfassen kann, wenn ein echter Benutzer seinen Finger über den Fingerabdrucksensor legt und diese dann im EEPROM am zugewiesenen Speicherplatz speichert.

Der Benutzer kann die Anwesenheitsdaten herunterladen, indem er die Taste 4 gedrückt hält. Schließen Sie die Stromversorgung an den Stromkreis an und warten Sie. Nach einiger Zeit zeigt das LCD "Herunterladen…." an. Und der Benutzer kann die Anwesenheitsdaten über den seriellen Monitor sehen. Hier in dieser Codesoftware ist UART an Pin PD7-Pin20 als Tx programmiert, um Daten an das Terminal zu senden. Der Benutzer benötigt außerdem einen TTL-zu-USB-Konverter, um die Anwesenheitsdaten über das serielle Terminal anzuzeigen.

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.