Automação Residencial

Controle de Acesso RFID via Celular

Eletrogate 7 de novembro de 2023

Introdução

Já imaginou ter o controle total do acesso a qualquer ambiente na palma da sua mão? Neste post, você vai descobrir como transformar esse cenário em realidade, usando a combinação do Arduino e tecnologia RFID, além de conhecer uma plataforma que possibilita desenvolver um aplicativo de forma simples e rápida, o MIT App Inventor.


Sobre o Projeto

Este projeto consiste em uma integração entre tecnologia RFID e aplicativos móveis, para criar um sistema de controle de acesso inovador e com diversas aplicações. Entre as funções do projeto:

  • Reconhecimento de Tags RFID: O módulo MFRC-522 possibilita a leitura de informações das tags RFID, nas quais possuem caráter único e dessa forma atuam como chaves eletrônicas para o acesso a um determinado espaço.
  • Conexão Bluetooth e Aplicativo: Uma das características principais deste projeto é a integração com um aplicativo móvel via conexão Bluetooth. O aplicativo, desenvolvido usando o MIT App Inventor, permite ao usuário autorizar ou negar o acesso de cada cartão RFID. Quando um cartão é lido, as informações são comparadas com os dados antes enviados por bluetooth, para analisar se o cartão está na base de tags autorizadas ou não.
  • Controle da Trava da Porta: Se o cartão RFID for autorizado pelo aplicativo, o sistema aciona um Relé. Esse Relé, por sua vez, controla a trava da porta ou outro mecanismo. Quando o acesso é concedido, a trava é liberada, permitindo que a porta seja aberta. Se o acesso for negado, a porta permanece trancada.
  • Display LCD: Para fornecer informações sobre a leitura da TAG ao usuário, um display LCD é incorporado ao sistema. Ele exibe mensagens, como “Cartão não autorizado” quando um cartão não autorizado é lido, ou “Acesso Autorizado” quando o acesso é concedido. Isso garante uma experiência de usuário eficiente e informativa.

De modo geral, este projeto combina a sofisticação da tecnologia RFID com a conveniência da conectividade Bluetooth por meio de um aplicativo móvel. E como resultado, um sistema de controle de acesso personalizável e seguro, que pode ser inserido em várias aplicações, desde o controle de acesso residencial até o gerenciamento de segurança em escritórios e empresas.


MIT App Inventor

O MIT App Inventor é uma plataforma de desenvolvimento de aplicativos móveis que torna a criação de aplicativos para dispositivos Android acessível a pessoas de todas as idades e níveis de habilidade. Desenvolvido pelo Instituto de Tecnologia de Massachusetts (MIT), o App Inventor foi lançado com o objetivo de democratizar o desenvolvimento de aplicativos e permitir que qualquer pessoa transforme suas ideias em aplicativos funcionais.

Uma das principais vantagens notáveis dessa plataforma é a sua capacidade de simplificar consideravelmente a criação de aplicativos. Todo o processo é eficiente e a interface é altamente intuitiva, facilitando a criação.


Criando o Aplicativo

Primeiramente acesse a plataforma MIT App inventor e crie uma conta de acesso para a plataforma. Em seguida importe o projeto (APP simplificado) que serve como uma base para você adicionar demais funções.

Importando o projeto:

    1. Baixe o arquivo disponibilizado.
    2. Abra a plataforma MIT App inventor e na área “meus projetos” clique em “projetos”.
    3. Ao abrir todas as opções selecione “importar projeto (.aia) do meu computador.

Ao selecionar o arquivo o projeto será aberto automaticamente:

  1. Paleta: Nesta seção, você terá acesso a todos os componentes disponíveis que podem ser incorporados ao seu aplicativo.
  2. Componentes: Aqui você encontrará uma lista de todos os componentes que foram adicionados ao seu projeto. É o lugar onde você pode selecionar componentes específicos e personalizar suas configurações conforme necessário.
  3. Blocos: Nesta área, você terá acesso ao código do programa, onde você define as ações realizadas por cada interação do seu aplicativo. É o local onde você define o comportamento e a lógica do seu aplicativo.
  4. Compilar: Nesta área, você consegue exportar seu aplicativo.

Explicando a lógica do programa:


Esquema de Montagem

Existem duas formas para realizar a conexão do projeto:

Alimentação da Arduino nano via cabo mini USB:

Alimentação do Arduino via Fonte externa:

Pode ser necessário substituir o resistor de 1000 ohms para obter uma imagem mais clara do Display LCD.


Código

O código a seguir é utilizado junto com o aplicativo disponibilizado acima, em conjunto eles realizam as seguintes funções:

  • Reseta todas as TAGs armazenadas.
  • Adiciona novas TAGs.
  • Compara se a TAG já foi adicionada.
  • Aciona a trava, caso encontre uma TAG autorizada.

Baixe a pasta “RFID_ELETROGATE_porRafaelFaleiros” neste link: https://github.com/eletrogate/rfid_celular/tree/main

Vamos analisar o código em partes:

#include <SPI.h>
#include <MFRC522.h>
#include <EEPROM.h>
#include <SoftwareSerial.h>
#include <LiquidCrystal.h>

#define EEPROM_SIZE 1000 // Escolha o tamanho da EEPROM que deseja usar

#define trava 8 // define pino para trava solenoide da porta
#define ledVerde A5 // define o pino em que está conectado o terminal referente a cor verde do LED RGB
#define ledVermelho A1 // define o pino em que está conectado o terminal referente a cor vermelha do LED RGB
#define ledAzul A2 // define o pino em que está conectado o terminal referente a cor verde do LED RGB
// Define os pinos para a conexão ao display LCD
LiquidCrystal lcd(2,3,4,5,6,7);

// Define os pinos RX e TX para o módulo HC-05
const int bluetoothRxPin = 9;  // Conecte o TX do HC-05 ao pino 9 do Arduino
const int bluetoothTxPin = 10; // Conecte o RX do HC-05 ao pino 10 do Arduino
SoftwareSerial bluetoothSerial(bluetoothRxPin, bluetoothTxPin);

char receivedText[9]; // Cria um array para armazenar os 8 caracteres mais o caractere nulo

#define SDA_PIN A4  // Pino SS do MFRC522
#define RST_PIN A3   // Pino RST do MFRC522
#define RFID_TAG_LENGTH 8 // Tamanho da tag RFID (ajuste conforme necessário)
MFRC522 mfrc522(SDA_PIN, RST_PIN);  // Criação de uma instância do MFRC522
int incomingByte;

void setup() {

//Define os pinos do LED RGB e do módulo relé como saida.
pinMode(ledAzul,OUTPUT);
pinMode(ledVerde,OUTPUT);
pinMode(ledVermelho,OUTPUT);
pinMode(trava, OUTPUT);
  // Inicialização do LCD
  lcd.begin(16, 2);

  // Inicialização das comunicações
  Serial.begin(9600);
  bluetoothSerial.begin(9600);
  SPI.begin();
  mfrc522.PCD_Init();

  // Verifica se a EEPROM está limpa ou contém dados
  if (isEEPROMCleared()) {
    // Se limpa, exibe mensagem e imprime no monitor serial
    escreve("EEPROM LIMPA", 0, 0, 1);
    Serial.println("A EEPROM está limpa.");
  } else {
    // Se contém dados, exibe mensagem e imprime no monitor serial
    escreve("EEPROM ESCRITA", 0, 0, 1);
    Serial.println("A EEPROM não está limpa.");
  }
  delay(1000);
}

void loop() {
  digitalWrite(trava,HIGH); 
  digitalWrite(ledAzul,HIGH);
  leituraTAG(); // Função para ler as tags RFID
  bluetooth(); // Função para lidar com a comunicação Bluetooth
}

Este trecho de código se concentra na configuração inicial do projeto. Vamos descrevê-lo brevemente:

  1. As bibliotecas necessárias, como SPI, MFRC522, EEPROM, SoftwareSerial e LiquidCrystal, são incluídas no início do código para habilitar funcionalidades específicas.
  2. O tamanho da EEPROM é definido como EEPROM_SIZE. Isso permite ajustar o tamanho da memória EEPROM para armazenar dados, como IDs de RFID, conforme necessário.
  3. Define os pinos utilizados no módulo relé e led RGB.
  4. A configuração dos pinos para a conexão ao display LCD é definida usando a biblioteca LiquidCrystal.
  5. Os pinos RX e TX são definidos para o módulo Bluetooth HC-05, e uma instância SoftwareSerial chamada bluetoothSerial é criada para lidar com a comunicação Bluetooth.
  6. Um array chamado receivedText é definido para armazenar dados recebidos via Bluetooth.
  7. Os pinos SDA e RST para o módulo RFID MFRC522 são definidos, juntamente com o tamanho esperado da tag RFID.
  8. Na função setup(), são realizadas as seguintes ações:
    • Define os pinos utilizados no led RGB e módulo relé como saída (OUTPUT).
    • Inicialização do display LCD e configuração das comunicações serial padrão, serial Bluetooth, SPI e do módulo RFID MFRC522.
    • Verificação se a EEPROM está limpa ou contém dados. Dependendo do resultado, uma mensagem apropriada é exibida no LCD e no monitor serial.
  9. Na função loop(), as seguintes funções são chamadas repetidamente:
    • leituraTAG(): Esta função lida com a leitura de tags RFID.
    • bluetooth(): Esta função lida com a comunicação Bluetooth.

Este trecho de código estabelece a base para o funcionamento do seu projeto, configurando as conexões de hardware e verificando o estado da EEPROM antes de iniciar as operações principais, como leitura de tags RFID e comunicação Bluetooth.

// Função para encontrar o próximo endereço disponível na EEPROM
int findNextAvailableAddress() {
  for (int addr = 0; addr < EEPROM_SIZE; addr += RFID_TAG_LENGTH) {
    bool isEmpty = true;

    // Verifica cada byte na EEPROM no espaço reservado para a tag RFID
    for (int i = 0; i < RFID_TAG_LENGTH; i++) {
      if (EEPROM.read(addr + i) != 0) {
        isEmpty = false;
        break; // Se encontrar um byte não vazio, a tag não está presente
      }
    }

    // Se não foi encontrado nenhum byte não vazio (tag presente), retorna o endereço
    if (isEmpty) {
      return addr;
    }
  }
  return -1; // Retorna -1 se não houver espaço disponível na EEPROM
}

// Função para verificar se a EEPROM está limpa (todos os bytes são 0)
bool isEEPROMCleared() {
  for (int i = 0; i < EEPROM_SIZE; i++) {

    // Verifica cada byte na EEPROM
    if (EEPROM.read(i) != 0) {
      return false; // Se encontrar um byte diferente de zero, a EEPROM não está limpa
    }
  }
  return true; // Se não encontrou nenhum byte diferente de zero, a EEPROM está limpa
}

Função findNextAvailableAddress():

Esta função tem a finalidade de encontrar o próximo endereço disponível na memória EEPROM para armazenar uma nova tag RFID. A memória EEPROM é dividida em blocos, cada um com um tamanho igual ao da tag RFID. Aqui está como a função opera:

  1. Inicia um loop que varre a memória EEPROM procurando por espaços vazios, começando do endereço 0 até o tamanho total da EEPROM (EEPROM_SIZE).
  2. Para cada endereço, a função verifica se o bloco de memória correspondente ao tamanho de uma tag RFID (RFID_TAG_LENGTH) está vazio. Isso é feito comparando cada byte no bloco com zero.
  3. Se um bloco estiver vazio (ou seja, todos os bytes dentro do bloco são iguais a zero), a função determina que esse espaço está disponível para armazenar uma nova tag RFID.
  4. A função retorna o endereço do espaço disponível encontrado. Caso contrário, se não houver espaço disponível na EEPROM, a função retorna -1.

Função isEEPROMCleared():

Esta função tem como objetivo verificar se a memória EEPROM está limpa, o que significa que todos os seus bytes são iguais a zero. A memória EEPROM é considerada “limpa” quando não contém dados previamente armazenados. Aqui está como a função opera:

  1. Inicia um loop que varre toda a memória EEPROM, de 0 até o tamanho total da EEPROM (EEPROM_SIZE).
  2. Para cada byte na memória EEPROM, a função verifica se o valor desse byte é igual a zero.
  3. Se um byte diferente de zero for encontrado em qualquer ponto da EEPROM, a função determina que a memória EEPROM não está limpa, pois contém dados previamente armazenados.
  4. A função retorna false para indicar que a EEPROM não está limpa. Caso contrário, se não for encontrado nenhum byte diferente de zero em toda a EEPROM, a função retorna true, indicando que a EEPROM está limpa.

Essas funções desempenham um papel importante no gerenciamento da memória EEPROM, permitindo que o programa saiba onde armazenar novas tags RFID e se a EEPROM já contém dados anteriormente gravados.

// Função para limpar (apagar) todos os dados na memória EEPROM
void clearEEPROM() {
  for (int i = 0; i < EEPROM_SIZE; i++) {
    EEPROM.write(i, 0); // Escreve o valor zero em cada endereço da EEPROM
  }
  Serial.println("EEPROM limpa."); // Imprime uma mensagem indicando que a EEPROM foi apagada
}

Descrição da Função clearEEPROM():

A função clearEEPROM() é responsável por apagar (ou limpar) todos os dados armazenados na memória EEPROM do Arduino. Aqui está como a função opera:

  1. Inicia um loop que varre toda a memória EEPROM, indo de 0 até o tamanho total da EEPROM (EEPROM_SIZE).
  2. Em cada iteração do loop, a função utiliza EEPROM.write(i, 0) para escrever o valor zero (0) no endereço de memória correspondente. Isso efetivamente apaga ou substitui qualquer dado que estava previamente armazenado naquele endereço da EEPROM.
  3. A função percorre todos os endereços da EEPROM, garantindo que todos os dados sejam substituídos por zeros.
  4. Após concluir a operação de limpeza, a função imprime a mensagem “EEPROM limpa.” no monitor serial. Isso indica que a memória EEPROM foi completamente apagada e agora está em um estado vazio.

Ao chamar esta função no seu código, todos os dados previamente armazenados na EEPROM serão permanentemente apagados, deixando-a vazia e pronta para ser utilizada para armazenar novas informações. Certifique-se de usar esta função com cuidado, pois a limpeza da EEPROM é irreversível, e os dados antigos serão perdidos. É útil quando você deseja redefinir a memória EEPROM para um estado inicial limpo antes de armazenar novos dados.

// Função para lidar com a comunicação Bluetooth
void bluetooth() {
  if (bluetoothSerial.available() >= 8) {
    // Verifica se há pelo menos 8 caracteres disponíveis para leitura no buffer Bluetooth
    bluetoothSerial.readBytes(receivedText, 8); // Lê os 8 caracteres
    receivedText[8] = '\0'; // Adiciona um caractere nulo para formar uma string válida

    // Exibe o texto recebido no monitor serial
    Serial.println("Texto recebido: " + String(receivedText));

    escreve("Tag adicionada:", 0, 0, 1); // Exibe a mensagem "Tag adicionada" no LCD
    escreve(receivedText, 0, 1, 0); // Exibe o conteúdo da tag RFID no LCD
    writeRFIDTagToEEPROM(receivedText); // Chama uma função para escrever a tag RFID na EEPROM
  }

  if (bluetoothSerial.available() > 0) {
    // Lê o byte mais antigo no buffer serial Bluetooth
    incomingByte = bluetoothSerial.read();
    
    // Se o byte recebido for 'R', realiza uma ação específica (no caso, limpa a EEPROM)
    if (incomingByte == 'R') {
      clearEEPROM(); // Chama uma função para limpar a EEPROM
      escreve("EEPROM limpa.", 0, 0, 1); // Exibe uma mensagem no LCD indicando que a EEPROM foi limpa
    }
  }
}

Descrição da Função bluetooth():

A função bluetooth() é responsável por lidar com a comunicação Bluetooth e executar ações com base nos dados recebidos via Bluetooth. Aqui está como a função opera:

  1. Verifica se há pelo menos 8 caracteres disponíveis para leitura no buffer Bluetooth. Isso é feito com a condição if (bluetoothSerial.available() >= 8).
  2. Se houver pelo menos 8 caracteres disponíveis, a função lê esses caracteres usando bluetoothSerial.readBytes() e os armazena na variável receivedText como uma string válida.
  3. A função exibe a string recebida no monitor serial.
  4. A função escreve a mensagem “Tag adicionada:” no LCD e exibe o conteúdo da tag RFID recebida no LCD. Em seguida, chama uma função chamada writeRFIDTagToEEPROM() para escrever a tag RFID na EEPROM.
  5. A função verifica se há mais dados disponíveis no buffer Bluetooth e, se houver, lê o próximo byte.
  6. Se o byte recebido for ‘R’, a função chama clearEEPROM() para limpar todos os dados na EEPROM e exibe “EEPROM limpa” no LCD.

Essa função permite que o Arduino interaja com um dispositivo Bluetooth externo, processando os comandos recebidos e realizando ações específicas, como adicionar tags RFID à EEPROM ou limpar a EEPROM quando necessário.

// Função para verificar se uma tag RFID está cadastrada na memória EEPROM
bool isTagRegistered(const String &tag) {
  for (int addr = 0; addr < EEPROM_SIZE; addr += RFID_TAG_LENGTH) {
    bool match = true;

    // Verifica se cada byte da EEPROM corresponde ao conteúdo da tag fornecida
    for (int i = 0; i < RFID_TAG_LENGTH; i++) {
      if (EEPROM.read(addr + i) != tag[i]) {
        match = false;
        break;
      }
    }

    // Se todas as posições da tag coincidirem, a tag está cadastrada
    if (match) {
      return true; // A tag está cadastrada na EEPROM
    }
  }

  // Se a função chegou até aqui, a tag não foi encontrada na EEPROM
  return false; // A tag não está cadastrada na EEPROM
}

Descrição da Função isTagRegistered(const String &tag):

A função isTagRegistered() tem como objetivo verificar se uma tag RFID específica está cadastrada na memória EEPROM. Ela opera da seguinte maneira:

  1. Inicia um loop que percorre toda a memória EEPROM, de 0 até o tamanho total da EEPROM (EEPROM_SIZE). Isso é feito avançando de acordo com o tamanho da tag RFID (RFID_TAG_LENGTH), garantindo que cada bloco de memória correspondente ao tamanho de uma tag seja verificado.
  2. Para cada bloco de memória na EEPROM, a função verifica se todos os bytes correspondem ao conteúdo da tag fornecida. Isso é feito comparando byte a byte.
  3. Se todos os bytes do bloco de memória coincidirem com os bytes da tag, a variável match é definida como verdadeira, indicando que a tag está cadastrada naquele endereço da EEPROM.
  4. Se a variável match permanecer verdadeira após a verificação de todos os bytes da tag, a função retorna true, indicando que a tag está cadastrada na EEPROM.
  5. Se a função não encontrou nenhuma correspondência após verificar todos os blocos de memória, ela retorna false, indicando que a tag não está cadastrada na EEPROM.

Essa função é útil para verificar se uma tag específica já foi registrada anteriormente na EEPROM, permitindo assim o controle de acesso com base nas tags cadastradas.

// Função para escrever uma tag RFID na memória EEPROM, se ainda não estiver cadastrada
void writeRFIDTagToEEPROM(const String &tag) {
  if (isTagRegistered(receivedText)) {
    // Se a tag já estiver cadastrada, exibe uma mensagem e informa que a tag já existe
    escreve("TAG cadastrada", 0, 0, 1); // Exibe "TAG cadastrada" no LCD
    escreve(receivedText, 0, 1, 0); // Exibe o conteúdo da tag RFID no LCD
    Serial.println("Tag RFID já cadastrada.");
  } else {
    // Se a tag não estiver cadastrada, exibe uma mensagem e adiciona a tag à EEPROM
    escreve("TAG adicionada", 1, 0, 1); // Exibe "TAG adicionada" no LCD
    escreve(receivedText, 0, 1, 0); // Exibe o conteúdo da tag RFID no LCD
    Serial.println("Tag RFID adicionada");

    // Encontra o próximo endereço disponível na EEPROM
    int addr = findNextAvailableAddress();

    // Escreve a tag RFID na EEPROM
    for (int i = 0; i < RFID_TAG_LENGTH; i++) {
      EEPROM.write(addr + i, tag[i]);
    }
  }
}

Descrição da Função writeRFIDTagToEEPROM(const String &tag):

A função writeRFIDTagToEEPROM() é responsável por escrever uma tag RFID na memória EEPROM, mas somente se ela ainda não estiver cadastrada. Aqui está como a função opera:

  1. Verifica se a tag já está registrada na EEPROM, chamando a função isTagRegistered(receivedText). Se a tag já estiver cadastrada, a função exibe uma mensagem no LCD indicando que a tag já existe e também imprime “Tag RFID já cadastrada” no monitor serial.
  2. Se a tag não estiver cadastrada, a função exibe uma mensagem no LCD indicando que a tag foi adicionada e também imprime “Tag RFID adicionada” no monitor serial.
  3. A função então utiliza a função findNextAvailableAddress() para encontrar o próximo endereço disponível na EEPROM onde a nova tag RFID será escrita.
  4. Em seguida, a função escreve a tag RFID na EEPROM, byte a byte, iniciando no endereço encontrado no passo anterior.

Essa função é crucial para o processo de adicionar novas tags RFID ao sistema de controle de acesso. Ela evita a duplicação de tags cadastradas, garantindo que apenas tags não registradas sejam adicionadas à EEPROM.

// Função para escrever texto no display LCD
void escreve(String palavra, int linha, int coluna, int apagar) {
  if (apagar == 1) {
    lcd.clear(); // Limpa o conteúdo do LCD se o parâmetro "apagar" for igual a 1
  }
  lcd.setCursor(linha, coluna); // Define a posição de escrita no LCD
  lcd.print(palavra); // Exibe a palavra no LCD na posição definida
}

Descrição da Função escreve(String palavra, int linha, int coluna, int apagar):

A função escreve() é responsável por exibir texto no display LCD, permitindo que você defina a posição exata (linha e coluna) onde o texto será exibido. Aqui está como a função opera:

  1. Verifica o valor do parâmetro apagar. Se apagar for igual a 1, a função chama lcd.clear() para limpar o conteúdo atual do LCD antes de escrever o novo texto. Isso permite substituir o conteúdo anterior por um novo.
  2. Em seguida, a função utiliza lcd.setCursor(linha, coluna) para definir a posição de escrita no LCD, onde linha e coluna são os parâmetros que determinam a posição.
  3. Finalmente, a função utiliza lcd.print(palavra) para exibir a palavra especificada no LCD na posição definida.

Essa função é útil para atualizar e exibir informações no display LCD, como mensagens de status, dados de RFID lidos ou qualquer outra informação que você deseja apresentar visualmente no projeto. O parâmetro apagar permite que você escolha se deseja limpar o conteúdo anterior antes de exibir o novo texto.

// Função para ler e processar uma tag RFID
void leituraTAG() {
   escreve("Aproxime a TAG", 0, 0, 1); // Exibe "TAG cadastrada" no LCD
   escreve("do leitor", 0, 1, 0); // Exibe "TAG cadastrada" no LCD
   digitalWrite(ledAzul,HIGH);
  // Verifica se uma tag RFID está presente no leitor
  if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial()) {
    // Lê a tag RFID e a armazena em uma string
    String rfidTag = "";
    for (byte i = 0; i < mfrc522.uid.size; i++) {
      rfidTag += String(mfrc522.uid.uidByte[i], HEX);
    }

    // Verifica se a tag lida está cadastrada na EEPROM
    if (isTagRegistered(rfidTag)) {
      escreve("TAG cadastrada", 0, 0, 1); // Exibe "TAG cadastrada" no LCD
      escreve(rfidTag, 0, 1, 0); // Exibe o conteúdo da tag RFID no LCD
      Serial.println("Tag RFID cadastrada.");
      Serial.println("Tag RFID lida: " + rfidTag); // Imprime a tag RFID no monitor serial 
    // aciona a trava por 3seg
     digitalWrite(ledAzul,LOW);
     digitalWrite(trava,LOW);
     digitalWrite(ledVerde,HIGH);
     delay(3000);
     digitalWrite(trava,HIGH);
     digitalWrite(ledVerde,LOW);
    } else {
      escreve("TAG incorreta", 0, 0, 1); // Exibe "TAG incorreta" no LCD
      escreve(rfidTag, 0, 1, 0); // Exibe o conteúdo da tag RFID no LCD
      Serial.println("Tag RFID não cadastrada.");
      Serial.println("Tag RFID lida: " + rfidTag); // Imprime a tag RFID no monitor serial 
      digitalWrite(ledAzul,LOW);
      digitalWrite(ledVermelho, HIGH);
      delay(3000);
      digitalWrite(ledVermelho, LOW);
    }
    // Aguarda um momento para evitar leituras múltiplas da mesma tag
    delay(1000);
  }
}

Descrição da Função leituraTAG():

A função leituraTAG() é responsável por ler e processar uma tag RFID quando ela está presente no leitor MFRC522. Aqui está como a função opera:

  1. Inicialmente mostra uma mensagem no display LCD e acende o led azul pedindo para aproximar uma TAG do leitor.
  2. A função verifica se uma tag RFID está presente no leitor usando mfrc522.PICC_IsNewCardPresent(). Se uma tag estiver presente, a função continua a execução.
  3. A função utiliza mfrc522.PICC_ReadCardSerial() para efetivamente ler a tag RFID e armazenar seu conteúdo em uma string chamada rfidTag. A tag é representada como uma sequência hexadecimal na string.
  4. A função chama isTagRegistered(rfidTag) para verificar se a tag lida está cadastrada na EEPROM. Se a tag estiver cadastrada, a função exibe “TAG cadastrada” no LCD, exibe o conteúdo da tag RFID no LCD e imprime “Tag RFID cadastrada” no monitor serial. Caso contrário, exibe “TAG incorreta” no LCD, exibe o conteúdo da tag RFID no LCD e imprime “Tag RFID não cadastrada” no monitor serial.
  5. Caso a TAG esteja cadastrada aciona a trava solenoide e o led verde como indicação de que a porta foi aberta.
  6. Caso a TAG não esteja cadastrada aciona o led vermelho.
  7. Para evitar leituras múltiplas da mesma tag em curtos intervalos, a função aguarda 1 segundo usando delay(1000) antes de continuar a executar o loop.

Essa função é essencial para o processo de leitura e validação de tags RFID no sistema de controle de acesso. Ela exibe informações relevantes no LCD e no monitor serial, permitindo que você saiba se a tag é válida ou não. Além disso, o atraso de 1 segundo ajuda a evitar leituras consecutivas da mesma tag.


Arquivos Necessários

Baixe todos os arquivos disponibilizados no link https://github.com/eletrogate/rfid_celular/tree/main

Baixe o aplicativo disponibilizado neste link com o nome “Eletrogate_RFID2_basic3.apk”

Baixe a pasta com os códigos nomeada como “RFID_ELETROGATE_porRafaelFaleiros”

Como acessar o código:

  1. Após realizar o download de todos os arquivos abra a pasta compactada e extraia todos os arquivos.
  2. Adicione a biblioteca “MFRC522.zip” na sua IDE do Arduino.
  3. Encontre a pasta “RFID_ELETROGATE_porRafaelFaleiros” e selecione o arquivo nomeado como “RFID_ELETROGATE_porRafaelFaleiros.ino”, mantenha todos os outros arquivos “.ino” na mesma pasta desse arquivo citado, e os mesmos serão abertos como abas ao abrir este arquivo principal. Observe a imagem abaixo:

Como acessar o aplicativo:

  1. Envie o Arquivo “Eletrogate_RFID2_basic3.apk” para seu celular (o arquivo só pode ser instalado em aparelhos Android).
  2. Abra o arquivo no seu smartphone e autorize sua instalação. Pode ser necessário que você habilite a instalação de aplicativos desconhecidos nas configurações do seu aparelho.

Como Conectar

  1. Instale e o programa disponibilizado na postagem e carrega para sua placa.
  2. Instale o aplicativo também disponibilizado.
  3. Abra o aplicativo
  4. Na tela inicial clique no botão “buscar dispositivos.
  5. selecione o módulo HC05 conectado ao Arduino.

Observação: Você pode precisar emparelhar inicialmente a placa com seu celular. Para fazer isso, vá para as configurações do seu smartphone, acesse ‘Dispositivos Bluetooth’ e selecione a placa. Se for solicitada uma senha, insira ‘0000’ (que é o padrão de fábrica).

Em seguida, você pode adicionar as tags desejadas e, se desejar, solicitar nomes a elas para facilitar a identificação das TAGs cadastradas para acessar seu ambiente. Depois de adicionar todas as TAGs desejadas, clique na opção ‘Atualizar Dados’. Isso salvará todas as novas TAGs no dispositivo.

IMPORTANTE:

  1. Todas as TAGs ja enviadas ficam salvas no aparelho até que o comando “Resetar” seja enviado.
  2. O Arduino tem um número máximo de tags a ser armazenada. No caso dos modelos “Nano” e “Uno”, é possível guardar até 125 TAGs de 8 digitos.
  3. Caso a TAG a ser adicionada tenha menos ou mais de 8 dígitos deve ser realizado alterações no código e no aplicativo.

Conclusão

No encerramento deste post, mergulhamos em um projeto prático de controle de acesso RFID, explorando a integração do Arduino, módulos RFID e o MIT App Inventor. Através deste tutorial, você teve a oportunidade de aprender como ler tags RFID, armazenar dados na memória EEPROM, estabelecer comunicação via Bluetooth e até mesmo reiniciar a memória quando necessário. Este projeto oferece uma visão prática da integração de tecnologias diversas para criar soluções de controle de acesso personalizadas.


Projeto em Funcionamento

Como pode ser observado a TAG do cartão não é reconhecida até que a mesma seja adicionada pelo aplicativo.


Sobre o Autor


Rafael Faleiros

Estudante do ensino médio com formação técnica em eletrônica. Atua como consultor e projetista de sistemas embarcados.


Eletrogate

7 de novembro de 2023

A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.

Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!

Eletrogate Robô

Cadastre-se e fique por
dentro de novidades!