Capteur d'empreinte digitale Arduino : AS608, R307 et serrure

Un capteur d'empreinte digitale permet à ton projet Arduino de demander « qui es-tu ? » d'un simple toucher et d'ouvrir une porte, un tiroir ou un coffre quand il reconnaît ton doigt. Les modèles les plus répandus en électronique de loisir sont des modules optiques basés sur l'AS608 et le R307 : ils traitent eux-mêmes l'image du doigt, stockent les empreintes dans leur propre mémoire et n'envoient à l'Arduino qu'une courte réponse du type « correspond à l'ID 3 ». C'est pourquoi même une petite carte comme l'Arduino Uno peut gérer sans peine une serrure à empreinte pour des centaines de personnes.

Dans ce guide, tu vas voir comment fonctionne le capteur, comment le câbler correctement alors que les couleurs des fils changent d'un fabricant à l'autre, comment enregistrer (enroll) et vérifier des empreintes avec la bibliothèque Adafruit Fingerprint, et ce que signifient l'ID et le score de confiance. Ensuite, tu fabriqueras une vraie serrure avec un relais et un solénoïde 12 V, tu feras la même chose avec un ESP32 et un Raspberry Pi Pico, et tu corrigeras pas à pas la fameuse erreur « Did not find fingerprint sensor ».

Qu'est-ce qu'un capteur d'empreinte digitale et comment fonctionne-t-il ?

Les modules comme l'AS608 et le R307 sont des capteurs optiques. Quand tu poses le doigt sur la vitre, une LED intérieure éclaire le prisme situé dessous ; les crêtes de l'empreinte touchent la vitre et réfléchissent la lumière différemment, alors que les sillons ne la touchent pas. Une minuscule caméra capture ce motif sous forme d'image en niveaux de gris d'environ 500 dpi. La puce DSP du module repère les points où les lignes s'arrêtent ou se divisent (minuties) et les convertit en un fichier de caractéristiques de quelques centaines d'octets. Deux fichiers issus du même doigt sont fusionnés en un modèle (template), qui est enregistré dans la mémoire flash du capteur sous un numéro d'ID.

Lors de la vérification, le capteur convertit à nouveau l'image en fichier de caractéristiques et le compare à tous les modèles enregistrés. Cette recherche 1:N prend généralement moins d'une seconde ; à la fin, le capteur renvoie l'ID correspondant et un score de confiance (confidence) qui indique la force de la correspondance. Point essentiel : l'image de l'empreinte n'arrive jamais à l'Arduino, tout le travail lourd se fait dans le capteur. L'Arduino se contente d'envoyer des commandes par le port série (UART) et de lire de courtes réponses.

Les valeurs du tableau peuvent varier selon le vendeur et la version de la carte, surtout la capacité. Le plus fiable est d'exécuter le programme de test ci-dessous et de lire la capacité annoncée par le capteur lui-même. Clarifions aussi trois notions : l'ID est le numéro d'emplacement du modèle en mémoire (de 0 à la capacité moins un) ; le niveau de sécurité fixe le seuil de correspondance de 1 (le plus tolérant) à 5 (le plus strict) ; le score de confiance est la note de similarité renvoyée par le capteur à chaque correspondance.

Couleurs des fils et alimentation : quel fil va où ?

L'erreur la plus fréquente avec les capteurs d'empreinte est de croire que les couleurs des fils sont standard. Le même modèle peut arriver avec des fils rouge-noir-jaune-blanc chez un vendeur et rouge-noir-vert-bleu chez un autre ; même Adafruit indique des combinaisons de couleurs différentes selon les versions de ses capteurs. Ne te fie donc pas à la couleur, mais aux marquages des broches au dos du capteur ou à côté du connecteur, et au schéma du vendeur. Les modules AS608 ont généralement 6 broches : V+ (Vi), TX, RX, GND, WAK (Touch) et Vt (3.3VT). Pour un usage de base, les quatre premières suffisent.

La broche WAK (ou Touch) est reliée au circuit de détection tactile du capteur, qui consomme très peu. Avec 3,3 V sur la broche Vt, elle change de niveau dès qu'un doigt touche la vitre ; sur la plupart des modules elle passe à HIGH, sur certains à LOW, alors teste-la sur ta carte. Dans une serrure sur piles, tu peux couper l'alimentation principale avec un MOSFET, laisser seulement Vt alimentée, réveiller le microcontrôleur avec le signal WAK et n'allumer le capteur qu'à ce moment-là.

Installer la bibliothèque Adafruit Fingerprint

1. Dans l'Arduino IDE, ouvre Outils > Gérer les bibliothèques, cherche Adafruit Fingerprint Sensor Library et installe-la. Si tu n'as jamais ajouté de bibliothèque, consulte Ajouter une bibliothèque à Arduino.
2. La bibliothèque fonctionne avec tous les capteurs qui utilisent le même jeu de commandes, comme l'AS608, le R307, le R503, le FPM10A et la série ZFM ; aucun changement de code n'est nécessaire.
3. Dans Fichier > Exemples, tu trouveras enroll (enregistrement), fingerprint (vérification), delete (supprimer une entrée) et emptyDatabase (tout effacer).
4. Sur l'Uno et le Nano, le capteur se branche sur D2 et D3 via SoftwareSerial pour ne pas occuper les broches 0 et 1 utilisées par l'USB. Les cartes dotées d'un second port série matériel, comme la Mega, la Leonardo et l'ESP32, utilisent Serial1 ou Serial2.

Premier test : le capteur est-il détecté ?

Avant d'enregistrer des empreintes, vérifions que le capteur dialogue avec l'Arduino. Le programme ci-dessous cherche d'abord le capteur à la vitesse par défaut de 57600 bps puis, s'il ne le trouve pas, essaie les autres vitesses courantes. Une fois le capteur trouvé, il affiche dans le Moniteur série la vitesse à laquelle il a répondu, la capacité annoncée, le niveau de sécurité et le nombre d'empreintes enregistrées. N'oublie pas de régler le Moniteur série sur 9600 bauds ; c'est indépendant de la vitesse du capteur.

1#include <Adafruit_Fingerprint.h>
2#include <SoftwareSerial.h>
3
4SoftwareSerial fpSerial(2, 3);            // D2 = RX (sensör TX), D3 = TX (sensör RX) / D2 = RX (sensor TX), D3 = TX (sensor RX)
5Adafruit_Fingerprint finger(&fpSerial);
6
7const uint32_t rates[] = {57600, 9600, 19200, 38400, 115200};   // denenecek hızlar / baud rates to try
8
9void setup() {
10  Serial.begin(9600);
11  Serial.println(F("Sensor araniyor / searching for sensor..."));
12  bool found = false;
13  for (uint8_t i = 0; i < 5 && !found; i++) {
14    finger.begin(rates[i]);               // 1 sn bekler, portu açar / waits 1 s, opens the port
15    if (finger.verifyPassword()) {        // sensör cevap verdi mi? / did the sensor answer?
16      Serial.print(F("Bulundu / found @ "));
17      Serial.println(rates[i]);
18      found = true;
19    }
20  }
21  if (!found) {
22    Serial.println(F("Did not find fingerprint sensor :("));
23    while (1) delay(1);
24  }
25  finger.getParameters();                 // kapasite ve ayarları oku / read capacity and settings
26  Serial.print(F("Kapasite / capacity: "));
27  Serial.println(finger.capacity);
28  Serial.print(F("Guvenlik / security level: "));
29  Serial.println(finger.security_level);
30  finger.getTemplateCount();              // kayıtlı şablon sayısı / number of stored templates
31  Serial.print(F("Kayitli iz / templates: "));
32  Serial.println(finger.templateCount);
33}
34
35void loop() {
36}

Enregistrer une empreinte (enroll) pas à pas

Pendant l'enregistrement, le capteur prend deux images distinctes du même doigt, les place sous forme de fichiers de caractéristiques dans deux tampons (CharBuffer1 et CharBuffer2), les fusionne en un modèle puis l'écrit à l'ID choisi. L'exemple enroll d'Adafruit demande un ID entre 1 et 127 et le garde dans une variable d'un octet. La version simplifiée ci-dessous stocke l'ID sur 16 bits et prend la limite haute dans la capacité réelle du capteur, pour que tu puisses utiliser tous les emplacements d'un capteur de 300 ou 1000 empreintes. Voici les étapes côté bibliothèque :

1. getImage() : essaie de prendre une image jusqu'à ce qu'un doigt soit sur la vitre ; sans doigt, renvoie FINGERPRINT_NOFINGER.
2. image2Tz(1) : convertit la première image en fichier de caractéristiques et la place dans le tampon 1.
3. On retire le doigt puis on repose le même ; image2Tz(2) place la seconde image dans le tampon 2.
4. createModel() : compare et fusionne les deux tampons ; s'ils ne correspondent pas, renvoie FINGERPRINT_ENROLLMISMATCH.
5. storeModel(id) : écrit le modèle de façon permanente dans la mémoire flash du capteur ; il résiste aux coupures de courant.

1#include <Adafruit_Fingerprint.h>
2#include <SoftwareSerial.h>
3
4SoftwareSerial fpSerial(2, 3);            // D2 = RX, D3 = TX
5Adafruit_Fingerprint finger(&fpSerial);
6
7void setup() {
8  Serial.begin(9600);
9  finger.begin(57600);
10  if (!finger.verifyPassword()) {
11    Serial.println(F("Did not find fingerprint sensor :("));
12    while (1) delay(1);
13  }
14  finger.getParameters();                 // gerçek kapasiteyi öğren / learn the real capacity
15  Serial.println(F("Kayit modu / enroll mode"));
16}
17
18// Parmak gelene kadar bekle, görüntüyü tampona çevir / wait for a finger, convert the image into a buffer
19bool captureTo(uint8_t slot) {
20  while (finger.getImage() != FINGERPRINT_OK) delay(50);
21  uint8_t p = finger.image2Tz(slot);
22  if (p != FINGERPRINT_OK) {
23    Serial.print(F("Goruntu kotu / bad image, kod / code 0x"));
24    Serial.println(p, HEX);
25    return false;
26  }
27  return true;
28}
29
30void loop() {
31  Serial.print(F("ID gir / enter ID (1-"));
32  Serial.print(finger.capacity - 1);
33  Serial.println(F("):"));
34  while (!Serial.available()) delay(10);
35  uint16_t id = Serial.parseInt();
36  while (Serial.available()) Serial.read();   // satır sonunu temizle / clear the line ending
37  if (id == 0 || id >= finger.capacity) return;
38
39  Serial.println(F("Parmagini koy / place your finger"));
40  if (!captureTo(1)) return;
41  Serial.println(F("Kaldir / remove your finger"));
42  delay(1000);
43  while (finger.getImage() != FINGERPRINT_NOFINGER) delay(50);   // parmak kalkana kadar / until the finger is lifted
44
45  Serial.println(F("Ayni parmagi tekrar koy / place the same finger again"));
46  if (!captureTo(2)) return;
47
48  uint8_t p = finger.createModel();       // iki görüntüyü birleştir / merge the two images
49  if (p == FINGERPRINT_ENROLLMISMATCH) {
50    Serial.println(F("Fingerprints did not match"));
51    return;
52  }
53  if (p != FINGERPRINT_OK) return;
54
55  p = finger.storeModel(id);              // sensörün flash belleğine yaz / write to the sensor's flash
56  if (p == FINGERPRINT_OK) {
57    Serial.print(F("Kaydedildi / stored, ID #"));
58    Serial.println(id);
59  } else {
60    Serial.print(F("Kayit hatasi / store error 0x"));
61    Serial.println(p, HEX);
62  }
63}

Vérifier une empreinte : ID et score de confiance

Pour vérifier, tu prends d'abord une image avec getImage(), tu la convertis avec image2Tz(), puis tu cherches parmi les modèles enregistrés. La bibliothèque propose deux fonctions de recherche : fingerFastSearch() est rapide, mais la commande envoyée par la bibliothèque ne parcourt que les 163 premières entrées (ID 0–162) ; fingerSearch() cherche dans toute la capacité lue avec getParameters(). Si tu utilises des ID supérieurs à 162, prends fingerSearch() et appelle toujours getParameters() dans setup() ; sinon la bibliothèque suppose la capacité par défaut de 64 et ne cherche que dans les 64 premières entrées.

Quand la recherche réussit, finger.fingerID donne le numéro de l'entrée correspondante et finger.confidence le score de confiance. C'est déjà le capteur qui décide s'il y a correspondance selon le niveau de sécurité ; le score indique seulement à quel point elle est forte. Avec un doigt bien enregistré, il se situe généralement entre quelques dizaines et quelques centaines. Pour une serrure plus stricte, tu peux relever le seuil avec setSecurityLevel(4) ou setSecurityLevel(5), ou fixer ta propre limite dans le code (par exemple refuser tout ce qui est sous 50). Un seuil plus élevé réduit le risque d'accepter la mauvaise personne mais augmente celui de refuser la bonne ; trouve l'équilibre en testant avec tes propres doigts.

Serrure à empreinte digitale avec relais et solénoïde

Assemblons maintenant le tout pour fabriquer une serrure qui s'ouvre 3 secondes pour un doigt autorisé, bipe trois fois pour un doigt inconnu et bloque le système 30 secondes après 5 échecs consécutifs. Comme verrou, on utilise une serrure à solénoïde 12 V. Un solénoïde consomme 0,5 à 1 A : il ne se branche donc jamais directement sur une broche de l'Arduino ; on intercale un module relais ou un MOSFET à niveau logique. Le câblage : VCC et GND du module relais sur le 5V et le GND de l'Arduino, sa broche IN sur D8, buzzer actif sur D9, plus de l'adaptateur 12 V sur la borne COM du relais, borne NO du relais sur le plus du solénoïde et moins du solénoïde sur le moins de l'adaptateur.

Un solénoïde est une bobine qui produit une forte tension inverse dès qu'on coupe son courant. Branche donc une diode 1N4007 en parallèle sur le solénoïde, en inverse ; l'extrémité marquée d'un anneau va au plus. Si tu utilises un MOSFET à la place du relais, choisis un modèle à niveau logique comme l'IRLZ44N et relie le moins de l'alimentation 12 V au GND de l'Arduino. Pour les détails, vois Piloter de forts courants avec un MOSFET, et pour l'ordre des broches du MOSFET l'outil Brochage des transistors.

1#include <Adafruit_Fingerprint.h>
2#include <SoftwareSerial.h>
3
4SoftwareSerial fpSerial(2, 3);            // D2 = RX, D3 = TX
5Adafruit_Fingerprint finger(&fpSerial);
6
7const int RELAY_PIN = 8;                  // röle modülü IN / relay module IN
8const int BUZZER_PIN = 9;                 // aktif buzzer / active buzzer
9const uint8_t RELAY_ON = LOW;             // çoğu röle modülü LOW ile çeker / most relay modules switch on LOW
10const uint8_t RELAY_OFF = HIGH;
11const uint16_t MIN_CONFIDENCE = 50;       // ek güven eşiği / extra confidence threshold
12const unsigned long OPEN_MS = 3000;       // kilidin açık kalma süresi / unlock time
13
14uint8_t failCount = 0;
15
16void setup() {
17  digitalWrite(RELAY_PIN, RELAY_OFF);     // açılışta kilitli kalsın / stay locked at power-up
18  pinMode(RELAY_PIN, OUTPUT);
19  pinMode(BUZZER_PIN, OUTPUT);
20  Serial.begin(9600);
21  finger.begin(57600);
22  if (!finger.verifyPassword()) {
23    Serial.println(F("Did not find fingerprint sensor :("));
24    while (1) delay(1);
25  }
26  finger.getParameters();                 // fingerSearch için kapasite / capacity for fingerSearch
27}
28
29// Eşleşen ID; parmak yoksa -1, tanınmadıysa -2 / matching ID; -1 no finger, -2 not recognised
30int readFinger() {
31  if (finger.getImage() != FINGERPRINT_OK) return -1;
32  if (finger.image2Tz(1) != FINGERPRINT_OK) return -2;
33  if (finger.fingerSearch(1) != FINGERPRINT_OK) return -2;
34  if (finger.confidence < MIN_CONFIDENCE) return -2;
35  return finger.fingerID;
36}
37
38void beep(int count, int ms) {
39  for (int i = 0; i < count; i++) {
40    digitalWrite(BUZZER_PIN, HIGH);
41    delay(ms);
42    digitalWrite(BUZZER_PIN, LOW);
43    delay(ms);
44  }
45}
46
47void loop() {
48  int id = readFinger();
49  if (id >= 0) {
50    Serial.print(F("Hos geldin / welcome, ID #"));
51    Serial.print(id);
52    Serial.print(F(", guven / confidence "));
53    Serial.println(finger.confidence);
54    failCount = 0;
55    beep(1, 100);
56    digitalWrite(RELAY_PIN, RELAY_ON);    // kilidi aç / unlock
57    delay(OPEN_MS);
58    digitalWrite(RELAY_PIN, RELAY_OFF);   // yeniden kilitle / lock again
59  } else if (id == -2) {
60    failCount++;
61    Serial.println(F("Yetkisiz / not authorised"));
62    beep(3, 80);
63    if (failCount >= 5) {                 // 5 hatada 30 sn bekle / 30 s lockout after 5 failures
64      Serial.println(F("30 sn kilitli / locked for 30 s"));
65      delay(30000);
66      failCount = 0;
67    }
68    delay(1000);
69  }
70  delay(50);
71}

Capteur d'empreinte avec ESP32 : connexion sur Serial2

L'ESP32 possède trois ports série matériels, tu n'as donc pas besoin de SoftwareSerial : tu branches le capteur sur l'UART2 (Serial2). Comme l'ESP32 fonctionne en 3,3 V, il correspond exactement aux niveaux de signal de l'AS608 et aucun pont diviseur n'est nécessaire. Seul point d'attention, les broches : dans le cœur Arduino-ESP32 actuel (3.x), les broches par défaut de Serial2 ne sont plus GPIO 16/17 comme dans les anciens tutoriels, mais GPIO 4 (RX) et GPIO 25 (TX). Indique donc explicitement les broches dans Serial2.begin() ; la fonction begin() de la bibliothèque conserve les broches définies auparavant. Tu peux voir le brochage de ta carte dans l'outil Pinout.

1#include <Adafruit_Fingerprint.h>
2
3#define FP_RX 16                          // ESP32 RX2 <- sensör TX / sensor TX
4#define FP_TX 17                          // ESP32 TX2 -> sensör RX / sensor RX
5const int RELAY_PIN = 23;                 // röle modülü IN / relay module IN
6
7Adafruit_Fingerprint finger(&Serial2);
8
9void setup() {
10  Serial.begin(115200);
11  pinMode(RELAY_PIN, OUTPUT);
12  digitalWrite(RELAY_PIN, HIGH);          // LOW tetiklemeli röle kapalı / active-LOW relay off
13  Serial2.begin(57600, SERIAL_8N1, FP_RX, FP_TX);   // pinleri açıkça ver / set the pins explicitly
14  finger.begin(57600);                    // önceki pinleri korur / keeps the pins set above
15  if (!finger.verifyPassword()) {
16    Serial.println("Did not find fingerprint sensor :(");
17    while (true) delay(10);
18  }
19  finger.getParameters();
20  finger.getTemplateCount();
21  Serial.printf("Kapasite / capacity: %u, kayitli / stored: %u\n", finger.capacity, finger.templateCount);
22}
23
24void loop() {
25  if (finger.getImage() == FINGERPRINT_OK && finger.image2Tz(1) == FINGERPRINT_OK) {
26    if (finger.fingerSearch(1) == FINGERPRINT_OK) {
27      Serial.printf("ID #%u, guven / confidence %u\n", finger.fingerID, finger.confidence);
28      digitalWrite(RELAY_PIN, LOW);       // kilidi aç / unlock
29      delay(3000);
30      digitalWrite(RELAY_PIN, HIGH);      // yeniden kilitle / lock again
31    } else {
32      Serial.println("Did not find a match");
33      delay(1000);
34    }
35  }
36  delay(50);
37}

Sur les cartes à module ESP32-WROVER, les GPIO 16 et 17 sont reliés à la PSRAM ; sur une telle carte, passe FP_RX et FP_TX par exemple à 25 et 26. L'ESP32-C3 n'a que deux UART, donc pas de Serial2 ; tu peux utiliser le même code avec Serial1 et les deux broches de ton choix. Grâce au Wi-Fi, tu peux enregistrer chaque passage avec l'heure sur un serveur, ou recevoir une alerte sur ton téléphone via un bot Telegram quand un doigt inconnu se présente.

Capteur d'empreinte avec Raspberry Pi Pico et MicroPython

Il n'existe pas de version officielle de la bibliothèque Adafruit pour MicroPython, mais le protocole du capteur est assez simple pour lui parler toi-même en quelques lignes. Chaque paquet commence par le code de début EF 01, suivi d'une adresse de 4 octets (FF FF FF FF par défaut), du type de paquet (01 commande, 07 réponse), d'une longueur sur 2 octets, de la commande et de ses paramètres, et enfin d'une somme de contrôle de 2 octets égale à la somme des octets de type, de longueur et de données. Le premier octet de données de la réponse est le code de confirmation : 00 succès, 02 aucun doigt, 09 aucune correspondance. Le code ci-dessous vérifie le capteur, lit la capacité et identifie le doigt posé avec son ID et son score de confiance. Comme le Pico fonctionne en 3,3 V, tu peux brancher l'AS608 directement sur la broche 3V3(OUT) ; si tu débutes avec le Pico, Qu'est-ce que le Raspberry Pi Pico ? est un bon point de départ.

1from machine import UART, Pin
2import time
3
4# GP0 = UART0 TX -> sensör RX, GP1 = UART0 RX <- sensör TX / sensor RX, sensor TX
5uart = UART(0, baudrate=57600, tx=Pin(0), rx=Pin(1), timeout=2000, timeout_char=100)
6HEADER = b'\xEF\x01\xFF\xFF\xFF\xFF'          # başlangıç kodu + adres / start code + address
7
8def command(*data):
9    while uart.any():                          # eski baytları at / drop stale bytes
10        uart.read()
11    length = len(data) + 2                     # veri + 2 bayt sağlama / data + 2-byte checksum
12    body = bytes([0x01, length >> 8, length & 0xFF]) + bytes(data)   # 0x01 = komut paketi / command packet
13    s = sum(body)
14    uart.write(HEADER + body + bytes([(s >> 8) & 0xFF, s & 0xFF]))
15    head = uart.read(9)                        # başlık + tip + uzunluk / header + type + length
16    if not head or len(head) < 9 or head[0] != 0xEF:
17        return None
18    n = (head[7] << 8) | head[8]
19    rest = uart.read(n)
20    if not rest or len(rest) < n:
21        return None
22    return rest[:-2]                           # sağlama hariç veri / data without checksum
23
24def ok(r):
25    return r is not None and r[0] == 0x00      # 0x00 = başarılı / success
26
27time.sleep(1)                                  # sensörün açılmasını bekle / let the sensor boot up
28if not ok(command(0x13, 0, 0, 0, 0)):          # VfyPwd: şifre 0 / password 0
29    print("Did not find fingerprint sensor")
30    while True:
31        time.sleep(1)
32
33p = command(0x0F)                              # ReadSysPara: sistem parametreleri / system parameters
34capacity = (p[5] << 8) | p[6] if ok(p) else 162
35print("Kapasite / capacity:", capacity)
36
37def identify():
38    if not ok(command(0x01)):                  # GenImg: parmak yoksa 0x02 / 0x02 = no finger
39        return None
40    if not ok(command(0x02, 1)):               # Img2Tz: CharBuffer1'e çevir / convert into CharBuffer1
41        return (-1, 0)
42    r = command(0x04, 1, 0, 0, capacity >> 8, capacity & 0xFF)   # Search: tüm kayıtlar / all records
43    if not ok(r):
44        return (-1, 0)                         # 0x09 = eşleşme yok / no match
45    return ((r[1] << 8) | r[2], (r[3] << 8) | r[4])   # (ID, güven / confidence)
46
47while True:
48    res = identify()
49    if res:
50        fid, score = res
51        if fid >= 0:
52            print("ID", fid, "guven / confidence", score)
53        else:
54            print("Eslesme yok / no match")
55        time.sleep(1)
56    time.sleep_ms(100)

L'erreur « Did not find fingerprint sensor » et autres problèmes fréquents

Ce message signifie que la bibliothèque n'a pas reçu de réponse valide du capteur à sa commande verifyPassword() ; il ne veut pas dire que le capteur est cassé. La grande majorité des cas viennent du câblage, de l'alimentation ou d'une mauvaise vitesse. Parcours le tableau de haut en bas :

Lecteur d'empreinte UART Waveshare : petite remarque

Bien qu'il lui ressemble, le lecteur d'empreinte UART de Waveshare parle un autre protocole que l'AS608 et le R307 : les commandes font 8 octets, commencent et finissent par 0xF5, et la vitesse par défaut est de 19200 bps. Il ne fonctionne donc pas avec la bibliothèque Adafruit Fingerprint ; on utilise le tableau des commandes et les exemples du manuel Waveshare. À l'enregistrement, le doigt est lu trois fois, chaque utilisateur peut recevoir un niveau de droits de 1 à 3, et une comparaison 1:N se fait en une seule commande. La carte s'alimente en 3,3 V ou en 5 V ; on relie TXD au RX du microcontrôleur et RXD à son TX. Si tu veux beaucoup de bibliothèques et d'exemples prêts à l'emploi, choisis l'AS608 ou le R307 ; si écrire ton propre code de protocole ne te dérange pas, le Waveshare est un bon choix.

Idées de projets avec un capteur d'empreinte

• Tiroir ou coffre à empreinte : un petit coffre qui s'ouvre avec un servo ou un solénoïde et déclenche une alarme en cas de tentative non autorisée. Pour un verrou à servo, lis Qu'est-ce qu'un servomoteur ?
• Porte en deux étapes : un accès plus sûr qui demande d'abord l'empreinte puis un code PIN sur un clavier matriciel.
• Badge ou doigt : ajoute un lecteur RFID RC522 à la même serrure pour que ceux qui ont un badge l'utilisent et les autres leur doigt.
• Système de pointage : associe chaque ID à un nom pour une école ou un club et enregistre les heures d'arrivée.
• Serrure avec écran : affiche un message d'accueil et le nom de la personne sur un écran OLED.
• Avec une alarme maison : un système d'alarme Arduino qu'on arme et désarme avec son empreinte.

Avec quelques fils et la bonne bibliothèque, un capteur d'empreinte ajoute une vraie couche d'identification à ton projet : teste d'abord le capteur, enregistre les doigts avec soin, puis monte la serrure avec relais et solénoïde. Dans l'application BlueGrays, tu trouveras des projets de sécurité comme un coffre électronique intelligent, l'authentification RFID, une serrure RFID à ESP32 et un code d'accès sur clavier, avec schémas de câblage et code pas à pas, de quoi disposer d'une base prête pour ajouter un capteur d'empreinte.