Sistema de asistencia biométrico basado en huellas dactilares usando microcontrolador atmega32

Según los investigadores de la Universidad Pen State, es más probable que los humanos confíen en las máquinas que en las personas, lo que probablemente sea evidente si revelamos nuestro pin de cajero automático a una máquina con tanta facilidad. Hoy en día, en el mundo donde la inteligencia artificial, el aprendizaje automático, los bots de chat, los altavoces inteligentes, los robots, etc.están progresando activamente, esta sinergia entre humanos y robots solo aumentará. Hoy en día, desde los cobradores de peajes hasta los cajeros de caja, todo lo que nos rodea está siendo reemplazado por máquinas para hacer el trabajo más fácil y eficiente. Para seguir el ritmo de la fase, en este proyecto construiremos un sistema de asistencia biométrica utilizando microcontroladores AVR para reemplazar el procedimiento manual de toma de asistencia. Este sistema será más confiable y eficiente ya que ahorraría tiempo y evitaría evasores.

Los sistemas de asistencia de huellas dactilares ya están disponibles directamente en el mercado, pero ¿qué es más divertido que construir uno? También hemos construido una amplia variedad de sistemas de asistencia anteriormente, desde un sistema de asistencia basado en RFID simple hasta un sistema de asistencia biométrico basado en IoT utilizando Arduino y Raspberry Pi. En este proyecto, hemos utilizado el módulo de huellas dactilares y AVR (atmega32) para registrar la asistencia. Al utilizar el sensor de huellas dactilares, el sistema será más seguro para los usuarios. Las siguientes secciones explican los detalles técnicos de cómo hacer un sistema de asistencia biométrico basado en huellas dactilares usando AVR.

Componentes requeridos

1. Atmega32 -1
2. Módulo de huellas dactilares (r305) -1
3. Botones pulsadores o de membrana - 4
4. LEDs -2
5. Resistencia 1K -2
6. Resistencia de 2,2 K -1
7. Adaptador de corriente 12v
8. Cables de conexión
9. Zumbador -1
10. Pantalla LCD 16x2 -1
11. PCB o tablero de pan
12. Módulo RTC (ds1307 o ds3231) -1
13. LM7805 -1
14. 1000uf, 10uf condensador -1
15. Burgstips macho hembra
16. DC JACK (opcional)
17. Transistor -1 BC547

En este circuito del sistema de asistencia de huellas dactilares, hemos utilizado el módulo del sensor de huellas dactilares para autenticar la identidad de una persona o empleado tomando su entrada de huellas dactilares en el sistema. Aquí estamos usando 4 botones para registrar, eliminar, incrementar y disminuir los datos de huellas dactilares . La clave 1 se utiliza para inscribir a una nueva persona en el sistema. Entonces, cuando el usuario desea registrar un nuevo dedo, debe presionar la tecla 1, luego la pantalla LCD le pide que coloque un dedo en el sensor de huellas dactilares dos veces y luego solicita una identificación de empleado. De manera similar, la tecla 2 tiene una función doble, como cuando el usuario inscribe un nuevo dedo, luego debe seleccionar la identificación de la huella digitalusando otras dos teclas, a saber, 3 y 4. Ahora el usuario debe presionar la tecla 1 (esta vez esta tecla se comporta como OK) para continuar con la ID seleccionada. Y la tecla 2 también se usa para restablecer o eliminar datos de EEPROM del microcontrolador.

El módulo del sensor de huellas dactilares captura la imagen de la huella dactilar y luego la convierte en la plantilla equivalente y la guarda en su memoria según la identificación seleccionada por el microcontrolador. Todo el proceso es comandado por el microcontrolador, como tomar una imagen de la huella dactilar; conviértalo en plantillas y almacénelo como ID, etc. También puede ver estos otros proyectos de sensores de huellas dactilares, donde hemos construido un sistema de seguridad con sensor de huellas dactilares y una máquina de votación con sensor de huellas dactilares.

Diagrama de circuito

El diagrama de circuito completo para el proyecto del sistema de asistencia basado en huellas dactilares se muestra a continuación. Dispone de microcontrolador Atmega32 para controlar todo el proceso del proyecto. El botón pulsador o de membrana se usa para registrar, eliminar, seleccionar ID para asistencia, se usa un timbre para indicar y una pantalla LCD de 16x2 para instruir al usuario sobre cómo usar la máquina.

Como se muestra en el diagrama del circuito, los botones pulsadores o de membrana están conectados directamente al pin PA2 (tecla ENROLL 1), PA3 (tecla DEL 2), PA0 (tecla ARRIBA 3), PA1 (tecla ABAJO 4) del microcontrolador con respecto a tierra o PA4. Y un LED está conectado en el pin PC2 del microcontrolador con respecto a tierra a través de una resistencia de 1k. Rx y Tx del módulo de huellas dactilares conectados directamente al pin serial PD1 y PD3 del microcontrolador. La fuente de 5v se usa para alimentar todo el circuito usando el regulador de voltaje LM7805que está alimentado por un adaptador de 12v dc. También se conecta un zumbador en el pin PC3. Una pantalla LCD de 16x2 está configurada en modo de 4 bits y sus RS, RW, EN, D4, D5, D6 y D7 están conectados directamente en los pines PB0, PB1, PB2, PB4, PB5, PB6, PB7 del microcontrolador. El módulo RTC está conectado en I2Cpin PC0 SCL y PC1 SDA. Y PD7 se utiliza como un pin UART Tx suave para obtener la hora actual.

Cómo funciona el sistema de asistencia de huellas dactilares

Siempre que el usuario coloca su dedo sobre el módulo de huellas dactilares, el módulo de huellas dactilares captura la imagen del dedo y busca si hay alguna identificación asociada con esta huella dactilar en el sistema. Si se detecta la identificación de la huella digital, la pantalla LCD mostrará Asistencia registrada y, al mismo tiempo, el zumbador sonará una vez.

Junto con el módulo de huellas dactilares, también hemos utilizado un módulo RTC para datos de fecha y hora. La hora y la fecha se ejecutan continuamente en el sistema, por lo que el microcontrolador puede tomar la hora y la fecha cada vez que un usuario real coloca su dedo sobre el sensor de huellas dactilares y luego guardarlos en la EEPROM en la ranura de memoria asignada.

El usuario puede descargar los datos de asistencia presionando y manteniendo presionada la tecla 4. Conecte el suministro al circuito y espere y después de un tiempo, la pantalla LCD mostrará 'Descargando….'. Y el usuario puede ver los datos de asistencia a través del monitor en serie, aquí en este código, el software UART está programado en el pin PD7-pin20 como Tx para enviar datos al terminal. El usuario también necesita un convertidor TTL a USB para ver los datos de asistencia a través del terminal serie.

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.