Sensor de impressão digital com Arduino: AS608, R307 e fechadura de porta

Um sensor de impressão digital permite que um projeto Arduino pergunte “quem é você?” com um único toque e abra uma porta, gaveta ou cofre quando reconhece o seu dedo. Os modelos mais comuns na eletrônica hobby são módulos ópticos baseados no AS608 e no R307: eles processam a imagem do dedo internamente, guardam as impressões digitais na própria memória e enviam ao Arduino só uma resposta curta, como “correspondeu ao ID 3”. Por isso, até uma placa pequena como o Arduino Uno consegue controlar com folga uma fechadura biométrica para centenas de pessoas.

Neste guia você vai aprender como o sensor funciona, como ligá-lo corretamente mesmo que as cores dos fios mudem de fabricante para fabricante, como cadastrar (enroll) e verificar impressões digitais com a biblioteca Adafruit Fingerprint e o que significam o ID e a pontuação de confiança. Depois você vai montar uma fechadura de porta de verdade com um relé e um solenoide de 12 V, fazer o mesmo com um ESP32 e um Raspberry Pi Pico e resolver passo a passo o famoso erro “Did not find fingerprint sensor”.

O que é um sensor de impressão digital e como ele funciona?

Módulos como o AS608 e o R307 são sensores ópticos. Quando você coloca o dedo sobre o vidro, um LED interno ilumina o prisma que fica embaixo dele; as cristas da sua impressão digital tocam o vidro e refletem a luz de forma diferente, enquanto os vales não tocam. Uma pequena câmera captura esse padrão como uma imagem em tons de cinza com cerca de 500 dpi. O chip DSP do módulo extrai os pontos onde as cristas terminam ou se bifurcam (minúcias) e os transforma em um arquivo de características de algumas centenas de bytes. Dois arquivos de características obtidos do mesmo dedo são combinados em um modelo (template), e esse modelo é salvo na própria memória flash do sensor com um número de ID.

Na verificação, o sensor também converte a nova imagem em um arquivo de características e a compara com todos os modelos armazenados. Essa busca 1:N costuma levar menos de um segundo; no final, o sensor devolve o ID correspondente e uma pontuação de confiança que mostra o quanto a correspondência é forte. O ponto principal: a imagem da impressão digital nunca chega ao Arduino, todo o trabalho pesado acontece dentro do sensor. O Arduino só envia comandos pela porta serial (UART) e lê respostas curtas.

Os valores da tabela podem variar conforme o vendedor e a revisão da placa, principalmente a capacidade. O jeito mais confiável é rodar o sketch de teste abaixo e ler a capacidade que o próprio sensor informa. Vamos também deixar três termos claros: o ID é o número da posição do modelo na memória (de 0 até a capacidade menos um); o nível de segurança define o limite de correspondência de 1 (mais tolerante) a 5 (mais rigoroso); e a pontuação de confiança é a nota de semelhança que o sensor devolve a cada correspondência.

Cores dos fios e alimentação: qual fio vai onde?

O erro mais comum com sensores de impressão digital é achar que as cores dos fios são padronizadas. O mesmo modelo pode vir com fios vermelho-preto-amarelo-branco de um vendedor e vermelho-preto-verde-azul de outro; até a Adafruit lista disposições de cores diferentes para versões diferentes do sensor. Então não se guie pela cor: confira as marcações dos pinos na parte de trás do sensor ou ao lado do conector, e o diagrama do vendedor. Os módulos AS608 normalmente têm 6 pinos: V+ (Vi), TX, RX, GND, WAK (Touch) e Vt (3.3VT). Para o uso básico, só os quatro primeiros são necessários.

O pino WAK (ou Touch) está ligado ao circuito de detecção de toque de baixo consumo do sensor. Com 3,3 V no pino Vt, ele muda de nível no instante em que um dedo toca o vidro; na maioria dos módulos ele vai para HIGH, em alguns vai para LOW, então teste na sua própria placa. Em uma fechadura alimentada por bateria, você pode cortar a alimentação principal com um MOSFET, deixar só o Vt alimentado e usar o sinal WAK para acordar o microcontrolador do modo de suspensão e ligar o sensor só nessa hora.

Instalando a biblioteca Adafruit Fingerprint

1. No Arduino IDE, abra Ferramentas > Gerenciar Bibliotecas, busque Adafruit Fingerprint Sensor Library e instale. Se você nunca adicionou uma biblioteca, veja Como instalar uma biblioteca no Arduino.
2. A biblioteca funciona com todos os sensores que usam o mesmo conjunto de comandos, como o AS608, R307, R503, FPM10A e a série ZFM; não é preciso mudar o código.
3. Em Arquivo > Exemplos você encontra os exemplos enroll (cadastro), fingerprint (verificação), delete (apaga um registro) e emptyDatabase (apaga tudo).
4. No Uno e no Nano, o sensor é ligado a D2 e D3 com SoftwareSerial, para não ocupar os pinos 0 e 1, que a conexão USB usa. Placas com uma segunda porta serial de hardware, como o Mega, o Leonardo e o ESP32, usam Serial1 ou Serial2.

Primeiro teste: o sensor é encontrado?

Antes de cadastrar, vamos confirmar que o sensor está conversando com o Arduino. O sketch abaixo primeiro procura o sensor na velocidade padrão de 57600 bps e, se não encontrar, testa as outras taxas de baud comuns. Quando encontra o sensor, ele mostra no Monitor Serial a taxa de baud em que o sensor respondeu, a capacidade informada, o nível de segurança e o número de impressões digitais armazenadas. Não se esqueça de ajustar o Monitor Serial para 9600 baud; isso é independente da velocidade do 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}

Cadastrando uma impressão digital passo a passo

No cadastro, o sensor tira duas imagens separadas do mesmo dedo, guarda cada uma como arquivo de características em dois buffers (CharBuffer1 e CharBuffer2), junta as duas em um modelo e grava o modelo no ID que você escolher. O exemplo enroll pronto da Adafruit pede um ID entre 1 e 127 e o guarda em uma variável de um byte. A versão simplificada abaixo guarda o ID em 16 bits e pega o limite superior da capacidade real do sensor; assim, você pode usar todas as posições de um sensor de 300 ou 1000 impressões. Estes são os passos da biblioteca:

1. getImage(): Tenta capturar uma imagem até haver um dedo no vidro; retorna FINGERPRINT_NOFINGER quando não há nenhum.
2. image2Tz(1): Converte a primeira imagem em um arquivo de características e o coloca no buffer 1.
3. O dedo é levantado e o mesmo dedo é colocado de novo; image2Tz(2) coloca a segunda imagem no buffer 2.
4. createModel(): Compara e junta os dois buffers; retorna FINGERPRINT_ENROLLMISMATCH se eles não corresponderem.
5. storeModel(id): Grava o modelo de forma permanente na memória flash do sensor; ele não se perde se faltar energia.

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}

Verificando uma impressão digital: ID e pontuação de confiança

Para verificar, você primeiro captura uma imagem com getImage(), converte com image2Tz() e depois busca entre os modelos armazenados. A biblioteca tem duas funções de busca: fingerFastSearch() é rápida, mas o comando que a biblioteca envia só varre os primeiros 163 registros (IDs 0–162); fingerSearch() busca em toda a capacidade lida com getParameters(). Se você vai usar IDs acima de 162, use fingerSearch() e sempre chame getParameters() no setup(); caso contrário, a biblioteca assume a capacidade padrão de 64 e busca só nos primeiros 64 registros.

Quando a busca dá certo, finger.fingerID informa o número do registro correspondente e finger.confidence, a pontuação de confiança. O próprio sensor já decide se há correspondência com base no nível de segurança; a pontuação só diz o quanto ela é forte. Com um dedo bem cadastrado, a pontuação costuma ficar entre algumas dezenas e algumas centenas. Para uma fechadura mais rigorosa, você pode subir o limite com setSecurityLevel(4) ou setSecurityLevel(5), ou acrescentar seu próprio limite mínimo no código (por exemplo, rejeitar tudo abaixo de 50). Um limite mais alto diminui a chance de aceitar a pessoa errada, mas aumenta a chance de rejeitar a certa; encontre o equilíbrio testando com os seus próprios dedos.

Fechadura de porta biométrica com relé e solenoide

Agora vamos juntar tudo e montar uma fechadura de porta que abre por 3 segundos para um dedo autorizado, apita três vezes para um desconhecido e bloqueia o sistema por 30 segundos depois de 5 tentativas erradas seguidas. Como trava, usamos uma fechadura solenoide de 12 V. Um solenoide consome 0,5–1 A, então ele nunca deve ser ligado diretamente a um pino do Arduino; coloque um módulo relé ou um MOSFET de nível lógico no meio. A ligação: o VCC e o GND do módulo relé vão ao 5V e ao GND do Arduino, e o pino IN vai ao D8; um buzzer ativo vai ao D9; o positivo da fonte de 12 V vai ao terminal COM do relé, o terminal NO (normalmente aberto) do relé vai ao positivo do solenoide, e o negativo do solenoide vai ao negativo da fonte.

Um solenoide é uma bobina e gera uma tensão reversa alta no instante em que a corrente é cortada. Por isso, ligue um diodo 1N4007 em paralelo com o solenoide, polarizado ao contrário; a ponta do diodo com a faixa vai para o lado positivo. Se você usar um MOSFET no lugar do relé, escolha um modelo de nível lógico, como o IRLZ44N, e ligue o negativo da fonte de 12 V ao GND do Arduino. Para mais detalhes, veja Acionando correntes altas com um MOSFET e, para a ordem dos pinos do MOSFET, consulte a ferramenta Pinagem 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 impressão digital com ESP32: a ligação pela Serial2

O ESP32 tem três portas seriais de hardware, então você não precisa do SoftwareSerial; basta ligar o sensor à UART2 (Serial2). Como o ESP32 trabalha com 3,3 V, ele combina exatamente com os níveis de sinal do AS608 e nenhum divisor de tensão é necessário. O único cuidado são os pinos: no core Arduino-ESP32 atual (3.x), os pinos padrão da Serial2 não são mais GPIO 16/17, como em tutoriais antigos, e sim GPIO 4 (RX) e GPIO 25 (TX). Por isso, você deve passar os pinos explicitamente para Serial2.begin(); o begin() da biblioteca mantém os pinos que você definiu antes. Você pode ver o mapa de pinos da sua placa na ferramenta Pinagem.

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}

Em placas com módulo ESP32-WROVER, os GPIO 16 e 17 estão ligados à PSRAM; numa placa assim, mude FP_RX e FP_TX para, por exemplo, 25 e 26. O ESP32-C3 tem só duas UARTs, então não há Serial2; você pode usar o mesmo código com a Serial1 e quaisquer dois pinos que quiser. Graças ao Wi-Fi, você pode registrar cada entrada com data e hora em um servidor ou enviar uma notificação para o celular com um bot do Telegram quando um dedo desconhecido for detectado.

Sensor de impressão digital com Raspberry Pi Pico e MicroPython

Não existe uma versão oficial da biblioteca da Adafruit para MicroPython, mas o protocolo do sensor é simples o bastante para você conversar com ele em poucas linhas. Todo pacote começa com o código de início EF 01, seguido de um endereço de 4 bytes (FF FF FF FF por padrão), do tipo de pacote (01 comando, 07 resposta), de um comprimento de 2 bytes, do comando e seus parâmetros e, por fim, de um checksum de 2 bytes formado pela soma dos bytes de tipo, comprimento e dados. O primeiro byte de dados da resposta é o código de confirmação: 00 sucesso, 02 sem dedo, 09 sem correspondência. O código abaixo verifica o sensor, lê a capacidade e identifica o dedo no vidro com o ID e a pontuação de confiança. Como o Pico trabalha com 3,3 V, você pode ligar o AS608 direto no pino 3V3(OUT); se você está começando com o Pico, O que é o Raspberry Pi Pico? é um bom ponto 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)

O erro “Did not find fingerprint sensor” e outros problemas comuns

Essa mensagem significa que a biblioteca não recebeu do sensor uma resposta válida ao comando verifyPassword(); ela não quer dizer que o sensor está com defeito. A grande maioria dos casos se resume a fiação, alimentação ou taxa de baud errada. Siga a tabela abaixo de cima para baixo:

Leitor de impressão digital UART da Waveshare: uma observação rápida

Apesar de parecer igual, o leitor de impressão digital UART da Waveshare fala um protocolo diferente do AS608 e do R307: os comandos têm 8 bytes, começam e terminam com 0xF5, e a velocidade padrão é 19200 bps. Por isso ele não funciona com a biblioteca Adafruit Fingerprint; em vez dela, você usa a tabela de comandos e o código de exemplo do manual do usuário da Waveshare. No cadastro, o dedo é lido três vezes, cada usuário pode receber um nível de permissão de 1 a 3, e a comparação 1:N é feita com um único comando. A placa pode ser alimentada com 3,3 V ou 5 V; você liga o TXD ao RX do microcontrolador e o RXD ao TX dele. Se você quer muitas bibliotecas e exemplos prontos, escolha o AS608 ou o R307; se não se importa de escrever seu próprio código de protocolo, o Waveshare é uma boa escolha.

Ideias de projetos com sensor de impressão digital

• Gaveta ou cofre biométrico: Um pequeno cofre que abre com um servo ou solenoide e dispara um alarme em tentativas não autorizadas. Para um mecanismo de trava com servo, veja O que é um servo motor?
• Porta em duas etapas: Uma entrada mais segura que pede primeiro a impressão digital e depois um PIN em um teclado matricial.
• Cartão ou dedo: Acrescente um leitor RFID RC522 à mesma fechadura, para que quem tem cartão entre com o cartão e os outros, com o dedo.
• Sistema de controle de presença: Associe cada ID a um nome em uma escola ou clube e registre os horários de entrada.
• Fechadura com display: Mostre uma mensagem de boas-vindas e o nome da pessoa em um display OLED de 0,96 polegada.
• Junto com um alarme residencial: Um sistema de alarme com Arduino que é armado e desarmado com a impressão digital.

Com alguns fios e a biblioteca certa, um sensor de impressão digital acrescenta uma camada real de identificação ao seu projeto: teste o sensor primeiro, cadastre os dedos com cuidado e depois monte a fechadura com relé e solenoide. No app BlueGrays você encontra projetos de segurança como um cofre eletrônico inteligente, autenticação RFID, uma fechadura de porta RFID com ESP32 e um app de senha com teclado matricial, cada um com esquemas do circuito e código passo a passo, o que dá uma base pronta para adicionar um sensor de impressão digital.