Leitura e Escrita com o RFID MIFARE MFRC522

Introdução

Você já precisou guardar uma informação importante, que ninguém poderia saber e não soube onde guardar? É possível deixar sua informação criptografada com o Kit RFID MFRC522 (13,56MHz). Com esse kit é possível fazer a leitura e gravação de dados dentro de uma tag. Neste tutorial, você aprenderá de maneira simples como realizar a leitura e gravação de dados em uma tag RFID de 13,56 MHz.

Observação: Este tutorial é apenas para fins educacionais com tags compatíveis (13,56 MHz). Nunca tente regravar cartões de transporte, bancários ou outros, pois pode ser que algum dado importante do cartão seja apagado e deixe-o inutilizável.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 98,90

Kit RFID Mfrc522 (13,56MHz)

R$ 13,50

Chave Momentânea (PushButton) - Pacote com 10 unidades

R$ 1,50

Protoboard 400 Pontos

R$ 6,90

Jumpers Macho-Macho x40 Unidades

R$ 7,90

Cabo USB AB 30cm

R$ 9,90

Conceitos teóricos

As tags (cartão e chaveiro) de 13,56 MHz incluídas no kit possuem memória EEPROM de 1 KB, com aproximadamente 768 bytes disponíveis para armazenamento de dados. Essa memória é organizada em 16 setores, cada um contendo 4 blocos de 16 bytes. Cada bloco pode ser regravado inúmeras vezes, permitindo alterar seu conteúdo conforme necessário.

Os blocos de dados são protegidos, daí a popularidade de tags MIFARE. É necessário autenticar o leitor para o setor respectivo antes de ler ou escrever dados em um bloco. Também é possível alterar essas configurações de segurança. Contudo, esse tipo de alteração pode corromper a tag, então é preciso ter cuidado ao trabalhar nos blocos de configuração.

Circuito

Para realizar a leitura ou gravação da tag, através do leitor MFRC522, monte o circuito a seguir:

Biblioteca

Para o projeto deste tutorial, é necessário realizar a instalação da biblioteca do leitor RFID. A biblioteca está disponível para ser instalada 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, digite "MFRC522" e, em seguida, clique em instalar a biblioteca desenvolvida por "GithubCommunity". Após alguns instantes, será exibido INSTALADA ao lado do seu nome, indicando que a instalação foi feita com sucesso, conforme mostrado na imagem abaixo.

Biblioteca MFRC522 Encontrada — Biblioteca "MFRC522" Encontrada.

Codigo

Com a biblioteca adicionada à Arduino IDE e o circuito montado, carregue o código a seguir para sua placa.

 /*******************************************************************************
Leitura e gravacao de dados usando o Kit RFID MFRC522 (v1.0).

Codigo de exemplo para leitura e gravacao de dados em uma tag


Copyright 2025 RoboCore.
Escrito por Carlos Daniel (06/08/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>

const int PINO_RST = 9;   // Define o pino RST
const int PINO_SDA = 10;  // Define o pino SDA

MFRC522 mfrc522(PINO_SDA, PINO_RST);  // Criacao do objeto "mfrc522" com os pinos SDA e RST definidos
MFRC522::MIFARE_Key chave;            // Cria uma instancia de chave que sera usada para acessar a tag

const int BOTAO_GRAVACAO = 6;  // Define o pino do botao de gravacao
const int BOTAO_LEITURA = 7;   // Define o pino do botao de leitura

// Criacao das variaveis do tipo Byte
byte bloco = 4;     // Define qual bloco da tag vai ser ultizado para a leitura ou gravacao
byte buffer[18];    // Armazena temporariamente no programa o conteudo lido da tag
byte tamanho = 18;  // Define o total de caracteres a serem lido ou gravados

// ALTERE PARA UM TEXTO DE SUA PREFERENCIA, RESPEITANDO O LIMITE MAXIMO DE 16 CARACTERES//
byte texto[16] = "ROBOCORE";  // Variavel do tipo Byte, responsavel por armazenar o texto que vai ser gravado na tag

void setup() {
  pinMode(BOTAO_GRAVACAO, INPUT_PULLUP);  // Define o botao "gravacao" como entrada e habilita o resistor da porta digital
  pinMode(BOTAO_LEITURA, INPUT_PULLUP);   // Define o botao "leitura" como entrada e habilita o resistor da porta digital

  Serial.begin(9600);  // Inicializacao do monitor serial
  SPI.begin();         // Inicializacao da comunicacao SPI
  mfrc522.PCD_Init();  // Inicializacao do leitor RFID

  // Prepara a chave de autenticacao da tag
  for (byte i = 0; i < 6; i++) {
    chave.keyByte[i] = 0xFF;
  }

  Serial.print("Selecione um botão para leitura ou gravação: ");  // Imprime no monitor serial
}

void loop() {
  // Se o botao de leitura foi pressionado
  if (digitalRead(BOTAO_LEITURA) == LOW) {
    leitura();
    while (digitalRead(BOTAO_LEITURA) == LOW);  // Espera o botão ser solto
    delay(300);                                 // Debounce
  }

  // Se o botao de gravacao foi pressionado
  if (digitalRead(BOTAO_GRAVACAO) == LOW) {
    gravacao();                                  // Executa a função
    while (digitalRead(BOTAO_GRAVACAO) == LOW);  // Espera o botão ser solto
    delay(300);                                  // Debounce
  }
}

void leitura() {
  Serial.println("Modo leitura selecionado");  // Imprime no monitor serial

  // Aguarda uma tag ser aproximada do leitor
  while (!mfrc522.PICC_IsNewCardPresent()) {
    delay(100);
  }

  if (!mfrc522.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 obtem sucesso ao ler
  else {
    // Faz a autenticacao da tag usando a chave A
    mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, bloco, &chave, &(mfrc522.uid));

    // Le os dados da tag
    mfrc522.MIFARE_Read(bloco, buffer, &tamanho);

    Serial.print("------> ");  // Imprime no monitor serial

    // Faz a conversao dos dados lidos de Hexadecimal para texto
    for (byte i = 0; i < 16; i++) {
      if (buffer[i] != 0) {
        Serial.write(buffer[i]);
      }
    }

    Serial.println('\n');                                           // Pula uma linha no monitor serial
    Serial.print("Selecione um botão para leitura ou gravação: ");  // Imprime no monitor serial
    mfrc522.PCD_StopCrypto1();                                      // Pausa a criptografia
    mfrc522.PICC_HaltA();                                           // Coloca o leitor em standby, para aguardar uma nova tag a ser aproximada
  }
}

void gravacao() {
  Serial.println("Modo gravação selecionado");  // Imprime no monitor serial

  // Fica constantemente a procura de uma tag
  while (!mfrc522.PICC_IsNewCardPresent()) {
    delay(100);
  }

  if (!mfrc522.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");
    Serial.println("");
  }
  // Caso obtem sucesso ao ler
  else {
    // Faz a autenticacao da tag usando a chave A
    mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, bloco, &chave, &(mfrc522.uid));

    // Grava o texto no bloco definido da tag
    mfrc522.MIFARE_Write(bloco, texto, &tamanho);

    Serial.print("Dados gravados com sucesso!");                    // Imprime no monitor serial
    Serial.println('\n');                                           // Pula uma linha no monitor serial
    Serial.print("Selecione um botão para leitura ou gravação: ");  // Imprime no monitor serial
    mfrc522.PCD_StopCrypto1();                                      // Pausa a criptografia
    mfrc522.PICC_HaltA();                                           // Coloca o leitor em standby, para aguardar uma nova tag a ser 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. Então, criamos o objeto mfrc522 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 mfrc522(PINO_SDA, PINO_RST). Por fim, criamos uma instância de chave de acesso MFRC522::MIFARE_Key chamada chave que conterá as informações de autenticação para a tag.

#include <SPI.h>
#include <MFRC522.h>

const int PINO_RST = 9; //Define o pino RST
const int PINO_SDA = 10; //Define o pino SDA

MFRC522 mfrc522(PINO_SDA, PINO_RST);  //Criacao do objeto "mfrc522" com os pinos SDA e RST definidos
MFRC522::MIFARE_Key chave; //Cria uma instancia de chave de acesso que contera as informações da tag

Em seguida declaramos as variáveis que armazenam os pinos conectados aos botões, criamos quatro variáveis do tipo byte, que são: a variável bloco, que irá armazenar o valor que vai ser responsável por definir qual bloco da tag vai ser utilizado; a variável buffer, que é responsável por armazenar temporariamente o conteúdo lido da tag; a variável tamanho, que define o total de caracteres a serem lido ou gravados na tag; e a última variável texto, que define os dados que serão gravados na tag. O tamanho está definido como 18 bytes, porém é possível gravar apenas 16 bytes em cada bloco, os outros 2 bytes são utilizados como uma verificação "CRC", que é uma "verificação cíclica de redundância para detecção de mudança acidental em cadeias de dados".

const int BOTAO_GRAVACAO = 6; //Define o pino do botao de gravacao
const int BOTAO_LEITURA = 7; //Define o pino do botao de leitura

//Criacao das variaveis do tipo Byte
byte bloco = 4; //Define qual bloco da tag vai ser ultizado para a leitura ou gravacao
byte  buffer[18]; //Armazena temporariamente no programa o conteudo lido da tag
byte tamanho = 18; //Define o total de caracteres a serem lido ou gravados

//ALTERE PARA UM TEXTO DE SUA PREFERENCIA, RESPEITANDO O LIMITE MAXIMO DE 16 CARACTERES//
byte texto[16] = "ROBOCORE"; //Variavel do tipo Byte, responsavel por armazenar o texto que vai ser gravado na tag

Na função setup(), realizamos as configurações iniciais. Primeiro, definimos os pinos dos botões BOTAO_GRAVACAO e BOTAO_LEITURA como entrada e com resistor pull-up interno, o que elimina a necessidade de resistores externos. Em seguida, inicializamos a comunicação serial, a interface SPI e o módulo RFID.

Além disso, definimos a chave de autenticação das tags a serem lidas, com a chave padrão que vem de fábrica. A chave de autenticação padrão (chave A) é usada para acessar os blocos de memória da tag. Essa chave, composta por seis bytes, é necessária tanto para leitura quanto para gravação dos dados. Por fim, exibimos uma mensagem no monitor serial instruindo o usuário a pressionar um dos botões.

void setup() {
  pinMode(BOTAO_GRAVACAO, INPUT_PULLUP);//Define o botao "gravacao" como entrada e habilita o resistor da porta digital
  pinMode(BOTAO_LEITURA, INPUT_PULLUP);//Define o botao "leitura" como entrada e habilita o resistor da porta digital

  Serial.begin(9600); //Inicializacao do monitor serial
  SPI.begin(); //Inicializacao da comunicacao SPI
  mfrc522.PCD_Init(); //Inicializacao do leitor RFID

  //Prepara a chave de autenticacao da tag
  for (byte i = 0; i < 6; i++) {
    chave.keyByte[i] = 0xFF;
  }
  
  Serial.print("Selecione um botão para leitura ou gravação: "); //Imprime no monitor serial
}

No looping do programa, criamos duas condições que verificam se um dos botões foi pressionado. Com o comando if (digitalRead(BOTAO_LEITURA) == 0) verificamos se o botão de leitura é pressionado, e caso seja, chamamos a função leitura() . Já com o comando if (digitalRead(BOTAO_GRAVACAO) == 0), verificamos se o botão de gravação foi pressionado, e caso seja, chamamos a função gravacao(). Além disso, utilizamos a estrutura while após detectar o pressionamento de um botão para evitar leituras múltiplas e imprecisas. Esse processo é conhecido como tratamento de debounce por software.

void loop() {
  // Se o botao de leitura foi pressionado
  if (digitalRead(BOTAO_LEITURA) == LOW) {
    leitura();
    while (digitalRead(BOTAO_LEITURA) == LOW);  // Espera o botão ser solto
    delay(300);                                 // Debounce
  }

  // Se o botao de gravacao foi pressionado
  if (digitalRead(BOTAO_GRAVACAO) == LOW) {
    gravacao();                                  // Executa a função
    while (digitalRead(BOTAO_GRAVACAO) == LOW);  // Espera o botão ser solto
    delay(300);                                  // Debounce
  }
}

Na função leitura(), exibimos uma mensagem no serial monitor indicando que o modo leitura foi selecionado. Feito isso, com a condição while (!mfrc522.PICC_IsNewCardPresent()), mantemos o código à procura de uma tag constantemente. Caso encontre, a leitura é verificada através da condição if (!mfrc522.PICC_ReadCardSerial()). Se o leitor não conseguir realizar a leitura de todos os bytes da tag, será exibida uma mensagem de erro no monitor serial e o código voltará para a repetição principal.

Serial.println("Modo leitura selecionado"); //Imprime no monitor serial

//Fica constantemente a procura de uma tag
while (!mfrc522.PICC_IsNewCardPresent()) {
  delay(100);
}

if (!mfrc522.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, usamos o comando else, e fazemos a autenticação da tag utilizando a chave A. Logo em seguida lemos os dados contidos no bloco 4 da tag pelo comando status = mfrc522.MIFARE_Read(block, buffer, &tamanho). Após ler os dados, convertemos de hexadecimal para texto e exibimos no monitor serial.

else {
  // Faz a autenticacao da tag usando a chave A
  mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, bloco,&chave, &(mfrc522.uid));

  // Le os dados da tag
  mfrc522.MIFARE_Read(bloco, buffer, &tamanho);

  Serial.print("------> ");  // Imprime no monitor serial

  // Faz a conversao dos dados lidos de Hexadecimal para texto
  for (byte i = 0; i < 16; i++) {
    if (buffer[i] != 0) {
      Serial.write(buffer[i]);
    }
  }

  // continua...
}

Em seguida, após exibir os dados lidos no monitor serial, pulamos uma linha e exibimos a mensagem inicial para que possa ser pressionado um botão para fazer a leitura ou gravação de uma nova tag novamente, pausamos a criptografia do leitor e colocamos o leitor em standby, para aguardar uma tag a ser aproximada.

Serial.println('\n'); //Pula uma linha no monitor serial
Serial.print("Selecione um botão para leitura ou gravação: "); //Imprime no monitor serial
mfrc522.PCD_StopCrypto1(); //Pausa a criptografia
mfrc522.PICC_HaltA(); //Desliga o leitor, colocando em standby, para aguardar uma nova tag aproximada

Já na função gravaçao(), a procura de uma tag e a validação da mesma é feita de maneira igual à de leitura. Após ler todos os dados da tag com sucesso, autenticamos a tag usando a chave A, e logo em seguida gravamos o texto que estava armazenado na variável texto, no bloco 4 da tag.

//Faz a autenticacao da tag usando a chave A
mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, bloco, &chave, &(mfrc522.uid));
//Grava o conteudo contido da variavel "texto" na tag
mfrc522.MIFARE_Write(bloco, texto, &tamanho);

Após gravar com sucesso, exibimos a mensagem de gravação com sucesso, pausamos a criptografia do leitor e colocamos o leitor em standby, para aguardar uma tag a ser aproximada.

Serial.print("Dados gravados com sucesso!"); //Imprime no monitor serial
Serial.println('\n'); //Pula uma linha no monitor serial
Serial.print("Selecione um botão para leitura ou gravação: "); //Imprime no monitor serial
mfrc522.PCD_StopCrypto1(); //Pausa a criptografia
mfrc522.PICC_HaltA(); //Desliga o leitor, colocando em standby, para aguardar uma nova tag aproximada

O que deve acontecer

Após carregar o código na placa e montar o circuito, abra o Monitor Serial (9600 bps). Pressione o botão de gravação, aproxime a tag do leitor e aguarde a mensagem de sucesso.

Para conferir o conteúdo gravado, pressione o botão de leitura e aproxime a mesma tag: os dados aparecerão no serial. Caso deseje gravar uma informação de sua preferência, edite o conteúdo da variável texto, e digite o que deseja. Lembrando que o cartão consegue armazenar apenas 16 caracteres.

Indo além

Agora que você sabe como ler e gravar dados em tags RFID, por que não criar um sistema de controle de acesso ou um simulador de créditos? Por exemplo, um sistema onde, ao detectar uma tag com saldo suficiente, um relé é acionado e o saldo é descontado, ideal para catracas, vending machines ou sistemas de bilhetagem.

Conclusão

Neste tutorial, você aprendeu como utilizar o módulo MFRC522 com Arduino para ler e gravar informações em tags RFID. Este é o primeiro passo para desenvolver projetos mais avançados com RFID no mundo maker.