Componenten · 13 min leestijd

Vingerafdruksensor met Arduino: AS608, R307 en deurslot

Een vingerafdruksensor gebruiken met Arduino: draadkleuren en voeding van de AS608/R307, registreren en vergelijken met Adafruit Fingerprint, een deurslot met relais, ESP32 en oplossingen.

Met een vingerafdruksensor laat je een Arduino-project met één aanraking vragen: "wie ben jij?" en open je een deur, lade of kluis als je vinger wordt herkend. De meest gebruikte modellen in de hobbyelektronica zijn optische modules op basis van de AS608 en R307: ze verwerken het vingerbeeld intern, bewaren de vingerafdrukken in hun eigen geheugen en sturen de Arduino alleen een kort antwoord zoals "match met ID 3". Daardoor kan zelfs een klein board als de Arduino Uno gemakkelijk een vingerafdrukslot voor honderden mensen aansturen.

In deze gids leer je hoe de sensor werkt, hoe je hem correct aansluit ook al verschillen de draadkleuren per maker, hoe je vingerafdrukken registreert en controleert met de Adafruit Fingerprint-bibliotheek en wat het ID en de betrouwbaarheidsscore betekenen. Daarna bouw je een echt deurslot met een relais en een solenoïde van 12 V, doe je hetzelfde met een ESP32 en een Raspberry Pi Pico en los je stap voor stap de beruchte fout "Did not find fingerprint sensor" op.

Optische AS608-vingerafdruksensor met een connector met 6 draden
Optische AS608-vingerafdruksensor: een leesvenster met een prisma, een DSP-chip die het beeld verwerkt en een set connectordraadjes. De draadkleuren verschillen per verkoper.

Wat is een vingerafdruksensor en hoe werkt hij?

Modules zoals de AS608 en R307 zijn optische sensoren. Als je je vinger op het glas legt, licht een led in de sensor het prisma eronder op; de ribbels van je vingerafdruk raken het glas en weerkaatsen het licht anders dan de dalen. Een piepkleine camera legt dit patroon vast als grijswaardenbeeld van ongeveer 500 dpi. De DSP-chip in de module haalt de punten eruit waar ribbels eindigen of splitsen (minutiae) en maakt daar een karakterbestand van een paar honderd bytes van. Twee karakterbestanden van dezelfde vinger worden samengevoegd tot een template, dat onder een ID-nummer in het eigen flashgeheugen van de sensor wordt opgeslagen.

Bij het controleren zet de sensor het nieuwe beeld opnieuw om in een karakterbestand en vergelijkt hij dat met elk opgeslagen template. Deze 1:N-zoekopdracht duurt meestal minder dan een seconde; aan het eind stuurt de sensor het ID van de match terug en een betrouwbaarheidsscore die laat zien hoe sterk de match is. Het belangrijkste: het vingerafdrukbeeld bereikt de Arduino nooit, al het zware werk gebeurt in de sensor. De Arduino stuurt alleen commando's over de seriële poort (UART) en leest korte antwoorden.

EigenschapAS608-moduleR307FPM10A / ZFM-20
Voeding3,3 V4,2–6 V (meestal 5 V)3,6–6 V
OpslagcapaciteitMeestal 300 (162 op sommige boards)1000162
InterfaceUART (TTL), standaard 57600 bpsUART (TTL), standaard 57600 bpsUART (TTL), standaard 57600 bps
Pin voor aanraakdetectieJa (WAK + Vt)Ja (Touch + 3.3VT)Niet op de meeste
Beveiligingsniveau1–51–51–5
Valse acceptatiegraad (FAR)< 0,001%< 0,001%< 0,001%
Arduino-bibliotheekAdafruit FingerprintAdafruit FingerprintAdafruit Fingerprint

De waarden in de tabel kunnen per verkoper en boardrevisie verschillen, vooral de capaciteit. Het betrouwbaarst is om de testsketch hieronder te draaien en de capaciteit te lezen die de sensor zelf meldt. Laten we ook drie termen vastleggen: het ID is het slotnummer van het template in het geheugen (van 0 tot capaciteit min één); het beveiligingsniveau stelt de drempel voor vergelijken in van 1 (meest soepel) tot 5 (strengst); en de betrouwbaarheidsscore is de gelijkenisscore die de sensor bij elke match teruggeeft.

Draadkleuren en voeding: welke draad gaat waarheen?

De meest gemaakte fout bij vingerafdruksensoren is denken dat de draadkleuren standaard zijn. Hetzelfde model kan bij de ene verkoper rood-zwart-geel-wit zijn en bij de andere rood-zwart-groen-blauw; zelfs Adafruit noemt verschillende kleurindelingen voor verschillende sensorversies. Ga dus niet af op kleur: controleer de pinlabels op de achterkant van de sensor of naast de connector en het schema van de verkoper. AS608-modules hebben meestal 6 pins: V+ (Vi), TX, RX, GND, WAK (Touch) en Vt (3.3VT). Voor basisgebruik heb je alleen de eerste vier nodig.

SensorpinFunctieArduino UnoESP32Raspberry Pi Pico
V+ / Vi / VCCVoeding3.3V (AS608) of 5V (R307)3V3 (5V/VIN voor R307)3V3(OUT) (VBUS voor R307)
GNDMassaGNDGNDGND
TXData uit de sensorD2 (SoftwareSerial RX)GPIO 16 (RX2)GP1 (UART0 RX)
RXData naar de sensorD3 (SoftwareSerial TX)GPIO 17 (TX2)GP0 (UART0 TX)
WAK / TouchSignaal vinger gedetecteerd (optioneel)D4GPIO 27GP2
Vt / 3.3VTVoeding voor het aanraakcircuit (optioneel)3.3V3V33V3(OUT)
De meeste AS608-boards werken op 3,3 V; 5 V op een sensor met de markering 3.3V kan hem blijvend beschadigen. De R307 heeft daarentegen 5 V nodig en reageert op 3,3 V vaak helemaal niet. De 3.3V-pin van de Uno is officieel maar voor 50 mA gespecificeerd en een optische sensor trekt meer stroom tijdens het vastleggen van een beeld (Adafruit noemt tot 120 mA bedrijfsstroom voor zijn eigen optische sensor). Als het board willekeurig reset of de sensor steeds wegvalt, voed de sensor dan met een externe 3,3 V-regelaar zoals een AMS1117 en verbind de massa's met elkaar. Omdat pin D3 van de Uno 5 V uitgeeft, is een spanningsdeler van 1 kΩ + 2 kΩ op de RX-lijn van een 3,3 V-sensor de veiligste optie.

De WAK-pin (of Touch) is verbonden met het zuinige aanraakdetectiecircuit van de sensor. Met 3,3 V op de Vt-pin verandert hij van niveau zodra een vinger het glas raakt; bij de meeste modules gaat hij HIGH, bij sommige LOW, dus test het op je eigen board. In een slot op batterijen kun je de hoofdvoeding met een MOSFET afsnijden, alleen Vt gevoed houden en het WAK-signaal gebruiken om de microcontroller uit slaapstand te halen en de sensor pas dan in te schakelen.

De Adafruit Fingerprint-bibliotheek installeren

  1. Open in de Arduino IDE Tools > Manage Libraries, zoek Adafruit Fingerprint Sensor Library en installeer hem. Heb je nog nooit een bibliotheek toegevoegd, kijk dan bij Bibliotheken toevoegen aan Arduino.
  2. De bibliotheek werkt met elke sensor die dezelfde commandoset gebruikt, zoals de AS608, R307, R503, FPM10A en de ZFM-serie; je hoeft de code niet aan te passen.
  3. Onder File > Examples vind je de voorbeelden enroll, fingerprint (controleren), delete (één record wissen) en emptyDatabase (alles wissen).
  4. Op de Uno en Nano is de sensor met SoftwareSerial aangesloten op D2 en D3, zodat pin 0 en 1, die de USB-verbinding gebruikt, vrij blijven. Boards met een tweede hardware-seriële poort, zoals de Mega, Leonardo en ESP32, gebruiken Serial1 of Serial2.

Eerste test: wordt de sensor gevonden?

Voordat je gaat registreren, controleren we of de sensor met de Arduino praat. De sketch hieronder zoekt de sensor eerst op de standaard 57600 bps en probeert, als hij hem niet vindt, de andere gangbare baudrates. Zodra hij de sensor vindt, toont hij in de Serial Monitor de baudrate waarop de sensor antwoordde, de gemelde capaciteit, het beveiligingsniveau en het aantal opgeslagen vingerafdrukken. Vergeet niet de Serial Monitor op 9600 baud te zetten; dat staat los van de snelheid van de sensor.

C++ (Arduino IDE)
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}

Een vingerafdruk registreren, stap voor stap

Bij het registreren maakt de sensor twee aparte beelden van dezelfde vinger, bewaart ze als karakterbestanden in twee buffers (CharBuffer1 en CharBuffer2), voegt ze samen tot een template en schrijft dat naar het ID dat je kiest. Het kant-en-klare enroll-voorbeeld van Adafruit vraagt om een ID tussen 1 en 127 en bewaart dat in een variabele van één byte. De vereenvoudigde versie hieronder bewaart het ID in 16 bits en neemt de bovengrens uit de echte capaciteit van de sensor, zodat je elk slot van een sensor met 300 of 1000 afdrukken kunt gebruiken. Dit zijn de stappen van de bibliotheek:

  1. getImage(): Blijft proberen een beeld te maken tot er een vinger op het glas ligt; geeft FINGERPRINT_NOFINGER terug als er geen is.
  2. image2Tz(1): Zet het eerste beeld om in een karakterbestand en plaatst het in buffer 1.
  3. De vinger wordt opgetild en dezelfde vinger wordt opnieuw geplaatst; image2Tz(2) zet het tweede beeld in buffer 2.
  4. createModel(): Vergelijkt en voegt de twee buffers samen; geeft FINGERPRINT_ENROLLMISMATCH terug als ze niet overeenkomen.
  5. storeModel(id): Schrijft het template blijvend naar het flashgeheugen van de sensor; het blijft bewaard bij stroomverlies.
C++ (Arduino IDE)
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}
Typ het ID in de Serial Monitor, druk op Enter en volg de aanwijzingen. Een goede registratie bepaalt de kwaliteit van elke latere match: leg je vinger in het midden van het glas zonder te hard te drukken en verander de hoek voor het tweede beeld maar een heel klein beetje. Bij een slot dat dagelijks wordt gebruikt verlaagt het registreren van dezelfde vinger onder twee verschillende ID's (eenmaal plat, eenmaal licht gekanteld) merkbaar het aantal afwijzingen. Houd bij welk ID bij wie hoort; de sensor kent alleen nummers, geen namen.

Een vingerafdruk controleren: ID en betrouwbaarheidsscore

Om te controleren maak je eerst met getImage() een beeld, zet je dat om met image2Tz() en doorzoek je daarna de opgeslagen templates. De bibliotheek heeft twee zoekfuncties: fingerFastSearch() is snel, maar het commando dat de bibliotheek verstuurt scant alleen de eerste 163 records (ID's 0–162); fingerSearch() doorzoekt de hele capaciteit die met getParameters() is uitgelezen. Als je ID's boven 162 gebruikt, gebruik dan fingerSearch() en roep altijd getParameters() aan in setup(); anders gaat de bibliotheek uit van de standaardcapaciteit van 64 en doorzoekt ze alleen de eerste 64 records.

Als het zoeken lukt, geeft finger.fingerID het nummer van het overeenkomende record en finger.confidence de betrouwbaarheidsscore. De sensor bepaalt zelf al op basis van het beveiligingsniveau of er een match is; de score zegt alleen hoe sterk de match is. Bij een goed geregistreerde vinger ligt de score meestal ergens tussen enkele tientallen en een paar honderd. Voor een strenger slot kun je de drempel verhogen met setSecurityLevel(4) of setSecurityLevel(5), of in de code je eigen ondergrens toevoegen (bijvoorbeeld alles onder 50 afwijzen). Een hogere drempel verkleint de kans de verkeerde persoon toe te laten, maar vergroot de kans de juiste af te wijzen; vind de balans door met je eigen vingers te testen.

RetourcodeMelding in de Serial MonitorBetekenis en oplossing
FINGERPRINT_OK (0x00)Image taken / Stored!Bewerking geslaagd.
FINGERPRINT_NOFINGER (0x02)No finger detectedGeen vinger op het glas; blijf wachten in de lus.
FINGERPRINT_PACKETRECIEVEERR (0x01)Communication errorGeen antwoordpakket ontvangen; controleer de bedrading, baudrate en voeding.
FINGERPRINT_IMAGEFAIL (0x03)Imaging errorKon geen beeld vastleggen; plaats de vinger opnieuw.
FINGERPRINT_IMAGEMESS (0x06)Image too messyOnscherp beeld; maak het glas schoon, de vinger kan te nat of te droog zijn.
FINGERPRINT_FEATUREFAIL (0x07)Could not find fingerprint featuresTe weinig detail; centreer de vinger en druk licht.
FINGERPRINT_NOTFOUND (0x09)Did not find a matchGeen overeenkomend record; de vinger is niet geregistreerd of slecht geregistreerd.
FINGERPRINT_ENROLLMISMATCH (0x0A)Fingerprints did not matchDe twee registratiebeelden kwamen niet overeen; herhaal de procedure.
FINGERPRINT_BADLOCATION (0x0B)Could not store in that locationHet ID ligt buiten de capaciteit; lees de limiet uit met getParameters().
FINGERPRINT_FLASHERR (0x18)Error writing to flashKon niet naar het geheugen van de sensor schrijven; controleer de voeding en bedrading.

Vingerafdrukdeurslot met relais en solenoïde

Nu zetten we alles samen en bouwen we een deurslot dat 3 seconden opent voor een geautoriseerde vinger, drie keer piept bij een onbekende en het systeem 30 seconden vergrendelt na 5 mislukte pogingen achter elkaar. Als slot gebruiken we een solenoïdeslot van 12 V. Een solenoïde trekt 0,5–1 A en mag dus nooit direct op een Arduino-pin worden aangesloten; zet er een relaismodule of een logic-level MOSFET tussen. De bedrading: VCC en GND van de relaismodule gaan naar 5V en GND van de Arduino en de IN-pin naar D8, een actieve buzzer naar D9, de plus van de 12 V-adapter naar de COM-aansluiting van het relais, de NO-aansluiting van het relais naar de plus van de solenoïde en de min van de solenoïde naar de min van de adapter.

Een solenoïde is een spoel en geeft een hoge omgekeerde spanning af op het moment dat de stroom wordt onderbroken. Daarom moet je een diode 1N4007 in sperrichting over de solenoïde plaatsen; de kant met de streep van de diode gaat naar de plus. Gebruik je een MOSFET in plaats van een relais, kies dan een logic-level type zoals de IRLZ44N en verbind de min van de 12 V-voeding met de GND van de Arduino. Voor details zie Hoge stromen schakelen met een MOSFET; de pinvolgorde van de MOSFET vind je in de tool Transistor Pinouts.

C++ (Arduino IDE)
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}
Dit project is prima om te leren en als hobby, maar op zichzelf is het geen echt beveiligingssysteem. Optische sensoren kunnen worden misleid met een goed gemaakte vingerafdrukmal en wie bij de draden kan, kan het relais direct activeren. Houd de elektronica bij een echte deur aan de binnenkant, laat een mechanische sleutel of een andere manier om te openen toe en bedenk wat het slot doet bij stroomuitval: solenoïden van het doostype blijven zonder stroom meestal vergrendeld, terwijl elektromagnetische sloten openen. Laat de solenoïde niet lang bekrachtigd; de spoel wordt heet en kan beschadigen.

Vingerafdruksensor met ESP32: de Serial2-verbinding

De ESP32 heeft drie hardware-seriële poorten, dus je hebt SoftwareSerial niet nodig; je sluit de sensor aan op UART2 (Serial2). Omdat de ESP32 op 3,3 V werkt, komt hij precies overeen met de signaalniveaus van de AS608 en is geen spanningsdeler nodig. Waar je op moet letten zijn de pins: in de huidige Arduino-ESP32-core (3.x) zijn de standaard Serial2-pins niet meer GPIO 16/17 zoals in oudere tutorials, maar GPIO 4 (RX) en GPIO 25 (TX). Geef de pins dus expliciet mee aan Serial2.begin(); de begin() van de bibliotheek behoudt de pins die je eerder hebt ingesteld. De pinindeling van je board zie je in de tool Pinout.

C++ (Arduino IDE)
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}

Op boards met een ESP32-WROVER-module zijn GPIO 16 en 17 verbonden met het PSRAM; verander op zo'n board FP_RX en FP_TX bijvoorbeeld in 25 en 26. De ESP32-C3 heeft maar twee UART's, dus er is geen Serial2; je kunt dezelfde code gebruiken met Serial1 en twee willekeurige pins. Dankzij Wi-Fi kun je elke toegang met een tijdstempel naar een server loggen of met een Telegram-bot een melding naar je telefoon sturen als een onbekende vinger wordt gedetecteerd.

Vingerafdruksensor met Raspberry Pi Pico en MicroPython

Er is geen officiële MicroPython-versie van de Adafruit-bibliotheek, maar het protocol van de sensor is eenvoudig genoeg om er zelf in een paar regels mee te praten. Elk pakket begint met de startcode EF 01, gevolgd door een adres van 4 bytes (standaard FF FF FF FF), het pakkettype (01 commando, 07 antwoord), een lengte van 2 bytes, het commando met zijn parameters en ten slotte een checksum van 2 bytes die de som is van de type-, lengte- en databytes. De eerste databyte van het antwoord is de bevestigingscode: 00 geslaagd, 02 geen vinger, 09 geen match. De code hieronder controleert de sensor, leest de capaciteit uit en identificeert de vinger op het glas met ID en betrouwbaarheidsscore. Omdat de Pico op 3,3 V werkt, kun je de AS608 direct op de 3V3(OUT)-pin aansluiten; ben je nieuw met de Pico, begin dan bij Wat is de Raspberry Pi Pico?.

MicroPython
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)

De fout "Did not find fingerprint sensor" en andere veelvoorkomende problemen

Deze melding betekent dat de bibliotheek geen geldig antwoord van de sensor kreeg op het commando verifyPassword(); het betekent niet dat de sensor kapot is. In de overgrote meerderheid van de gevallen ligt het aan bedrading, voeding of een verkeerde baudrate. Loop de tabel hieronder van boven naar beneden door:

SymptoomWaarschijnlijke oorzaakOplossing
Did not find fingerprint sensor :(TX en RX recht doorverbondenDe TX van de sensor gaat naar de RX (D2) van de Arduino en de RX naar TX (D3). De twee datadraden verwisselen kan geen kwaad, dus probeer het.
Did not find fingerprint sensor :(Op de draadkleuren vertrouwenBedraad opnieuw volgens de pinlabels op het board of het schema van de verkoper; controleer GND met een multimeter.
Did not find fingerprint sensor :(Verkeerde of onvoldoende voedingGeef de AS608 3,3 V en de R307 5 V; als de 3.3V-pin van de Uno niet genoeg is, gebruik een externe regelaar en verbind de massa's.
Did not find fingerprint sensor :(De sensor werkt op een andere baudrateVoer de baudscan in de eerste testsketch uit en zet de gevonden waarde in finger.begin().
Did not find fingerprint sensor :(Het wachtwoord van de sensor is gewijzigdGeef het wachtwoord mee aan de constructor: Adafruit_Fingerprint finger(&fpSerial, 0x12345678);
Sensor niet gevonden op een Mega of LeonardoSoftwareSerial kan niet op elke pin ontvangenGebruik Serial1: RX1 19, TX1 18 op de Mega; RX 0, TX 1 op de Leonardo.
Sensor niet gevonden op een ESP32Andere standaardpins van Serial2 of een PSRAM-conflictStel de pins expliciet in met Serial2.begin(57600, SERIAL_8N1, RX, TX); gebruik 16/17 niet op een WROVER.
Vaak "Communication error"Losse connector, lange of dunne dradenHoud de draden kort, gebruik gesoldeerde verbindingen in plaats van een breadboard en voeg een condensator van 100 µF toe aan de voeding.
Een geregistreerde vinger wordt vaak afgewezenVuil glas, droge of natte vinger, maar vanuit één hoek geregistreerdVeeg het glas af met een zachte doek, registreer dezelfde vinger onder twee ID's en verlaag zo nodig het beveiligingsniveau naar 2.
De sensor wordt warm, de led gaat nooit brandenOmgekeerde voeding of 5 V op een AS608Haal direct de voeding eraf en herstel de bedrading; de sensor kan beschadigd zijn.
Een snelle manier om het probleem in te perken is de sensor aan te sluiten op een USB-naar-TTL-converter en te testen met een Windows-testprogramma zoals SFGDemo: als de sensor daar verschijnt, zit het probleem in de bedrading of code aan de Arduino-kant. Bedenk ook dat de snelheid van de Serial Monitor (9600) en die van de sensor (57600) twee verschillende dingen zijn; haal ze niet door elkaar.

Waveshare UART-vingerafdruklezer: een korte opmerking

Waveshare UART-vingerafdruklezermodule en controllerboard
Waveshare UART Fingerprint Reader: de optische sensor wordt met een lintkabel verbonden met een apart controllerboard met een STM32F205-processor; het board heeft de pins VCC, GND, TXD, RXD, BL en RST.

Hoewel hij er vergelijkbaar uitziet, spreekt de UART-vingerafdruklezer van Waveshare een ander protocol dan de AS608 en R307: commando's zijn 8 bytes lang, beginnen en eindigen met 0xF5 en de standaardsnelheid is 19200 bps. Daarom werkt hij niet met de Adafruit Fingerprint-bibliotheek; je gebruikt in plaats daarvan de commandotabel en voorbeeldcode uit de handleiding van Waveshare. Bij het registreren wordt een vinger drie keer gescand, kan elke gebruiker een rechtenniveau van 1 tot 3 krijgen en gebeurt een 1:N-vergelijking met één commando. Het board kan op 3,3 V of 5 V worden gevoed; je verbindt TXD met de RX van de microcontroller en RXD met zijn TX. Wil je veel kant-en-klare bibliotheken en voorbeelden, kies dan de AS608 of R307; vind je het niet erg zelf protocolcode te schrijven, dan is de Waveshare een goede keuze.

Projectideeën met een vingerafdruksensor

  • Vingerafdruklade of -kluis: Een kleine kluis die met een servo of solenoïde opent en alarm slaat bij onbevoegde pogingen. Voor een servovergrendeling, zie Wat is een servomotor?
  • Deur met twee stappen: Een veiligere toegang die eerst om een vingerafdruk vraagt en daarna om een pincode op een keypad.
  • Pas of vinger: Voeg een RFID RC522-lezer toe aan hetzelfde slot, zodat mensen met een pas de pas gebruiken en anderen een vinger.
  • Aanwezigheidssysteem: Koppel elk ID aan een naam voor een school of club en log de tijden van binnenkomst.
  • Slot met display: Toon een welkomstbericht en de naam van de persoon op een OLED-display.
  • Samen met een huisalarm: Een Arduino-alarmsysteem dat je met een vingerafdruk in- en uitschakelt.

Met een paar draden en de juiste bibliotheek voegt een vingerafdruksensor een echte identiteitslaag toe aan je project: test eerst de sensor, registreer vingers zorgvuldig en bouw dan het slot met een relais en solenoïde. In de BlueGrays-app vind je beveiligingsprojecten zoals een slimme elektronische kluis, RFID-authenticatie, een ESP32-RFID-deurslot en een keypad-wachtwoordapp, elk met stapsgewijze schakelschema's en code, zodat je een kant-en-klare basis hebt om een vingerafdruksensor toe te voegen.

Veelgestelde vragen

Hoeveel vingerafdrukken kan een vingerafdruksensor opslaan?

Dat hangt van het model af: AS608-boards bewaren meestal 300 (sommige 162), de R307 bewaart 1000 en de FPM10A en ZFM-20 bewaren 162. Om de capaciteit van je eigen sensor te weten roep je getParameters() aan en toon je finger.capacity in de Serial Monitor. Bedenk dat het registreren van dezelfde vinger onder twee ID's twee slots gebruikt.

Werkt een vingerafdruksensor op 5V of 3,3V?

De meeste AS608-boards hebben 3,3 V nodig, terwijl de R307 werkt op 4,2–6 V, meestal 5 V. Zet geen spanning erop voordat je het label op de sensor en de specificaties van de verkoper hebt gecontroleerd. Als je de TX-uitgang van een Arduino van 5 V verbindt met de RX van een sensor van 3,3 V, is een spanningsdeler de veiligste keuze.

Worden vingerafdrukken op de Arduino opgeslagen en gaan ze verloren als de stroom uitvalt?

Nee, de templates worden in het eigen flashgeheugen van de sensor opgeslagen en worden niet gewist als de stroom uitvalt. Ook als je de Arduino verwisselt of nieuwe code uploadt, blijven de records op de sensor staan. Aan de Arduino-kant hoef je alleen bij te houden welk ID bij wie hoort; dat kun je desgewenst in EEPROM opslaan.

Hoe los ik de fout "Did not find fingerprint sensor" op?

Controleer eerst of TX en RX gekruist zijn: de TX van de sensor gaat naar de RX-pin van de Arduino (D2 op de Uno). Controleer daarna of de voeding de juiste spanning heeft met genoeg stroom en of de massa's gedeeld zijn. Wordt hij nog steeds niet gevonden, dan gebruikt de sensor misschien een andere baudrate of een wachtwoord; draai een testsketch die meerdere baudrates probeert.

Wat is het verschil tussen de AS608 en de R307?

Beide zijn optische sensoren met dezelfde commandoset die met dezelfde code in de Adafruit Fingerprint-bibliotheek werken. De belangrijkste verschillen zijn voeding en capaciteit: AS608-boards werken meestal op 3,3 V en bewaren ongeveer 300 records, terwijl de R307 op 5 V werkt en er 1000 kan bewaren. Controleer de pinvolgorde op het label van je eigen model voordat je gaat bedraden.

Hoe wis ik een opgeslagen vingerafdruk?

Gebruik finger.deleteModel(id) om één record te wissen en finger.emptyDatabase() om ze allemaal te wissen. De voorbeelden delete en emptyDatabase van de bibliotheek doen dit vanuit de Serial Monitor. Je kunt later een nieuwe vingerafdruk registreren onder een gewist ID.

Alle projecten bekijken
Slimme elektronische kluis
AR-92Gevorderd
Premium

Slimme elektronische kluis

Een kleine kluis voor je waardevolle spullen die opent met een code. Je tikt je viercijferige code in op het toetsenbord; klopt hij, dan opent de servomotor het slot, gaat het groene lampje aan en…

4.7(42)
63
ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
ES-35Gevorderd
Premium

ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)

We bouwen een slim deurslot met een ESP32, een RC522 RFID-module, een SG90-servo, een SSD1306 OLED-display, een actieve buzzer en 2 leds. Bij het scannen van een kaart wordt de UID vergeleken met de geautoriseerde kaarten in de code; bij een match ontgrendelt de servo (groene led + 2 korte piepjes) en vergrendelt na 5 seconden weer. Een onbekende kaart laat de rode led branden, geeft 3 snelle piepjes en toont de UID op de OLED.

4.8(9)
16
RFID-authenticatie
AR-54Gemiddeld
Premium

RFID-authenticatie

Net als de kaartlezer bij een appartementsdeur: je houdt je kaart bij de RFID-lezer en de Arduino vergelijkt het nummer met het opgeslagen nummer.

4.8(65)
84
RFID-waarde uitlezen
AR-53Beginner
Premium

RFID-waarde uitlezen

Je sleutelhanger of toegangskaart verbergt een geheim ID-nummer en dit project leest het uit. Houd de kaart bij de RFID-lezer en de Arduino schrijft het kaartnummer naar je computerscherm.

4.7(47)
61
Codeslot met 4x4-keypad en LCD
AR-64Gevorderd
Premium

Codeslot met 4x4-keypad en LCD

Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.

4.8(59)
75
ESP32 RFID-RC522-kaartlezer (met LCD)
ES-21Gemiddeld

ESP32 RFID-RC522-kaartlezer (met LCD)

In dit project sluit je de RC522-RFID-module op basis van de MFRC522 via SPI aan op de ESP32 en lees je de UID van een kaart of tag uit. Dit vormt de basis voor toepassingen zoals deursloten, ledensystemen en toegangscontrole. De uitgelezen UID tonen we op een LCD; deze versie vergelijkt hem niet met een lijst van geautoriseerde kaarten. LET OP: de RC522 werkt alleen op 3,3 V; geef je hem 5 V, dan brandt de module door!

4.8(21)
42
Deursensor met reedschakelaar
AR-38Beginner
Premium

Deursensor met reedschakelaar

Zie aan een lampje of je deur open of dicht is. Je bevestigt een kleine magneet aan de deur en een magneetgevoelige schakelaar aan de deurpost; als de deur dicht is, zitten ze naast elkaar en brandt…

4.7(34)
44
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9