Fechadura Digital com Arduino: Aproximação e Senha

Este post é a parte dois da série da fechadura digital, para entender e obter explicações do código é necessário a leitura da primeira parte: http://agrodadosbr.blogspot.com/2019/05/fechadura-digital-com-arduino-uno-e-rfid.html

A fechadura digital baseada no Arduino UNO já estava bem interessante da forma que estava, lógico que aqui estamos apenas trabalhando a parte digital, ficando a mecânica e seu desafio de abrir quando a fechadura estragar para outra situação. Grande parte já estava pronto, tínhamos uma interface de comunicação e uma automação interessante, um produto já funcional.

Ocorre que o módulo RFID utilizado RC522 não apresenta tecnologias recentes de segurança, de modo a não ser recomendado como única forma de autenticação, sendo ideal utilizar autenticação dupla, sendo essa segunda forma, por exemplo, uma senha. Então resolvi adicionar um teclado a fechadura.

Mas de verdade, nem foi esse motivo, pois a fechadura que estou desenvolvendo não vai ser exposta. Então alguém para ter acesso indevido a ela vai precisar pular o portão principal (da rua), descobrir como ela funciona, acessar ela (que estará chumbada no concreto) para depois fazer alguma coisa. Então de verdade, não vai ser aqui que vão hackear a tag RFID ou algo do tipo, não é porque a autenticação do módulo é falha que isso vai representar uma falha no tipo de uso que vou utilizar. Mas se for a sua questão existe um módulo com bem mais segurança: PN532 e olha que não é tão mais caro e vem com NFC.

A questão do teclado, já que ele não vai ser usado para dupla autenticação, é mais pela comodidade. O intuito é poder sair de casa sem nada e poder retornar sem problemas, mesmo sem o celular poder adentrar. Então o teclado serve como método alternativo de entrada. No futuro desejo ter três: RFID, Google Assistant e teclado.

O teclado utilizado é um matricial 4x4

Não é a minha opção favorita, prefiro o 1x4, até para poupar pinos, que estão escassos já. Mas se precisar de mais teclas o touch 4x4 é mais confiável e robusto.

Mas como tenho em mãos apenas o matricial, vai ele mesmo. Esse teclado por ter seu código todo feito de forma manual, sem a utilização de bibliotecas, existem inúmeros exemplos em português, e no final pretendo exemplificar porque esse opção é super interessante e vai ser extremamente útil para aplicar funcionalidades.

Mas no caso em questão em optei pelo uso de bibliotecas por alguns fatores simples. Primeiro é a facilidade de código, depois vem a organização e a simplicidade do código, uma vez que essa clareza auxilia muito em um código que está sendo trabalhado e ainda terá tantas mais linhas a serem implementadas.

Desta forma foram adicionadas duas bibliotecas. Password.h e Keypad.h. A primeira automatiza toda a parte de digitação e verificação do código, a segunda permite utilizar o teclado de forma simples, e com um número bem reduzido de linhas e configurações no código. Logo acima do setup foi acionado o bloco que chamei de "Informações a respeito do teclado". Ali existe o cadastro da senha, eu optei no momento por ter apenas uma senha mesmo. Basta substituir o entre aspas (123) pela senha que desejar, aqui vale utilizar O ABCD do teclado. Não recomendo o uso do * e #, pois mais adiantes vamos ver que estão reservados.

Logo em seguida duas constantes, informam a quantidade de linhas e colunas do teclado. Depois como as teclas estão ordenadas. A seguir você informa em quais portas conectou as linhas e colunas do teclado. No caso, visto de frente, os quatro primeiros pinos são as quatro linhas, respectivamente. Ou seja, na porta 14 está conectado o pino 2 do teclado. Observe que a seguir também é criado um objeto para o teclado, com todas aquelas informações anteriores.

Já entrando no setup foi adicionado o evento que recebe as informações digitadas. Já o loop mudou pouco, antes se a porta estava trancada ele verificava o aperto do botão interno de abertura e se havia alguma leitura no RFID. Agora além de verificar tudo isso ele verifica também se existe entrada no teclado, pela função keypad.getKey().

Lá no final do código foram adicionadas as funções expostas das biblioteca, várias funções chamadas são internas da biblioteca e não visíveis pelo código. Assim a lógica ali no final é mais ou menos essa: Verifica o teclado, se foi pressionado algo ele vai ativar o buzer rapidamento, confirmando que o valor digitado foi recebido. Assim ele verifica qual o valor digitado e segue a lógica:

• Se for *: Ele verifica se a senha digitada confere com a senha correta
• Se for #: Ele deleta a senha que está armazenada, limpa o que foi digitado
• Se for outro valor ele armazena como um dígito da senha

É por isso que a senha não deve conter * e #, pois são estruturas de controle. A última função verifica a senha, se for a cadastrada roda a função acessoLiberado. Se não for roda a acessoNegado. 

Aqui é importante um detalhe: Depois que a senha for digitada certa, ao rodar a função acessoLiberado é preciso limpar a memória da senha digitado rodando a função password.reset();.

Pode se rodar também quando a senha for errada, mas essa situação não interfere muito no uso do usuário, e acho até mais seguro sem ela. Forçando sempre o uso do # antes da senha. É importante fazer o reset porque se não a senha correta vai estar sempre gravada, até o # ser pressionado. Ou seja, ao apertar apenas o * ele vai confirmar a senha, uma vez que a correta está salva. Apague essa linha, digite a senha correta e depois tente abrir a fechadura apenas apertando o asterisco, você entenderá.

Assim, resumindo o funcionamento da senha:

• Aperta o # para limpar a senha
• Digita a senha
• Cada tecla pressionada tem um feedback sonoro de confirmação
• A própria biblioteca controla que cada clique digita o valor apenas uma vez
• Se a senha for a correta a fechadura se abre igual pelos outros métodos e a senha é limpa
• Se a senha for incorreta existe o feedback visual padrão, e a contagem de 4 erros para o alarme se soma
• Ou seja, dois erros pelo RFID e dois erros pelo senha já são suficientes para ativar o alarme.
• Então 4 erros, quais quer sejam os métodos é suficiente para ativar o alarme.

/* Controle de acesso por fechadura RFID */ //Bibliotecas para o RFID e para o Servo #include <SPI.h> //Para a comunicação SPI do Servo #include <MFRC522.h> //Para o leitor RFID #include <Servo.h> //Para controle do Servo #include <Password.h> //Para controle da senha digitada #include <Keypad.h> //Para uso do teclado matricial 4x4 //Definição dos pinos utilizados #define LED_OK 6 //LED que informa que o cartão lido está cadastrado #define LED_ERRO 5 //LED que informa que o cartão lido NÃO está cadastrado #define FECHADO 0 //Pino que verifica se a porta está fechada #define SIRENE 7 //Buzzer indicador #define ABERTURA 8 //Botão de abertura interna #define SS_PIN 10 //SPI #define RST_PIN 9 //SPI int errado = 0; // Conta quantas vezes tentou um acesso errado String TAG = ""; //Armazena o ID que foi lido pelo RFID bool Permitido = false; //Verfica se a abertura foi permitida //Vetor que armazena as TAGs que a entrada é permitida String TagsCadastradas[] = {"8da023d9", "ID_Gui", "ID_Andrea", "ID_Carro"}; //Informações a respeito do teclado Password password = Password( "123" ); //Cadastro da senha correta const byte ROWS = 4; // Quantidade de linhas const byte COLS = 4; // Quantidade de colunas // Formato do teclado 4x4 char keys[ROWS][COLS] = { {'1','2','3','A'}, {'4','5','6','B'}, {'7','8','9','C'}, {'*','0','#','D'} }; byte rowPins[ROWS] = { 2, 14, 15, 16 };// Pinos do Arduino que estão conectadas as linhas - Saída 1 a 4 do teclado byte colPins[COLS] = { 17, 18, 19, 3};// Pinos do Arduino que estão conectadas as colunas - Saída 4 a 8 do teclado //Inicia as instâncias dos objetos MFRC522 LeitorRFID(SS_PIN, RST_PIN); //Observe que informa os pinos cadastrados anteriormente Servo motor; //Inicia o Servo o chamando de motor Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); //Cria o objeto do teclado void setup(){ motor.attach(4); // Informa o pino de dados do motor motor.write(0); // Coloca o motor na posição 0, fechado Serial.begin(9600); // Inicia a comunição serial apenas para os testes SPI.begin(); // Inicia a SPI LeitorRFID.PCD_Init(); // Inicializa o leitor RFID keypad.addEventListener(keypadEvent); //Adiciona o evento para receber as informações do teclado pinMode(LED_OK, OUTPUT); // Declara o pino do led verde como saída pinMode(LED_ERRO, OUTPUT); // Declara o pino do led vermelho como saída pinMode(SIRENE, OUTPUT); // Declara o pino do buzzer como saída pinMode(FECHADO, INPUT); // Declara a entrada da informação de porta fechada pinMode(ABERTURA, INPUT); // Botão de abertura interna como entrada } void loop (){ //Verifica se a porta está fechada, se estiver aciona a leitura de RFID. Se a porta estiver aberta espera fechar bool porta = digitalRead(FECHADO); Serial.println(porta); if (porta == 0){ delay(200); } else { if( digitalRead(ABERTURA) == 1 ){ //se o botão estiver pressionado acessoLiberado(); } leitura(); keypad.getKey(); }} //Fim do loop, ele apenas verifica o estado da porta, se fechada lê a RFID void leitura(){ TAG = ""; // Define a TAG como vazia sempre que terminar o loop //Aguarda pela leitura de uma TAG if ( !LeitorRFID.PICC_IsNewCardPresent() || !LeitorRFID.PICC_ReadCardSerial() ) { delay(50); return; } //Pega o ID da TAG lida e armazena for (byte i = 0; i < LeitorRFID.uid.size; i++) { TAG.concat(String(LeitorRFID.uid.uidByte[i], HEX)); } //Se uma TAG foi lida verifica se ela é uma cadastrada ou não for (int i = 0; i < (sizeof(TagsCadastradas)/sizeof(String)); i++) { if( TAG.equalsIgnoreCase(TagsCadastradas[i]) ){ Permitido = true; //Variável Permitido assume valor verdadeiro caso o ID Lido esteja cadastrado } } //Se ela for permitida roda a função de permissão if(Permitido == true){ acessoLiberado(); } else{ delay(1000); acessoNegado(); } } void acessoLiberado(){ Serial.println("TAG Liberada"); motor.write(90); //Abre a fechadura //Roda a IHM digitalWrite(LED_OK, HIGH); digitalWrite(SIRENE, HIGH); delay(300); digitalWrite(SIRENE, LOW); delay(100); digitalWrite(SIRENE, HIGH); delay(300); digitalWrite(SIRENE, LOW); delay(5000); int porta = digitalRead(FECHADO); while( porta == 0 ) //enquanto a porta estiver aberta { //blink digitalWrite(LED_OK,HIGH); delay(1000); digitalWrite(LED_OK,LOW); delay(1000); porta = digitalRead(FECHADO); //actualiza o valor da variável } //Depois que a porta fechou motor.write(0); //Tranca a porta digitalWrite(LED_OK, LOW); digitalWrite(SIRENE, HIGH); delay(600); digitalWrite(SIRENE, LOW); Permitido = false; //Só roda o permitido depois de ler um TAG permitida errado=0; //Reseta o contador de erros password.reset(); } void acessoNegado(){ Serial.println("TAG não liberada + TAG"); errado++; digitalWrite(LED_ERRO, HIGH); digitalWrite(SIRENE, HIGH); delay(200); digitalWrite(SIRENE, LOW); digitalWrite(LED_ERRO, LOW); Serial.print("Quantidade de erros: "); Serial.println(errado); if(errado > 3){ ativaAlarme(); } } void ativaAlarme (){ digitalWrite (SIRENE, HIGH); delay (2000); digitalWrite (SIRENE, LOW); errado = 0; } void keypadEvent(KeypadEvent eKey){ switch (keypad.getState()){ case PRESSED: Serial.print("Pressed: "); Serial.println(eKey); digitalWrite(SIRENE, HIGH); delay(30); digitalWrite(SIRENE, LOW); switch (eKey){ case '*': checkPassword(); break; case '#': password.reset(); break; default: password.append(eKey); } } } void checkPassword(){ if (password.evaluate()){ Serial.println("Success"); acessoLiberado(); //Add code to run if it works }else{ Serial.println("Wrong"); acessoNegado(); //add code to run if it did not work } }