Sistema d'assistència biomètrica basat en empremta digital mitjançant microcontrolador atmega32

Segons investigadors de la Pen state University, és més probable que els humans confiem en les màquines per sobre de les persones, cosa que és evident que revelem amb tanta facilitat el pin ATM a una màquina. Avui, al món on la IA, l’aprenentatge automàtic, els bots de xat, els altaveus intel·ligents, els robots, etc. progressen activament, aquesta sinergia entre humans i robots només està prevista per augmentar. Avui en dia, des dels cobradors de peatges dels ponts fins als caixers de sortida, tot el que ens envolta està sent substituït per màquines per fer la feina més fàcil i eficaç. Per estar al dia de la fase, en aquest projecte construirem un sistema d’assistència biomètrica mitjançant microcontroladors AVR per substituir el procediment manual d’assistència. Aquest sistema serà més fiable i eficient, ja que estalviaria temps i evitaria els esquivadors.

Els sistemes d’assistència d’empremtes digitals ja estan disponibles directament al mercat, però què és més divertit que construir-ne un? També hem creat una àmplia varietat de sistemes d’assistència anteriorment, des d’un simple sistema d’assistència basat en RFID fins a un sistema d’assistència biomètric basat en IoT que utilitza Arduino i Raspberry Pi. En aquest projecte, hem utilitzat el mòdul d’empremtes digitals i l’AVR (atmega32) per registrar l’assistència. En utilitzar el sensor d’empremtes digitals, el sistema serà més segur per als usuaris. A les seccions següents s’expliquen els detalls tècnics de la creació d’un sistema d’assistència biomètric basat en empremtes digitals mitjançant AVR.

Components necessaris

1. Atmega32 -1
2. Mòdul d’empremta digital (r305) -1
3. Polsadors o botons de membrana: 4
4. LEDs -2
5. Resistència 1K -2
6. Resistència de 2,2K -1
7. Adaptador de potència 12v
8. Connexió de cables
9. Buzzer -1
10. LCD de 16 x 2 -1
11. PCB o tauler de pa
12. Mòdul RTC (ds1307 o ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf condensador -1
15. Burgstips femella masculina
16. DC JACK (opcional)
17. BC547 Transistor -1

En aquest circuit del sistema d’assistència d’empremtes digitals, hem utilitzat el mòdul Sensor d’empremtes dactilars per autenticar la identitat d’una persona o empleat prenent la seva entrada d’ empremta digital al sistema. Aquí fem servir 4 botons policials per registrar, suprimir, incrementar i disminuir les dades d’impressió digital . La clau 1 s'utilitza per inscriure una nova persona al sistema. Per tant, quan l'usuari vol registrar un nou dit, ha de prémer la tecla 1 i, a continuació, el LCD li demana que col·loqui un dit al sensor d'empremtes digitals dues vegades i després li demani una identificació d'empleat. De la mateixa manera, la tecla 2 té una doble funció, com quan l'usuari registra un dit nou, ha de seleccionar un identificador d'empremta digitalutilitzant altres dues tecles, és a dir, la 3 i la 4. Ara l’usuari ha de prémer la tecla 1 (aquesta vegada es comporta com a OK) per continuar amb l’identificador seleccionat. I la clau 2 també s’utilitza per restablir o eliminar dades de l’EEPROM del microcontrolador.

El mòdul del sensor d’empremtes digitals captura la imatge d’impressió digital i la converteix en la plantilla equivalent i les guarda a la memòria segons l’identificador seleccionat pel microcontrolador. El microcontrolador mana tot el procés, com prendre una imatge de la empremta digital; convertir-lo en plantilles i emmagatzemar-lo com a identificador, etc. També podeu consultar aquests altres projectes de sensor d’empremta digital, on hem construït un sistema de seguretat de sensors d’empremtes digitals i una màquina de votar amb sensor d’empremtes digitals.

Esquema de connexions

A continuació es mostra el diagrama complet del circuit per al projecte de sistema d’assistència basat en empremtes digitals. Disposa de microcontrolador Atmega32 per controlar tot el procés del projecte. El polsador o el botó de membrana s’utilitza per inscriure’s, suprimir-los, seleccionar identificadors d’assistència, s’utilitza un brunzidor per indicar-los i un LCD de 16x2 per instruir l’usuari sobre com utilitzar la màquina.

Com es mostra al diagrama del circuit, els botons de pressió o de membrana estan connectats directament al pin PA2 (tecla ENROLL 1), PA3 (tecla DEL 2), PA0 (tecla UP 3), PA1 (tecla DOWN 4) del microcontrolador respecte a terra o PA4. I es connecta un LED al pin PC2 del microcontrolador respecte a terra mitjançant una resistència de 1 k. Rx i Tx del mòdul d’empremta digital connectats directament al pin sèrie PD1 i PD3 del microcontrolador. L’alimentació de 5v s’utilitza per alimentar tot el circuit mitjançant el regulador de tensió LM7805alimentat per un adaptador de corrent continu de 12v. També es connecta un brunzidor al pin PC3. Una pantalla LCD de 16x2 està configurada en mode de 4 bits i els seus RS, RW, EN, D4, D5, D6 i D7 estan connectats directament als pins PB0, PB1, PB2, PB4, PB5, PB6, PB7 del microcontrolador. El mòdul RTC està connectat a I2Cpin PC0 SCL i PC1 SDA. I PD7 s’utilitza com a pin UART Tx suau per obtenir l’hora actual.

Com funciona el sistema d’assistència d’empremtes digitals

Sempre que l'usuari col·loca el dit sobre el mòdul d'empremtes digitals, el mòdul d'empremtes digitals captura la imatge del dit i busca si hi ha alguna identificació associada amb aquesta empremta digital al sistema. Si es detecta una identificació d'empremta digital, el LCD mostrarà l'assistència registrada i, al mateix temps, el timbre emetrà un so.

Juntament amb el mòdul d’empremtes digitals, també hem utilitzat un mòdul RTC per a dades de data i hora. L’hora i la data s’executen contínuament al sistema, de manera que el microcontrolador pot trigar la data i l’hora sempre que un usuari real col·loca el dit sobre el sensor d’empremtes digitals i, a continuació, els guardi a la EEPROM a la ranura de memòria assignada.

L'usuari pot descarregar les dades d'assistència prement i mantenint premuda la tecla 4. Connecteu el subministrament al circuit i espereu i després d'un temps, la pantalla LCD mostrarà "Descarregant….". I l'usuari pot veure les dades d'assistència a través del monitor sèrie, aquí en aquest codi el programari UART està programat al pin PD7-pin20 com Tx per enviar dades al terminal. L'usuari també necessita un convertidor TTL a USB per veure les dades d'assistència a través del terminal sèrie.

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.