Club robotique de Sophia-Antipolis

Accueil > Projets, études > Nos jeunes roboticiens l’ont fait > Digital Poignée

Lecteur d’empreintes digitales

Digital Poignée

dimanche 19 juillet 2015, par michael

Reconnaissance d’empreintes digitales ADA751

Utilisation de la reconnaissance d’empreintes digitales (capteur ADA751) pour commander l’ouverture d’une serrure au moyen d’un servo moteur.
Je place mon doigt sur la poignée et la porte s’ouvre si elle le reconnaît. Mais comment ça marche ?

Remerciements : nous tenons à remercier Jean B. pour ses conseils avisés !

ÉTAPE 1 : Adapter la serrure du commerce au besoin du projet

JPEG - 416 ko

La serrure du commerce fonctionne avec l’intervention d’une main humaine. Au contraire, dans notre projet, la main humaine ne doit pas intervenir ; c’est un servomoteur qui devra agir. La difficulté consiste donc à vider les composants de la serrure qui ne nous servent pas pour n’utiliser que la partie du verrou. Le but étant de minimiser les efforts du servomoteur (éviter les frottements).

ÉTAPE 2 : Relier mécaniquement la serrure au servomoteur

PNG - 12.3 ko

Dans un premier temps, nous avons essayé de relier directement le servomoteur à l’axe du verrou, mais cela prenait trop de place dans la boite. Cette idée a été abandonnée.

Jean B a trouvé une solution qui fonctionne. Nous avons relié le moteur au verrou par l’intermédiaire d’une biellette en corde à piano de diamètre 1mm. Cette solution présente l’avantage de transformer le mouvement de rotation du servomoteur en une translation. De plus, il offre une élasticité suffisante en cas de blocage du verrou (s’il ne s’était que partiellement refermé).

ÉTAPE 3 : Système de fermeture de la boite

JPEG - 171.3 ko
La gâche

Le penne du verrou doit pénétrer dans une encoche lorsque le système est sollicité. A cet effet nous avons créé une pièce sur mesure, placée sur la partie opposée de la boite qui accueillera le verrou..

ÉTAPE 4 Placer les différents éléments de la fermeture dans la boite

PNG - 1.3 Mo

Nous avons placé à l’intérieur de la boite, le servo-moteur, la serrure, la carte Arduino et la poignée (qui comporte le lecteur d’empreintes digitales). Notre but était de loger l’ensemble des éléments dans le minimum de place, sans empiéter sur le volume de rangement de la boite ; cette disposition permettait en outre de limiter les câblages.

  • Les câbles sont collés au pisto-colle sur la boite et ne sont pas apparents.
  • La serrure est fixée avec des vis sur un socle en PVC (hauteur 1cm). Cette plaque a été collée avec de la colle epoxy.
  • La carte Arduino est vissée sur un socle de 5mm, lui-même collé à la boite. Ce socle doit impérativement pouvoir être décollé au besoin pour permettre le démontage éventuel du servomoteur. Nous avons donc opté pour l’utilisation du pisto-colle (démontage facile avec un tournevis plat en guise de levier).

ÉTAPE 5 : Placer le lecteur d’empreintes digitales sur la poignée

JPEG - 405.7 ko

Le lecteur d’empreintes digitales a été placé dans une poignée de valise. Cette poignée présente l’avantage de posséder des pieds creux qui permettent de laisser passer les câbles destinés au lecteur d’empreintes, habilement placé à extrémité de la poignée.

ETAPE 6 : Programme du servo et du lecteur d’empreintes

JPEG - 51.3 ko

Ce programme doit pouvoir reconnaître une empreinte digitale lorsque celle-ci a été enregistrée ; il actionnera alors le servo-moteur pour déverrouiller la boite. A l’inverse, lorsque l’empreinte n’est pas reconnue la boite reste verrouillée.

Durée du projet

  • Le temps du collage n’est pas compté dans cette liste.
  • Récupération de la poignée de valise et fixation du lecteur d’empreinte 1h30.
  • Liaison du moteur à la serrure avec de la corde à piano 45 min
  • Fixation de la gâche de la serrure 45 min.
  • Connexion et fixation de tous les éléments sur le support (nous avons utilisé une boite à pharmacie mais on aurait pu utiliser une porte) 2h.
  • Programmation Arduino 5h.

Durée totale de l’opération 10h.

Programme Arduino

Ce programme a pour but de piloter le capteur optique et le servomoteur

Attention, Avant de lancer le programme, il faut brancher le capteur d’empruntes digitales :

  • Fil vert sur le pin 2
  • Fil blanc sur le pin 3
  • Fil rouge +5V
  • Fil noir GND (masse)

Le servomoteur est directement alimenté au +5V et GND sans passer par la carte Arduino car le courant qu’il utilise peut dépasser le courant maximum que la carte Arduino peut supporter. Le servomoteur est piloté par un câble qui est relié au pin 9

Lorsqu’un utilisateur présente son doigt au capteur d’empruntes digitales placé sur la poignée, le programme vérifie si l’emprunte est reconnue. Si celle-ci est reconnue, le programme actionne le servomoteur qui déverrouille la porte.
Lorsque l’utilisateur referme la porte, un capteur fin de course devient passant et le programme verrouille automatiquement la porte

  1. /***************************************************
  2. ouvre la serrure (servo) si l'emprunte digitale est reconnue. on peut
  3. utiliser le programme enroll et delete pour actualiser la base de données
  4. des empruntes reconnues
  5.  
  6. // pin #2 fingerPrint (fil VERT)
  7. // pin #3 fingerPrint (fil BLANC)
  8. // pin #9 Servo
  9.  
  10. auteur michael
  11. date 12/04/2015
  12. version  : 0.4
  13.  ****************************************************/
  14.  
  15.  
  16.  
  17. // ****************************************************/
  18. //DECLARATION
  19. // ****************************************************/
  20.  
  21. //bibliothèques utilisées
  22. #include <Servo.h> //on a le droit d'utiliser les fonctions de la bibl. Servo
  23.  
  24. #include <Adafruit_Fingerprint.h>
  25. #if ARDUINO >= 100
  26.  #include <SoftwareSerial.h>
  27. #else
  28.  #include <NewSoftSerial.h>
  29. #endif
  30.  
  31. #if ARDUINO >= 100
  32. SoftwareSerial mySerial(2, 3);
  33. #else
  34. NewSoftSerial mySerial(2, 3);
  35. #endif
  36.  
  37. // ****************************************************/
  38. //                          mode debug
  39. #define DEBUG true
  40. // ****************************************************/
  41.  
  42. //déclaration des constantes et variables
  43. const int BOUTON_COUVERCLE = 4;   //le fin de course du couvercle est branché sur le pin #4
  44. const int PIN_SERVO = 9;                   //le servo est branché sur le pin #9
  45. const int ANGLE_MAX = 140;               // angle à effectuer pour fermer le verrou
  46. const int TEMPS_ACTION = 1000;       // temps que met le verrou pour réaliser l'action
  47.  
  48. Servo servo_verrou;                // servo_verrou est un objet de type servo
  49. int etat_couvercle = 0;           // variable qui indique si le couvercle est ouvert (1)
  50. Adafruit_Fingerprint le_doigt = Adafruit_Fingerprint(&mySerial);
  51. boolean le_verrou_est_ferme = true;
  52.  
  53. // ****************************************************/
  54. //fonctions à appeler
  55. // ****************************************************/
  56.  
  57. void fermer()
  58. {      
  59.       #if DEBUG
  60.           Serial.println("fermer() : fermeture du verrou");
  61.       #endif
  62.       servo_verrou.attach(PIN_SERVO);
  63.       servo_verrou.write(ANGLE_MAX);          //   servo_verrou va à la position pos
  64.       le_verrou_est_ferme = true;
  65.       delay(TEMPS_ACTION);
  66.       servo_verrou.detach();
  67. }
  68.  
  69. void ouvrir()
  70. {    
  71.  
  72.       #if DEBUG
  73.           Serial.println("ouvrir() : ouverture du verrou");
  74.       #endif
  75.       servo_verrou.attach(PIN_SERVO);
  76.       servo_verrou.write(0);                  //   servo_verrou va à la position pos
  77.       le_verrou_est_ferme = false;
  78.       delay(TEMPS_ACTION);
  79.       servo_verrou.detach();
  80. }
  81.  
  82. // retourne le numéro de la personne
  83. // inscrite dans la base de données ou -1 en cas d'erreur
  84. int verifier_emprunte() {  
  85.     int p;
  86.     //lire emprunte
  87.     p = le_doigt.getImage();
  88.     if (p != FINGERPRINT_OK)  return -1;
  89.    
  90.     //creer image de l'emprunte
  91.     p = le_doigt.image2Tz();
  92.     if (p != FINGERPRINT_OK)  return -1;
  93.  
  94.     //je recherche l'image dans la base de données
  95.     p = le_doigt.fingerFastSearch();  
  96.     if (p != FINGERPRINT_OK)  { // l'emprunte est trouvée
  97.         return -1; //je ne connais pas cette personne
  98.     }
  99.     return le_doigt.fingerID;
  100.      
  101. }
  102.  
  103. // ****************************************************/
  104. //INITIATLISATION
  105. // ****************************************************/
  106.  
  107. void setup()  
  108. {
  109.  
  110.   #if DEBUG
  111.       Serial.begin(9600);
  112.       Serial.println("début du programme");
  113.   #endif
  114.   pinMode(BOUTON_COUVERCLE, INPUT_PULLUP);  // initialise BOUTON_COUVERCLE comme une valeur à lire (à la masse)
  115.   le_doigt.begin(57600);                      //vitesse de travail (bus série) du capteur
  116.  
  117.   // position ouvert par défaut... mesure de sécurité !
  118.   ouvrir();                                
  119.   delay(2000);
  120.  
  121.   //si capteur d'emprunte digitales n'est pas trouvé :( ... on en reste là !!!
  122.   if (!le_doigt.verifyPassword())  while (1);    
  123. }
  124.  
  125.  
  126.  
  127.  
  128. // ****************************************************/
  129. //BOUCLE INFINIE
  130. // ****************************************************/
  131.  
  132.  
  133. void loop()                  
  134. {
  135.     etat_couvercle = digitalRead(BOUTON_COUVERCLE);  //comment est le couvercle ?
  136.    
  137.     if (etat_couvercle == LOW) { // le couvercle est fermé
  138.  
  139.        //fermer le verrou si ce n'est pas déjà fait
  140.         if (!le_verrou_est_ferme) fermer();
  141.        
  142.         //si l'emprunte est connue, on ouvre
  143.         if ( int num=verifier_emprunte() >0 ) {
  144.               #if DEBUG
  145.                   Serial.println("je reconnais le doigt num="+num);
  146.               #endif
  147.               ouvrir();
  148.         }
  149.     } // fin couvercle fermé
  150.    
  151.     else { //le couvercle est ouvert...
  152.             if (le_verrou_est_ferme) ouvrir();
  153.          }
  154. }

Télécharger

Résultat final

JPEG - 986.9 ko

Après une longue phase de tests et de recherches, nous avons réussi à ouvrir et fermer la boite de pharmacie grâce à notre capteur d’empreintes digitales.
Au début nous avions pensé à un servomoteur qui entrainait directement la clef mais nous nous sommes vite rendu compte que cela prenait trop de place et que le moteur se bloquait faute de puissance.

Michaël aidé de Jean B. a ensuite eu l’idée d’utiliser une corde à piano pour transmettre le mouvement du servomoteur jusqu’à la serrure.

Concernant le détecteur d’empreintes digitales, nous l’avons commandé sur internet et nous avons ensuite réfléchi sur le type de poignée sur laquelle on pouvait le fixer. Nous avons rencontré un problème : si une personne droitière veut ouvrir la porte, elle doit positionner le capteur à droite mais si elle est gauchère, il vaut mieux le placer à gauche. Notre solution est d’utiliser une poignée verticale avec le capteur placé en haut de cette poignée.

Pour insérer une nouvelle empreinte nous utilisons le programme fourni en exemple par le constructeur. Il faut en outre télécharger la bibliothèque : https://github.com/adafruit/Adafruit-Fingerprint-Sensor-Library

Nous avons utilisé une poignée de valise que nous avons “aménagée” et à l’aide de deux cercles en PVC que nous avions placés verticalement sur la boite à pharmacie, nous y avons alors inséré la poignée ainsi que son capteur d’empreintes.

Pour boucher les trous restants, nous avons utilisé une pâte bi-composant et concernant la programmation, nous nous sommes aidés de deux programmes déjà existant mais aussi de Frédéric R. que nous remercions pour sa patience et son temps donné pour nous.

Le point fort de notre projet est d’avoir trouvé le moyen d’ouvrir une porte d’une seule main puisque le capteur est directement placé sur une poignée verticale, ce qui convient autant aux droitiers qu’aux gauchers.

PNG - 56.2 ko

Par la suite

Nous aimerions intégrer notre système à une porte pour que cela ait une véritable utilité (même si cela sert aussi sur la boite).

Nous aimerions également intégrer une batterie à notre système pour parer à d’éventuelles coupures de courant car si l’on veut rentrer chez soi et que l’on ne peut pas à cause d’une simple coupure de courant, ce serait dommage.

Nous pensons aussi intégrer un clavier ou un écran pour pouvoir insérer ou supprimer des empreintes digitales plus rapidement et plus facilement.

JPEG - 595.6 ko

Portfolio

Vos commentaires

  • Le 25 février 2018 à 10:54, par Hid En réponse à : Digital Poignée

    Bonjour, je travaille sur le meme projet que vous mais je fait face a un probleme lors de l’uttilisation du logiciel SFGDemo, en effet je recoit une alerte quand je selectionne le port USB et j’arrive toujour pas a enroller mes empreintes. Pouvez-vous m’ader ? Merci.

    • Le 27 mars 2018 à 14:26, par Eric P. En réponse à : Digital Poignée

      Bonjour,

      je recoit une alerte quand je selectionne le port USB

      Vous pouvez préciser laquelle ? Sans cette information, impossible de pouvoir vous aider.
      Cordialement

    Répondre à ce message

  • Le 5 mai 2017 à 14:58, par Mohammed En réponse à : Digital Poignée

    Pas mal, c’est cool

    Répondre à ce message

  • Le 15 août 2015 à 14:34, par Esprit En réponse à : Digital Poignée

    Chouette de voir des jeunes faire des petits projets intéressants comme ça. Merci pour le partage et merci à Pobot d’encourager ces "jeunes talents" ! ;-)

    Répondre à ce message

Un message, un commentaire ?

modération a priori

Attention, votre message n’apparaîtra qu’après avoir été relu et approuvé.

Qui êtes-vous ?

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici

Ce champ accepte les raccourcis SPIP {{gras}} {italique} -*liste [texte->url] <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.