Fingerabdrucksensor Arduino: AS608, R307 und Türschloss bauen

Ein Fingerabdrucksensor lässt dein Arduino-Projekt mit einer einzigen Berührung fragen „Wer bist du?“ und öffnet Tür, Schublade oder Tresor, sobald er deinen Finger erkennt. Am weitesten verbreitet sind im Hobbybereich optische Module auf Basis von AS608 und R307: Sie verarbeiten das Fingerbild selbst, speichern die Fingerabdrücke im eigenen Speicher und schicken dem Arduino nur eine kurze Antwort wie „Treffer mit ID 3“. Deshalb kann selbst ein kleines Board wie der Arduino Uno problemlos ein Fingerabdruckschloss für Hunderte Personen steuern.

In dieser Anleitung lernst du, wie der Sensor funktioniert, wie du ihn richtig verkabelst, obwohl die Kabelfarben je nach Hersteller variieren, wie du mit der Bibliothek Adafruit Fingerprint Fingerabdrücke anlernst (Enroll) und prüfst und was ID und Konfidenzwert bedeuten. Danach baust du ein echtes Türschloss mit Relais und 12-V-Hubmagnet, machst dasselbe mit ESP32 und Raspberry Pi Pico und behebst Schritt für Schritt den berüchtigten Fehler „Did not find fingerprint sensor“.

Was ist ein Fingerabdrucksensor und wie funktioniert er?

Module wie AS608 und R307 sind optische Sensoren. Legst du den Finger auf das Glas, beleuchtet eine LED im Inneren das Prisma darunter; die Papillarleisten berühren das Glas und reflektieren das Licht anders als die Täler dazwischen. Eine winzige Kamera nimmt dieses Muster als Graustufenbild mit etwa 500 dpi auf. Der DSP-Chip im Modul sucht die Stellen, an denen Linien enden oder sich gabeln (Minutien), und wandelt sie in eine Merkmalsdatei von einigen hundert Byte um. Zwei Merkmalsdateien desselben Fingers werden zu einer Vorlage (Template) zusammengeführt, die der Sensor unter einer ID-Nummer im eigenen Flash-Speicher ablegt.

Bei der Prüfung wandelt der Sensor das neue Bild wieder in eine Merkmalsdatei um und vergleicht sie mit allen gespeicherten Vorlagen. Diese 1:N-Suche dauert meist weniger als eine Sekunde; am Ende sendet der Sensor die passende ID und einen Konfidenzwert (confidence), der zeigt, wie stark die Übereinstimmung ist. Wichtig dabei: Das Fingerbild erreicht den Arduino nie, die ganze Rechenarbeit erledigt der Sensor. Der Arduino schickt über die serielle Schnittstelle (UART) nur Befehle und liest kurze Antworten.

Die Werte in der Tabelle können je nach Händler und Board-Version abweichen, vor allem die Kapazität. Am zuverlässigsten ist es, den Testsketch unten auszuführen und die Kapazität abzulesen, die der Sensor selbst meldet. Klären wir noch drei Begriffe: Die ID ist die Platznummer der Vorlage im Speicher (von 0 bis Kapazität minus eins); die Sicherheitsstufe legt die Vergleichsschwelle von 1 (am tolerantesten) bis 5 (am strengsten) fest; der Konfidenzwert ist die Ähnlichkeitspunktzahl, die der Sensor bei jedem Treffer liefert.

Kabelfarben und Stromversorgung: Welches Kabel kommt wohin?

Der häufigste Fehler bei Fingerabdrucksensoren ist die Annahme, die Kabelfarben seien genormt. Dasselbe Modell kommt beim einen Händler mit Rot-Schwarz-Gelb-Weiß, beim anderen mit Rot-Schwarz-Grün-Blau; sogar Adafruit listet für verschiedene Sensorversionen unterschiedliche Farbbelegungen. Verlass dich also nicht auf die Farbe, sondern auf die Pinbeschriftung auf der Rückseite oder neben dem Stecker und auf das Schaltbild des Händlers. AS608-Module haben meist 6 Pins: V+ (Vi), TX, RX, GND, WAK (Touch) und Vt (3.3VT). Für die Grundfunktion reichen die ersten vier.

Der WAK-Pin (oder Touch) hängt an der stromsparenden Berührungserkennung des Sensors. Liegen 3,3 V am Vt-Pin, ändert er seinen Pegel, sobald ein Finger das Glas berührt; bei den meisten Modulen geht er auf HIGH, bei manchen auf LOW, also probier es mit deinem Board aus. In einem batteriebetriebenen Schloss kannst du die Hauptversorgung per MOSFET abschalten, nur Vt versorgt lassen, den Mikrocontroller mit dem WAK-Signal aus dem Schlaf wecken und den Sensor erst dann einschalten.

Die Bibliothek Adafruit Fingerprint installieren

1. Öffne in der Arduino IDE Werkzeuge > Bibliotheken verwalten, suche nach Adafruit Fingerprint Sensor Library und installiere sie. Wenn du noch nie eine Bibliothek hinzugefügt hast, lies Bibliotheken in Arduino hinzufügen.
2. Die Bibliothek funktioniert mit allen Sensoren, die denselben Befehlssatz nutzen, etwa AS608, R307, R503, FPM10A und die ZFM-Serie; du musst keinen Code ändern.
3. Unter Datei > Beispiele findest du enroll (Anlernen), fingerprint (Prüfen), delete (einen Eintrag löschen) und emptyDatabase (alles löschen).
4. Beim Uno und Nano wird der Sensor per SoftwareSerial an D2 und D3 angeschlossen, damit die Pins 0 und 1 für USB frei bleiben. Boards mit zweiter Hardware-Schnittstelle wie Mega, Leonardo und ESP32 nutzen Serial1 oder Serial2.

Erster Test: Wird der Sensor gefunden?

Bevor du Finger anlernst, prüfen wir, ob der Sensor mit dem Arduino spricht. Der folgende Sketch sucht den Sensor zuerst mit der Standardrate 57600 bps und probiert sonst die anderen üblichen Baudraten. Findet er den Sensor, gibt er im seriellen Monitor die Baudrate, die gemeldete Kapazität, die Sicherheitsstufe und die Zahl der gespeicherten Fingerabdrücke aus. Stell den seriellen Monitor auf 9600 Baud; das ist unabhängig von der Geschwindigkeit des Sensors.

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}

Fingerabdruck anlernen (Enroll) Schritt für Schritt

Beim Anlernen nimmt der Sensor zwei getrennte Bilder desselben Fingers auf, legt sie als Merkmalsdateien in zwei Puffer (CharBuffer1 und CharBuffer2), führt beide zu einer Vorlage zusammen und schreibt sie unter die gewählte ID. Das fertige Enroll-Beispiel von Adafruit fragt eine ID zwischen 1 und 127 ab und speichert sie in einer Ein-Byte-Variable. Die vereinfachte Version unten speichert die ID mit 16 Bit und nimmt die Obergrenze aus der echten Kapazität des Sensors, sodass du alle Plätze eines Sensors mit 300 oder 1000 Einträgen nutzen kannst. Die Schritte in der Bibliothek:

1. getImage(): Versucht so lange ein Bild aufzunehmen, bis ein Finger auf dem Glas liegt; ohne Finger kommt FINGERPRINT_NOFINGER zurück.
2. image2Tz(1): Wandelt das erste Bild in eine Merkmalsdatei um und legt sie in Puffer 1.
3. Der Finger wird abgehoben und erneut aufgelegt; image2Tz(2) legt das zweite Bild in Puffer 2.
4. createModel(): Vergleicht und kombiniert beide Puffer; passen sie nicht zusammen, kommt FINGERPRINT_ENROLLMISMATCH zurück.
5. storeModel(id): Schreibt die Vorlage dauerhaft in den Flash-Speicher des Sensors; sie bleibt auch ohne Strom erhalten.

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}

Fingerabdruck prüfen: ID und Konfidenzwert

Zum Prüfen nimmst du zuerst mit getImage() ein Bild auf, wandelst es mit image2Tz() um und durchsuchst dann die gespeicherten Vorlagen. Die Bibliothek hat zwei Suchfunktionen: fingerFastSearch() ist schnell, aber der Befehl, den die Bibliothek sendet, durchsucht nur die ersten 163 Einträge (ID 0–162); fingerSearch() durchsucht die gesamte, mit getParameters() gelesene Kapazität. Nutzt du IDs über 162, verwende fingerSearch() und ruf in setup() unbedingt getParameters() auf; sonst nimmt die Bibliothek die Standardkapazität 64 an und durchsucht nur die ersten 64 Einträge.

Bei Erfolg liefert finger.fingerID die Nummer des passenden Eintrags und finger.confidence den Konfidenzwert. Ob es ein Treffer ist, entscheidet der Sensor bereits selbst anhand der Sicherheitsstufe; der Wert zeigt nur, wie stark die Übereinstimmung ist. Bei einem gut angelernten Finger liegt er meist zwischen einigen Dutzend und einigen Hundert. Für ein strengeres Schloss kannst du die Schwelle mit setSecurityLevel(4) oder setSecurityLevel(5) anheben oder im Code eine eigene Untergrenze setzen (zum Beispiel alles unter 50 ablehnen). Eine höhere Schwelle senkt das Risiko, die falsche Person einzulassen, erhöht aber das Risiko, die richtige abzuweisen; finde die Balance durch Tests mit deinen eigenen Fingern.

Fingerabdruck-Türschloss mit Relais und Hubmagnet

Jetzt setzen wir alles zusammen und bauen ein Türschloss, das bei einem berechtigten Finger 3 Sekunden öffnet, bei einem unbekannten dreimal piept und nach 5 Fehlversuchen in Folge das System für 30 Sekunden sperrt. Als Verriegelung nutzen wir ein 12-V-Hubmagnet-Schloss. Ein Hubmagnet zieht 0,5–1 A und darf deshalb nie direkt an einen Arduino-Pin; dazwischen gehört ein Relaismodul oder ein Logic-Level-MOSFET. Die Verdrahtung: VCC und GND des Relaismoduls an 5V und GND des Arduino, IN an D8, ein aktiver Summer an D9, Plus des 12-V-Netzteils an COM des Relais, NO des Relais an Plus des Hubmagneten und dessen Minus an Minus des Netzteils.

Ein Hubmagnet ist eine Spule und erzeugt beim Abschalten eine hohe Gegenspannung. Schließ deshalb eine 1N4007-Diode in Sperrrichtung parallel zum Hubmagneten an; das Ende mit dem Ring kommt an Plus. Nimmst du statt des Relais einen MOSFET, wähle ein Logic-Level-Modell wie den IRLZ44N und verbinde Minus der 12-V-Quelle mit GND des Arduino. Details findest du unter Hohe Ströme mit einem MOSFET schalten, die Pinbelegung des MOSFETs im Tool Transistor-Pinbelegung.

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}

Fingerabdrucksensor mit ESP32: Anschluss an Serial2

Der ESP32 hat drei Hardware-UARTs, daher brauchst du kein SoftwareSerial und schließt den Sensor an UART2 (Serial2) an. Weil der ESP32 mit 3,3 V arbeitet, passt er genau zu den Signalpegeln des AS608, ein Spannungsteiler ist nicht nötig. Achten musst du nur auf die Pins: Im aktuellen Arduino-ESP32-Core (3.x) sind die Standardpins von Serial2 nicht mehr GPIO 16/17 wie in älteren Anleitungen, sondern GPIO 4 (RX) und GPIO 25 (TX). Gib die Pins deshalb ausdrücklich in Serial2.begin() an; begin() der Bibliothek behält die zuvor gesetzten Pins bei. Die Pinbelegung deines Boards siehst du im Tool 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}

Auf Boards mit ESP32-WROVER-Modul sind GPIO 16 und 17 mit dem PSRAM verbunden; setze FP_RX und FP_TX dort zum Beispiel auf 25 und 26. Der ESP32-C3 hat nur zwei UARTs und damit kein Serial2; denselben Code kannst du mit Serial1 und zwei beliebigen Pins nutzen. Dank WLAN kannst du jeden Zutritt mit Uhrzeit auf einem Server protokollieren oder bei einem unbekannten Finger per Telegram-Bot eine Nachricht aufs Handy schicken.

Fingerabdrucksensor mit Raspberry Pi Pico und MicroPython

Für MicroPython gibt es keine offizielle Version der Adafruit-Bibliothek, doch das Protokoll des Sensors ist so einfach, dass du in wenigen Zeilen selbst mit ihm sprechen kannst. Jedes Paket beginnt mit dem Startcode EF 01, gefolgt von einer 4-Byte-Adresse (standardmäßig FF FF FF FF), dem Pakettyp (01 Befehl, 07 Antwort), einer 2-Byte-Länge, dem Befehl mit Parametern und zuletzt einer 2-Byte-Prüfsumme aus der Summe von Typ-, Längen- und Datenbytes. Das erste Datenbyte der Antwort ist der Bestätigungscode: 00 Erfolg, 02 kein Finger, 09 kein Treffer. Der Code unten prüft den Sensor, liest die Kapazität und erkennt den aufgelegten Finger mit ID und Konfidenzwert. Da der Pico mit 3,3 V läuft, kannst du den AS608 direkt an den Pin 3V3(OUT) anschließen; bist du neu beim Pico, ist Was ist der Raspberry Pi Pico? ein guter Einstieg.

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)

Fehler „Did not find fingerprint sensor“ und andere häufige Probleme

Diese Meldung bedeutet, dass die Bibliothek auf ihren Befehl verifyPassword() keine gültige Antwort vom Sensor erhalten hat; dass der Sensor defekt ist, heißt sie nicht. Die allermeisten Fälle gehen auf Verkabelung, Versorgung oder eine falsche Baudrate zurück. Geh die Tabelle von oben nach unten durch:

Waveshare UART Fingerprint Reader: kurzer Hinweis

Auch wenn er ähnlich aussieht, spricht der UART-Fingerabdruckleser von Waveshare ein anderes Protokoll als AS608 und R307: Befehle sind 8 Byte lang, beginnen und enden mit 0xF5, und die Standardgeschwindigkeit beträgt 19200 bps. Deshalb funktioniert er nicht mit der Bibliothek Adafruit Fingerprint; stattdessen nutzt du die Befehlstabelle und den Beispielcode aus dem Handbuch von Waveshare. Beim Anlernen wird der Finger dreimal gescannt, jedem Benutzer lässt sich eine Berechtigungsstufe von 1 bis 3 zuweisen, und ein 1:N-Vergleich erfolgt mit einem einzigen Befehl. Die Platine lässt sich mit 3,3 V oder 5 V versorgen; TXD kommt an RX des Mikrocontrollers, RXD an TX. Willst du viele fertige Bibliotheken und Beispiele, nimm AS608 oder R307; schreibst du gern eigenen Protokollcode, ist der Waveshare eine gute Wahl.

Projektideen mit dem Fingerabdrucksensor

• Schublade oder Tresor mit Fingerabdruck: Ein kleiner Tresor, der per Servo oder Hubmagnet öffnet und bei unbefugten Versuchen Alarm gibt. Für einen Servo-Riegel lies Was ist ein Servomotor?
• Zweistufige Tür: Ein sichererer Zugang, der zuerst den Fingerabdruck und dann eine PIN über ein Keypad verlangt.
• Karte oder Finger: Ergänze das Schloss um einen RFID-RC522-Leser, damit Personen mit Karte die Karte und alle anderen den Finger nutzen.
• Anwesenheitssystem: Jede ID für Schule oder Verein einem Namen zuordnen und Ankunftszeiten speichern.
• Schloss mit Display: Begrüßung und Namen der Person auf einem OLED-Display anzeigen.
• Zusammen mit einer Alarmanlage: Eine Arduino-Alarmanlage, die per Fingerabdruck scharf- und unscharf geschaltet wird.

Mit ein paar Kabeln und der richtigen Bibliothek bringt ein Fingerabdrucksensor eine echte Identitätsprüfung in dein Projekt: Teste zuerst den Sensor, lerne die Finger sorgfältig an und baue dann das Schloss mit Relais und Hubmagnet. In der BlueGrays-App findest du Sicherheitsprojekte wie einen smarten elektronischen Tresor, RFID-Authentifizierung, ein ESP32-RFID-Türschloss und eine Keypad-Passwortabfrage mit Schaltplänen und Code Schritt für Schritt und hast damit eine fertige Grundlage, um einen Fingerabdrucksensor zu ergänzen.