Sensor de huella dactilar Arduino: AS608, R307 y cerradura

Un sensor de huella dactilar permite que tu proyecto con Arduino pregunte "¿quién eres?" con un solo toque y abra una puerta, un cajón o una caja fuerte cuando reconoce tu dedo. Los modelos más comunes en electrónica de afición son módulos ópticos basados en el AS608 y el R307: procesan la imagen del dedo por dentro, guardan las huellas en su propia memoria y solo envían al Arduino una respuesta corta como "coincide con el ID 3". Por eso incluso una placa pequeña como el Arduino Uno puede gestionar sin esfuerzo una cerradura de huella para cientos de personas.

En esta guía aprenderás cómo funciona el sensor, cómo conectarlo bien aunque los colores de los cables cambien según el fabricante, cómo registrar (enroll) y verificar huellas con la librería Adafruit Fingerprint y qué significan el ID y la puntuación de confianza. Después montarás una cerradura real con un relé y un solenoide de 12 V, harás lo mismo con un ESP32 y una Raspberry Pi Pico y resolverás paso a paso el famoso error "Did not find fingerprint sensor".

¿Qué es un sensor de huella dactilar y cómo funciona?

Módulos como el AS608 y el R307 son sensores ópticos. Cuando apoyas el dedo en el cristal, un LED interior ilumina el prisma que hay debajo; las crestas de la huella tocan el cristal y reflejan la luz de forma distinta, mientras que los valles no lo tocan. Una cámara diminuta captura ese patrón como una imagen en escala de grises de unos 500 ppp. El chip DSP del módulo localiza los puntos donde las líneas terminan o se bifurcan (minucias) y los convierte en un archivo de características de unos cientos de bytes. Dos archivos del mismo dedo se combinan en una plantilla (template), que se guarda en la memoria flash del propio sensor con un número de ID.

Al verificar, el sensor vuelve a convertir la nueva imagen en un archivo de características y la compara con todas las plantillas guardadas. Esta búsqueda 1:N suele tardar menos de un segundo; al final el sensor devuelve el ID que coincide y una puntuación de confianza (confidence) que indica lo fuerte que es la coincidencia. Lo importante: la imagen de la huella nunca llega al Arduino, todo el trabajo pesado lo hace el sensor. El Arduino solo envía comandos por el puerto serie (UART) y lee respuestas cortas.

Los valores de la tabla pueden variar según el vendedor y la versión de la placa, sobre todo la capacidad. Lo más fiable es ejecutar el sketch de prueba de abajo y leer la capacidad que informa el propio sensor. Aclaremos también tres conceptos: el ID es el número de posición de la plantilla en memoria (de 0 a la capacidad menos uno); el nivel de seguridad fija el umbral de coincidencia de 1 (el más permisivo) a 5 (el más estricto); y la puntuación de confianza es la nota de similitud que el sensor devuelve en cada coincidencia.

Colores de los cables y alimentación: ¿qué cable va a dónde?

El error más habitual con los sensores de huella es pensar que los colores de los cables son estándar. El mismo modelo puede llegar con cables rojo-negro-amarillo-blanco de un vendedor y rojo-negro-verde-azul de otro; incluso Adafruit indica distintas combinaciones de colores para distintas versiones de sus sensores. Así que no te fíes del color: mira las serigrafías de los pines en la parte trasera del sensor o junto al conector, y el esquema del vendedor. Los módulos AS608 suelen tener 6 pines: V+ (Vi), TX, RX, GND, WAK (Touch) y Vt (3.3VT). Para el uso básico basta con los cuatro primeros.

El pin WAK (o Touch) está conectado al circuito de detección táctil del sensor, que consume muy poco. Con 3,3 V en el pin Vt, cambia de nivel en cuanto un dedo toca el cristal; en la mayoría de los módulos pasa a HIGH y en algunos a LOW, así que pruébalo en tu placa. En una cerradura a pilas puedes cortar la alimentación principal con un MOSFET, dejar solo Vt alimentado y usar la señal WAK para despertar al microcontrolador y encender el sensor solo en ese momento.

Instalar la librería Adafruit Fingerprint

1. En el Arduino IDE abre Herramientas > Administrar bibliotecas, busca Adafruit Fingerprint Sensor Library e instálala. Si nunca has añadido una librería, mira Cómo añadir librerías en Arduino.
2. La librería funciona con todos los sensores que usan el mismo juego de comandos, como el AS608, R307, R503, FPM10A y la serie ZFM; no hace falta cambiar el código.
3. En Archivo > Ejemplos encontrarás enroll (registro), fingerprint (verificación), delete (borrar un registro) y emptyDatabase (borrarlo todo).
4. En el Uno y el Nano el sensor se conecta a D2 y D3 con SoftwareSerial para no ocupar los pines 0 y 1, que usa el USB. Las placas con un segundo puerto serie por hardware, como el Mega, el Leonardo y el ESP32, usan Serial1 o Serial2.

Primera prueba: ¿se detecta el sensor?

Antes de registrar huellas, comprobemos que el sensor habla con el Arduino. El sketch de abajo busca primero el sensor a la velocidad por defecto de 57600 bps y, si no lo encuentra, prueba las demás velocidades habituales. Cuando lo encuentra, escribe en el Monitor Serie la velocidad a la que respondió, la capacidad que informa, el nivel de seguridad y el número de huellas guardadas. No olvides poner el Monitor Serie a 9600 baudios; es independiente de la velocidad del sensor.

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}

Registrar una huella (enroll) paso a paso

Durante el registro el sensor toma dos imágenes distintas del mismo dedo, las guarda como archivos de características en dos búferes (CharBuffer1 y CharBuffer2), las combina en una plantilla y la escribe en el ID que elijas. El ejemplo enroll de Adafruit pide un ID entre 1 y 127 y lo guarda en una variable de un byte. La versión simplificada de abajo guarda el ID en 16 bits y toma el límite superior de la capacidad real del sensor, así puedes usar todas las posiciones de un sensor de 300 o 1000 huellas. Estos son los pasos de la librería:

1. getImage(): Intenta tomar una imagen hasta que haya un dedo sobre el cristal; si no lo hay, devuelve FINGERPRINT_NOFINGER.
2. image2Tz(1): Convierte la primera imagen en un archivo de características y lo guarda en el búfer 1.
3. Se levanta el dedo y se vuelve a apoyar el mismo; image2Tz(2) guarda la segunda imagen en el búfer 2.
4. createModel(): Compara y combina los dos búferes; si no coinciden, devuelve FINGERPRINT_ENROLLMISMATCH.
5. storeModel(id): Escribe la plantilla de forma permanente en la memoria flash del sensor; no se borra aunque se corte la corriente.

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}

Verificar una huella: ID y puntuación de confianza

Para verificar, primero tomas una imagen con getImage(), la conviertes con image2Tz() y luego buscas entre las plantillas guardadas. La librería tiene dos funciones de búsqueda: fingerFastSearch() es rápida, pero el comando que envía la librería solo revisa los primeros 163 registros (ID 0–162); fingerSearch() busca en toda la capacidad leída con getParameters(). Si vas a usar ID mayores de 162, usa fingerSearch() y llama siempre a getParameters() en setup(); si no, la librería supone la capacidad por defecto de 64 y solo busca en los primeros 64 registros.

Si la búsqueda tiene éxito, finger.fingerID da el número del registro que coincide y finger.confidence la puntuación de confianza. El sensor ya decide por sí mismo si hay coincidencia según el nivel de seguridad; la puntuación solo indica lo fuerte que es. Con un dedo bien registrado suele quedar entre unas decenas y unos cientos. Para una cerradura más estricta puedes subir el umbral con setSecurityLevel(4) o setSecurityLevel(5), o poner tu propio mínimo en el código (por ejemplo, rechazar todo lo que esté por debajo de 50). Un umbral más alto reduce la probabilidad de aceptar a la persona equivocada, pero aumenta la de rechazar a la correcta; busca el equilibrio probando con tus propios dedos.

Cerradura de huella dactilar con relé y solenoide

Ahora juntamos todo y montamos una cerradura que se abre 3 segundos con un dedo autorizado, pita tres veces con uno desconocido y bloquea el sistema 30 segundos tras 5 intentos fallidos seguidos. Como cerrojo usamos una cerradura de solenoide de 12 V. Un solenoide consume 0,5–1 A, así que nunca se conecta directamente a un pin del Arduino; entre ambos va un módulo relé o un MOSFET de nivel lógico. El conexionado: VCC y GND del módulo relé a 5V y GND del Arduino, su pin IN a D8, un zumbador activo a D9, el positivo del adaptador de 12 V al borne COM del relé, el borne NO del relé al positivo del solenoide y el negativo del solenoide al negativo del adaptador.

Un solenoide es una bobina y genera una tensión inversa alta en el instante en que se corta su corriente. Por eso debes conectar un diodo 1N4007 en paralelo con el solenoide y en sentido inverso; el extremo con la franja va al positivo. Si usas un MOSFET en lugar del relé, elige uno de nivel lógico como el IRLZ44N y une el negativo de la fuente de 12 V con el GND del Arduino. Tienes los detalles en Controlar corrientes altas con un MOSFET, y el orden de patillas del MOSFET en la herramienta Patillaje de transistores.

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}

Sensor de huella con ESP32: conexión por Serial2

El ESP32 tiene tres puertos serie por hardware, así que no necesitas SoftwareSerial: conectas el sensor a la UART2 (Serial2). Como el ESP32 trabaja a 3,3 V, coincide exactamente con los niveles de señal del AS608 y no hace falta divisor de tensión. Lo único que debes vigilar son los pines: en el núcleo actual de Arduino-ESP32 (3.x) los pines por defecto de Serial2 ya no son GPIO 16/17 como en los tutoriales antiguos, sino GPIO 4 (RX) y GPIO 25 (TX). Por eso conviene indicar los pines de forma explícita en Serial2.begin(); el begin() de la librería conserva los pines fijados antes. Puedes ver el mapa de pines de tu placa en la herramienta 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}

En las placas con módulo ESP32-WROVER, los GPIO 16 y 17 están conectados a la PSRAM; en ese caso cambia FP_RX y FP_TX, por ejemplo, a 25 y 26. El ESP32-C3 solo tiene dos UART, así que no hay Serial2; puedes usar el mismo código con Serial1 y los dos pines que quieras. Gracias al Wi-Fi puedes registrar cada entrada con su hora en un servidor o enviarte un aviso al móvil con un bot de Telegram cuando aparezca un dedo desconocido.

Sensor de huella con Raspberry Pi Pico y MicroPython

No existe una versión oficial de la librería de Adafruit para MicroPython, pero el protocolo del sensor es lo bastante sencillo como para hablarle tú mismo en pocas líneas. Cada paquete empieza con el código de inicio EF 01, seguido de una dirección de 4 bytes (FF FF FF FF por defecto), el tipo de paquete (01 comando, 07 respuesta), una longitud de 2 bytes, el comando y sus parámetros y, al final, una suma de comprobación de 2 bytes formada por la suma de los bytes de tipo, longitud y datos. El primer byte de datos de la respuesta es el código de confirmación: 00 correcto, 02 sin dedo, 09 sin coincidencia. El código de abajo verifica el sensor, lee la capacidad e identifica el dedo apoyado con su ID y su puntuación de confianza. Como la Pico funciona a 3,3 V, puedes conectar el AS608 directamente al pin 3V3(OUT); si empiezas con la Pico, ¿Qué es la Raspberry Pi Pico? es un buen punto de partida.

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)

El error "Did not find fingerprint sensor" y otros problemas frecuentes

Este mensaje significa que la librería no recibió una respuesta válida del sensor a su comando verifyPassword(); no quiere decir que el sensor esté roto. La gran mayoría de los casos se deben al cableado, a la alimentación o a una velocidad incorrecta. Revisa la tabla de arriba abajo:

Lector de huella UART de Waveshare: una nota breve

Aunque se parece, el lector de huella UART de Waveshare habla un protocolo distinto al del AS608 y el R307: los comandos tienen 8 bytes, empiezan y terminan con 0xF5 y la velocidad por defecto es 19200 bps. Por eso no funciona con la librería Adafruit Fingerprint; se usan la tabla de comandos y los ejemplos del manual de Waveshare. En el registro el dedo se lee tres veces, a cada usuario se le puede asignar un nivel de permiso de 1 a 3 y la comparación 1:N se hace con un único comando. La placa admite 3,3 V o 5 V; conectas TXD al RX del microcontrolador y RXD a su TX. Si quieres muchas librerías y ejemplos listos, elige el AS608 o el R307; si no te importa escribir tu propio código de protocolo, el de Waveshare es una buena opción.

Ideas de proyectos con sensor de huella

• Cajón o caja fuerte con huella: Una pequeña caja que se abre con un servo o un solenoide y da la alarma ante intentos no autorizados. Para un cierre con servo, consulta ¿Qué es un servomotor?
• Puerta en dos pasos: Un acceso más seguro que pide primero la huella y después un PIN en un teclado matricial.
• Tarjeta o dedo: Añade un lector RFID RC522 a la misma cerradura para que quien tenga tarjeta entre con ella y los demás con el dedo.
• Control de asistencia: Asocia cada ID a un nombre para un colegio o un club y guarda las horas de entrada.
• Cerradura con pantalla: Muestra un mensaje de bienvenida y el nombre de la persona en una pantalla OLED.
• Junto a una alarma de casa: Un sistema de alarma con Arduino que se activa y desactiva con la huella.

Con unos pocos cables y la librería adecuada, un sensor de huella añade una auténtica capa de identidad a tu proyecto: primero prueba el sensor, registra los dedos con cuidado y luego monta la cerradura con relé y solenoide. En la app BlueGrays encontrarás proyectos de seguridad como una caja fuerte electrónica inteligente, autenticación RFID, una cerradura RFID con ESP32 y una aplicación de contraseña con teclado, con esquemas y código paso a paso, una base lista para añadir un sensor de huella.