Sistema de atendimento biométrico baseado em impressão digital usando microcontrolador atmega32

De acordo com pesquisadores da Pen State University, os humanos são mais propensos a confiar nas máquinas do que nas pessoas, o que é provavelmente evidente quando revelamos nosso PIN do caixa eletrônico a uma máquina com tanta facilidade. Hoje, no mundo onde IA, aprendizado de máquina, bots de bate-papo, alto-falantes inteligentes, robôs etc. estão progredindo ativamente, essa sinergia entre humanos e robôs tende a aumentar. Hoje, de cobradores de pedágio a caixas, tudo ao nosso redor está sendo substituído por máquinas para fazer o trabalho com mais facilidade e eficiência. Para acompanhar a fase, neste projeto iremos construir um sistema Biométrico de Atendimento utilizando microcontroladores AVR em substituição ao procedimento manual de atendimento. Este sistema será mais confiável e eficiente, pois economizará tempo e evitará esquivas.

Os sistemas de atendimento por impressão digital já estão disponíveis diretamente no mercado, mas o que é mais divertido do que construir um? Também construímos uma ampla variedade de sistemas de atendimento anteriormente, desde um sistema de atendimento simples baseado em RFID até um sistema de atendimento biométrico baseado em IoT usando Arduino e Raspberry Pi. Neste projeto, utilizamos o Módulo de impressão digital e AVR (atmega32) para o registro de atendimento. Ao usar o sensor de impressão digital, o sistema se tornará mais seguro para os usuários. As seções a seguir explicam detalhes técnicos de como fazer um sistema de atendimento biométrico baseado em impressão digital usando AVR.

Componentes Requeridos

1. Atmega32 -1
2. Módulo de impressão digital (r305) -1
3. Botão de pressão ou botões de membrana - 4
4. LEDs -2
5. 1K Resistor -2
6. 2.2K resistor -1
7. Adaptador de energia 12v
8. Fios de conexão
9. Buzzer -1
10. 16x2 LCD -1
11. PCB ou placa de pão
12. Módulo RTC (ds1307 ou ds3231) -1
13. LM7805 -1
14. 1000uf, capacitor de 10uf -1
15. Burgstips masculino feminino
16. DC JACK (opcional)
17. BC547 Transistor -1

Neste circuito do sistema de atendimento por impressão digital, usamos o módulo Sensor de Impressão Digital para autenticar a identidade de uma pessoa ou funcionário, obtendo sua entrada de impressão digital no sistema. Aqui, estamos usando 4 botões para registrar, excluir, aumentar e diminuir os dados de impressão digital . A chave 1 é usada para inscrição de uma nova pessoa no sistema. Portanto, quando o usuário deseja registrar um novo dedo, ele precisa pressionar a tecla 1 e o LCD pede que ele coloque um dedo no sensor de impressão digital duas vezes e, em seguida, solicita uma ID de funcionário. Da mesma forma, a tecla 2 tem função dupla, como quando o usuário registra um novo dedo, então ele / ela precisa selecionar a identificação da impressão digitalusando outras duas teclas, a saber, 3 e 4. Agora o usuário precisa pressionar a tecla 1 (desta vez, esta tecla se comporta como OK) para prosseguir com a ID selecionada. E a tecla 2 também é usada para redefinir ou excluir dados da EEPROM do microcontrolador.

O módulo sensor de impressão digital captura a imagem da impressão digital e, em seguida, converte-a no modelo equivalente e os salva em sua memória de acordo com a ID selecionada pelo microcontrolador. Todo o processo é comandado pelo microcontrolador, como tirar uma imagem da impressão digital; convertê-lo em modelos e armazená-lo como ID etc. Você também pode verificar esses outros projetos de sensor de impressão digital, onde construímos um sistema de segurança de sensor de impressão digital e uma máquina de votação de sensor de impressão digital.

Diagrama de circuito

O diagrama de circuito completo para projeto de sistema de atendimento baseado em impressão digital é mostrado abaixo. Possui microcontrolador Atmega32 para controle de todo o processo do projeto. O botão pulsador ou de membrana é utilizado para cadastrar, deletar, selecionar IDs para atendimento, uma campainha é utilizada para indicação e um LCD 16x2 para instruir o usuário sobre como utilizar a máquina.

Conforme mostrado no diagrama de circuito, os botões de pressão ou de membrana são conectados diretamente ao pino PA2 (tecla ENROLL 1), PA3 (tecla DEL 2), PA0 (tecla UP 3), PA1 (tecla DOWN 4) do microcontrolador em relação ao solo ou PA4. E um LED é conectado no pino PC2 do microcontrolador em relação ao aterramento por meio de um resistor de 1k. Rx e Tx do módulo de impressão digital diretamente conectado ao pino serial PD1 e PD3 do microcontrolador. A fonte de 5v é usada para alimentar todo o circuito usando o regulador de tensão LM7805que é alimentado por adaptador 12v dc. Uma campainha também está conectada no pino PC3. Um LCD 16x2 é configurado no modo de 4 bits e seus RS, RW, EN, D4, D5, D6 e D7 são conectados diretamente no pino PB0, PB1, PB2, PB4, PB5, PB6, PB7 do microcontrolador. O módulo RTC está conectado a I2Cpin PC0 SCL e PC1 SDA. E o PD7 é usado como um pino UART Tx flexível para obter a hora atual.

Como funciona o sistema de atendimento por impressão digital

Sempre que o usuário colocar o dedo sobre o módulo de impressão digital, o módulo de impressão digital captura a imagem do dedo e pesquisa se algum ID está associado a essa impressão digital no sistema. Se a identificação da impressão digital for detectada, o LCD mostrará Presença registrada e ao mesmo tempo a campainha emitirá um bipe.

Junto com o módulo de impressão digital, também usamos um módulo RTC para dados de data e hora. A hora e a data estão funcionando continuamente no sistema, então o microcontrolador pode levar a hora e a data sempre que um verdadeiro usuário colocar seu dedo sobre o sensor de impressão digital e salvá-los na EEPROM no slot de memória alocado.

O usuário pode baixar os dados de atendimento pressionando e segurando a tecla 4. Conecte a alimentação ao circuito e aguarde e, após algum tempo, o LCD mostrará 'Baixando….'. E o usuário pode ver os dados de atendimento pelo monitor serial, aqui neste código o software UART é programado no pino PD7-pin20 como Tx para enviar dados ao terminal. O usuário também precisa de um conversor TTL para USB para ver os dados de atendimento no terminal 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.