Proteja sua moto com Arduino e leitor biométrico 9

Neste post vamos aprender como construir um sistema anti furto para moto com Arduino e leitor biométrico! Afinal, no Brasil a média é de um roubo ou furto de veículo a cada minuto, segundo dados de 2016.  Foram 557 mil no ano passado, segundo o fórum Brasileiro de segurança Pública. Significa um crescimento de 8% em relação ao ano anterior, de acordo com informações de 25 Estados e do DF.

Baseado nessa problemática, foi desenvolvido um sistema anti furto com tecnologia biométrica para proteger sua moto e garantir que apenas você possa acioná-la através da sua digital. A princípio, pode parecer um sistema difícil e complexo, mas o objetivo deste post é mostrar que usando um Arduino, um leitor biométrico, um módulo relé, um LED RGB e um regulador de tensão é possível desenvolver um sistema anti furto e manter sua moto segura.

Material necessário

A seguir está a lista de componentes utilizados no protótipo:

• Arduino Pro Micro
• Sensor Biométrico Fpm10aDy50
• Modulo Relé de 01 canal
• Módulo Regulador de Tensão LM250
• LED RGB

Arduino Pro Micro

Usamos um Arduino Pro Micro pelo seu tamanho compacto e baixo custo de aquisição. Essa placa utiliza o microcontrolador ATMega32U4, 12 portas de I/O (entrada/saída) de uso geral, 4 canais ADC de 10 bits e 5 pinos PWM, comunicando-se com um computador por meio da porta micro-usb. Pode ser programada utilizando-se a IDE do Arduino.

Sensor Biométrico

Usamos o sensor biométrico modelo Fpm10aDy50 para o controle de bloqueio e desbloqueio da moto. É nele que fica cadastrado as imagens da digital que serão usadas para bloqueio da moto, ou seja, é o item de segurança deste projeto.

LED RGB

O LED RGB tem a função de nos avisar se a comunicação entre a placa Arduino e o Sensor Biométrico foi estabelecida com sucesso. Caso o sensor não tenha sido reconhecido, o LED fica na cor vermelha. Se estabelecida a conexão, o LED ficaria azul e o sistema pronto para a leitura da digital. Após o reconhecimento da sua digital, a moto estará pronta para dar  partida e o LED irá desligar.

Observe que existem dois tipos de LED RGB: o Anodo comum, que é o LED que tem seu pino comum ligado ao positivo; E o catodo comum, que é o LED que tem o seu pino comum ligado ao polo negativo. No nosso projeto usamos o LED Catodo comum.

Módulo relé

O modulo relé é o responsável pelo fechamento da chave de bloqueio da corrente, logo ele substitui a chave on/off convencional da sua moto, como essa da figura abaixo:

O módulo relé nada mais é do que uma chave que fecha ou abre de forma eletrônica. Ele possui dois tipos de saída: NF (Normalmente Fechada), que quando não existe tensão elétrica em sua entrada ela permanece em seu estado de repouso no modo fechado, ou seja, conduzindo corrente elétrica; E temos o modo NA (Normalmente Aberta), ou seja , seu estado de repouso é com a chave aberta só fechando o circuito quando energizada. No caso, a configuração que utilizaremos é a de normalmente aberta.

Módulo regulador de tensão

Tem a função de estabilizar a tensão de entrada no Arduino em 5 V, além de a moto trabalhar com a tensão da bateria em 12 V, essa tensão oscila bastante em relação a sua aceleração, para garantir que nosso sistema não receba essa oscilação nem sobre tensão utilizamos esse modulo relé na entrada do sistema, ou seja, entre a bateria e a placa Arduino.

Código

/*
* O código consiste de um sistema que irá primeiro cadastrar as imagens das digitais que
* serão usadas no sistema para após entrar no modo loop e passar a reconhecer cada digital
* . Informo que o cadastro não exige uma posição definida, caso voce cadastre seu dedo
* na posição vertical, no momento da leitura o sistema também irá lê-lo na horizontal
*/

int chave=0;
int verde=5; //Porta do Arduino onde a perna referente a cor verde do LED está conectado
int azul=4; //Porta do Arduino onde a perna referente a cor azul do LED está conectado
int vermelho=6; //Porta do Arduino onde a perna referente a cor vermelha do LED está conectado
int rele=7; //Porta do Arduino onde o Relé está conectado
#include <Adafruit_Fingerprint.h> //Biblioteca para uso do sensoor Biométrico

// #define mySerial Serial1
//Pino  0 no fio verde e o pino 1 no fio branco

SoftwareSerial mySerial(2, 3);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

void setup()  
{
//Declara a portas como saída
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  digitalWrite(rele,1);
  //Serial.begin(9600);
  //while (!Serial);  
  delay(100);
  //Serial.println("\n\nAdafruit finger detect test");
  digitalWrite(azul,1);
  // Iniciacializa a comunicação com o Sensor
  finger.begin(57600);
  /*
  if (finger.verifyPassword()) {
    Serial.println("Found fingerprint sensor!");
  } else {
    Serial.println("Did not find fingerprint sensor :(");
    while (1) { delay(1); }
  }
*/
  //finger.getTemplateCount();
  //Serial.print("Sensor contains "); Serial.print(finger.templateCount); Serial.println(" templates");
  //Serial.println("Waiting for valid finger...");
  digitalWrite(azul,0);
  digitalWrite(vermelho,1);
  digitalWrite(verde,0);
}


void loop()                  //Inicio do LOOP
{
  
  if(getFingerprintIDez()==1){
    chave=!chave;
    
    delay(500);
  }
  digitalWrite(rele,!chave);
  digitalWrite(verde,chave);
  digitalWrite(vermelho,digitalRead(rele));
  delay(50);            //Espera para aguardar a comutação do relé.
}

uint8_t getFingerprintID() {
  uint8_t p = finger.getImage();
  switch (p) {
    case FINGERPRINT_OK:
      //Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      //Serial.println("No finger detected");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      //Serial.println("Communication error");
      return p;
    case FINGERPRINT_IMAGEFAIL:
      //Serial.println("Imaging error");
      return p;
    default:
      //Serial.println("Unknown error");
      return p;
  }

  // OK success!

  p = finger.image2Tz();
  switch (p) {
    case FINGERPRINT_OK:
      //Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      //Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      //Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      //Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      //Serial.println("Could not find fingerprint features");
      return p;
    default:
      //Serial.println("Unknown error");
      return p;
  }
  
  // OK converted!
  p = finger.fingerFastSearch();
  if (p == FINGERPRINT_OK) {
    //Serial.println("Found a print match!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    //Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_NOTFOUND) {
    //Serial.println("Did not find a match");
    return p;
  } else {
    //Serial.println("Unknown error");
    return p;
  }   
  
  // found a match!
  //Serial.print("Found ID #"); Serial.print(finger.fingerID); 
  //Serial.print(" with confidence of "); Serial.println(finger.confidence); 

  return finger.fingerID;
}

// returns -1 if failed, otherwise returns ID #
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;
  
 
  return finger.fingerID; 
} 

Acesse o código no github aqui

Circuito de montagem

Com o entendimento dos componentes e do código, chegou a hora de montar seu projeto. Analise o esquema de montagem abaixo. Neste circuito, nós temos inicialmente um regulador de tensão que serve para baixar a tensão da bateria da moto de 12 V para 5 V e estabilizar as oscilações da entrada. A tensão de saída do regulador será utilizada para alimentar  o  Arduino e o Sensor Biométrico (sensor responsável em fazer a leitura da sua digital). No relé, você deve liga o fio que vem direto da bateria da moto no conector comum (borne do meio, conforme a figura)  e no borne NA (normalmente Aberto) você deve conectar o fio que vai para a chave on/off. O led RGB serve para indicar ao usuário se a moto já está destravada, ou seja habilitada para a partida.

Verifique as conexões dos componentes segundo as declarações no código:

int chave=0; 
int verde=5; //Porta do Arduino onde a perna referente a cor verde do LED está conectado 
int azul=4; //Porta do Arduino onde a perna referente a cor azul do LED está conectado 
int vermelho=6; //Porta do Arduino onde a perna referente a cor vermelha do LED está conectado
int rele=7; //Porta do Arduino onde o Relé está conectado

Atenção! Teste seu circuito antes de montá-lo na moto. Cuidado ao trabalhar com energia elétrica, caso você não seja habilitado solicite a presença de um profissional da área para lhe auxiliar com segurança no sucesso deste projeto, não aconselhamos a intervenção em sua motocicleta por alguém não habilitado, leve em uma oficina de sua confiança e monte o sistema junto com o profissional da área.

Dica

Esse projeto pode ser expandido e aplicado no controle de outras cargas como por exemplo Lâmpadas, portas, cofres, eletrodomésticos e computadores, com pequenas alterações no circuito de montagem ele será aplicável onde sua imaginação permitir pois o código será basicamente o mesmo mudando apenas os condicionais inicias caso queira comandar mais equipamentos.

Conclusão

Qualquer ideia pode ser posta em prática, basta a ferramenta e as instruções certas. Neste post,  nosso Maker Hero Sandro Mesquita nos apresentou o passo a passo de como materializar um projeto inovador para sua moto com poucos componentes e investindo pouco dinheiro.

O uso do sensor biométrico para exclusividade de acesso já é realidade em nosso meio, por exemplo nossos celulares, porém quando se trata de veículos o custo aumenta, e apenas uma pequena parcela da população tem acesso a essa tecnologia. Aqui neste projeto da escola Pixels compartilhado com a FilipeFlop você passa a conhecer a simplicidade da montagem e programação e poder implementar em seu veículo, porém aconselhamos um acompanhamento de um profissional qualificado em elétrica automotiva.

Este projeto já esta na terceira versão ligando pelo celular e agora interagindo com o capacete, sempre seguindo o mesmo conceito de simplicidade e praticidade, acompanhe o desenvolvimento no canal do Youtube Sandro Mesquita – Roboticamente, aproveite as dicas da FilipeFlop divirta-se e bons estudos.

Gostou de proteger sua moto com Arduino? Ajude-nos a melhorar o blog comentando abaixo sobre este tutorial.