- Composants requis
- Schéma de circuit et explication
- Fonctionnement du capteur d'empreintes digitales avec microcontrôleur PIC
- Explication de la programmation
Le capteur d'empreintes digitales, que nous avions l'habitude de voir dans les films de science-fiction il y a quelques années, est maintenant devenu très courant pour vérifier l'identité d'une personne à diverses fins. À l'heure actuelle, nous pouvons voir des systèmes basés sur les empreintes digitales partout dans notre vie quotidienne comme pour la présence dans les bureaux, la vérification des employés dans les banques, pour les retraits d'espèces ou les dépôts dans les guichets automatiques, pour la vérification d'identité dans les bureaux gouvernementaux, etc. Nous l'avons déjà interfacé avec Arduino et avec Raspberry Pi, nous allons aujourd'hui interfacer le capteur d'empreintes digitales avec le microcontrôleur PIC. En utilisant ce microcontrôleur PIC PIC16f877A Finger Print System, nous pouvons enregistrer de nouvelles empreintes digitales dans le système et supprimer les empreintes digitales déjà alimentées. Le fonctionnement complet du système a été montré dans la vidéo donné en fin d'article.
Composants requis
- Microcontrôleur PIC16f877A
- Module d'empreintes digitales
- Boutons poussoirs ou clavier
- Écran LCD 16x2
- Pot de 10k
- Oscillateur à cristal 18,432000 MHz
- Planche à pain ou PCB (commandé auprès de JLCPCB)
- Fils de cavalier
- LED (en option)
- Résistance 150 ohm -1 k ohm (en option)
- Alimentation 5v
Schéma de circuit et explication
Dans ce projet d'interfaçage de capteur PIC Microcontroller Finger Print, nous avons utilisé 4 boutons poussoirs: ces boutons sont utilisés pour le multifonction. La touche 1 est utilisée pour faire correspondre l'empreinte digitale et incrémenter l'ID d'empreinte digitale lors du stockage ou de la suppression de l'empreinte digitale dans le système. La touche 2 est utilisée pour enregistrer la nouvelle empreinte digitale et pour décrémenter l'ID d'empreinte lors du stockage ou de la suppression de l'empreinte digitale dans le système. La touche 3 est utilisée pour supprimer le doigt enregistré du système et la touche 4 pour OK. Une LED est utilisé pour indiquer que l'empreinte digitale est détectée ou mise en correspondance. Ici, nous avons utilisé un module d'empreintes digitales qui fonctionne sur UART. Nous avons donc interfacé ce module d'empreintes digitales avec le microcontrôleur PIC à sa vitesse de transmission par défaut qui est de 57600.
Donc, tout d'abord, nous devons effectuer toutes les connexions requises comme indiqué dans le schéma de circuit ci-dessous. Les connexions sont simples, nous venons de connecter le module d'empreintes digitales à l'UART du microcontrôleur PIC. Un écran LCD 16x2 est utilisé pour afficher tous les messages. Un pot 10k est également utilisé avec l'écran LCD pour contrôler le contraste de celui-ci. Les broches de données LCD 16x2 sont des broches PORTA connectées. Les broches d4, d5, d6 et d7 de l'écran LCD sont respectivement connectées aux broches RA0, RA1, RA2 et RA3 du microcontrôleur PIC. Quatre boutons poussoirs (ou clavier) sont connectés aux broches RD0, RD1, RD2 et RD de PORTD. La LED est également connectée à la broche RC3 du port PORTC. Ici, nous avons utilisé un oscillateur à cristal externe de 18,432000 MHz pour synchroniser le microcontrôleur.
Fonctionnement du capteur d'empreintes digitales avec microcontrôleur PIC
Le fonctionnement de ce projet est simple, il suffit de télécharger un fichier hexadécimal, généré à partir du code source, dans le microcontrôleur PIC à l'aide du programmeur ou du graveur PIC (PIckit2 ou Pickit3 ou autres), puis vous verrez des messages d'introduction sur l'écran LCD, puis l'utilisateur sera invité à entrer un choix pour les opérations. Pour faire correspondre l'empreinte digitale, l'utilisateur doit appuyer sur la touche 1, puis l'écran LCD vous demandera de placer le doigt sur le capteur d' empreinte digitale. Maintenant, en plaçant un doigt sur le module d'empreintes digitales, nous pouvons vérifier si nos empreintes digitales sont déjà stockées ou non. Si votre empreinte digitale est stockée, l'écran LCD affichera le message avec l'ID de stockage de ' ID: 2' de type empreinte digitale , sinon il affichera 'Not Found' .
Maintenant, pour enregistrer une empreinte digitale , l' utilisateur doit appuyer sur le bouton d'enregistrement ou la touche 2 et suivre les messages d'instructions sur l'écran LCD.
Si l'utilisateur souhaite supprimer l'une des empreintes digitales, il doit appuyer sur le bouton ou la touche 3 de suppression . Après quoi, l'écran LCD demandera l'ID de l'empreinte à supprimer. Maintenant, en utilisant le bouton-poussoir d'incrémentation ou la touche 1 (faire correspondre le bouton-poussoir ou la touche 1) et le bouton-poussoir ou la touche 2 de décrémentation (bouton-poussoir d'enregistrement ou touche 2) pour incrémenter et décrémenter, l'utilisateur peut sélectionner l'ID de l'empreinte digitale enregistrée et appuyer sur OK bouton pour supprimer cette empreinte digitale. Pour plus de compréhension, jetez un œil à la vidéo donnée à la fin du projet.
Interfaçage FingerPrint Remarque: Le programme de ce projet est un peu complexe pour un débutant. Mais son code d'interfaçage simple fait en utilisant la lecture de la fiche technique du module d'empreintes digitales r305. Toutes les instructions de fonctionnement de ce module d'empreintes digitales sont données dans la fiche technique.
Ici, nous avons utilisé un format de trame pour parler avec le module d'empreintes digitales. Chaque fois que nous envoyons une commande ou une trame de demande de données au module d'empreintes digitales, il nous répond avec le même format de trame contenant des données ou des informations liées à la commande appliquée. Toutes les données et le format de la trame de commande ont été indiqués dans le manuel d'utilisation ou dans la fiche technique du module d'empreintes digitales R305.
Explication de la programmation
En programmation, nous avons utilisé le format de trame ci-dessous.
Nous commençons le programme en définissant les bits de configuration et en définissant des macros et des broches pour LCD, boutons et LED, que vous pouvez vérifier dans le code complet donné à la fin de ce projet. Si vous êtes nouveau sur PIC Microcontroller, commencez par Démarrer avec PIC Microcontroller Project.
Ensuite, nous avons déclaré et initialisé une variable et un tableau, et créé une trame que nous devons utiliser dans ce projet pour interfacer le module d'empreintes digitales avec le microcontrôleur PIC.
uchar buf; uchar buf1; indice uint volatil = 0; indicateur int volatile = 0; uint msCount = 0; uint g_timerflag = 1; nombre uint volatil = 0; données uchar; uint id = 1; énumération { CMD, DATA, SBIT_CREN = 4, SBIT_TXEN, SBIT_SPEN, }; const char passPack = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x7, 0x13, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1B}; const char f_detect = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x3, 0x1, 0x0, 0x5}; const char f_imz2ch1 = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x4, 0x2, 0x1, 0x0, 0x8}; const char f_imz2ch2 = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x4, 0x2, 0x2, 0x0, 0x9}; const char f_createModel = {0xEF, 0x1,0xFF, 0xFF, 0xFF, 0xFF, 0x1,0x0,0x3,0x5,0x0,0x9}; char f_storeModel = {0xEF, 0x1,0xFF, 0xFF, 0xFF, 0xFF, 0x1,0x0,0x6,0x6,0x1,0x0,0x1,0x0,0xE}; const char f_search = {0xEF, 0x1, 0xFF, 0xFF, 0xFF, 0xFF, 0x1, 0x0, 0x8, 0x1B, 0x1, 0x0, 0x0, 0x0, 0xA3, 0x0, 0xC8}; char f_delete = {0xEF, 0x1,0xFF, 0xFF, 0xFF, 0xFF, 0x1,0x0,0x7,0xC, 0x0,0x0,0x0,0x1,0x0,0x15};
Après cela, nous avons créé une fonction LCD pour piloter l'écran LCD.
void lcdwrite (uchar ch, uchar rw) { LCDPORT = ch >> 4 & 0x0F; RS = rw; EN = 1; __delay_ms (5); EN = 0; LCDPORT = ch & 0x0F; EN = 1; __delay_ms (5); EN = 0; } Lcdprint (char * str) { while (* str) { lcdwrite (* str ++, DATA); // __ delay_ms (20); } } lcdbegin () { uchar lcdcmd = {0x02,0x28,0x0E, 0x06,0x01}; uint i = 0; pour (i = 0; i <5; i ++) lcdwrite (lcdcmd, CMD); }
La fonction donnée est utilisée pour initialiser UART
void serialbegin (uint baudrate) { SPBRG = (18432000UL / (long) (64UL * baudrate)) - 1; // débit en bauds @ 18.432000Mhz Horloge TXSTAbits.SYNC = 0; // Réglage du mode asynchrone, ie UART RCSTAbits.SPEN = 1; // Active le port série TRISC7 = 1; // Tel que prescrit dans la fiche technique TRISC6 = 0; // Tel que prescrit dans la fiche technique RCSTAbits.CREN = 1; // Active la réception continue TXSTAbits.TXEN = 1; // Active la transmission GIE = 1; // ENABLE interrompt INTCONbits.PEIE = 1; // Activer les interruptions périphériques. PIE1bits.RCIE = 1; // ACTIVER l'interruption de réception USART PIE1bits.TXIE = 0; // désactiver l'interruption USART TX PIR1bits.RCIF = 0; }
Les fonctions données sont utilisées pour transférer des commandes vers le module d'empreintes digitales et recevoir des données du module d'empreintes digitales.
void serialwrite (char ch) { while (TXIF == 0); // Attendre que le registre de l'émetteur devienne vide TXIF = 0; // Effacer l'indicateur d'émetteur TXREG = ch; // charge le caractère à transmettre dans le registre de transmission } serialprint (char * str) { while (* str) { serialwrite (* str ++); } } interruption vide SerialRxPinInterrupt (void) { if ((PIR1bits.RCIF == 1) && (PIE1bits.RCIE == 1)) { uchar ch = RCREG; buf = ch; si (index> 0) indicateur = 1; RCIF = 0; // effacer l'indicateur rx } } void serialFlush () { for (int i = 0; i
Après cela, nous devons créer une fonction qui prépare les données à transmettre à l'empreinte digitale et décode les données provenant du module d'empreintes digitales.
int sendcmd2fp (char * pack, int len) { uint res = ERROR; serialFlush (); index = 0; __delay_ms (100); pour (int i = 0; i
Maintenant, il y a quatre fonctions disponibles dans le code pour quatre tâches différentes:
- Fonction de saisie de l'ID d'empreinte digitale - unit getId ()
- Fonction pour faire correspondre le doigt - void matchFinger ()
- Fonction d' enregistrement d'un nouveau doigt - void enrolFinger ()
- Fonction de suppression d'un doigt - void deleteFinger ()
Le code complet avec les quatre fonctions est donné à la fin.
Maintenant, dans la fonction principale, nous initialisons les GPIO, LCD, UART et vérifions si le module d'empreintes digitales est connecté à un microcontrôleur ou non. Ensuite, il affiche des messages d'introduction sur l'écran LCD. Enfin, en tout en boucle on lit toutes les touches ou boutons pour faire fonctionner le projet.
int main () { void (* FP) (); ADCON1 = 0b00000110; LEDdir = 0; SWPORTdir = 0xF0; SWPORT = 0x0F; serialbegin (57600); LCDPORTDIR = 0x00; TRISE = 0; lcdbegin (); lcdprint ("Fingerprint"); lcdwrite (192, CMD); lcdprint ("Interfaçage"); __delay_ms (2000); lcdwrite (1, CMD); lcdprint ("Utilisation de PIC16F877A"); lcdwrite (192, CMD); lcdprint ("Circuit Digest"); __delay_ms (2000); index = 0; while (sendcmd2fp (& passPack, sizeof (passPack))) { lcdwrite (1, CMD); lcdprint ("FP introuvable"); __delay_ms (2000); index = 0; } lcdwrite (1, CMD); lcdprint ("FP Found"); __delay_ms (1000); lcdinst (); while (1) { FP = match
Le code PIC complet et une vidéo de travail sont donnés ci-dessous. Consultez également nos autres projets utilisant le module de capteur d'empreinte digitale:
- Machine de vote biométrique basée sur les empreintes digitales utilisant Arduino
- Système de sécurité biométrique utilisant Arduino et capteur d'empreintes digitales
- Système de présence biométrique basé sur les empreintes digitales utilisant Arduino
- Interfaçage du capteur d'empreintes digitales avec Raspberry Pi