Olá tudo bem? Preparado(a) para estar utilizando a tecnologia RFID com arduino hoje? Espero que sim, pois hoje estudaremos toda o seu funcionamento e esclarecer algumas dúvidas recorrentes a sua utilização. Vamos nessa?
Quando o RFID surgiu?
A tecnologia de RFID (Identificação por radiofrequência) surge inicialmente na Segunda Guerra Mundial, tendo como base, os radares utilizados na época. O que gerou a necessidade de desenvolver uma tecnologia como essa, foi o problema de identificação das aeronaves que apareciam nos radares, não sendo possível identificar se era inimigo ou não.
Dessa forma, a Inglaterra consegue desenvolver o primeiro identificador ativo de amigo ou inimigo (IFF – Identify Friend or Foe). Para isso, foi implementado em seus aviões um transmissor que, ao receberem sinais das estações de radar, começavam a transmitir um sinal de resposta.
Portanto, esse mesmo princípio é aplicado ao RFID de hoje. Ou seja, um sinal é enviado a uma etiqueta eletrônica, que é ativada e reflete de volta o sinal (sistema passivo) ou transmita seu próprio sinal (sistemas ativos).
Qual seria a sua utilização?
Atualmente, podem existir diversas maneiras de utilização, porém, o mais comum é armazenar um número de série (gerado pelas etiquetas, cartões, tags) que possam identificar uma pessoa ou um objeto.
Dessa forma, a tecnologia de RFID vai possibilitar a captura automática de dados para identificação de objetos com dispositivos eletrônicos conhecidos como etiquetas eletrônicas, RF tags e cartões RF. Esses dispositivos, emitem sinais de radiofrequência para os leitores que captam estas informações.
Portanto, o RFID pode ser utilizado em diferentes aplicações, inclusive na parte de segurança, onde podemos citar como exemplos de sua utilização o controle de acesso em catracas, alarmes contra furtos em lojas e até mesmo para o acesso a lugares desbloqueando travas de portas.
Outra função muito comum que é atribuída a essa tecnologia, são os cartões de utilização de transporte público. Por fim, nos últimos anos a sua implementação está sendo utilizada também para realizar compras aproximando o cartão as maquininhas de cartões.
Funcionamento da Tecnologia RFID
Agora, vamos analisar como toda essa tecnologia funciona. Basicamente, todo o sistema de RFID é composto de dois dispositivos:
- Um transceptor com decodificador e uma antena;
- Um transponder (chamado também de Tag) que é eletronicamente programado com informações.
Portanto, observando a imagem acima, temos desenhado todo o circuito base. Assim, o “interrogador” ou dispositivo de leitura vai emitir sinais através da sua antena. Este sinal, quando captado pela tag (que pode ser os diversos tipos explicados acima) irá responder enviando toda a informação armazenada nela.
Sendo assim, vamos estudar um pouco mais sobre essa tag. Observe a imagem abaixo:
Como mostrado na imagem acima, temos um microchip (para armazenar os dados da tag) e também uma antena integrada (que faz a captação do sinal enviado pelo receptor), beleza? Contudo, como já falado inicialmente, temos dois tipos de sistemas quando trabalhamos com RFID.
Sistemas Passivos
As tags do tipo passivas utilizam a energia da onda de radiofrequência gerada pelo receptor para poder transmitir o seu sinal de resposta (com os dados gravados nelas). Porém, normalmente elas vêm com suas informações já gravadas permanentemente quando são fabricadas. Entretanto, temos em alguns casos, a possibilidade de alterar as informações armazenadas em seu microchip.
A sua vantagem então? Simples, é a sua facilidade de uso! Como já vimos, podemos utilizar desde em roupas de lojas até em cartões para realizar compras, ou passaportes, enfim, tudo!
Sistemas Ativos
Já os sistemas ativos, irão contar com uma espécie de fonte de energia própria. Essa fonte será responsável por transmitir o sinal de resposta, e consequentemente, aumentando o alcance dele.
Algumas Observações Importantes
Quando estamos trabalhando com radiofrequência, um detalhe importante é saber a faixa de transmissão. Isso porque, essa frequência de transmissão vai interferir na taxa de transferência de dados entre etiqueta e o leitor dela.
Sabendo disso, temos que as três frequências mais utilizadas para o sistema RFID passivo são:
- Baixa frequência (LF): 125kHz.
- Alta frequência (HF): 13,56 MHz.
- Ultra alta frequência (UHF): 860 a 960MHz.
Dessa forma, a relação de frequência e alcance é diretamente proporcional. Assim, quanto maior a frequência, maior será o alcance máximo, mas esse não é o único fator.
Conhecendo Módulo RC522
O nosso módulo RFID da imagem abaixo, utiliza o chip da empresa NXP, o chip MFRC522. Ele pode ser implementado para comunicações a uma frequência de 13,56MHz (ou seja, em alta frequência), permitindo por aproximação, a leitura e escrita em cartões que seguem o padrão Mifare.
Dados Importantes
- Velocidades de transferência de até 848 kB
- Distância de operação típica no modo de leitura/gravação de até 50 mm, dependendo do tamanho e ajuste da antena
- Fonte de alimentação de 2,5 V a 3,3 V
- Pinos de E/S programáveis
Para maiores informações e detalhes sobre módulo RFID, basta acessar o seu datasheet clicando no botão abaixo!
Assim, como já visto, para podermos utilizar a tecnologia RFID, é necessário um receptor e um emissor. Dessa forma, ao comprar o módulo leitor RFID RC522, você receberá um kit de tags e um cartão RFID o qual usaremos nesse projeto como mostrado na imagem abaixo.
Componentes do Projeto
Primeiro, agora que entendemos como surgiu essa tecnologia e como ela trabalha, vamos partir para a criação de nosso projeto. Para isso, separe os seguintes componentes:
Montagem do Circuito
Componentes separados? Então, realize a ligação de todos eles seguindo a imagem abaixo:
Código do Projeto Comentado
Antes de iniciar o nosso estudo da programação, realize o download da biblioteca de nosso módulo RFID.
Na sequência, descompacte, troque o nome da pasta por MFRC522 e coloque ela na pasta “libraries” do Arduino. Por fim, realize o upload do código abaixo no Arduino.
/* ==================================================================================================
Projeto: Controle de Acesso com RFID
Autor: Danilo Nogueira
Data: 24/10/2019
// ==================================================================================================*/
// --- Declaração Bibliotecas ---
#include <SPI.h>
#include <MFRC522.h>
// --- Declaração das variáveis --
int pino_ss = 10;
int pino_rst = 9;
int led_acesso = 5;
int led_erro = 6;
MFRC522 mfrc522(pino_ss, pino_rst); // Criando o objeto do nosso sensor
// =================================================================================================
// --- Configurando o void setup() ---
void setup()
{
pinMode(led_acesso, OUTPUT);
pinMode(led_erro, OUTPUT);
// Iniciando a serial
Serial.begin(9600);
SPI.begin();
// Inicia MFRC522
mfrc522.PCD_Init();
// Mensagens iniciais no serial monitor
Serial.println("Aproxime o cartao do leitor...");
Serial.println();
}
// =================================================================================================
// --- Configurando o void loop() ---
void loop()
{
// Verifica se algum cartão foi aproximado do sensor
if ( ! mfrc522.PICC_IsNewCardPresent()) { return; }
// Verifica qual cartão foi lido
if ( ! mfrc522.PICC_ReadCardSerial()) { return; }
// Mostra UID na serial
Serial.print("UID da tag :");
String conteudo= "";
byte letra;
// --- Escrevendo na serial a UID do cartão --
for (byte i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
Serial.print("Mensagem : ");
conteudo.toUpperCase();
// Testa se o cartao1 foi lido
if (conteudo.substring(1) == "D8 4B 12 22")
{
// Acende o LED verde e libera o acesso
digitalWrite(led_acesso, HIGH);
Serial.println("Cartao1 - Acesso liberado !");
Serial.println();
delay(2000);
digitalWrite(led_acesso, LOW);
}
// Testa se o cartao2 foi lido
if (conteudo.substring(1) == "87 4B DC 8A")
{
Serial.println("Cartao2 - Acesso negado !!");
Serial.println();
// Pisca o led vermelho sinalizando um erro de acesso
for (int i= 1; i<5 ; i++)
{
digitalWrite(led_erro, HIGH);
delay(200);
digitalWrite(led_erro, LOW);
delay(200);
}
}
delay(1000);
}
// ===================================== F I M =========================================Explicação do Código
Inicialmente, temos a declaração das nossas bibliotecas utilizadas no código e também as variáveis. As duas principais bibliotecas que estamos utilizando são do nosso módulo de RFID e também do protocolo SPI. Caso não tenha visto o post sobre este protocolo, clique no botão abaixo.
Na sequência, definimos um objeto do nosso módulo o qual vamos utilizar para chamar os comandos durante nosso código. Dentro do objeto criado, ele recebe como parâmetros (entradas) a pinagem do RST e SDA.
// --- Declaração Bibliotecas ---
#include <SPI.h>
#include <MFRC522.h>
// --- Declaração das variáveis --
int pino_ss = 10;
int pino_rst = 9;
int led_acesso = 5;
int led_erro = 6;
MFRC522 mfrc522(pino_ss, pino_rst); // Criando o objeto do nosso sensorEntão, entrando no void setup, temos a definição do modo de operação de nossos leds e também a inicialização do nosso protocolo SPI, do monitor Serial que mostrará as mensagens e do RFID.
Por fim, entramos no void loop, onde temos dois blocos if iniciais, verificando se alguma TAG foi aproximada e qual a sua UID.
// --- Configurando o void loop() ---
void loop()
{
// Verifica se algum cartão foi aproximado do sensor
if ( ! mfrc522.PICC_IsNewCardPresent()) { return; }
// Verifica qual cartão foi lido
if ( ! mfrc522.PICC_ReadCardSerial()) { return; }Dois desse blocos de condição, é realizado dentro do bloco for, a leitura da sua UID (código de identificação). Para isso, ele coleta “pacotes” de valores em HEX (hexadecimal) e agrupa tudo isso através do comando “concat”. O resultado disso é um valor como este (84 4D CD 7U).
// --- Escrevendo na serial a UID do cartão --
for (byte i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
Serial.print("Mensagem : ");
conteudo.toUpperCase();Por fim, temos dois últimos blocos if. Eles verificam qual TAG/Cartão foi aproximado do sensor e realiza a verificação de qual fornece o acesso e qual deles não.
Para isso, na primeira execução do código, colete os valores lidos do seu cartão ou TAG e troque no if correspondente.
// Testa se o cartao1 foi lido
if (conteudo.substring(1) == "D8 4B 12 22")
{
// Acende o LED verde e libera o acesso
digitalWrite(led_acesso, HIGH);
Serial.println("Cartao1 - Acesso liberado !");
Serial.println();
delay(2000);
digitalWrite(led_acesso, LOW);
}
// Testa se o cartao2 foi lido
if (conteudo.substring(1) == "87 4B DC 8A")
{
Serial.println("Cartao2 - Acesso negado !!");
Serial.println();
// Pisca o led vermelho sinalizando um erro de acesso
for (int i= 1; i<5 ; i++)
{
digitalWrite(led_erro, HIGH);
delay(200);
digitalWrite(led_erro, LOW);
delay(200);
}
}Resultado do Projeto
Por fim, confira o resultado do projeto em nosso canal do Youtube!
Mas e ai? Gostou do post? Caso tenha ficado algo incompleto para você, comente abaixo 📝
Dicas? Dúvidas? 🤔 Críticas? 😱 Só comentar abaixo! 👇
Forte abraço e compartilha se gostou! 🤘