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 Cabos

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 "MFRC522v2" 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.

Código

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 (v2.0)

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

  Copyright 2026 RoboCore.
  Escrito por Carlos Daniel (09/02/2026).

  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>

// RFID_MFRC522v2
#include <MFRC522v2.h>
#include <MFRC522DriverSPI.h>
#include <MFRC522DriverPinSimple.h>

const int PINO_SDA = 10;  // SS / SDA (Chip Select) do RC522

// Cria o driver para o pino de selecao (SS/CS)
// e outro driver para a comunicacao SPI e entao cria o objeto MFRC522
MFRC522DriverPinSimple ssPin(PINO_SDA);
MFRC522DriverSPI driver(ssPin, SPI);
MFRC522 mfrc522(driver);

// Cria uma instancia de chave que sera usada para acessar a tag
MFRC522::MIFARE_Key chave;

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 utilizado 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 lidos 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

// Autenticacao Key A (MIFARE Classic)
const byte AUTH_KEY_A = 0x60;

// Variaveis para repetirmos a deteccao/leitura para uma melhor precisao
const byte MAX_TENTATIVAS = 25;
const unsigned long TIMEOUT_MS = 8000;
const unsigned long PAUSA_MS = 15;

// Estados das operacoes
bool tagSelecionada = false;
bool autenticado = false;
bool leituraOK = false;
bool gravacaoOK = false;

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

  // Chave padrao (FF FF FF FF FF FF)
  for (byte i = 0; i < 6; i++) {
    chave.keyByte[i] = 0xFF;
  }

  Serial.print("Selecione um botao para leitura ou gravacao: ");  // 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
  }
}

// Funcao para detectar e selecionar a TAG, autenticar o bloco e ler os 16 bytes do bloco para imprimir o texto
void leitura() {
  Serial.println("\nModo leitura selecionado");  // Imprime no monitor serial

  esperarTagESelecionar();
  if (!tagSelecionada) {
    Serial.println("Nenhuma TAG detectada (timeout ou leitura instavel).");
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  autenticarBloco();
  if (!autenticado) {
    Serial.println("Falha na autenticacao (comunicacao instavel).");
    finalizaOperacao();
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  byte dados[16];
  lerBloco16(dados);

  if (!leituraOK) {
    Serial.println("Falha na leitura do bloco (comunicacao instavel).");
    finalizaOperacao();
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  Serial.print("------> ");

  // Mostra os bytes gravados como texto (caracteres ASCII) no Monitor Serial
  for (byte i = 0; i < 16; i++) {
    if (dados[i] != 0) {
      Serial.write(dados[i]);
    }
  }

  Serial.println("\n");
  Serial.print("Selecione um botao para leitura ou gravacao: ");

  finalizaOperacao();
}

// Funcao para detectar e selecionar a TAG, gravar o texto no bloco da TAG e confirmar se foi gravado com sucesso
void gravacao() {
  Serial.println("\nModo gravacao selecionado");  // Imprime no monitor serial

  esperarTagESelecionar();
  if (!tagSelecionada) {
    Serial.println("Nenhuma TAG detectada (timeout ou leitura instavel).");
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  // Para confirmar a gravacao, lemos o mesmo bloco novamente e comparamos byte a byte.
  gravarBloco16Verificado(texto);

  if (gravacaoOK) {
    Serial.println("Dados gravados com sucesso!");
  } else {
    Serial.println("Falha ao confirmar a gravacao. Tente novamente.");
  }

  Serial.println();
  Serial.print("Selecione um botao para leitura ou gravacao: ");

  finalizaOperacao();
}

void limpaEstado() {
  mfrc522.PCD_StopCrypto1();
  delay(5);
}

void finalizaOperacao() {
  mfrc522.PCD_StopCrypto1();
  mfrc522.PICC_HaltA();
  delay(5);
}

// Confirmar se o que foi lido e igual ao que foi gravado.
bool igual16(const byte a[16], const byte b[16]) {
  for (byte i = 0; i < 16; i++) {
    if (a[i] != b[i]) {
      return false;
    }
  }
  return true;
}

// Detecao + selecao de TAG
void esperarTagESelecionar() {
  tagSelecionada = false;
  unsigned long inicio = millis();

  while (millis() - inicio < TIMEOUT_MS) {
    for (byte t = 0; t < MAX_TENTATIVAS; t++) {

      byte atqa[2];
      byte atqaSize = sizeof(atqa);

      bool detectou =
        mfrc522.PICC_IsNewCardPresent() || (mfrc522.PICC_RequestA(atqa, &atqaSize) == 0) || (mfrc522.PICC_WakeupA(atqa, &atqaSize) == 0);

      // Se detectou, tenta selecionar (ler UID)
      if (detectou && mfrc522.PICC_ReadCardSerial()) {
        tagSelecionada = true;
        return;
      }

      limpaEstado();
      delay(PAUSA_MS);
    }
    delay(20);
  }
}

// Autenticacao do bloco da TAG (com repeticoes)
void autenticarBloco() {
  autenticado = false;

  for (byte t = 0; t < MAX_TENTATIVAS; t++) {

    // Retorno 0 significa sucesso (OK)
    byte status = mfrc522.PCD_Authenticate(AUTH_KEY_A, bloco, &chave, &(mfrc522.uid));
    if (status == 0) {
      autenticado = true;
      return;
    }

    limpaEstado();
    delay(PAUSA_MS);

    esperarTagESelecionar();
    if (!tagSelecionada) {
      return;
    }
  }
}

// Leitura de 16 bytes do bloco
void lerBloco16(byte saida[16]) {
  leituraOK = false;

  for (byte t = 0; t < MAX_TENTATIVAS; t++) {

    tamanho = 18;
    byte status = mfrc522.MIFARE_Read(bloco, buffer, &tamanho);

    // Retorno 0 significa sucesso (OK)
    if (status == 0) {
      for (byte i = 0; i < 16; i++) {
        saida[i] = buffer[i];
      }
      leituraOK = true;
      return;
    }

    limpaEstado();
    delay(PAUSA_MS);

    esperarTagESelecionar();
    if (!tagSelecionada) {
      return;
    }

    autenticarBloco();
    if (!autenticado) {
      return;
    }
  }
}

// Grava e depois le o mesmo bloco e compara 16 bytes
void gravarBloco16Verificado(const byte entrada[16]) {
  gravacaoOK = false;

  for (byte t = 0; t < MAX_TENTATIVAS; t++) {

    autenticarBloco();
    if (!autenticado) {
      limpaEstado();
      delay(PAUSA_MS);

      esperarTagESelecionar();
      if (!tagSelecionada) {
        return;
      }

      continue;
    }

    // Grava 16 bytes
    mfrc522.MIFARE_Write(bloco, (byte*)entrada, 16);

    // Confirma lendo e comparando byte a byte
    byte ver[16];
    lerBloco16(ver);

    if (leituraOK && igual16(ver, entrada)) {
      gravacaoOK = true;
      return;
    }

    limpaEstado();
    delay(PAUSA_MS);

    esperarTagESelecionar();
    if (!tagSelecionada) {
      return;
    }
  }
}

Entendendo o Código

Primeiramente, incluímos a biblioteca de comunicação SPI e as bibliotecas MFRC522v2. E então criamos o objeto mfrc522, que será responsável por inicializar o leitor e realizar as operações na tag. Por fim, criamos uma instância de chave MFRC522::MIFARE_Key chamada chave, usada para autenticar a tag antes de ler ou gravar um bloco.

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

// RFID_MFRC522v2
#include <MFRC522v2.h>
#include <MFRC522DriverSPI.h>
#include <MFRC522DriverPinSimple.h>

const int PINO_SDA = 10;  // SS / SDA (Chip Select) do RC522

// Cria o driver para o pino de selecao (SS/CS)
// e outro driver para a comunicacao SPI e entao cria o objeto MFRC522
MFRC522DriverPinSimple ssPin(PINO_SDA);
MFRC522DriverSPI driver(ssPin, SPI);
MFRC522 mfrc522(driver);

// Cria uma instancia de chave que sera usada para acessar a tag
MFRC522::MIFARE_Key chave;

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 lidos 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 utilizado 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 lidos 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

// Autenticacao Key A (MIFARE Classic)
const byte AUTH_KEY_A = 0x60;

// Variaveis para repetirmos a deteccao/leitura para uma melhor precisao
const byte MAX_TENTATIVAS = 25;
const unsigned long TIMEOUT_MS = 8000;
const unsigned long PAUSA_MS = 15;

// Estados das operacoes
bool tagSelecionada = false;
bool autenticado = false;
bool leituraOK = false;
bool gravacaoOK = false;

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 Monitor Serial indicando que o modo leitura foi selecionado. Em seguida, chamamos a função esperarTagESelecionar(), que tenta detectar e selecionar uma tag (ler o UID) por um tempo limitado. Esse processo é repetido algumas vezes para aumentar a confiabilidade, pois dependendo da distância, posição da tag ou interferência, a leitura pode falhar mesmo com a tag próxima.

Se uma tag for detectada, o próximo passo é autenticar o bloco de memória que será acessado. Para isso, usamos a função autenticarBloco(), que realiza a autenticação do bloco definido na variável bloco utilizando a chave A (armazenada na variável chave). A autenticação é necessária nas tags MIFARE Classic antes de permitir a leitura ou gravação de dados.

Após autenticar com sucesso, chamamos a função lerBloco16() para ler os 16 bytes do bloco selecionado e armazená-los em um vetor de bytes. Por fim, percorremos esses 16 bytes e os exibimos no Monitor Serial como texto (caracteres ASCII). Ao terminar, chamamos finalizaOperacao() para encerrar a comunicação com a tag e deixar o leitor pronto para a próxima leitura.

// Funcao para detectar e selecionar a TAG, autenticar o bloco e ler os 16 bytes do bloco para imprimir o texto
void leitura() {
  Serial.println("\nModo leitura selecionado");  // Imprime no monitor serial

  esperarTagESelecionar();
  if (!tagSelecionada) {
    Serial.println("Nenhuma TAG detectada (timeout ou leitura instavel).");
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  autenticarBloco();
  if (!autenticado) {
    Serial.println("Falha na autenticacao (comunicacao instavel).");
    finalizaOperacao();
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  byte dados[16];
  lerBloco16(dados);

  if (!leituraOK) {
    Serial.println("Falha na leitura do bloco (comunicacao instavel).");
    finalizaOperacao();
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  Serial.print("------> ");

  // Mostra os bytes gravados como texto (caracteres ASCII) no Monitor Serial
  for (byte i = 0; i < 16; i++) {
    if (dados[i] != 0) {
      Serial.write(dados[i]);
    }
  }

  Serial.println("\n");
  Serial.print("Selecione um botao para leitura ou gravacao: ");

  finalizaOperacao();
}

Na função gravacao(), o processo inicial é o mesmo da leitura: o programa tenta detectar e selecionar uma tag RFID chamando a função esperarTagESelecionar(). Caso nenhuma tag seja detectada dentro do tempo limite, uma mensagem de erro é exibida no Monitor Serial e a operação é encerrada.

Com a tag selecionada, chamamos a função gravarBloco16Verificado(texto). Essa função é responsável por autenticar o bloco de memória definido na variável bloco utilizando a chave A, gravar os 16 bytes contidos na variável texto e, em seguida, realizar uma nova leitura do mesmo bloco para comparar byte a byte os dados gravados. Dessa forma, garantimos que a gravação foi concluída corretamente.

Por fim, de acordo com o resultado da verificação, o código exibe no Monitor Serial a mensagem de sucesso ou falha. Independentemente do resultado, chamamos a função finalizaOperacao(), que encerra a criptografia e coloca a tag em modo de espera, deixando o leitor pronto para uma nova operação.

void gravacao() {
  Serial.println("\nModo gravacao selecionado");  // Imprime no monitor serial

  esperarTagESelecionar();
  if (!tagSelecionada) {
    Serial.println("Nenhuma TAG detectada (timeout ou leitura instavel).");
    Serial.print("Selecione um botao para leitura ou gravacao: ");
    return;
  }

  // Para confirmar a gravacao, lemos o mesmo bloco novamente e comparamos byte a byte.
  gravarBloco16Verificado(texto);

  if (gravacaoOK) {
    Serial.println("Dados gravados com sucesso!");
  } else {
    Serial.println("Falha ao confirmar a gravacao. Tente novamente.");
  }

  Serial.println();
  Serial.print("Selecione um botao para leitura ou gravacao: ");

  finalizaOperacao();
}

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 cada bloco do cartão consegue armazenar até 16 caracteres (16 bytes).

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.