Fechadura Digital com Arduino UNO e RFID

Para o projeto de uma casa que integra uma automação residencial completa muitos pontos são importantes. Citaria logo a questão do assistente pessoal, do hub de automação, dos módulos relés, das lâmpadas inteligentes e por aí vamos longe.

Um dos pontos que não se cita normalmente são as fechaduras, ok, temos no mercado internacional e também nacional inúmeros modelos já difundidos, de sobrepor e de embutir. Elas possuem métodos de aberturas bem distintos, cartão, senha, biometria, chave física. Todas possuem um único objetivo, facilitar a abertura da sua casa e torná-la mais segura, mais complexo de violar digamos.

Um ponto que ainda é escasso é que essas fechaduras são apenas fechaduras, em pleno meio de 2019 os modelos são sim tecnológicos e super modernos, cumprem seu papel. Mas a grande maioria, e todos os modelos nacionais, pecam em um ponto. Não são pensados em automação residencial. Não possui conectividade, não tem sequer infravermelho, RF, IR, quem dirá integração com Google Assistant, Alexa, Siri. Alguns raros modelos possuem lá seu WiFi com aplicativo próprio e tal. Mas ainda sim se encontra bem mais modelos de qualquer outra coisa automatizada que de fechaduras automáticas.

Eu já passei alguns apuros por ter uma fechadura não conectada, a minha nem é dessas inteligentes, é apenas a velha chave mesmo. Já fiquei preso na rua, já deixei meu irmão preso na rua, já precisei abrir a casa a distância para parentes que chegaram de viagem. Não vejo ainda muito sentido nos benefícios e preços das fechaduras conectadas, ao menos os modelos atuais hiper limitados. E os que são conectados não facilitam a automação.

Eu quero ir dormir e dar boa noite ao Google Home, e ele sozinho vê se a porta está trancada, tranca meu carro, ativa o alarme, fecha as janelas, ativa a definição de luzes... Eu quero abrir a minha casa a distância para quem for, desde um prestador de serviço a uma ambulância. Eu quero viajar e perguntar ao Google Assistant se minha porta está trancada. Vai dizer que não perdeu muito tempo conferindo se tudo está fechado várias vezes da sua vida?

Então o básico é o seguinte, eu preciso de uma fechadura, com integração a um hub de automação residencial (Home Assistant), na qual eu posso controlar e verificar status remotamente. Além de que ela tenha funções de automação e um interface IHM embutida, afinal, um feedback sem precisar pegar o telefone é bem vindo. Assim eu desenhei no Google Documentos mesmo como seria mais ou menos a lógica de funcionamento.

Primeiro a fechadura verifica se está fechada, essa verificação pode parecer boba, mas ela vai me retornar o status que preciso para monitorar a porta remotamente. E também não faz muito sentido a porta estar aberta e mesmo assim ela ficar lendo o cartão, enfim, eu coloquei, dá pra tirar também, sem alarde. Como ela sabe se está trancada, a lingueta tem um imã na ponta, que trabalha em conjunto com o reed switch, basta ler o estado dele por meio do digitalRead. Se for 1 a porta está trancada, se for 0 a porta está destrancada. Lembrando que saber se está aberta ou não fica pro sistema de alarme, a fechadura informa apenas trancada ou destrancada.

Se ela está aberta ela fica lendo a informação. A partir do momento que está trancada ela fica lendo o leitor de RFID para ver se foi feita alguma leitura, enquanto monitora o botão de abertura interna para ver se foi acionado.

Se o cartão foi lido, ele verifica se o cartão está cadastrado. Se estiver ele roda a função de abrir a porta. Se não estiver ele indica erro e soma em uma variável. Ao atingir 4 erros a fechadura aciona o sistema de alarme da residencia. Da mesma forma que se o botão interno for pressionado a função de abertura é executada. 

Se a porta abriu ele faz a indicação visual, dois bipes e acendo o LED de confirmação. A partir desse momento ele roda um loop "enquanto" (while). Enquanto a porta está aberta ele fica verificando se a porta está aberta ou não e pisca o LED de confirmação. Quando ele verificar que a porta fechou ele tranca ela, apaga os LEDs e dá um bipe único de confirmação.

Agora vamos analisar o código que eu escrevi e os seus problemas (que são alguns).

/* 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 //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 3 //Pino que verifica se a porta está fechada #define SIRENE 7 //Buzzer indicador #define ABERTURA 2 //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"}; //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 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 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 ){ //enquanto o botão estiver pressionado acessoLiberado(); } leitura(); }} //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(3); while( porta == 0 ) //enquanto a porta estiver aberta { //blink digitalWrite(LED_OK,HIGH); delay(1000); digitalWrite(LED_OK,LOW); delay(1000); porta = digitalRead(3); //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 } 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; }

Copie e cole na Arduino IDE, ou melhor ainda, no Visual Studio Code e vamos analisar juntos.
Primeiro a lista de materiais é a seguinte: LED para status positivo (usei um branco alto brilho), LED para status negativo (usei um vermelho comum), Buzzer (usei um ativo mesmo), um botão (pushbutton comum), um Arduino, ESP ou o que for (Usei um Arduino Uno pq sempre testo nele, mas o final vai rodar em ESP), um motor servo (para ilustrar o mecanismo da fechadura), e o Leitor RFID-RC522.

Iniciamos o código com as três bibliotecas que vamos precisar, SPI (comunicação do RFID), MFRC522 (controle do RFID) e a Servo, para controlar o servo lúdico (posicionado como cancela).
Definimos logo em seguidas algumas informações para facilitar. Declaramos variáveis e o vetor que armazena quais TAGs RFID são as autorizadas para abrir a porta. Inicia os objetos.

Agora chegamos ao setup. Aqui são apenas declarações básicas de bibliotecas, início da serial (bom para teste) e declaração de tipo de pinos.

O loop é simples: Se grava o estado da fechadura (aberto ou fechado) na variável porta. Se esse valor é 0 (está aberta) aguarda 200ms e verifica novamente.
Se o valor for outro, no caso 1, ele verifica se o botão de abertura interna está pressionado, se estiver roda a função de abertura (acessoLiberado), se não ele efetua a função que lê o RFID (leitura). Lembrando que essa questão de verificar o botão e o cartão é extremamente rápido, mesmo em um UNO.

A função leitura é aquela responsável por ler a analisar o RFID. Primeiro ele esvazia a variável que guarda as informações do cartão lido, ou seja, sempre que se terminar de ler um cartão a função retorna e limpa a informação do último cartão lido (óbvio que se for desejado dá pra salvar bem facilmente). Então nessa função ele verifica se um cartão foi encontrado pelo leitor, se não ele aguarda 50ms e verifica novamente. Se tiver sido encontrado ele armazena o ID do cartão na variável TAG. Assim ele verifica se essa TAG se encontra na lista das permitidas. Se tiver a variável permitido tem seu valor alterado para verdadeiro, se não ela continua como falso.

Agora o programa analisa a variável Permitido. Se ela for verdadeira se roda a função que abre a fechadura (acessoLiberado), a mesma que roda quando o botão é pressionado. Se a variável Permitido é falsa, ou seja, a leitura verificou que a TAG não é permitida e não alterou a variável (lembra que essa verificação só existe após a leitura de uma TAG) é aguardado um segundo, para evitar leituras seguidas e se aciona a função acessoNegado.

Agora a função de acessoLiberado, aquela que roda quando o cartão RFID está na lista de permitidos ou quando o botão interno é acionado. A primeira coisa que é feita é abrir a fechadura, alterando o ângulo do servo. Após isso se roda a interface IHM que indica para o usuário que a fechadura se abriu. Ele acende o LED de confirmação, e dá dois bipes de 300ms no Buzzer. Aguarda 5 segundos (tempo para o usuário abrir a porta).

Depois desse intervalo ele verifica o estado da porta. Aqui uma questão, ele verifica para mesmo sensor da fechadura, então ele sempre verifica se a porta está trancada ou não, o que não funciona. Até então essa verificação era correta. Agora aqui não se pode verificar se está trancado ou não, precisa é verificar se a porta está fechada, ou seja, use outro sensor, como o do alarme. Então seguindo, ele verifica se a porta está fechada e guarda a informação na variável "porta". Enquanto a porta está aberta, valor da variável 0, ele pisca o LED de indicação e atualiza a variável, que logo em seguida vai ser verificada pelo while. Ou seja, enquanto a porta estiver aberta (0), pisca o LED, quando ela fechar (1), segue o loop.

Quando ela fechar aciona o servo para a posição de trancado, desliga o LED de indicação e aciona a sirene por um curto período. Depois altera a variável permitido para falso, assim a porta só vai abrir quando ela trocar para permitido, ou seja, um cartão cadastrado for usado. Ou a função de abertura ser chamada novamente. É importante trocar o valor da variável. E reseta o contador de erros que aciona o alarme. Ou seja, se tentar 4 vezes com um cartão não cadastrado o alarme é ativado, mas se tentar 2 vezes e depois acertar você terá 4 chances na próxima tentativa.

A próxima função é a acessoNegado, que funciona quando a TAG lida é errada. Ela apenas adiciona uma tentativa na variável "errado" que conta os erros, aciona o LED de erro e o buzzer para avisar o usuário do problema. Depois ela verifica quantos erros aconteceram, se foi mais de 3 ativa a função que ativa o alarme.

A função ativaAlarme é chamada em caso que seja necessário ativar o alarme da residencia, aqui se coloca o código necessário para tal, para exemplo coloquei o buzzer tocando por dois segundos. Depois reseta o número de erros, caso contrário ao errar 4 vezes, ativar o alarme e outro dia errar uma única vez novamente o alarme seria ativado, pois o número de erros iria apenas somando e sempre seria mais de 4.

Bom, agora é necessário integrar isso ao HUB de automação e colocar uma forma alternativa de entrada, como um teclado, que pode ter um código padrão de abertura e um de socorro. É necessário também fazer ajustes como os dos sensores utilizados. Também pode se ativar o alarme que houver algum violação de abertura, só chamar a função. A abertura remota pode ser feita por MQTT, acionando a função de abertura. Essa divisão de funções auxilia demais.

E para ativar sua fechadura basta trocar os comandos de posição do servo para as funções de abrir e fechar sua fechadura.

Mas acredito que o código como está já é de grande valia para qualquer um que queira fazer um fechadura digital, inteligente ou não, autônoma ou não, já polpa muito tempo.

Para finalizar vamos verificar se tudo que era necessário foi inicialmente cumprido.
''Então o básico é o seguinte, eu preciso de uma fechadura, com integração a um hub de automação residencial (Home Assistant), na qual eu posso controlar e verificar status remotamente. Além de que ela tenha funções de automação e um interface IHM embutida, afinal, um feedback sem precisar pegar o telefone é bem vindo. Assim eu desenhei no Google Documentos mesmo como seria mais ou menos a lógica de funcionamento.''

A integração ainda não existe, mas está pronta para ser implementada, por RF, MQTT ou o que for. Funções de automação existe, como acionar o alarme sozinha e trancar sozinha quando a porta fechar. O feedback também existe por buzzer e LED, e se for o caso um visor também pode ser facilmente incluído.

Vou continuar a trabalhar na fechadura, espero que o próximo post já tenhamos integração online (espero que por MQTT) e que ele já rode em um ESP, vamos ver se o 8266 vai dar conta sem precisar apelar para o mais caro ESP32.