Primeiros Passos com o RFID MIFARE MFRC522

This tutorial is not available in English

Introdução

Você já deve ter se deparado com controladores de acesso em algum portão, seja em um condomínio ou em uma empresa, onde o controle de acesso é feito por meio da leitura de tags (chaveiros ou cartões RFID). Neste tutorial, veremos como realizar leituras com o Kit RFID MFRC522 (13,56MHz) e criar um simples controle de acesso.

Lista de Materias

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 93,95 no PIX

-15%

Kit RFID Mfrc522 (13,56MHz)

R$ 12,82 no PIX

Display oLED 0.96 I2C Azul

R$ 33,25 no PIX

LED 5mm Vermelho (10 unidades)

R$ 1,90 no PIX

LED 5mm Verde (10 unidades)

R$ 1,90 no PIX

Buzzer Passivo 5V - Pacote com 5 unidades

R$ 8,45 no PIX

Resistor 300Ω - Pacote com 10 unidades

R$ 0,71 no PIX

Protoboard 830 Pontos

R$ 10,35 no PIX

Jumpers Macho-Macho x40 Unidades

R$ 7,50 no PIX

Cabo USB AB 30cm

R$ 9,40 no PIX

Conceitos Teóricos

RFID é a sigla em inglês para "Radio-Frequency Identification" ou identificação por radiofrequência. É uma tecnologia pela qual os dados digitais codificados em dispositivos de radiofrequência (cartões, etiquetas, entre outros) são captados por um leitor por meio de ondas de rádio. Quando aproximamos estes dispositivos do leitor RFID, o campo de radiofrequência do leitor alimenta o circuito da tag, assim, a tag envia ou recebe informações do leitor. Contudo, vale ressaltar que nem todas as tags podem receber informações.

sistema_RFID — Transmissão por radiofrequência.

Primeiros Passos com o RFID

Nesse projeto, você aprenderá de forma simples a fazer a leitura da UID (identificação única) de um cartão ou chaveiro RFID.

Circuito

Para realizar as leituras da identificação das tags através do leitor RFID MFRC522, monte o circuito a seguir.

Atenção: o leitor RFID não vai com a barra de pinos soldada, portanto é necessário realizar a soldagem antes do uso. Caso você ainda não possua os itens necessários para isso, confira o nosso Kit de Solda que temos disponível para facilitar a soldagem.

Biblioteca

Para os projetos deste tutorial, é necessário realizar a instalação de algumas bibliotecas, a do leitor RFID e a do display OLED. As bibliotecas estão disponíveis para serem instaladas diretamente pelo "Gerenciador de Bibliotecas" da Arduino IDE. Para acessá-lo, siga o caminho da imagem abaixo ou então pressione "Ctrl+Shift+I".

Com o gerenciador aberto, instalaremos primeiro a biblioteca do leitor RFID. Digite "MFRC522" e em seguida clique em instalar a biblioteca desenvolvida por "GithubCommunity", conforme mostrado na imagem abaixo. Após alguns instantes, será exibido INSTALADA ao lado do seu nome, indicando que a instalação foi feita com sucesso.

Biblioteca MFRC522 Encontrada — Biblioteca "MFRC522" Encontrada.

O mesmo deve ser feito com a biblioteca do display OLED. Digite "ADAFRUIT_SSD1306" e clique em instalar no primeiro resultado listado. Em seguida, será exibida uma mensagem perguntando se deseja instalar uma biblioteca de complemento da Adafruit, e como se trata de uma biblioteca auxiliar necessária para o controle do display, clique em "Instalar Tudo", como na imagem abaixo.

Biblioteca ADAFRUIT — Requisição de Instalação de Biblioteca Adicional.

Código

Com as bibliotecas adicionadas à Arduino IDE, carregue o código a seguir para sua placa:

/*******************************************************************************
  Primeiros Passos com o Kit RFID MFRC522 (v1.0).

  Codigo de exemplo para identificacao de UID
  atraves do leitor RFID MFRC522


  Copyright 2025 RoboCore.
  Escrito por Carlos Daniel (17/07/2025).

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

// Adicao de bibliotecas
#include <SPI.h>
#include <MFRC522.h>

const int PINO_RST = 9;            // Definicao do pino RST
const int PINO_SDA = 10;           // Definicao do pino SDA
MFRC522 rfid(PINO_SDA, PINO_RST);  // Criacao do objeto "rfid" com os pinos SDA e RST definidos

String conteudo;  // Define a variavel "conteudo" como uma String, essa variavel e usada para armazenar a UID da "tag" lida

void setup() {
  Serial.begin(9600);                 // Inicializacao do monitor serial
  SPI.begin();                        // Inicializacao da comunicacao SPI
  rfid.PCD_Init();                    // Inicializacao do leitor RFID
  Serial.println("Aproxime a TAG:");  // Imprime no monitor serial
}

void loop() {
  if (rfid.PICC_IsNewCardPresent()) {  // Se uma "tag" estiver presente

    if (!rfid.PICC_ReadCardSerial()) {  // Se a leitura da tag for invalida
      // Imprime erro de leitura no monitor serial
      Serial.println("");
      Serial.print("Erro na leitura do sensor"); 
    }

    // Caso a tag tenha sido lida corretamente
    else {

      // Faz a conversao de decimal para Hexadecimal
      for (byte i = 0; i < rfid.uid.size; i++) {
        if (rfid.uid.uidByte[i] < 0x10) {
          conteudo += " 0";
        } else {
          conteudo += " ";
        }
        conteudo += String(rfid.uid.uidByte[i], HEX);
      }
      // Imprime no monitor serial
      Serial.println("");
      Serial.print("UID da tag :");
      Serial.print(conteudo);  // Imprime no monitor serial a UID

      conteudo = "";  // Zera a variavel conteudo

      rfid.PICC_HaltA();  // Coloca o leitor em standby, para aguardar uma nova tag aproximada
    }
  }
}

Entendendo o Código

Primeiramente, incluímos a biblioteca instalada anteriormente MFRC522.h ao código e incluímos a biblioteca de comunicação SPI (essa biblioteca é nativa da IDE, portanto não requer instalação). Então, criamos o objeto rfid com os pinos SDA (10) e RST (9) da BlackBoard, armazenados nas variáveis PINO_SDA e PINO_RST, respectivamente, através do comando MFRC522 rfid(PINO_SDA, PINO_RST). Também definimos a variável conteudo, do tipo String, para armazenar as identificações lidas das tags.

// Adicao de bibliotecas
#include <SPI.h>
#include <MFRC522.h>

const int PINO_RST = 9; // Definicao do pino RST
const int PINO_SDA = 10; // Definicao do pino SDA
MFRC522 rfid(PINO_SDA, PINO_RST); // Criacao do objeto "rfid" com os pinos SDA e RST definidos

String conteudo; // Define a variavel "conteudo" como uma String, essa variavel e usada para armazenar a UID da "tag" lida

Na função setup() do código, utilizamos os comandos Serial.begin(9600) para inicializar o monitor serial, SPI.begin() para inicializar a comunicação SPI e rfid.PCD_Init() para inicializar o módulo MFRC522. Em seguida, emitimos no monitor serial uma mensagem de inicialização.

Serial.begin(9600); // Inicializacao do monitor serial
SPI.begin(); // Inicializacao da comunicacao SPI
rfid.PCD_Init(); // Inicializacao do leitor RFID
Serial.println("Aproxime a TAG:"); // Imprime no monitor serial

Já na rotina de repetição do código, inserimos uma condição if (rfid.PICC_IsNewCardPresent()) que consiste em procurar uma tag presente. Caso encontre, a leitura é validada através da condição if(!rfid.PICC_ReadCardSerial()). Se o leitor não conseguir realizar a leitura de todos os bytes da tag, será exibida no monitor serial uma mensagem de erro.

if (rfid.PICC_IsNewCardPresent()) {  // Se uma "tag" estiver presente

  if (!rfid.PICC_ReadCardSerial()) {  // Se a leitura da tag for invalida
    // Imprime erro de leitura no monitor serial
    Serial.println("");
    Serial.print("Erro na leitura do sensor");
  }
}

Caso o laço if anterior não seja verdadeiro, ou seja, se a leitura for verificada corretamente, usamos o comando else para executar uma rotina de conversão de decimal para hexadecimal, salvando os bytes coletados como String para a variável conteudo.

// Caso a tag tenha sido lida corretamente
else {

  // Faz a conversao de decimal para Hexadecimal
  for (byte i = 0; i < rfid.uid.size; i++) {
    if (rfid.uid.uidByte[i] < 0x10) {
      conteudo += " 0";
    } else {
      conteudo += " ";
    }
    conteudo += String(rfid.uid.uidByte[i], HEX);
  }
}

Após a conversão, imprimimos a UID identificada e zeramos o valor da variável conteudo para que esteja vazia ao armazenar a próxima tag. Em seguida, pelo comando rfid.PICC_HaltA(), colocamos o leitor em standby para aguardar uma nova tag aproximada.

// Imprime no monitor serial
Serial.println("");
Serial.print("UID da tag :");
Serial.print(conteudo); // Imprime no monitor serial a UID

conteudo = ""; // Zera a variavel conteudo

rfid.PICC_HaltA(); // Coloca o leitor em standby, para aguardar uma nova tag aproximada

O que deve acontecer

Após carregar o código à placa com o circuito montado e abrir o monitor serial com a velocidade de 9600 bps, será exibida a mensagem "Aproxime a TAG:". Ao aproximar uma tag, você verá a identificação dela, como na imagem a seguir.

Observação: copie e guarde a identificação de uma das tags do kit para que possamos utilizá-la no próximo projeto.

Projeto Controle de Acesso

Já que aprendemos a ler as identificações das tags, que tal criarmos um controle de acesso para liberar uma porta ou até mesmo um cofre? Neste projeto, o acesso liberado será simulado por LEDs e um Buzzer, porém você pode adaptar o projeto para fechaduras eletrônicas, por exemplo.

Circuito

No projeto a seguir, utilizaremos um display OLED para imprimir uma mensagem de liberação ou bloqueio. Também utilizaremos dois LEDs, sendo eles um vermelho para "acesso negado" e um verde para "acesso liberado", e um buzzer para efeitos sonoros.

Código

Para este projeto, carregue o código a seguir para a sua placa. Apenas se lembre de alterar a variável ID_AUTORIZADO pela UID (código de identificação) de sua tag coletada no projeto anterior.

/*******************************************************************************
  Controle de acesso simples utilizando o KIT RFID MFRC522 (v1.0)

  Codigo de exemplo para controle de acesso por RFID

  Copyright 2025 RoboCore.
  Escrito por Carlos Daniel (17/07/2025).

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/
// Adicao de bibliotecas
#include <MFRC522.h>
#include <SPI.h>
#include <Adafruit_SSD1306.h>

const int LARGURA_DISPLAY = 128;                            // Definicao da largura em pixels do OLED
const int ALTURA_DISPLAY = 64;                              // Definicao da altura em pixels do OLED
const int ENDERECO_DISPLAY = 0x3C;                          // Definicao do endereco do display
Adafruit_SSD1306 display(LARGURA_DISPLAY, ALTURA_DISPLAY);  // Criacao do objeto "display" com definicao da largura e altura

const int PINO_BUZZER = 5;    // Definicao do pino do buzzer
const int PINO_VERDE = 6;     // Definicao do pino do LED verde
const int PINO_VERMELHO = 7;  // Definicao do pino do LED vermelho

String conteudo;  // Define a variavel "conteudo" como uma String, essa variavel é usada para armazenar a UID da "tag" lida

// MODIFIQUE PARA A UID COPIADA NO PROJETO ANTERIOR //
String ID_AUTORIZADO = "SUA-UID-AUTORIZADA_AQUI"; // Variavel onde armazena a UID cadastrada

const int PINO_RST = 9;            // Definicao do pino RST
const int PINO_SDA = 10;           // Definicao do pino SDA
MFRC522 rfid(PINO_SDA, PINO_RST);  // Criacao do objeto "rfid" com os pinos SDA e RST definidos

void setup() {
  pinMode(PINO_BUZZER, OUTPUT);      // Define o buzzer como saida
  pinMode(PINO_VERDE, OUTPUT);       // Define o LED verde como saida
  pinMode(PINO_VERMELHO, OUTPUT);    // Define o LED vermelho como saida
  noTone(PINO_BUZZER);               // Inicializa com o buzzer desligado
  digitalWrite(PINO_VERDE, LOW);     // Inicializa com o LED verde desligado
  digitalWrite(PINO_VERMELHO, LOW);  // Inicializa com o LED vermelho desligado

  display.begin(SSD1306_SWITCHCAPVCC, ENDERECO_DISPLAY);  // Inicializa o display no endereco definido
  SPI.begin();                                            // Inicializa a comunicacao SPI
  rfid.PCD_Init();                                        // Inicializa o leitor RFID

  mensageminicial();  // Chama a funcao de mensagem inicial
}

void loop() {

  if (rfid.PICC_IsNewCardPresent()) {  // Se houver alguma tag presente

    if (!rfid.PICC_ReadCardSerial()) {  // Se a leitura da tag for invalida

      // Imprime erro de leitura
      digitalWrite(PINO_VERMELHO, HIGH);  // Liga o LED vermelho
      display.clearDisplay();             // Limpa o Display
      display.setCursor(30, 30);          // Posiciona o cursor na linha e coluna definida
      display.println("ERRO AO LER");     // Imprime uma mensagem no display
      display.display();                  // Atualiza o display
      delay(2000);                        // Tempo de espera para a mensagem e o LED ficarem visiveis
      digitalWrite(PINO_VERMELHO, LOW);   // Desliga o LED vermelho
      mensageminicial();                  // Chama a funcao de mensagem inicial
    }

    else {  // Caso a tag tenha sido lida corretamente
      // Faz a conversao de decimal para Hexadecimal
      for (byte i = 0; i < rfid.uid.size; i++) {
        if (rfid.uid.uidByte[i] < 0x10) {
          conteudo += " 0";
        } else {
          conteudo += " ";
        }
        conteudo += String(rfid.uid.uidByte[i], HEX);
      }

      conteudo.trim();                       // Remove qualquer espaco vazio no comeco ou no final da variavel
      if (conteudo == ID_AUTORIZADO) {       // Verifica se UID lida e correspondente com a UID cadastrada
        display.clearDisplay();              // Limpa o Display
        display.setCursor(20, 30);           // Posiciona o cursor na linha e coluna definida
        display.println("Acesso Liberado");  // Imprime no Display
        display.display();                   // Atualiza o Display

        // Pisca o LED verde e emite uma frequencia no buzzer por 6x
        for (int i = 0; i < 6; i++) {
          tone(PINO_BUZZER, 2000);         // Emite uma frequencia de 2000hz no Buzzer
          digitalWrite(PINO_VERDE, HIGH);  // Liga o LED verde
          delay(250);                      // Tempo de espera para o buzzer e o LED ficarem ligados
          noTone(PINO_BUZZER);             // Desliga o buzzer
          digitalWrite(PINO_VERDE, LOW);   // Desliga o LED verde
          delay(250);                      // Tempo de espera para o buzzer e o LED ficarem desligados
        }
        mensageminicial();  // Chama a funcao de mensagem inicial
      }

      // Caso a tag lida não seja cadastrada
      else {
        display.clearDisplay();             // Limpa o Display
        display.setCursor(25, 30);          // Posiciona o cursor na linha e coluna definida
        display.println("Acesso Negado");   // Imprime no Display
        display.display();                  // Atualiza o Display
        digitalWrite(PINO_VERMELHO, HIGH);  // Liga o LED vermelho
        tone(PINO_BUZZER, 4000);            // Emite um som no buzzer
        delay(1200);                        // Tempo de espera para o buzzer e o LED vermelho ficarem ligados
        digitalWrite(PINO_VERMELHO, LOW);   // Desliga o LED vermelho
        noTone(PINO_BUZZER);                // Desliga o buzzer
        mensageminicial();                  // Chama a funcao de mensagem inicial
      }
    }
  }
}

void mensageminicial() {
  conteudo = "";                      // Zera a variavel conteudo
  rfid.PICC_HaltA();                  // Coloca o leitor em standby, para aguardar uma tag a ser aproximada
  display.setTextSize(1);             // Define o tamanho da fonte
  display.setTextColor(WHITE);        // Define a cor do texto
  display.clearDisplay();             // Limpa o Display
  display.setCursor(20, 25);          // Posiciona o cursor na linha e coluna definida
  display.println("Aproxime a sua");  // Imprime no display
  display.setCursor(55, 40);          // Posiciona o cursor na linha e coluna definida
  display.println("TAG");             // Imprime no display
  display.display();                  // Atualiza o display
}

Entendendo o Código

Primeiramente, adicionamos uma nova biblioteca, a Adafruit_SSD1306.h, para o controle do display OLED. Além disso, definimos a largura e a altura do display em pixels e o endereço do mesmo nas variáveis LARGURA_DISPLAY, ALTURA_DISPLAY e ENDERECO_DISPLAY. Em seguida, com o comando Adafruit_SSD1306 display(LARGURA_DISPLAY, ALTURA_DISPLAY) criamos o objeto display com a definição da largura e altura.

#include <Adafruit_SSD1306.h>

const int LARGURA_DISPLAY = 128; // Definicao da largura em pixels do OLED
const int ALTURA_DISPLAY = 64; // Definicao da altura em pixels do OLED
const int ENDERECO_DISPLAY = 0x3C; // Definicao do endereco do display
Adafruit_SSD1306 display(LARGURA_DISPLAY, ALTURA_DISPLAY); // Criacao do objeto "display" com definicao da largura e altura

Também declaramos as variáveis que armazenam os pinos conectados aos LEDs e ao buzzer. Em seguida, definimos a variável conteudo como uma variável do tipo String, que receberá a UID da tag aproximada. No comando String ID_AUTORIZADO = "SUA-UID-AUTORIZADA_AQUI", definimos a variável ID_AUTORIZADO que armazena a UID autorizada.

const int PINO_BUZZER = 5; // Definicao do pino do buzzer
const int PINO_VERDE = 6; // Definicao do pino do LED verde
const int PINO_VERMELHO = 7; // Definicao do pino do LED vermelho

String conteudo; // Define a variavel "conteudo" como uma String, essa variavel é usada para armazenar a UID da "tag" lida

// MODIFIQUE PARA A UID COPIADA NO PROJETO ANTERIOR //
String ID_AUTORIZADO = "SUA-UID-AUTORIZADA_AQUI"; // Variavel onde armazena a UID cadastrada

Na função setup() do código, configuramos os pinos dos LEDs (PINO_VERDE e PINO_VERMELHO) e o pino do buzzer (PINO_BUZZER) como saídas e com o nível lógico baixo inicial. Inicializamos o display com o seu endereço I2C definido, inicializamos a comunicação SPI e o leitor RFID. E em seguida chamamos a função de mensagem inicial.

void setup() {
  pinMode(PINO_BUZZER, OUTPUT);      // Define o buzzer como saida
  pinMode(PINO_VERDE, OUTPUT);       // Define o LED verde como saida
  pinMode(PINO_VERMELHO, OUTPUT);    // Define o LED vermelho como saida
  noTone(PINO_BUZZER);               // Inicializa com o buzzer desligado
  digitalWrite(PINO_VERDE, LOW);     // Inicializa com o LED verde desligado
  digitalWrite(PINO_VERMELHO, LOW);  // Inicializa com o LED vermelho desligado

  display.begin(SSD1306_SWITCHCAPVCC, ENDERECO_DISPLAY);  // Inicializa o display no endereco definido
  SPI.begin();                                            // Inicializa a comunicacao SPI
  rfid.PCD_Init();                                        // Inicializa o leitor RFID

  mensageminicial();  // Chama a funcao de mensagem inicial
}

No laço de repetição, criamos uma condição que consiste em procurar uma nova tag como no código do projeto anterior, e assim que for identificada e lida corretamente, removemos qualquer espaço que haja no começo ou no final da UID lida com o comando conteudo.trim() e em seguida utilizamos a condição if (conteudo == ID_AUTORIZADO) para verificar se a UID da tag lida é igual ao código salvo na variável ID_AUTORIZADO. Caso a UID lida corresponda à UID definida, imprimimos no display uma mensagem de acesso liberado, emitimos seis vezes uma animação no buzzer e no LED verde e chamamos a função de mensagem inicial para reiniciar a tela.

conteudo.trim();                       // Remove qualquer espaco vazio no comeco ou no final da variavel
if (conteudo == ID_AUTORIZADO) {       // Verifica se UID lida e correspondente com a UID cadastrada
  display.clearDisplay();              // Limpa o Display
  display.setCursor(20, 30);           // Posiciona o cursor na linha e coluna definida
  display.println("Acesso Liberado");  // Imprime no Display
  display.display();                   // Atualiza o Display

  // Pisca o LED verde e emite uma frequencia no buzzer por 6x
  for (int i = 0; i & lt; 6; i++) {
    tone(PINO_BUZZER, 2000);         // Emite uma frequencia de 2000hz no Buzzer
    digitalWrite(PINO_VERDE, HIGH);  // Liga o LED verde
    delay(250);                      // Tempo de espera para o buzzer e o LED ficarem ligados
    noTone(PINO_BUZZER);             // Desliga o buzzer
    digitalWrite(PINO_VERDE, LOW);   // Desliga o LED verde
    delay(250);                      // Tempo de espera para o buzzer e o LED ficarem desligados
  }
  mensageminicial();  // Chama a funcao de mensagem inicial
}

Caso contrário, ou seja, se a tag lida não estiver liberada, por meio da condição else, imprimimos no display uma mensagem de acesso negado, acendemos o LED vermelho e emitimos uma animação musical no buzzer. Feito isso, chamamos a função de mensagem inicial.

// Caso a tag lida não seja cadastrada
else {
  display.clearDisplay();             // Limpa o Display
  display.setCursor(25, 30);          // Posiciona o cursor na linha e coluna definida
  display.println("Acesso Negado");   // Imprime no Display
  display.display();                  // Atualiza o Display
  digitalWrite(PINO_VERMELHO, HIGH);  // Liga o LED vermelho
  tone(PINO_BUZZER, 4000);            // Emite um som no buzzer
  delay(1200);                        // Tempo de espera para o buzzer e o LED vermelho ficarem ligados
  digitalWrite(PINO_VERMELHO, LOW);   // Desliga o LED vermelho
  noTone(PINO_BUZZER);                // Desliga o buzzer
  mensageminicial();                  // Chama a funcao de mensagem inicial
}

Na função mensageminicial(), zeramos a variável conteudo e colocamos o leitor em standby para aguardar uma tag ser aproximada, em seguida imprimimos no display a mensagem inicial para aproximar a tag.

void mensageminicial() {
  conteudo = "";                      // Zera a variavel conteudo
  rfid.PICC_HaltA();                  // Coloca o leitor em standby, para aguardar uma tag a ser aproximada
  display.setTextSize(1);             // Define o tamanho da fonte
  display.setTextColor(WHITE);        // Define a cor do texto
  display.clearDisplay();             // Limpa o Display
  display.setCursor(20, 25);          // Posiciona o cursor na linha e coluna definida
  display.println("Aproxime a sua");  // Imprime no display
  display.setCursor(55, 40);          // Posiciona o cursor na linha e coluna definida
  display.println("TAG");             // Imprime no display
  display.display();                  // Atualiza o display
}

O que deve acontecer

Após carregar o código à placa com o circuito montado, aproxime a tag com a UID cadastrada e veja uma mensagem de liberação no display, o LED verde piscando e o buzzer ativando, como no GIF a seguir.

Exemplo de Tag Autorizada.

Agora aproxime uma tag diferente da UID cadastrada e veja uma mensagem de bloqueio no display, o LED vermelho e o buzzer ativando, como no GIF a seguir.

Exemplo de Tag Negada.

Indo além

Você pode expandir esse projeto utilizando o Shield para Arduino - Ethernet W5500, que conta com conectividade à internet e um slot para cartão de memória. Com ele, é possível registrar as tags autorizadas e todas as tentativas de acesso em um banco de dados online. Além disso, em caso de falha ou instabilidade na conexão com a internet, o sistema pode utilizar o cartão de memória para armazenar localmente as informações de acesso, como data, hora, UID da tag e status da tentativa (liberada ou negada).

Conclusão

Neste tutorial aprendemos como realizar as leituras das tags RFID e aproveitar para fazer um simples controle de acesso.