Sensore di impronte digitali Arduino: AS608, R307 e serratura

Un sensore di impronte digitali permette al tuo progetto Arduino di chiedere "chi sei?" con un solo tocco e di aprire una porta, un cassetto o una cassaforte quando riconosce il tuo dito. I modelli più diffusi nell'elettronica hobbistica sono moduli ottici basati su AS608 e R307: elaborano l'immagine del dito al loro interno, conservano le impronte nella propria memoria e inviano ad Arduino solo una risposta breve come "corrisponde all'ID 3". Per questo anche una scheda piccola come Arduino Uno può gestire senza fatica una serratura a impronta per centinaia di persone.

In questa guida vedrai come funziona il sensore, come collegarlo correttamente anche se i colori dei fili cambiano da produttore a produttore, come registrare (enroll) e verificare le impronte con la libreria Adafruit Fingerprint e che cosa significano l'ID e il punteggio di confidenza. Poi costruirai una vera serratura con un relè e un solenoide da 12 V, farai lo stesso con un ESP32 e un Raspberry Pi Pico e risolverai passo dopo passo il famoso errore "Did not find fingerprint sensor".

Che cos'è un sensore di impronte digitali e come funziona?

Moduli come AS608 e R307 sono sensori ottici. Quando appoggi il dito sul vetro, un LED interno illumina il prisma sottostante; le creste dell'impronta toccano il vetro e riflettono la luce in modo diverso, mentre le valli non lo toccano. Una minuscola fotocamera cattura questo disegno come immagine in scala di grigi a circa 500 dpi. Il chip DSP del modulo individua i punti in cui le linee finiscono o si biforcano (minuzie) e li trasforma in un file di caratteristiche di qualche centinaio di byte. Due file dello stesso dito vengono uniti in un modello (template), salvato nella memoria flash del sensore con un numero di ID.

Durante la verifica il sensore converte di nuovo l'immagine in un file di caratteristiche e la confronta con tutti i modelli salvati. Questa ricerca 1:N di solito richiede meno di un secondo; alla fine il sensore restituisce l'ID corrispondente e un punteggio di confidenza (confidence) che indica quanto è forte la corrispondenza. Il punto chiave: l'immagine dell'impronta non arriva mai ad Arduino, tutto il lavoro pesante lo fa il sensore. Arduino si limita a inviare comandi sulla porta seriale (UART) e a leggere risposte brevi.

I valori della tabella possono variare a seconda del venditore e della versione della scheda, soprattutto la capacità. Il metodo più affidabile è eseguire lo sketch di prova qui sotto e leggere la capacità dichiarata dal sensore stesso. Chiariamo anche tre concetti: l'ID è il numero di posizione del modello in memoria (da 0 alla capacità meno uno); il livello di sicurezza fissa la soglia di corrispondenza da 1 (il più tollerante) a 5 (il più severo); il punteggio di confidenza è il valore di somiglianza che il sensore restituisce a ogni corrispondenza.

Colori dei fili e alimentazione: quale filo va dove?

L'errore più comune con i sensori di impronte è pensare che i colori dei fili siano standard. Lo stesso modello può arrivare con fili rosso-nero-giallo-bianco da un venditore e rosso-nero-verde-blu da un altro; perfino Adafruit indica combinazioni di colori diverse per versioni diverse dei suoi sensori. Quindi non fidarti del colore, ma delle serigrafie dei pin sul retro del sensore o accanto al connettore e dello schema del venditore. I moduli AS608 hanno di solito 6 pin: V+ (Vi), TX, RX, GND, WAK (Touch) e Vt (3.3VT). Per l'uso di base bastano i primi quattro.

Il pin WAK (o Touch) è collegato al circuito di rilevamento del tocco del sensore, che consuma pochissimo. Con 3,3 V sul pin Vt cambia livello appena un dito tocca il vetro; nella maggior parte dei moduli va a HIGH, in alcuni a LOW, quindi provalo sulla tua scheda. In una serratura a batteria puoi togliere l'alimentazione principale con un MOSFET, lasciare alimentato solo Vt, usare il segnale WAK per svegliare il microcontrollore e accendere il sensore solo in quel momento.

Installare la libreria Adafruit Fingerprint

1. Nell'Arduino IDE apri Strumenti > Gestione librerie, cerca Adafruit Fingerprint Sensor Library e installala. Se non hai mai aggiunto una libreria, leggi Come aggiungere una libreria ad Arduino.
2. La libreria funziona con tutti i sensori che usano lo stesso set di comandi, come AS608, R307, R503, FPM10A e la serie ZFM; non serve cambiare il codice.
3. In File > Esempi trovi enroll (registrazione), fingerprint (verifica), delete (eliminare una voce) ed emptyDatabase (cancellare tutto).
4. Su Uno e Nano il sensore si collega a D2 e D3 tramite SoftwareSerial, così i pin 0 e 1 usati dall'USB restano liberi. Le schede con una seconda seriale hardware, come Mega, Leonardo ed ESP32, usano Serial1 o Serial2.

Primo test: il sensore viene trovato?

Prima di registrare le impronte verifichiamo che il sensore comunichi con Arduino. Lo sketch qui sotto cerca prima il sensore alla velocità predefinita di 57600 bps e, se non lo trova, prova le altre velocità più comuni. Quando lo trova, scrive nel Monitor seriale la velocità a cui ha risposto, la capacità dichiarata, il livello di sicurezza e il numero di impronte salvate. Ricordati di impostare il Monitor seriale a 9600 baud; è indipendente dalla velocità del sensore.

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}

Registrare un'impronta (enroll) passo dopo passo

Durante la registrazione il sensore acquisisce due immagini distinte dello stesso dito, le mette come file di caratteristiche in due buffer (CharBuffer1 e CharBuffer2), le unisce in un modello e lo scrive nell'ID che scegli. L'esempio enroll di Adafruit chiede un ID tra 1 e 127 e lo conserva in una variabile da un byte. La versione semplificata qui sotto memorizza l'ID su 16 bit e prende il limite superiore dalla capacità reale del sensore, così puoi usare tutte le posizioni di un sensore da 300 o 1000 impronte. Ecco i passaggi nella libreria:

1. getImage(): prova ad acquisire un'immagine finché c'è un dito sul vetro; senza dito restituisce FINGERPRINT_NOFINGER.
2. image2Tz(1): converte la prima immagine in un file di caratteristiche e la mette nel buffer 1.
3. Si solleva il dito e si appoggia di nuovo lo stesso; image2Tz(2) mette la seconda immagine nel buffer 2.
4. createModel(): confronta e unisce i due buffer; se non corrispondono restituisce FINGERPRINT_ENROLLMISMATCH.
5. storeModel(id): scrive il modello in modo permanente nella memoria flash del sensore; resta salvato anche senza corrente.

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}

Verificare un'impronta: ID e punteggio di confidenza

Per verificare acquisisci prima un'immagine con getImage(), la converti con image2Tz() e poi cerchi tra i modelli salvati. La libreria ha due funzioni di ricerca: fingerFastSearch() è veloce, ma il comando inviato dalla libreria esamina solo le prime 163 voci (ID 0–162); fingerSearch() cerca invece in tutta la capacità letta con getParameters(). Se userai ID superiori a 162, usa fingerSearch() e chiama sempre getParameters() in setup(); altrimenti la libreria assume la capacità predefinita di 64 e cerca solo nelle prime 64 voci.

Se la ricerca riesce, finger.fingerID dà il numero della voce corrispondente e finger.confidence il punteggio di confidenza. È già il sensore a decidere se c'è corrispondenza in base al livello di sicurezza; il punteggio indica solo quanto è forte. Con un dito ben registrato di solito si colloca tra qualche decina e qualche centinaio. Per una serratura più severa puoi alzare la soglia con setSecurityLevel(4) o setSecurityLevel(5), oppure aggiungere un tuo limite minimo nel codice (per esempio rifiutare tutto ciò che sta sotto 50). Una soglia più alta riduce il rischio di accettare la persona sbagliata ma aumenta quello di rifiutare quella giusta; trova l'equilibrio provando con le tue dita.

Serratura a impronta digitale con relè e solenoide

Ora mettiamo insieme tutto e costruiamo una serratura che si apre per 3 secondi con un dito autorizzato, suona tre volte con uno sconosciuto e blocca il sistema per 30 secondi dopo 5 tentativi falliti di fila. Come chiusura usiamo una serratura a solenoide da 12 V. Un solenoide assorbe 0,5–1 A, quindi non va mai collegato direttamente a un pin di Arduino; in mezzo si mette un modulo relè o un MOSFET a livello logico. Il collegamento: VCC e GND del modulo relè vanno a 5V e GND di Arduino, il pin IN a D8, un buzzer attivo a D9, il positivo dell'alimentatore da 12 V al morsetto COM del relè, il morsetto NO del relè al positivo del solenoide e il negativo del solenoide al negativo dell'alimentatore.

Un solenoide è una bobina e genera un'alta tensione inversa nell'istante in cui si interrompe la corrente. Per questo collega un diodo 1N4007 in parallelo al solenoide, in senso inverso; l'estremità con la fascia va al positivo. Se al posto del relè usi un MOSFET, scegli un modello a livello logico come l'IRLZ44N e collega il negativo dell'alimentazione da 12 V al GND di Arduino. Per i dettagli vedi Pilotare correnti elevate con un MOSFET, e per l'ordine dei pin del MOSFET lo strumento Piedinatura dei transistor.

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}

Sensore di impronte con ESP32: collegamento su Serial2

L'ESP32 ha tre seriali hardware, quindi non ti serve SoftwareSerial: colleghi il sensore alla UART2 (Serial2). Poiché l'ESP32 lavora a 3,3 V, è perfettamente compatibile con i livelli di segnale dell'AS608 e non serve alcun partitore. L'unica cosa a cui fare attenzione sono i pin: nel core Arduino-ESP32 attuale (3.x) i pin predefiniti di Serial2 non sono più GPIO 16/17 come nelle vecchie guide, ma GPIO 4 (RX) e GPIO 25 (TX). Per questo conviene indicare i pin in modo esplicito in Serial2.begin(); la funzione begin() della libreria mantiene i pin impostati prima. Puoi vedere la piedinatura della tua scheda nello strumento 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}

Sulle schede con modulo ESP32-WROVER i GPIO 16 e 17 sono collegati alla PSRAM; su una scheda del genere imposta FP_RX e FP_TX, per esempio, a 25 e 26. L'ESP32-C3 ha solo due UART e quindi niente Serial2; puoi usare lo stesso codice con Serial1 e due pin a tua scelta. Grazie al Wi-Fi puoi registrare ogni accesso con l'orario su un server o ricevere un avviso sul telefono tramite un bot Telegram quando compare un dito sconosciuto.

Sensore di impronte con Raspberry Pi Pico e MicroPython

Per MicroPython non esiste una versione ufficiale della libreria Adafruit, ma il protocollo del sensore è abbastanza semplice da poterci parlare da solo in poche righe. Ogni pacchetto inizia con il codice di avvio EF 01, seguito da un indirizzo di 4 byte (FF FF FF FF per impostazione predefinita), dal tipo di pacchetto (01 comando, 07 risposta), da una lunghezza di 2 byte, dal comando con i parametri e infine da un checksum di 2 byte dato dalla somma dei byte di tipo, lunghezza e dati. Il primo byte di dati della risposta è il codice di conferma: 00 successo, 02 nessun dito, 09 nessuna corrispondenza. Il codice qui sotto verifica il sensore, legge la capacità e riconosce il dito appoggiato con ID e punteggio di confidenza. Poiché il Pico funziona a 3,3 V, puoi collegare l'AS608 direttamente al pin 3V3(OUT); se sei alle prime armi con il Pico, Che cos'è il Raspberry Pi Pico? è un buon punto di partenza.

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'errore "Did not find fingerprint sensor" e altri problemi frequenti

Questo messaggio significa che la libreria non ha ricevuto dal sensore una risposta valida al comando verifyPassword(); non vuol dire che il sensore sia rotto. La grande maggioranza dei casi dipende dal cablaggio, dall'alimentazione o da una velocità sbagliata. Controlla la tabella dall'alto verso il basso:

Lettore di impronte UART Waveshare: una breve nota

Anche se gli somiglia, il lettore di impronte UART di Waveshare usa un protocollo diverso da AS608 e R307: i comandi sono lunghi 8 byte, iniziano e finiscono con 0xF5 e la velocità predefinita è 19200 bps. Per questo non funziona con la libreria Adafruit Fingerprint; si usano la tabella dei comandi e gli esempi del manuale Waveshare. In registrazione il dito viene letto tre volte, a ogni utente si può assegnare un livello di permesso da 1 a 3 e il confronto 1:N si fa con un solo comando. La scheda si alimenta a 3,3 V o a 5 V; colleghi TXD all'RX del microcontrollore e RXD al suo TX. Se vuoi tante librerie ed esempi pronti, scegli AS608 o R307; se non ti pesa scrivere il tuo codice di protocollo, il Waveshare è un'ottima scelta.

Idee di progetto con il sensore di impronte

• Cassetto o cassaforte a impronta: una piccola cassaforte che si apre con un servo o un solenoide e dà l'allarme ai tentativi non autorizzati. Per un chiavistello a servo, leggi Che cos'è un servomotore?
• Porta a due passaggi: un accesso più sicuro che chiede prima l'impronta e poi un PIN su un tastierino.
• Tessera o dito: aggiungi un lettore RFID RC522 alla stessa serratura, così chi ha la tessera entra con quella e gli altri con il dito.
• Sistema di presenze: associa ogni ID a un nome per una scuola o un club e registra gli orari di ingresso.
• Serratura con display: mostra un messaggio di benvenuto e il nome della persona su un display OLED.
• Insieme all'antifurto di casa: un sistema di allarme con Arduino che si inserisce e disinserisce con l'impronta.

Con pochi fili e la libreria giusta, un sensore di impronte aggiunge un vero livello di identificazione al tuo progetto: prima prova il sensore, registra le dita con cura e poi costruisci la serratura con relè e solenoide. Nell'app BlueGrays trovi progetti di sicurezza come una cassaforte elettronica intelligente, l'autenticazione RFID, una serratura RFID con ESP32 e una password su tastierino, con schemi elettrici e codice passo dopo passo: una base pronta per aggiungere un sensore di impronte.