Automação Residencial

Porta Automática com Biometria

Eletrogate 10 de agosto de 2020

Introdução 

Use a tecnologia  da biometria para proteger seus projetos – este Sensor Óptico de Impressão Digital ( DY-50)  tornará a adição e detecção de impressões digitais muito simples. Esses módulos são geralmente usados ​​em cofres. Existe um Chip DSP ( Processador de Sinal Digital)  de alta potência que pode renderizar, calcular, localizar e pesquisar imagens. Conecte-se a qualquer microcontrolador ou sistema TTL Serial e envie pacotes de dados para tirar fotos, detectar conteúdo de impressão, hash , pesquisa entre outros. E no caso do sensor óptico, você pode registrar novos “dedos ” diretamente já que esses sensores suportam em média até 162 impressões digitais armazenadas na memória flash integrada.Falaremos mais a seguir.

Se você teve interesse neste leitor biométrico, mas ainda não tem os conhecimentos de sua funcionalidade, ou não entende os diagramas eletrônicos dele, chegou a hora de aprender!


Especificações Técnicas

– Modelo: DY50;
– Tensão de alimentação DC: 3,6 a 6V;
– Corrente de operação: <120mA;
Corrente de pico máx: 150mA;
– Tempo de impressão digital de imagem: <1,0 segundo;
– Capacidade de armazenamento on-board: 162 digitais;
– Nível de segurança configurável: 1-baixo, 3-médio, 5-alto;
– Taxa de aceitação falsa: <0,001% (nível de segurança 3);
– Taxa de rejeição falsa: <1,0% (nível de segurança 3);
– Interface: UART (Serial TTL);
– Taxa de transmissão: 9600, 19200, 28800, 38400, 57600 (o padrão é 57600);
– Temperatura de operação: -20ºC a +50ºC;
– Umidade de trabalho: <85%;
– Comprimento do cabo: 150mm;
– Área da janela de leitura: 14x18mm;
– Dimensões totais: 55x 21x21mm;
– Peso: 20g.

Dimensões Específicas para realização de projetos

Existem resumidamente alguns requisitos para o uso do leitor biométrico. Primeiro, você precisa registrar sua impressão digital, isso significa definir números de identificação a cada impressão, para que você possa acessá-las mais tarde. Depois de registrar todas as impressões, podemos “procurar” facilmente o sensor exigindo que ele reconheça o ID  que está sendo gravado no momento. E hoje ensinaremos um de seus modos de aplicação !


Pinos do Sensor

Como o fio do sensor é muito fino, usualmente descascamos um pouco o fio e o soldamos em um outro jumper para fazermos as conexões, já que assim evitamos mal contato, tornamos o projeto mais profissional e também fica mais firme. Depois de conectado, você pode ver um LED piscando, isso significa que o sensor está funcionando. O nosso sensor possui 6 fios, mas é necessário apenas 4 desses para que ele ligue e funcione perfeitamente! Se o seu sensor tiver todos os fios da mesma cor, o primeiro fio (da esquerda à direita) é o nosso GND, depois os dois pinos de dados ( Rx, Tx) e, em seguida, nosso Vcc. Caso os fios sejam de cores distintas, falaremos a seguir de como diferenciá-los  e para que servem!

Fios do Sensor Biométrico

Fios Sensor – Sistema cores iguais

Sensor com Fios coloridos

Sensor com sistema de fios coloridos

Vcc(fio vermelho): Deve ser alimentado pelo arduino de acordo com a tensão especificada ( 3,6V – 6V ).
GND (fio preto):  Este fio deve ser conectado ao GND do arduino para que ele esteja integrado ao circuito.
RX (fio branco): O fio de recepção ( Rx) deverá ser ligado à uma porta digital do arduino que será programada posteriormente.
TX (fio verde): O fio de trasmissão também deverá ser ligado à uma porta digital do arduino.

COMUNICAÇÃO E INTERFACE

Um aspecto interessante do sensor biométrico DY-50 é que não é necessário que o Arduino faça tratamento de imagem, toda a parte de identificação e detecção das digitais é feita pelo próprio sensor. A comunicação estabelecida entre o sensor e o Arduino é uma comunicação serial. A comunicação serial – especificamente neste caso também conhecida como UART (Serial TTL) é um elemento poderoso, que permite a comunicação entre a placa de desenvolvimento ( Arduino ) e o computador ou entre a placa de desenvolvimento e outros dispositivos (como módulos GPS, GSM e em nosso projeto o Sensor Óptico de Impressão Digital).  É desta forma que o código é carregado para o nosso Arduino. Uma das vantagens da UART é a simplicidade do protocolo, e também o fato de ser Full-Duplex. O pino de transmissão (Tx) do protocolo envia um pacote de dados, que será interpretado pouco a pouco pelo pino receptor. Cada pacote de dados enviado contém 1 bit de início, indicando o início da mensagem, 1 ou 2 bits de parada, indicando o final da mensagem, 5 a 9 bits de informação e 1 bit de paridade para evitar o recebimento de erros. Por ser uma conexão assíncrona, ela não requer um sinal de clock, portanto requer menos fios. No entanto, o envio de dados é mais complicado e propenso a erros, portanto, alguns parâmetros são necessários para garantir uma transmissão sem erros. Um parâmetro muito óbvio na comunicação assíncrona é a taxa de transmissão, que especifica a velocidade de recebimento e envio, portanto, é muito importante que os dois dispositivos usem a mesma taxa.

Fonte: https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi

Conexão:  Comunicação Assíncrona, a comunicação é realizada através de dois pinos Rx / Tx, que dependem da taxa de transmissão como referência, como mencionado acima.

Dentre as várias placas disponíveis no mercado, temos diversas configurações possíveis e combinações quem podem ser  feitas para essa estabelecer essa comunicação. O Arduino UNO, por exemplo,  possui um canal de comunicação de hardware e este canal fica conectado aos pinos digitais Rx e Tx ( Os pinos 0 e 1 do Arduino UNO). Esses pinos, por sua vez, são conectados ao microcontrolador ATMEGA16U2 que serve ​​para converter sinais de comunicação USB com o próprio computador.

É possível assim, atraves do Monitor Serial  fazermos essa leitura direta entre o sensor e o Arduino, não necessariamente precisando de algum softaware para isso. É admitido outras formas de interação com essa comunicação, por exemplo, os próprios softwares, ou displays devices.

Ficou com alguma dúvida, ou deseja aprender mais sobre o protocolo de comunicação? Clique nesse link para ver a matéria completa.

Estudamos e entendemos melhor através da descrição acima ,sobre a parte técnica do nosso sensor. Compreendemos também as suas especificações, portanto agora vamos aprender na prática uma de suas aplicabilidades, desenvolvendo um Sistema de Segurança utilizando uma trava elétrica, que é controlada remotamente pela digital do usuário! Continue conosco para aprender como desenvolver este projeto.


Materiais Necessários para o Projeto Porta Automática com Biometria

Começaremos agora a criar nosso sistema de segurança utilizando todo o conhecimento adquirido, e para montarmos será necessário:

cta_cart

DIAGRAMA ESQUEMÁTICO: 

O primeiro passo para montarmos, é entender o circuito apresentado a seguir. Portanto, preste bastante atenção na ligação dos jumpers e em como serão dispostos os fios. Logo abaixo apresentaremos o passo-a-passo de como ser montado. Observe:

Diagram esquematico

Diagrama Esquemático Completo

MONTANDO PASSO-A-PASSO:

O primeiro passo é pegarmos o sensor e como dito anterioremente na parte dos pinos, retirar o conector original em um dos lados e unir os fios a jumpers ou conectores que facilitem o contato com o arduino. Dica: Solde jumpers no lugar dos fios e prenda-os com algum material isolante ( fitas adesivas). Lembre se que apenas 4 fios são usados, portanto isole os outros dois que sobraram.

Conectores: Antes

Conectores: Depois

Após este processo, interligue os novos pinos no Arduino/protoboard, como feito em nosso diagrama esquemático. Os fios do Rx e Tx serão ligados respectivamente aos pinos digitais 7,6  do arduino.

Diagrama Sensor Biométrico

O segundo passo é colocar o PushButton que funcionará como segurança para gerenciamos e defnirmos quem será o administrador do sistema. Portanto, em projetos reais pode ser substituido por alguma fechadura para que apenas quem possui a chave poderá substituir e gerenciar quem será o administrador do projeto. Lembre-se: Alguns botões necessitam obrigatoriamente de resistor, então fique atento às especificações de seu botão. Em nosso projeto colocaremos um terminal do botão no pino digital 5 do Arduino  e o outro ligado ao GND. 

Conexão PushButton

O terceiro passo é inteligarmos o Relé, a Trava Solenoide FEC-91 e a nossa Fonte DC 12V. Fique bastante atento à esta parte do projeto, pois se tiver mal contato a trava não funcionará corretamente. O positivo da Fonte irá diretamente ao conector positivo da Trava solenoide. O negativo da fonte irá ao borne COMUM do relé e o negativo da Trava irá ao pino NORMAL ABERTO do relé. Dessa forma, o relé funciona como chave que só permitirá que o circuito feche quando ele for ativado pelo comando do Arduino.

Configuração Relé e Trava solenoide

Após conectarmos os pinos nos bornes, temos que alimentar o Relé com os 5V do Arduino e interligar o GND. O pino de sinal (1)do Relé será ligado ao pino digital 8 do Arduino.

Ficou com dúvida em relação ao funcionamento do Relé e suas portas ? Clique neste link para um tutorial completo sobre os relés 

O 4º passo é ligarmos o Liquid Crystal Display (LCD) ao nosso circuito. O nosso módulo I2C deverá estar conectador ao LCD e montaremos da seguinte forma: Alimentaremos o módulo com as entradas do Arduino, e a conexão SDA (Serial Data) será ligada ao pino ANALÓGICO A4 e nossa conexão SCL ( Serial Clock) será ligada ao pino ANALÓGICO A5 .

Ficou com dúvida em relação as portas SDA e SCL do LCD ? Clique neste link para um tutorial completo sobre os LCD’s! 

Diagrama LCD_I2C

Pronto ! Terminamos a parte física do projeto e agora será necessário programar nosso Arduino.


Programando o Arduino

Antes de começarmos, será necessário baixar algumas bibliotecas para utilizarmos o sensor, o LCD_Módulo I2C e caso utilize o botão, uma biblioteca para eliminar o efeito boucing  . Clique nos links abaixo para baixar as bibliotecas:

Adafruit_Fingerprint_Sensor_Library

Liquid_Crystal_Display_I2C_Library

PushButton_Library

Baixe os arquivos para seu computador e abra a pasta compactada

Clique na opção “extrair para” e adicione à pasta Libraries no arquivo da IDE do Arduino.
Pronto! Repita o processo para a biblioteca LIQUIDCRYSTAL_I2C  e a biblioteca PUSHBUTTON e então continue .

ENTENDENDO O PROJETO

Arduino: Será responsável por comandar os processos e será programado para executar todas as etapas do sistema.

Sensor Biométrico: Será responsável por ler, identificar, codificar e gravar as digitais recebidas e inseridas.

Botão: Definirá e registrará o  “Dedo Administrador” , após este processo, toda vez que o Administrador inserir o dedo . O sensor entra em modo de gravação e poderá ser adicionado novas digitais  que permitirão a abertura de nossa trava.

Relé: Controlará o estado da trava solenoide, habilitando sua abertura ou o seu  trancamento.

LCD: Display responsável por comunicar ao usuários as etapas que estão sendo realizadas, assim o usuário saberá exatamente o que fazer e o está sendo pedido.

Código

// INCLUSÃO DAS BIBLIOTECAS BAIXADAS!
#include <Adafruit_Fingerprint.h>
#include <SoftwareSerial.h>
#include <PushButton.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
 
//Inicializando o display no endereço 0x27
LiquidCrystal_I2C lcd(0x27,20,4); // Configura endereço I2C e display com 20 caracteres e 4 linhas  
 
// PINAGENS DO PROJETO
#define button 5
#define trava 8
 
// INSTANCIANDO OBJETOS
SoftwareSerial mySerial(7, 6); // mySerial( Rx, Tx) <-- Pinagens do Sensor;
 
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
PushButton botao(button);
 
// DECLARAÇÃO DAS VARIÁVEIS E FUNCOES
uint8_t numID = 1;
bool gravar=false;
 
uint8_t modoGravacaoID(uint8_t IDgravar);
 
void setup() {
  lcd.begin(16,2);
  lcd.noCursor();
  pinMode(trava, OUTPUT);
  digitalWrite(trava, HIGH);
  
  //Serial.begin(9600);
  finger.begin(57600);
 
  if(finger.verifyPassword()){
    lcd.print("DY-50 encontrado!");
    delay(1000);
      
  } else {
    lcd.autoscroll();
    lcd.print("DY-50 não encontrado");
    delay(3000);
    lcd.clear();
    while(true) { 
      delay(1); 
     }
  }
  
  lcd.print("sensor Carregado");
  delay(900);
  lcd.clear();
  lcd.print("   Aguardando");
  lcd.setCursor(1,1);
  lcd.print("   entrada");
  
 
}
 
void loop() {
  botao.button_loop();
 
  if ( botao.pressed() ){
    gravar = true;
  }
 
  if(gravar){
    modoGravacaoID(0);
    gravar = false;
  }
 
  getFingerprintIDez();
  
}
 
uint8_t modoGravacaoID(uint8_t IDgravar) {
 
  int p = -1;
  lcd.print("Registre o ADM #");
  lcd.print(IDgravar);
  delay(2000);
  lcd.clear();
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      lcd.clear();
      lcd.print(" concluído");
      break;
    case FINGERPRINT_NOFINGER:
      lcd.print(".");
      delay(200);
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      lcd.clear();
      lcd.print("Erro");
      break;
    case FINGERPRINT_IMAGEFAIL:
      lcd.print("Erro leitura");
      break;
    default:
      lcd.print("ERROR");
      break;
    }
  }
 
  // Se não entrou em algum dos erros, todos os processos estão OK ! 
 
  p = finger.image2Tz(1);
  switch (p) {
    case FINGERPRINT_OK:
      lcd.print("Leitura convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
      lcd.print("tente novamente ");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      lcd.print("ERROR");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      lcd.print("Endereço invalido");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      lcd.print("Imagem invalida");
      return p;
    default:
      lcd.print("ERRO");
      return p;
  }
   lcd.clear();
  lcd.print("Retire o Dedo");
  delay(2000);
  lcd.clear();
  p = 0;
  while (p != FINGERPRINT_NOFINGER) {
    p = finger.getImage();
  }
  lcd.print("ID "); 
  lcd.print(IDgravar);
  p = -1;
  lcd.print("  Insira o dedo ");
  lcd.setCursor(1,1);
  lcd.print("  novamente");
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      lcd.print("Concluido ! ");
      break;
    case FINGERPRINT_NOFINGER:
      lcd.print(".");
      delay(200);
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      lcd.print("Erro no pacote");
      break;
    case FINGERPRINT_IMAGEFAIL:
      lcd.print("Erro na imagem");
      break;
    default:
      lcd.print("Erro ");
      break;
    }
  }
 
  // Se não entrou em algum dos erros, o primeiro processo está OK ! 
 
  p = finger.image2Tz(2);
  switch (p) {
    case FINGERPRINT_OK:
    lcd.print("Leitura convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
     lcd.print("Má leitura");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
    lcd.print("Erro- comunicacao");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      lcd.print("Endereco invalido");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      lcd.print("imagem invalida");
      return p;
    default:
   lcd.print("Erro ");
      return p;
  }
  
  // Se não entrou em algum dos erros, todos os processos estão OK ! 
  lcd.print("Novo ID para #");  
  lcd.print(IDgravar);
  
  p = finger.createModel();
  if (p == FINGERPRINT_OK) {
  lcd.print("As digitais batem!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    lcd.print("Erro de comunicação");
    return p;
  } else if (p == FINGERPRINT_ENROLLMISMATCH) {
    lcd.print("As digitais não batem");
    return p;
  } else {
    lcd.print("Erro desconhecido");
    return p;
  }   
  
  lcd.print("ID "); 
  lcd.print(IDgravar);
  p = finger.storeModel(IDgravar);
  if (p == FINGERPRINT_OK) {
   lcd.print("Armazenado!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    lcd.print("Erro de comunicação");
    return p;
  } else if (p == FINGERPRINT_BADLOCATION) {
    lcd.print("Erro na memória");
    return p;
  } else if (p == FINGERPRINT_FLASHERR) {
    lcd.print("Erro-memória flash");
    return p;
  } else {
    lcd.print("Erro desconhecido");
    return p;
  }   
}
 
int getFingerprintIDez() {
  uint8_t p = finger.getImage();
  if (p != FINGERPRINT_OK)  return -1;
 
  p = finger.image2Tz();
  if (p != FINGERPRINT_OK)  return -1;
 
  p = finger.fingerFastSearch();
  if (p != FINGERPRINT_OK)  return -1;
  
  //Alguma digital foi reconhecida pelo sensor
  if (finger.fingerID == 0) {
     lcd.print("Modo ADM ON");
     
     numID++;
     modoGravacaoID(numID);
     return 0; 
  
  } else {
     lcd.clear();
     digitalWrite(trava, LOW);
     lcd.print("ID encontrado #"); 
     lcd.print(finger.fingerID); 
     lcd.setCursor(1,1);
     lcd.print("seguranca:");
     lcd.print(finger.confidence); //Confiabilidade da leitura ! 
     delay(1000); //<<----- Tempo que a trava ficará aberta em milisegundos
     digitalWrite(trava, HIGH);
     delay(1000);
     lcd.clear();
     lcd.print("   Aguardando");
     lcd.setCursor(1,1);
     lcd.print("   entrada"); 
    
  } 
}

Agora estudaremos o passo-a passo do nosso código, começando temos:

// INCLUSÃO DAS BIBLIOTECAS!
#include <Adafruit_Fingerprint.h>
#include <SoftwareSerial.h>
#include <PushButton.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>

//Inicializando o display no endereço 0x27
LiquidCrystal_I2C lcd(0x27,20,4); // Configura endereço I2C e display com 20 caracteres e 4 linhas

// PINAGENS DO PROJETO
#define button 5
#define trava 8

// INSTANCIANDO OBJETOS
SoftwareSerial mySerial(7, 6); // mySerial( Rx, Tx) <-- Pinagens do Sensor;

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial); //Criando o nosso objeto Sensro ! 
PushButton botao(button); 

// DECLARAÇÃO DAS VARIÁVEIS E FUNCOES
uint8_t numID = 1;  //Variável responsável pelo armazenamento da digital
bool gravar=false; // Indicador booleano para permitir que o sensor grave ou não

uint8_t modoGravacaoID(uint8_t IDgravar);

Neste primeiro passo, adicionamos todas as bibliotecas baixadas e algumas já dispostas para o Arduino, para que o nosso projeto funcione perfeitamente !
Observação:  Normalmente os endereços já definidos para os LCD’s é 0x27 . Mas o LCD usado veio configurado como 0x3f. Caso não funcione com o seu , abra este post para aprender como identificar.
Segue o próximo passo!

void setup() {
  lcd.begin(16,2); //Iniciando o nosso LCD
  lcd.noCursor();
  pinMode(trava, OUTPUT); //Definindo o pino da trava, como saída
  digitalWrite(trava, HIGH); 
  
  //Serial.begin(9600);
  finger.begin(57600); // O sensor nominalmente trabalha neste valor, confira no seu datasheet caso não seja este ! 

  if(finger.verifyPassword()){  // Testando se o sensor foi identificado
    lcd.print("DY-50 encontrado!");
    delay(1000);
    lcd.clear();
  } else {
    lcd.autoscroll();
    lcd.print("DY-50 não encontrado");
    delay(3000);
    lcd.clear();
    while(true) { 
      delay(1); 
     }
  }
 lcd.print("sensor Carregado");
  delay(900);
  lcd.clear();
  lcd.print("   Aguardando");
  lcd.setCursor(1,1);
  lcd.print("   entrada");

  }

Nessa segunda etapa, definimos as entradas e saidas do projeto, lembre-se que caso o seu display seja de outro tamanho , será necessário colocar as dimensões dele no comando lcd.begin(linhas,colunas). Se o sensor não for identificado, fique atento ao mal contato e reinicie o processo até que ele seja identificado.
Seguimos temos:

void loop() {
  botao.button_loop();

  if ( botao.pressed() ){
    gravar = true;
  }

  if(gravar){
    modoGravacaoID(0);
    gravar = false;
  }

  getFingerprintIDez();
  
}

uint8_t modoGravacaoID(uint8_t IDgravar) {

  int p = -1;
  lcd.print("Registre o ADM #");
  lcd.print(IDgravar);
  delay(2000);
  lcd.clear();
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      lcd.clear();
      lcd.print(" concluído");
      break;
    case FINGERPRINT_NOFINGER:
      lcd.print(".");
      delay(200);
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      lcd.clear();
      lcd.print("Erro");
      break;
    case FINGERPRINT_IMAGEFAIL:
      lcd.print("Erro leitura");
      break;
    default:
      lcd.print("ERROR");
      break;
    }
  }

//Foram configurados alguns dos erros mais comuns apresentandos pelo Sensor.   

  p = finger.image2Tz(1);
  switch (p) {
    case FINGERPRINT_OK:
      lcd.print("Leitura convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
      lcd.print("tente novamente ");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      lcd.print("ERROR");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      lcd.print("Endereço invalido");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      lcd.print("Imagem invalida");
      return p;
    default:
      lcd.print("ERRO");
      return p;
  }
   lcd.clear();
  lcd.print("Retire o Dedo");
  delay(2000);
  lcd.clear();
  p = 0;
  while (p != FINGERPRINT_NOFINGER) {
    p = finger.getImage();
  }
  lcd.print("ID "); 
  lcd.print(IDgravar);
  p = -1;
  lcd.print("  Insira o dedo ");
  lcd.setCursor(1,1);
  lcd.print("  novamente");
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      lcd.print("Concluido ! ");
      break;
    case FINGERPRINT_NOFINGER:
      lcd.print(".");
      delay(200);
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      lcd.print("Erro no pacote");
      break;
    case FINGERPRINT_IMAGEFAIL:
      lcd.print("Erro na imagem");
      break;
    default:
      lcd.print("Erro ");
      break;
    }
  }

  // Se não entrou em algum dos erros, o primeiro processo está OK ! 

  p = finger.image2Tz(2);
  switch (p) {
    case FINGERPRINT_OK:
    lcd.print("Leitura convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
     lcd.print("Má leitura");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
    lcd.print("Erro- comunicacao");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      lcd.print("Endereco invalido");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      lcd.print("imagem invalida");
      return p;
    default:
   lcd.print("Erro ");
      return p;
  }
  
  // Se não entrou em algum dos erros, todos os processos estão OK ! 
  lcd.print("Novo ID para #");  
  lcd.print(IDgravar);
  
  p = finger.createModel();
  if (p == FINGERPRINT_OK) {
  lcd.print("As digitais batem!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    lcd.print("Erro de comunicação");
    return p;
  } else if (p == FINGERPRINT_ENROLLMISMATCH) {
    lcd.print("As digitais não batem");
    return p;
  } else {
    lcd.print("Erro desconhecido");
    return p;
  }   
  
  lcd.print("ID "); 
  lcd.print(IDgravar);
  p = finger.storeModel(IDgravar);
  if (p == FINGERPRINT_OK) {
   lcd.print("Armazenado!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    lcd.print("Erro de comunicação");
    return p;
  } else if (p == FINGERPRINT_BADLOCATION) {
    lcd.print("Erro na memória");
    return p;
  } else if (p == FINGERPRINT_FLASHERR) {
    lcd.print("Erro-memória flash");
    return p;
  } else {
    lcd.print("Erro desconhecido");
    return p;
  }   
}

int getFingerprintIDez() {
  uint8_t p = finger.getImage();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.image2Tz();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.fingerFastSearch();
  if (p != FINGERPRINT_OK)  return -1;
  
  //Alguma digital foi reconhecida pelo sensor
  if (finger.fingerID == 0) {
     lcd.print("Modo ADM ON"); //Se for a digital ADM, ele entra em modo de gravação e acrescenta 1 valor ao numero 
                               // de endereço.
     numID++;
     modoGravacaoID(numID);
     return 0; 
  
  } else {
     lcd.clear();
     digitalWrite(trava, LOW); //Caso o dedo identificado não seja o adm, e esteja registrado a trava é aberta
     lcd.print("ID encontrado #"); 
     lcd.print(finger.fingerID); 
     lcd.setCursor(1,1);
     lcd.print("seguranca:");
     lcd.print(finger.confidence); //Confiabilidade da leitura ! 
     delay(2000); //<<----- Tempo que a trava ficará aberta em milisegundos
     digitalWrite(trava, HIGH);
     delay(1000);
     lcd.clear();
     lcd.print("   Aguardando");
     lcd.setCursor(1,1);
     lcd.print("   entrada"); 
    
  } 
}

Neste processo do void loop() definimos a constante verificação da leitura e do estado do sensor ! Foram programados comandos para caso o sensor apresente algum de seus erros, portanto verifique sempre o estado dos fios e deixe sempre o sensor limpo


Conclusão

Hoje aprendemos como utilizar o Sensor Óptico de Impressão Digital DY-50 e entendemos como ele funciona, estudamos suas especificações e criamos um sistema de segurança utilizando esse sensor. Esperamos que você tenha entendido e conseguido montar nosso projeto. Se você curtiu, aprendeu e/ou desenvolveu o Sistema de Segurança, poste nas redes sociais e nos marque lá no instagram: @eletrogate


Gostou? Deixe um curtir e compartilhe com seus amigos!  Ficou com alguma dúvida? Quer fazer um elogio?  Deixe um comentário!

Obrigado por nos acompanhar e ler até aqui.

Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!


Sobre o Autor


Cássio Henrique

Técnico em Eletrônica pelo Colégio Técnico da Universidade Federal de Minas Gerais (COLTEC – UFMG). Trabalhou como instrutor na CodeBuddy | Escola de tecnologia. Cássio Henrique adora aprender e pesquisar sobre os diversos ramos da tecnologia, principalmente na área de eletrônica. ” O conhecimento é o único bem que se adquire por toda eternidade”. É músico nos tempos livres!


Eletrogate

10 de agosto de 2020

A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.

Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!

Eletrogate Robô

Cadastre-se e fique por
dentro de novidades!