Capteur empreinte digitale

Le capteur d’empreinte digitale AS608 est un module optique complet : il éclaire le doigt, photographie les crêtes, en extrait un gabarit et le compare lui-même à ceux qu’il garde en mémoire. Votre carte n’a donc aucun calcul d’image à faire — elle envoie une commande sur la liaison série et reçoit un simple identifiant. C’est ce qui rend l’authentification biométrique accessible à un montage Arduino, sans caméra ni traitement d’image.

Caractéristiques techniques

Les six broches du module

Le connecteur regroupe l’alimentation et la liaison série. L’ordre des broches est le suivant :

Certains lots ne sortent que quatre conducteurs (V+, TXD, RXD, GND) : c’est suffisant, la broche TOUCH n’étant qu’un confort. La couleur des fils change d’un arrivage à l’autre — se repérer à l’ordre des broches et au marquage, jamais à la couleur seule.

Comment l’utiliser avec une carte Arduino

La liaison est croisée : TXD du module vers RX de la carte, RXD du module vers TX de la carte, masses communes. Sur un Arduino Uno, le port série matériel sert au moniteur série : on utilise donc deux broches ordinaires en liaison série logicielle. La bibliothèque Adafruit_Fingerprint, disponible pour AS608 et modules compatibles, prend en charge tout le protocole — vérification du mot de passe, image, gabarit, recherche et enregistrement.

Mini-projet : enrôler une empreinte et ouvrir un accès

Le montage enregistre une empreinte, la reconnaît, puis colle un relais pendant trois secondes — de quoi commander une gâche, une serrure électrique ou l’alimentation d’un appareil. Un buzzer signale chaque étape, un bouton poussoir peut remplacer la commande envoyée par le moniteur série.

Matériel

• une carte Arduino Uno et son cordon USB ;
• le capteur d’empreinte AS608 ;
• un module relais 5 V à un canal ;
• un buzzer actif ;
• quelques fils de liaison et une plaque de prototypage.

Câblage

• V+ du capteur vers 5 V, GND du capteur vers GND ;
• TXD du capteur vers la broche 2, RXD du capteur vers la broche 3 ;
• entrée du module relais vers la broche 8 ;
• buzzer entre la broche 9 et la masse.

Programme

Ouvrir le moniteur série à 9 600 bps, envoyer « e » pour enrôler l’empreinte sur l’identifiant 1, puis « v » pour la vérifier.

/*
 * Capteur d'empreinte AS608 : enrolement et verification
 * Composants, brochage et fiche complete : www.marocproduits.com
 *
 * Cablage : TXD capteur vers 2 (RX logiciel), RXD capteur vers 3 (TX logiciel)
 *           V+ capteur vers 5V, GND capteur vers GND
 *           entree du module relais vers 8, buzzer vers 9
 */

#include "Adafruit_Fingerprint.h"
#include "SoftwareSerial.h"

SoftwareSerial lienCapteur(2, 3);            // RX logiciel, TX logiciel
Adafruit_Fingerprint capteur(lienCapteur);

const uint8_t BROCHE_RELAIS = 8;
const uint8_t BROCHE_BUZZER = 9;
const uint8_t ID_UTILISE    = 1;             // identifiant de 1 a 127

void bip(uint16_t duree) {
  digitalWrite(BROCHE_BUZZER, HIGH);
  delay(duree);
  digitalWrite(BROCHE_BUZZER, LOW);
}

void ouvrirAcces(uint16_t duree) {
  digitalWrite(BROCHE_RELAIS, HIGH);
  bip(300);
  delay(duree);
  digitalWrite(BROCHE_RELAIS, LOW);
}

uint8_t capturerImage(uint8_t emplacement) { // emplacement 1 ou 2
  uint8_t etat;
  do {                                       // on attend une image lisible
    etat = capteur.getImage();
    delay(50);
  } while (etat != FINGERPRINT_OK);
  etat = capteur.image2Tz(emplacement);      // conversion en gabarit
  bip(80);
  return etat;
}

void enroller(uint8_t id) {
  Serial.println("Premiere pose du doigt");
  if (capturerImage(1) != FINGERPRINT_OK) {
    Serial.println("Image illisible, recommencer");
    return;
  }
  Serial.println("Retirer le doigt, puis poser le meme doigt une seconde fois");
  while (capteur.getImage() != FINGERPRINT_NOFINGER) {
    delay(50);
  }
  if (capturerImage(2) != FINGERPRINT_OK) {
    Serial.println("Image illisible, recommencer");
    return;
  }
  if (capteur.createModel() != FINGERPRINT_OK) {
    Serial.println("Les deux poses different, recommencer");
    return;
  }
  if (capteur.storeModel(id) != FINGERPRINT_OK) {
    Serial.println("Emplacement refuse par le module");
    return;
  }
  bip(500);
  Serial.println("Empreinte enregistree sur l'identifiant 1");
}

void verifier() {
  uint8_t etat = capteur.getImage();
  if (etat == FINGERPRINT_NOFINGER) {
    Serial.println("Aucun doigt sur le capteur");
    return;
  }
  if (capteur.image2Tz() != FINGERPRINT_OK) {
    Serial.println("Image illisible");
    return;
  }
  if (capteur.fingerFastSearch() != FINGERPRINT_OK) {
    Serial.println("Empreinte inconnue : acces refuse");
    return;
  }
  Serial.print("Acces autorise, identifiant ");
  Serial.println(capteur.fingerID);
  ouvrirAcces(3000);
}

void setup() {
  Serial.begin(9600);
  pinMode(BROCHE_RELAIS, OUTPUT);
  pinMode(BROCHE_BUZZER, OUTPUT);
  digitalWrite(BROCHE_RELAIS, LOW);
  capteur.begin(57600);                      // debit par defaut du module
  while (capteur.verifyPassword() != FINGERPRINT_OK) {
    Serial.println("Capteur introuvable : verifier le cablage et la masse");
    delay(1000);
  }
  Serial.println("Capteur pret. Envoyer e pour enroler, v pour verifier.");
}

void loop() {
  if (Serial.available() == 0) {
    return;
  }
  char commande = Serial.read();
  if (commande == 'e') {
    enroller(ID_UTILISE);
  }
  if (commande == 'v') {
    verifier();
  }
}

Points d’attention

• L’entrée RXD du module est une entrée TTL 3,3 V. Sur une carte alimentée en 5 V, placer un pont diviseur de deux résistances sur cette ligne est la précaution recommandée pour la protéger.
• Prévoir une alimentation stable capable de fournir 120 mA, avec des pointes à 150 mA : une sortie 3,3 V de carte limitée en courant provoque des erreurs de communication aléatoires.
• La liaison série logicielle à 57 600 bps est fiable sur un Arduino Uno, à condition de ne pas utiliser d’interruption longue pendant la lecture.
• Garder la fenêtre optique propre : un chiffon doux et sec suffit, sans solvant ni alcool agressif. Une vitre rayée abaisse nettement le taux de reconnaissance.
• Les gabarits restent dans la mémoire du module, conservée hors tension : on peut enrôler les empreintes avant de fermer le boîtier.

Questions fréquentes

Faut-il une bibliothèque particulière ?

Oui, Adafruit_Fingerprint, qui gère le protocole du module (mot de passe, image, gabarit, recherche, enregistrement). Toute la reconnaissance se fait dans le capteur : la carte n’envoie que des commandes courtes et reçoit un identifiant.

Combien d’empreintes puis-je enregistrer ?

Le module annonce une capacité de 162 empreintes. Les bibliothèques courantes manipulent des identifiants allant de 1 à 127.

L’empreinte est-elle stockée sur la carte ?

Non. Seul le gabarit calculé par le module y reste ; la carte ne conserve que des identifiants et les décisions d’accès qu’on lui programme.

Peut-il être alimenté en 3,3 V ?

Oui, il fonctionne de 3,3 à 5 V. C’est la tension de la carte qui décide : 5 V avec un Arduino Uno, 3,3 V avec un module ESP32 ou une carte 3,3 V.

Le capteur n’est pas détecté, que vérifier ?

D’abord la croisure de la liaison : TXD du module vers RX de la carte et RXD du module vers TX de la carte. Ensuite la masse commune entre le capteur et la carte, puis le débit, dont la valeur par défaut est 57 600 bps.

Faut-il retirer le doigt entre les deux poses ?

Oui, pour l’enrôlement : la première pose crée un gabarit, le module demande de retirer le doigt, la seconde pose confirme la lecture et les deux gabarits sont fusionnés puis enregistrés.

À combiner avec

• Uno R3 + câble USB — la carte qui pilote le module et le relais ;
• Module 1 relais 5 V — pour commander une gâche ou une serrure électrique depuis l’accès autorisé ;
• Afficheur LCD 16 × 02 I2C — pour afficher l’état de la serrure et le nom de la personne reconnue ;
• Buzzer actif — le retour sonore de chaque étape d’enrôlement et de vérification ;
• Mini bouton poussoir — pour lancer l’enrôlement sans passer par le moniteur série ;
• Alimentation 5 V 2 A — une source stable pour le module et le relais sur un montage autonome.