Système de présence biométrique basé sur les empreintes digitales utilisant le microcontrôleur atmega32

Selon des chercheurs de l'Université d'État de Pen, les humains sont plus susceptibles de faire confiance aux machines qu'aux personnes, ce qui est probablement évident lorsque nous révélons si facilement notre broche ATM à une machine. Aujourd'hui, dans le monde où l'IA, l'apprentissage automatique, les robots de chat, les haut-parleurs intelligents, les robots, etc. progressent activement, cette synergie entre humains et robots ne fera que croître. Aujourd'hui, des percepteurs de péage aux caisses de sortie, tout autour de nous est remplacé par des machines pour rendre le travail plus facile et plus efficace. Pour suivre la phase, dans ce projet, nous allons construire un système de présence bio-métrique utilisant des microcontrôleurs AVR pour remplacer la procédure manuelle de prise de présence. Ce système sera plus fiable et efficace car il gagnerait du temps et éviterait les escrocs.

Les systèmes de présence d'empreintes digitales sont déjà facilement disponibles directement sur le marché, mais quoi de plus amusant que d'en construire un? Nous avons également construit une grande variété de systèmes de présence plus tôt, d'un simple système de présence basé sur RFID à un système de présence biométrique basé sur l'IoT utilisant Arduino et Raspberry Pi. Dans ce projet, nous avons utilisé le module d'empreintes digitales et AVR (atmega32) pour enregistrer la présence. En utilisant un capteur d'empreintes digitales, le système deviendra plus sécurisé pour les utilisateurs. Les sections suivantes expliquent les détails techniques de la création d'un système de présence biométrique basé sur les empreintes digitales à l'aide d'AVR.

Composants requis

1. Atmega32 -1
2. Module d'empreintes digitales (r305) -1
3. Bouton poussoir ou boutons à membrane - 4
4. LED -2
5. Résistance 1K -2
6. 2.2K résistance -1
7. Adaptateur d'alimentation 12v
8. Fils de connexion
9. Buzzer -1
10. Écran LCD 16x2 -1
11. PCB ou planche à pain
12. Module RTC (ds1307 ou ds3231) -1
13. LM7805 -1
14. Condensateur 1000 uf, 10 uf -1
15. Burgstips mâle femelle
16. DC JACK (en option)
17. BC547 Transistor -1

Dans ce circuit du système de présence d'empreintes digitales, nous avons utilisé le module de capteur d'empreintes digitales pour authentifier l'identité d'une personne ou d'un employé en prenant leur entrée d'empreintes digitales dans le système. Ici, nous utilisons 4 boutons poussoirs pour enregistrer, supprimer, incrémenter et décrémenter les données d'empreintes digitales . La clé 1 est utilisée pour l'inscription d'une nouvelle personne dans le système. Ainsi, lorsque l'utilisateur souhaite enregistrer un nouveau doigt, il doit appuyer sur la touche 1, puis l'écran LCD lui demande de placer un doigt sur le capteur d'empreintes digitales deux fois, puis il demande un identifiant d'employé. De même, la touche 2 a une double fonction, comme lorsque l'utilisateur enregistre un nouveau doigt, alors il / elle doit sélectionner l'ID d'empreinte digitaleen utilisant deux autres touches, à savoir 3 et 4. Maintenant, l'utilisateur doit appuyer sur la touche 1 (cette fois cette touche se comporte comme OK) pour continuer avec l'ID sélectionné. Et la touche 2 est également utilisée pour réinitialiser ou supprimer des données de l'EEPROM du microcontrôleur.

Le module de capteur d'empreintes digitales capture l'image d'impression du doigt, puis la convertit en modèle équivalent et les enregistre dans sa mémoire selon l'ID sélectionné par le microcontrôleur. Tout le processus est commandé par le microcontrôleur, comme prendre une image d'empreinte digitale; convertissez-le en modèles et stockez-le en tant qu'ID, etc.

Schéma

Le schéma de circuit complet du projet de système de présence basé sur les empreintes digitales est illustré ci-dessous. Il a un microcontrôleur Atmega32 pour contrôler tout le processus du projet. Le bouton poussoir ou à membrane est utilisé pour enregistrer, supprimer, sélectionner les identifiants pour la présence, un buzzer est utilisé pour l'indication et un écran LCD 16x2 pour indiquer à l'utilisateur comment utiliser la machine.

Comme indiqué sur le schéma de circuit, les boutons poussoirs ou à membrane sont directement connectés à la broche PA2 (touche ENROLL 1), PA3 (touche DEL 2), PA0 (touche UP 3), PA1 (touche DOWN 4) du microcontrôleur par rapport à la terre ou PA4. Et une LED est connectée à la broche PC2 du microcontrôleur par rapport à la terre via une résistance de 1k. Rx et Tx du module d'empreintes digitales directement connectés aux broches série PD1 et PD3 du microcontrôleur. L'alimentation 5v est utilisée pour alimenter l'ensemble du circuit en utilisant le régulateur de tension LM7805qui est alimenté par un adaptateur 12v cc. Un buzzer est également connecté à la broche PC3. Un écran LCD 16x2 est configuré en mode 4 bits et ses RS, RW, EN, D4, D5, D6 et D7 sont directement connectés à la broche PB0, PB1, PB2, PB4, PB5, PB6, PB7 du microcontrôleur. Le module RTC est connecté à I2Cpin PC0 SCL et PC1 SDA. Et PD7 est utilisé comme broche UART Tx douce pour obtenir l'heure actuelle.

Fonctionnement du système de présence d'empreintes digitales

Chaque fois que l'utilisateur place son doigt sur le module d'empreinte digitale, le module d'empreinte digitale capture l'image du doigt et recherche si un identifiant est associé à cette empreinte digitale dans le système. Si l'ID d'empreinte digitale est détecté, l'écran LCD affichera Présence enregistrée et dans le même temps, le buzzer émettra un bip.

En plus du module d'empreintes digitales, nous avons également utilisé un module RTC pour les données d' heure et de date. L'heure et la date fonctionnent en continu dans le système, de sorte que le microcontrôleur peut prendre l'heure et la date chaque fois qu'un véritable utilisateur place son doigt sur le capteur d'empreintes digitales, puis les enregistre dans l'EEPROM à l'emplacement de mémoire alloué.

L'utilisateur peut télécharger les données de présence en appuyant sur la touche 4. et en la maintenant enfoncée. Connectez l'alimentation au circuit et attendez et après un certain temps, l'écran LCD affichera «Téléchargement…». Et l'utilisateur peut voir les données de présence sur le moniteur série, ici dans ce logiciel de code UART est programmé à la broche PD7-pin20 comme Tx pour envoyer des données au terminal. L'utilisateur a également besoin d'un convertisseur TTL vers USB pour voir les données de présence sur le 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.