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 ?
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
- 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
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.
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