Digital Poignée

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

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

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

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

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

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

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

/*************************************************** 
ouvre la serrure (servo) si l'emprunte digitale est reconnue. on peut 
utiliser le programme enroll et delete pour actualiser la base de données 
des empruntes reconnues

// pin #2 fingerPrint (fil VERT)
// pin #3 fingerPrint (fil BLANC)
// pin #9 Servo

auteur michael
date 12/04/2015
version  : 0.4
 ****************************************************/



// ****************************************************/
//DECLARATION 
// ****************************************************/
 
//bibliothèques utilisées
#include <Servo.h> //on a le droit d'utiliser les fonctions de la bibl. Servo
 
#include <Adafruit_Fingerprint.h>
#if ARDUINO >= 100
 #include <SoftwareSerial.h>
#else
 #include <NewSoftSerial.h>
#endif

#if ARDUINO >= 100
SoftwareSerial mySerial(2, 3);
#else
NewSoftSerial mySerial(2, 3);
#endif

// ****************************************************/
//                          mode debug
#define DEBUG true
// ****************************************************/

//déclaration des constantes et variables
const int BOUTON_COUVERCLE = 4;   //le fin de course du couvercle est branché sur le pin #4
const int PIN_SERVO = 9;                   //le servo est branché sur le pin #9
const int ANGLE_MAX = 140;               // angle à effectuer pour fermer le verrou
const int TEMPS_ACTION = 1000;       // temps que met le verrou pour réaliser l'action 

Servo servo_verrou;                // servo_verrou est un objet de type servo
int etat_couvercle = 0;           // variable qui indique si le couvercle est ouvert (1)
Adafruit_Fingerprint le_doigt = Adafruit_Fingerprint(&mySerial);
boolean le_verrou_est_ferme = true;

// ****************************************************/
//fonctions à appeler
// ****************************************************/

void fermer()
{      
      #if DEBUG
          Serial.println("fermer() : fermeture du verrou");
      #endif
      servo_verrou.attach(PIN_SERVO);
      servo_verrou.write(ANGLE_MAX);          //   servo_verrou va à la position pos
      le_verrou_est_ferme = true;
      delay(TEMPS_ACTION);
      servo_verrou.detach();
}

void ouvrir()
{    
  
      #if DEBUG
          Serial.println("ouvrir() : ouverture du verrou");
      #endif
      servo_verrou.attach(PIN_SERVO);
      servo_verrou.write(0);                  //   servo_verrou va à la position pos
      le_verrou_est_ferme = false;
      delay(TEMPS_ACTION);
      servo_verrou.detach();
}

// retourne le numéro de la personne 
// inscrite dans la base de données ou -1 en cas d'erreur
int verifier_emprunte() {  
    int p;
    //lire emprunte
    p = le_doigt.getImage();
    if (p != FINGERPRINT_OK)  return -1;
    
    //creer image de l'emprunte
    p = le_doigt.image2Tz();
    if (p != FINGERPRINT_OK)  return -1;

    //je recherche l'image dans la base de données
    p = le_doigt.fingerFastSearch();   
    if (p != FINGERPRINT_OK)  { // l'emprunte est trouvée
        return -1; //je ne connais pas cette personne
    }
    return le_doigt.fingerID;
     
}

// ****************************************************/
//INITIATLISATION
// ****************************************************/
 
void setup()  
{
  
  #if DEBUG
      Serial.begin(9600);
      Serial.println("début du programme"); 
  #endif
  pinMode(BOUTON_COUVERCLE, INPUT_PULLUP);  // initialise BOUTON_COUVERCLE comme une valeur à lire (à la masse)
  le_doigt.begin(57600);                      //vitesse de travail (bus série) du capteur
  
  // position ouvert par défaut... mesure de sécurité !
  ouvrir();                                 
  delay(2000);
  
  //si capteur d'emprunte digitales n'est pas trouvé :( ... on en reste là !!!
  if (!le_doigt.verifyPassword())  while (1);     
}


 

// ****************************************************/
//BOUCLE INFINIE
// ****************************************************/
 
 
void loop()                  
{
    etat_couvercle = digitalRead(BOUTON_COUVERCLE);  //comment est le couvercle ?
    
    if (etat_couvercle == LOW) { // le couvercle est fermé
 
       //fermer le verrou si ce n'est pas déjà fait
        if (!le_verrou_est_ferme) fermer();
        
        //si l'emprunte est connue, on ouvre
        if ( int num=verifier_emprunte() >0 ) {
              #if DEBUG 
                  Serial.println("je reconnais le doigt num="+num);
              #endif
              ouvrir();
        }
    } // fin couvercle fermé
    
    else { //le couvercle est ouvert...
            if (le_verrou_est_ferme) ouvrir();
         }
}

Résultat final

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.

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.