A tecnologia RFID (Radio Frequency Identification) está presente em diversos sistemas modernos de identificação e controle de acesso. Cartões, chaveiros e tags RFID podem ser utilizados para identificar pessoas e autorizar ou bloquear o acesso a determinados ambientes.

Neste projeto, vamos mostrar como criar um controle de acesso utilizando Arduino e o módulo RFID RC522, permitindo reconhecer cartões autorizados e indicar se o acesso foi liberado ou negado.

O projeto é uma excelente introdução à automação, Internet das Coisas (IoT), sistemas de segurança e eletrônica embarcada.

Projeto em vídeo: Arduino com RFID: RFID controle de acesso completo com Arduino

O que é RFID?

RFID é uma tecnologia que permite identificar objetos ou pessoas utilizando comunicação por radiofrequência, sem a necessidade de contato físico direto entre o cartão e o leitor.

Em projetos com Arduino, um dos módulos mais populares é o MFRC522/RC522, normalmente utilizado com cartões e chaveiros MIFARE de 13,56 MHz. O leitor utiliza comunicação SPI para conversar com o Arduino.

Quando aproximamos uma tag do leitor, o Arduino consegue obter informações da tag, incluindo seu UID (Unique Identifier). Esse identificador pode então ser comparado com uma lista de cartões autorizados.

O funcionamento básico é:

Cartão RFID → Leitor RC522 → Arduino → Verificação do UID → Acesso permitido ou negado

O que vamos construir?

Neste projeto, o Arduino será responsável por:

Ler cartões e tags RFID;
Identificar o UID do cartão;
Comparar o UID com cartões autorizados;
Acender um LED verde quando o acesso for permitido;
Acender um LED vermelho quando o acesso for negado;
Emitir um aviso sonoro através de um buzzer;
Exibir informações no Monitor Serial.

O mesmo conceito pode posteriormente ser utilizado para acionar uma fechadura elétrica, relé, servo motor, cancela ou outro dispositivo.

Materiais necessários

Para montar o projeto básico, você precisará de:

1 Arduino Uno;
1 módulo RFID RC522;
1 cartão RFID;
1 chaveiro/tag RFID;
1 LED verde;
1 LED vermelho;
2 resistores de 220 Ω ou 330 Ω;
1 buzzer;
Protoboard;
Jumpers;
Cabo USB.

O RC522 trabalha com alimentação de 3,3 V, portanto é importante prestar atenção à tensão utilizada no módulo.

Ligando o RFID RC522 ao Arduino Uno

A comunicação entre o RC522 e o Arduino Uno utiliza a interface SPI.

Uma configuração bastante utilizada é:

RC522	Arduino Uno
SDA/SS	D10
SCK	D13
MOSI	D11
MISO	D12
RST	D9
GND	GND
3.3V	3.3V
IRQ	Não conectado

Essa configuração é utilizada em diversos projetos com o RC522 e a biblioteca MFRC522.

Atenção à alimentação

Um dos erros mais comuns em projetos com o RC522 é conectar sua alimentação diretamente aos 5 V do Arduino.

Para o módulo RC522 utilizado neste projeto, utilize:

RC522 3.3V → Arduino 3.3V

Também confira a documentação do seu módulo específico antes de realizar a montagem, pois versões e placas diferentes podem apresentar características distintas.

Ligando os LEDs

Podemos utilizar dois LEDs para informar visualmente o resultado da leitura.

LED verde

Arduino D6
   |
Resistor 330 Ω
   |
LED verde
   |
GND

LED vermelho

Arduino D7
   |
Resistor 330 Ω
   |
LED vermelho
   |
GND

O LED verde será utilizado para indicar:

ACESSO LIBERADO

Enquanto o LED vermelho indicará:

ACESSO NEGADO

Ligando o buzzer

O buzzer pode ser conectado ao pino digital D8.

Arduino D8 → Buzzer → GND

Podemos utilizar sons diferentes para cada situação:

Um beep para cartão autorizado;
Dois ou mais beeps para cartão não autorizado.

Instalando a biblioteca MFRC522

Para que o Arduino consiga conversar com o leitor RC522, precisamos instalar uma biblioteca específica.

Na Arduino IDE, abra:

Sketch → Incluir Biblioteca → Gerenciar Bibliotecas

Pesquise por:

MFRC522

e instale uma biblioteca compatível com o seu módulo.

A biblioteca MFRC522 simplifica a comunicação entre o Arduino e o leitor RFID.

Depois da instalação, reinicie a IDE se necessário.

Primeiro passo: descobrir o UID do cartão

Antes de criar o controle de acesso, precisamos descobrir o UID dos cartões que serão utilizados.

O UID é o identificador que será utilizado pelo programa para decidir se determinada tag possui autorização.

Uma forma simples de fazer isso é utilizar um exemplo da própria biblioteca, como o DumpInfo, e observar o resultado no Monitor Serial.

Por exemplo, podemos obter algo semelhante a:

UID do cartão: 20 C3 93 5E

Anote esse valor.

Depois aproxime outro cartão:

UID do cartão: 83 4A 91 27

Esses valores serão utilizados posteriormente no programa.

Código completo do controle de acesso

Depois de descobrir os UIDs dos cartões, podemos criar o sistema de autorização.

O exemplo abaixo utiliza dois cartões autorizados.

Substitua os valores de UID_AUTORIZADO_1 e UID_AUTORIZADO_2 pelos UIDs dos seus próprios cartões.

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

#define SS_PIN 10
#define RST_PIN 9

#define LED_VERDE 6
#define LED_VERMELHO 7
#define BUZZER 8

MFRC522 rfid(SS_PIN, RST_PIN);

// UIDs autorizados
byte UID_AUTORIZADO_1[] = {
  0x20, 0xC3, 0x93, 0x5E
};

byte UID_AUTORIZADO_2[] = {
  0x83, 0x4A, 0x91, 0x27
};

void setup() {

  Serial.begin(9600);

  SPI.begin();
  rfid.PCD_Init();

  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_VERMELHO, OUTPUT);
  pinMode(BUZZER, OUTPUT);

  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_VERMELHO, LOW);

  Serial.println("================================");
  Serial.println("   CONTROLE DE ACESSO RFID");
  Serial.println("================================");
  Serial.println();
  Serial.println("Aproxime seu cartao RFID...");
}

void loop() {

  // Verifica se existe um novo cartão
  if (!rfid.PICC_IsNewCardPresent()) {
    return;
  }

  // Tenta realizar a leitura
  if (!rfid.PICC_ReadCardSerial()) {
    return;
  }

  Serial.print("UID detectado: ");

  for (byte i = 0; i < rfid.uid.size; i++) {

    if (rfid.uid.uidByte[i] < 0x10) {
      Serial.print("0");
    }

    Serial.print(rfid.uid.uidByte[i], HEX);
    Serial.print(" ");
  }

  Serial.println();

  if (cartaoAutorizado()) {

    Serial.println(">>> ACESSO LIBERADO <<<");

    digitalWrite(LED_VERDE, HIGH);

    tone(BUZZER, 2000);
    delay(200);
    noTone(BUZZER);

    delay(2000);

    digitalWrite(LED_VERDE, LOW);

  } else {

    Serial.println(">>> ACESSO NEGADO <<<");

    digitalWrite(LED_VERMELHO, HIGH);

    tone(BUZZER, 500);
    delay(500);
    noTone(BUZZER);

    delay(2000);

    digitalWrite(LED_VERMELHO, LOW);
  }

  // Finaliza a comunicação com o cartão
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();

  delay(500);
}


// Verifica se o cartão está autorizado
bool cartaoAutorizado() {

  if (rfid.uid.size != 4) {
    return false;
  }

  bool cartao1 = true;
  bool cartao2 = true;

  for (byte i = 0; i < 4; i++) {

    if (rfid.uid.uidByte[i] != UID_AUTORIZADO_1[i]) {
      cartao1 = false;
    }

    if (rfid.uid.uidByte[i] != UID_AUTORIZADO_2[i]) {
      cartao2 = false;
    }
  }

  return cartao1 || cartao2;
}

Como o programa funciona?

O funcionamento pode ser dividido em algumas etapas.

1. Inicialização

No setup() o Arduino inicializa:

SPI.begin();
rfid.PCD_Init();

A primeira instrução inicializa a comunicação SPI, enquanto a segunda inicializa o módulo RC522.

2. Aguardando um cartão

No loop(), o Arduino verifica continuamente se existe uma nova tag:

if (!rfid.PICC_IsNewCardPresent()) {
    return;
}

Caso nenhum cartão esteja presente, o programa continua aguardando.

3. Leitura do cartão

Quando uma tag é detectada, o Arduino executa:

rfid.PICC_ReadCardSerial();

O UID fica disponível através de:

rfid.uid.uidByte

O programa então mostra o UID no Monitor Serial.

4. Comparação do UID

A função:

cartaoAutorizado()

compara o UID recebido com os UIDs cadastrados no programa.

Se houver correspondência:

ACESSO LIBERADO

Caso contrário:

ACESSO NEGADO

Essa é a parte fundamental do sistema de controle de acesso.

Projetos semelhantes utilizam justamente a comparação do UID para determinar se uma tag está autorizada.

Transformando o projeto em uma fechadura eletrônica

Até agora o projeto apenas indica o resultado através de LEDs e buzzer.

Mas podemos transformar esse protótipo em um sistema de acesso real.

Por exemplo:

        CARTÃO RFID
             ↓
          RC522
             ↓
          ARDUINO
             ↓
      ┌──────┴──────┐
      ↓             ↓
   AUTORIZADO     NEGADO
      ↓             ↓
   RELÉ          LED VERMELHO
      ↓
FECHADURA

Quando um cartão autorizado for aproximado, o Arduino poderá acionar um relé.

O relé poderá controlar, por exemplo:

Fechadura elétrica;
Eletroímã;
Solenoide;
Cancela;
Porta automática;
Motor;
Sistema de alarme.

Outra possibilidade é utilizar um servo motor, algo bastante comum em protótipos de controle de acesso com Arduino.

Exemplo de funcionamento com servo motor

Imagine uma pequena cancela:

Cartão autorizado
       ↓
     RC522
       ↓
    Arduino
       ↓
 Servo motor
       ↓
Cancela aberta

O Arduino poderia movimentar o servo para 90 graus:

servo.write(90);

aguardar alguns segundos e depois retornar à posição inicial:

servo.write(0);

Dessa maneira podemos criar uma pequena cancela automática para projetos escolares, protótipos e sistemas de demonstração.

Podemos cadastrar vários cartões?

Sim.

Uma implementação simples pode armazenar vários UIDs no código:

byte cartao1[] = {0x20, 0xC3, 0x93, 0x5E};
byte cartao2[] = {0x83, 0x4A, 0x91, 0x27};
byte cartao3[] = {0x12, 0x34, 0x56, 0x78};

Porém, para um projeto maior, não é interessante precisar alterar o código toda vez que uma pessoa nova for cadastrada.

Uma solução melhor é utilizar a EEPROM do Arduino para armazenar os cartões cadastrados. Há projetos que utilizam justamente EEPROM para permitir cadastrar e remover cartões sem precisar recompilar o programa.

Controle de acesso com cadastro de usuários

Uma evolução interessante seria criar um botão de cadastro.

O funcionamento poderia ser:

Pressiona botão CADASTRAR
          ↓
Aproxima cartão
          ↓
Arduino lê UID
          ↓
UID é armazenado
          ↓
Cartão passa a ter acesso

Também podemos criar uma função para remover cartões:

Modo administrador
       ↓
Aproxima cartão
       ↓
Cartão já cadastrado?
       ↓
SIM → Remove autorização

Isso transforma o simples projeto de demonstração em um sistema muito mais próximo de um controle de acesso real.

Display LCD ou OLED

Outra melhoria interessante é adicionar um display.

Em vez de utilizar apenas o Monitor Serial, poderíamos apresentar:

CONTROLE DE ACESSO

Aproxime seu
cartao RFID

Quando o cartão for reconhecido:

ACESSO LIBERADO

Bem-vindo!

E para um cartão desconhecido:

ACESSO NEGADO

Cartao invalido

Displays LCD 16×2 e OLED I2C são opções comuns para esse tipo de projeto.

RFID + Arduino + Internet

O projeto também pode ser levado para um nível muito mais avançado.

Em vez de manter os cartões cadastrados apenas no Arduino, podemos utilizar uma placa com conectividade, como um ESP32, e enviar cada acesso para um servidor.

Por exemplo:

       CARTÃO
          ↓
        RC522
          ↓
        ESP32
          ↓
       Wi-Fi
          ↓
      SERVIDOR
          ↓
      BANCO SQL

Assim poderíamos registrar:

Data	Hora	UID	Usuário	Resultado
24/08/2026	08:01	20C3935E	João	Liberado
24/08/2026	08:15	83A49127	Maria	Liberado
24/08/2026	08:23	11223344	Desconhecido	Negado

Isso abre possibilidades para criar um verdadeiro sistema de controle de acesso conectado.

Aplicações práticas

Um sistema baseado em Arduino e RFID pode ser utilizado como base para diversos projetos:

🏢 Controle de acesso

Autorizar funcionários a entrar em determinadas áreas.

🚪 Fechadura eletrônica

Liberar uma porta mediante cartão autorizado.

🅿️ Controle de estacionamento

Utilizar cartões ou tags para identificar veículos e usuários.

🏫 Controle escolar

Registrar entradas e saídas de alunos.

🧰 Controle de equipamentos

Permitir que somente pessoas autorizadas utilizem determinado equipamento.

🏭 Automação industrial

Identificar operadores antes de permitir determinadas operações.

🖥️ Controle de computadores

Utilizar uma tag RFID como mecanismo de identificação para liberar uma estação.

🏠 Automação residencial

Integrar RFID a fechaduras, portões e sistemas de automação.

RFID é realmente seguro?

É importante fazer uma distinção.

Um projeto baseado simplesmente na comparação do UID é excelente para aprendizado, prototipagem e automação simples, mas não deve ser considerado automaticamente um sistema de segurança de alto nível.

O UID não deve ser tratado como uma senha secreta.

Para aplicações profissionais, é necessário avaliar a tecnologia específica do cartão, autenticação, criptografia, controle da fechadura, proteção contra clonagem e demais requisitos de segurança.

Por isso, um protótipo Arduino com RC522 é excelente para aprender os conceitos, mas sistemas comerciais de controle de acesso devem utilizar componentes e protocolos adequados ao nível de segurança necessário.

Conclusão

O Arduino + RFID RC522 é uma excelente combinação para aprender como funcionam sistemas de identificação e controle de acesso.

Com poucos componentes podemos construir um sistema capaz de:

Ler → Identificar → Autorizar → Acionar

E o mais interessante é que esse projeto pode evoluir bastante.

Começamos com:

Arduino + RC522 + LED

Depois podemos adicionar:

Buzzer → Servo → Relé → Fechadura → Display → EEPROM

E finalmente podemos transformar o projeto em um sistema conectado:

RFID + ESP32 + Wi-Fi + Banco de Dados + Dashboard

Esse é justamente um dos pontos fortes do Arduino: um projeto simples pode servir como base para sistemas cada vez mais completos de automação e IoT.

🎥 Veja o projeto em funcionamento

Confira o vídeo “Arduino com RFID: RFID controle de acesso completo com Arduino” para acompanhar a demonstração prática do projeto:

Próximo projeto: uma evolução muito interessante seria criar um controle de acesso RFID com Arduino + servo motor + LCD + cadastro de cartões na EEPROM, permitindo cadastrar e remover usuários sem precisar alterar o código.