Sensor Biométrico de Impressão Digital - Parte 4: Identificando Digitais

Continuando o nosso estudo do módulo FPM10A, vamos ver como identificar uma digital capturada pelo módulo. Recomendo dar uma lida no post anterior para entender a terminologia.

Fonte: https://www.jfsmonline.com/text.asp?2016/2/1/60/162807

Como vimos na parte anterior, as digitais são cadastradas em um memória (ou "biblioteca") do módulo. Existem duas operações que podemos fazer para identificar uma digital recém capturada em relação às cadastradas:

• Comparar com uma digital específica. Esta operação tipicamente é usada quando a digital é usada como uma "senha" após a identificação da pessoa (por exemplo, pela digitação de um código ou leitura de um cartão).
• Procurar a digital na biblioteca. Nesta operação a digital está sendo usada para identificar a pessoa.

O módulo FPM10A possui dois comandos separados para isso. O comando MATCH compara as duas digitais que estão em CharBuffer1 e CharBuffer2. O comando SEARCH procura uma digital que está em CharBuffer1 ou CharBuffer2 em um trecho da biblioteca (definido pela posição inicial e a quantidade de posições).

Para usar o MATCH vamos ter que usar o comando LOAD, que recupera uma digital da biblioteca e coloca em CharBuffer1 ou CharBuffer2.

O programa completo (Digital3) está no github. Vou apresentar aqui apenas os trechos que ilustram o processo.

Estas duas rotinas são da parte anteior, estão aqui para facilitar o entendimento.

view plaincopy to clipboardprint?

1. // Faz a captura de imagem e geração da feature  
2. void capturaFeature(byte numBuf) {  
3.   while (true) {  
4.     // Captura a imagem  
5.     Serial.println("Coloque o dedo");  
6.     do {  
7.       delay(50);  
8.     } while (!fpm.capturaDigital());  
9.     Serial.println("OK");  
10.   
11.     // Tenta gerar as features  
12.     bool ok = fpm.geraFeature(numBuf);  
13.   
14.     // Pede para retirar o dedo  
15.     Serial.println("Retire o dedo");  
16.     do {  
17.       delay(2000);  
18.     } while (fpm.capturaDigital() || (fpm.ultimaResposta() != FPM10A::RESP_NOFINGER));  
19.   
20.     // Verifica se precisa tentar novamente  
21.     if (ok) {  
22.       return;  
23.     }  
24.     Serial.println("Imagem ruim, vamos tentar novamente");  
25.   }  
26. }  
27.   
28. // Lê uma posição (0 a maxDigitais-1)  
29. int lePosicao() {  
30.   int posicao;  
31.   int c;  
32.   
33.   while (Serial.read() != -1) {  
34.     delay(100);  
35.   }  
36.     
37.   while (true) {  
38.     posicao = 0;  
39.     Serial.print ("Posicao? ");  
40.     while (true) {  
41.       c = Serial.read();  
42.       if (c == 0x0D) {  
43.         break;  // enter  
44.       }  
45.       if ((c >= '0') && (c <= '9') && (posicao < 100)) {  
46.         Serial.write(c);  
47.         posicao = (posicao*10 + c - '0');  
48.       }  
49.     }  
50.     Serial.println();  
51.     if (posicao < maxDigitais) {  
52.       return posicao;  
53.     }  
54.     Serial.println ("Posicao invalida");      
55.   }  
56. }  

// Faz a captura de imagem e geração da feature
void capturaFeature(byte numBuf) {
  while (true) {
    // Captura a imagem
    Serial.println("Coloque o dedo");
    do {
      delay(50);
    } while (!fpm.capturaDigital());
    Serial.println("OK");

    // Tenta gerar as features
    bool ok = fpm.geraFeature(numBuf);

    // Pede para retirar o dedo
    Serial.println("Retire o dedo");
    do {
      delay(2000);
    } while (fpm.capturaDigital() || (fpm.ultimaResposta() != FPM10A::RESP_NOFINGER));

    // Verifica se precisa tentar novamente
    if (ok) {
      return;
    }
    Serial.println("Imagem ruim, vamos tentar novamente");
  }
}

// Lê uma posição (0 a maxDigitais-1)
int lePosicao() {
  int posicao;
  int c;

  while (Serial.read() != -1) {
    delay(100);
  }
  
  while (true) {
    posicao = 0;
    Serial.print ("Posicao? ");
    while (true) {
      c = Serial.read();
      if (c == 0x0D) {
        break;  // enter
      }
      if ((c >= '0') && (c <= '9') && (posicao < 100)) {
        Serial.write(c);
        posicao = (posicao*10 + c - '0');
      }
    }
    Serial.println();
    if (posicao < maxDigitais) {
      return posicao;
    }
    Serial.println ("Posicao invalida");    
  }
}

A comparação da digital com uma armazenada fica assim:

view plaincopy to clipboardprint?

1. Serial.println("Compara digital");  
2. posicao = lePosicao();  
3. capturaFeature(1);  
4. if (!fpm.recuperaDigital(2, posicao)) {  
5.   Serial.println ("Erro ao recuperar digital");  
6.   break;  
7. }  
8. if (fpm.comparaDigital()) {  
9.   Serial.println ("Digitais iguais");  
10. } else {  
11.   Serial.println ("Digitais diferentes");  
12. }  

Serial.println("Compara digital");
posicao = lePosicao();
capturaFeature(1);
if (!fpm.recuperaDigital(2, posicao)) {
  Serial.println ("Erro ao recuperar digital");
  break;
}
if (fpm.comparaDigital()) {
  Serial.println ("Digitais iguais");
} else {
  Serial.println ("Digitais diferentes");
}

A busca da digital na bilioteca é mais simples:

view plaincopy to clipboardprint?

1. Serial.println("Procura digital");  
2. capturaFeature(1);  
3. posicao = fpm.procuraDigital(1, 0, maxDigitais);  
4. if (posicao == -1) {  
5.   Serial.println ("Digital nao encontrada");  
6. } else {  
7.   Serial.print ("Identificou digital ");  
8.   Serial.println (posicao);  
9. }  

Serial.println("Procura digital");
capturaFeature(1);
posicao = fpm.procuraDigital(1, 0, maxDigitais);
if (posicao == -1) {
  Serial.println ("Digital nao encontrada");
} else {
  Serial.print ("Identificou digital ");
  Serial.println (posicao);
}

Eu não usei neste exemplo, mas os dois comandos de comparação retornam também um número que indica o grau de semelhança entre as digitais consideradas iguais. No próximo post da série vamos ver como "puxar" a imagem da digital capturada.