Arduino – Cancela Controlada por RFID

Arduino – Cancela Controlada por RFID

O uso do RFID é algo bastante comum, seja para identificar produtos, objetos, animais e até mesmo para controle de acesso em vários tipos de ambiente. Com intuito de demonstrar uma das aplicações desta tecnologia, criei um protótipo de uma cancela que é acionada mediante a leitura de uma TAG RFID que está inserida na parte debaixo de um veículo, e a partir desta leitura algumas ações são executadas pelo Arduino.

O RFID (Radio Frequency Identification ou Identificação por radiofrequência, em português) é uma tecnologia que utiliza radiofrequência para coletar dados. Essa tecnologia permite que uma tag seja lida sem um campo de visão, portanto, mesmo que exista barreiras ou objetos a leitura da tag poderá ser feita. A leitura dos dados acontece em tempo real sem a necessidade de intervenção manual ou visual, o que torna a tecnologia bem eficiente.

Uma tag ou etiqueta RFID é composta basicamente por um circuito eletrônico que tem a capacidade de armazenar diversas informações. No caso das tags voltadas para controle de acesso, cada uma possui um UID (User ID ou identificação do usuário, em português) e a partir deste identificador é que um sistema determina se a tag tem acesso liberado ou negado. Há tags em diversos formatos, contudo, as mais comuns são do tipo cartão e do tipo chaveiro.

A tecnologia RFID é aplicada a diversos setores e como exemplo podemos citar, o controle de tráfego de pessoas (indústria ou instituição de ensino) ou em supermercados, onde os produtos possuem uma tag RFID e ao final da compra o cliente só precisa passar o carrinho com os produtos por um leitor RFID de médio porte para que as tags dos produtos sejam lidas e o valor final da compra seja apresentado ao cliente.

O RFID também é muito aplicado em pequenos projetos com plataformas embarcadas / microcontroladas. Como exemplo, temos o Arduino que comumente é associado a projetos com RFID, onde a partir da leitura de uma tag uma ação pode ser executada através da plataforma.

O protótipo que criei para esta postagem é basicamente a junção do Arduino com o RFID para fazer o acionamento de uma cancela que é representada por um servo motor. Se o identificador da tag lida pelo leitor for igual ao UID inserido no código carregado no Arduino, o acesso será autorizado e a cancela será acionada para dar passagem ao veículo, e em seguida a cancela fecha a passagem novamente. Caso o UID lido seja diferente do identificador inserido no código carregado no Arduino, o acesso será negado e a cancela permanece imóvel.

Para deixar o protótipo mais interessante, adicionei um display OLED para mostrar algumas informações e coloquei também dois LEDs para sinalizar acesso autorizado e acesso negado.

Para montagem do protótipo utilizei:

Arduino Uno R3 com Cabo USB A/B
KIT com Leitor RFID MFRC522
Tag (Chaveiro) RFID 13.56MHz
Servo Motor SG90
Display OLED 128×64 0.96″ I2C Azul
Fonte DC 9V 1A Bivolt Chaveada
Cabo Jumper Macho-macho
Cabo Jumper Macho-fêmea
LED Difuso 5MM Vermelho
LED Difuso 5MM Verde
Resistor de 150Ω

Além dos itens mencionados acima, utilizei também isopor para criação da maquete, cola quente para fixar os componentes do projeto, pedaço de tubo plástico para simular a barreira da cancela, cabo de par trançado (cabo de rede) para fazer as conexões ao Arduino e ferro de solda para soldagem das conexões entre os cabos.

Para fazer o acionamento da cancela, será necessário que a tag seja lida pelo leitor RFID e em seguida validada pelo Arduino. Desta forma, é necessário inserir o UID da tag dentro do código para que a validação seja realizada.

Inicialmente monte o esquema de ligação abaixo entre o leitor RFID e o Arduino para capturar os UIDs das tags:

ATENÇÃO: FAÇA TODAS AS LIGAÇÕES COM SEU ARDUINO DESCONECTADO DA ALIMENTAÇÃO.

img01_arduino_cancela_controlada_por_rfid_servo_motor_sg90_display_oled_tag_cartao_chaveiro_automacao_controle_acesso_uno_mega_2560

Feito o esquema de ligação, será necessário instalar algumas bibliotecas na IDE do Arduino para em seguida carregar o código. A biblioteca MFRC522 é responsável pelo controle do leitor RFID e as bibliotecas Adafruit_GFX_Library e Adafruit_SSD1306 nos permite fazer controle e escrita no display OLED:

Download Biblioteca MFRC522

Download Biblioteca Adafruit_GFX_Library

Download Biblioteca Adafruit_SSD1306

Se você não sabe como fazer a instalação de bibliotecas na IDE, acesse o link abaixo e em seguida retorne para continuar:

Arduino – Importando bibliotecas para a IDE

Carregue o código abaixo para identificar os UIDs das tags:

Após o carregamento do código abra o monitor serial na IDE do Arduino e em seguida aproxime do leitor uma das tags para que a leitura seja realizada. Note que no monitor serial vai aparecer o identificador da tag:

img03_arduino_cancela_controlada_por_rfid_servo_motor_sg90_display_oled_tag_cartao_chaveiro_automacao_controle_acesso_uno_mega_2560

Salve este UID em um bloco de notas. Execute este procedimento para as demais tags que deseja obter o identificador.

Em seguida, desconecte o cabo USB do computador e complete o esquema de ligação conforme a imagem abaixo:

ATENÇÃO: FAÇA TODAS AS LIGAÇÕES COM SEU ARDUINO DESCONECTADO DA ALIMENTAÇÃO.

img02_arduino_cancela_controlada_por_rfid_servo_motor_sg90_display_oled_tag_cartao_chaveiro_automacao_controle_acesso_uno_mega_2560

(Clique na imagem para ampliar)

Você pode montar o esquema acima em uma protoboard, por exemplo. Eu optei por fazer uma pequena maquete para representar bem esta aplicação. Na galeria de imagens abaixo você pode ver algumas fotos do processo de montagem:

Independente se você montou o esquema na protoboard ou fez um protótipo similar ao que fiz, a proposta final será a mesma em ambos.

Antes de carregar o código abaixo no Arduino, substitua o texto D0:64:BB:4F na linha “if (strID.indexOf(“D0:64:BB:4F”) >= 0) {” pelo UID da tag que irá acionar a cancela. Qualquer outro UID diferente do identificador que você inserir no código terá acesso negado.

Em seguida, conecte a fonte de alimentação na tomada e no plug jack do Arduino, e por fim conecte o cabo USB novamente no Arduino e faça upload do código.

No vídeo abaixo você pode ver o resultado final do protótipo da cancela controlada através de RFID:

O primeiro veículo teve o acesso negado, pois a tag inserida no mesmo não está autorizada a acionar a cancela. Já o segundo veículo teve o acesso autorizado para acionar a cancela, pois a tag do mesmo condiz com o UID que foi inserido no código carregado no Arduino para validação de acesso.

Neste protótipo você pôde ver um exemplo comum de uso da tecnologia de RFID. Conforme informando anteriormente, há muitas outras situações em que esta tecnologia pode ser aplicada.

Espero que tenha gostado do resultado final deste pequeno projeto.

Gostou deste tutorial? Então deixa seu comentário, dúvida ou sugestão aí embaixo!

Loja online: https://www.masterwalkershop.com.br
Fan page no Facebook: https://www.facebook.com/masterwalkershop

Nos ajude a espalhar conhecimento clicando no botão de compartilhar (f Like) que está mais abaixo.

Obrigado e até a próxima!

Seu feedback é muito importante! Que tal dar uma nota para esta postagem?! Faça sua avaliação aqui embaixo.

Arduino – Cancela Controlada por RFID
2 votos / Média de avaliação: 5 / Pontuação: 100%


Postagem anterior:
Próxima postagem:
Postagem feita por

Formado em Engenharia da Computação pela Faculdade Presidente Antônio Carlos, fundador e CEO da MasterWalker Electronic Shop. Se preocupa com o aprendizado dos seus clientes e daqueles interessados em aprender sobre Arduino e plataformas embarcadas em geral.

Existem 19 comentários para esta postagem
    • Euler Oliveira Autor às 15:14

      Olá Jander.

      Na linha if (strID.indexOf(“D0:64:BB:4F”) >= 0) basta adicionar a condicional OU e as UIDs das novas tags.

      Exemplo:

      Veja que a condicional OU é representada pelas barras || e as novas UIDs são A0:56:FG:9B e E9:55:OH:7T. Caso a tag lida corresponda a alguma das UIDs inseridas, a cancela será aberta.

      • Jander às 02:50

        Olá prezado Euler, não deu certo! copiei o código igual ao seu e colei lá, claro colocando os UIDs das minhas tags, acontece que ela passa a não liberara mais nenhuma.

        O que pode ser feito?

          • Jander às 08:44

            #include //INCLUSÃO DE BIBLIOTECA
            #include //INCLUSÃO DE BIBLIOTECA
            #include //INCLUSÃO DE BIBLIOTECA
            #include //INCLUSÃO DE BIBLIOTECA
            #include //INCLUSÃO DE BIBLIOTECA
            #include //INCLUSÃO DE BIBLIOTECA

            Adafruit_SSD1306 display = Adafruit_SSD1306(); //OBJETO DO TIPO Adafruit_SSD1306

            #define SS_PIN 10 //PINO SDA
            #define RST_PIN 9 //PINO DE RESET

            MFRC522 rfid(SS_PIN, RST_PIN); //PASSAGEM DE PARÂMETROS REFERENTE AOS PINOS

            Servo s; //OBJETO DO TIPO SERVO
            int pos; //POSIÇÃO DO SERVO

            const int pinoLedVerde = 2; //PINO DIGITAL REFERENTE AO LED VERDE
            const int pinoLedVermelho = 3; //PINO DIGITAL REFERENTE AO LED VERMELHO
            const int pinoServo = 6; // PINO DIGITAL REFERENTE AO SERVO MOTOR

            byte anguloCancelaFechada = 74; //VALOR DO ÂNGULO PARA CANCELA FECHADA
            byte anguloCancelaAberta = 174; //VALOR DO ÂNGULO PARA CANCELA ABERTA

            void setup(){

            Wire.begin(); //INICIALIZA A BIBLIOTECA WIRE
            display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //INICIALIZA O DISPLAY COM ENDEREÇO I2C 0x3C
            display.setTextColor(WHITE); //DEFINE A COR DO TEXTO
            display.setTextSize(1); //DEFINE O TAMANHO DA FONTE DO TEXTO
            display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
            display.setCursor(8,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“SISTEMA DE IGINICAO”); //ESCREVE O TEXTO NO DISPLAY

            display.setCursor(33,20); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“ELETRONICA”); //ESCREVE O TEXTO NO DISPLAY

            display.display(); //EFETIVA A ESCRITA NO DISPLAY

            SPI.begin(); //INICIALIZA O BARRAMENTO SPI
            rfid.PCD_Init(); //INICIALIZA MFRC522

            s.attach(pinoServo); //ASSOCIAÇÃO DO PINO DIGITAL AO OBJETO DO TIPO SERVO
            s.write(74); //INICIA O MOTOR NA POSIÇÃO 0º

            pinMode(pinoLedVerde, OUTPUT); //DEFINE O PINO COMO SAÍDA
            pinMode(pinoLedVermelho, OUTPUT); //DEFINE O PINO COMO SAÍDA

            digitalWrite(pinoLedVerde, LOW); //LED INICIA DESLIGADO
            digitalWrite(pinoLedVermelho, LOW); //LED INICIA DESLIGADO
            }

            void loop() {
            leituraRfid(); //CHAMA A FUNÇÃO RESPONSÁVEL PELA VALIDAÇÃO DA TAG RFID
            }

            //FUNÇÃO DE VALIDAÇÃO DA TAG RFID
            void leituraRfid(){
            if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) //VERIFICA SE O CARTÃO PRESENTE NO LEITOR É DIFERENTE DO ÚLTIMO CARTÃO LIDO. CASO NÃO SEJA, FAZ
            return; //RETORNA PARA LER NOVAMENTE

            display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
            display.setCursor(40,0); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“Aguarde”); //ESCREVE O TEXTO NO DISPLAY
            display.setCursor(50,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“por”); //ESCREVE O TEXTO NO DISPLAY
            display.setCursor(30,20); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“autorizacao…”); //ESCREVE O TEXTO NO DISPLAY
            display.display(); //EFETIVA A ESCRITA NO DISPLAY
            delay(1000); //INTERVALO DE 1 SEGUNDOS

            /***INICIO BLOCO DE CÓDIGO RESPONSÁVEL POR GERAR A TAG RFID LIDA***/
            String strID = “”;
            for (byte i = 0; i < 4; i++) {
            strID +=
            (rfid.uid.uidByte[i] = 0)

            {
            digitalWrite(pinoLedVerde, HIGH); //LIGA O LED VERDE
            display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
            display.setCursor(45,5); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“Acesso”); //ESCREVE O TEXTO NO DISPLAY
            display.setCursor(9,15); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“A u t o r i z a d o”); //ESCREVE O TEXTO NO DISPLAY
            display.display(); //EFETIVA A ESCRITA NO DISPLAY
            delay(1); //INTERVALO DE 4 SEGUNDOS
            abrirCancela(); //CHAMA A FUNÇÃO RESPONSÁVEL POR ABRIR A CANCELA
            delay(1000); //INTERVALO DE 6 SEGUNDOS
            fecharCancela(); //CHAMA A FUNÇÃO RESPONSÁVEL POR FECHAR A CANCELA
            digitalWrite(pinoLedVerde, LOW); //DESLIGA O LED VERDE
            }else{ //SENÃO, FAZ (CASO A TAG LIDA NÃO SEJÁ VÁLIDA)
            digitalWrite(pinoLedVermelho, HIGH); //LIGA O LED VERMELHO
            display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
            display.setCursor(45,5); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“Acesso”); //ESCREVE O TEXTO NO DISPLAY
            display.setCursor(30,15); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“N e g a d o”); //ESCREVE O TEXTO NO DISPLAY
            display.display(); //EFETIVA A ESCRITA NO DISPLAY
            delay(2000); ////INTERVALO DE 6 SEGUNDOS
            digitalWrite(pinoLedVermelho, LOW); //DESLIGA O LED VERDE
            display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
            display.setCursor(23,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“A T E N C A O”); //ESCREVE O TEXTO NO DISPLAY

            display.setCursor(6,20); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“Carro sera Bloqueado”); //ESCREVE O TEXTO NO DISPLAY
            display.display(); //EFETIVA A ESCRITA NO DISPLAY
            }

            rfid.PICC_HaltA(); //PARADA DA LEITURA DO CARTÃO
            rfid.PCD_StopCrypto1(); //PARADA DA CRIPTOGRAFIA NO PCD
            }

            //FUNÇÃO PARA ABRIR A CANCELA
            void abrirCancela(){
            for(pos = anguloCancelaFechada; pos = anguloCancelaFechada; pos–){ //PARA “pos” IGUAL A “anguloCancelaAberta”,
            //ENQUANTO “pos” MAIOR OU IGUAL “anguloCancelaFechada”, DECREMENTA “pos”
            s.write(pos); //ESCREVE O VALOR DA POSIÇÃO QUE O SERVO DEVE GIRAR
            delay(01); //INTERVALO DE 15 MILISEGUNDOS
            }
            display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
            display.setCursor(33,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“Boa Viagem”); //ESCREVE O TEXTO NO DISPLAY

            display.setCursor(8,20); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
            display.print(“Use sempre o Cinto”); //ESCREVE O TEXTO NO DISPLAY
            display.display(); //EFETIVA A ESCRITA NO DISPLAY
            }

          • Jander às 08:47

            Neste caso estou incrementando para dar partida em um carro , mas quando eu coloco as novas tags ele não aceita nenhuma delas.

          • Euler Oliveira Autor às 14:41

            Seu código está incompleto. Não encontrei o trecho de código que faz a leitura do UID da tag e que faz a chamada das funções.

            Preciso do código todo que está usando para verificar se há algum erro.

          • Jander às 20:21

            Prezado; conseguiu analisar o código? se não consegui, me mande o seu e-mail que eu envio o Sketch para o senhor.

          • Euler Oliveira Autor às 06:49

            O seu código está sem o trecho de código que faz a leitura do UID da tag e que faz a chamada das funções. Sem esse trecho não tem como fazer a análise.

            Favor postar aqui o código completo com as UID que definiu no mesmo.

          • Jander às 09:34

            Prezado Euler, estou copiando o código completo da ide do arduino, não seu porque não esta conseguindo visualizar, eu copiei o código postado pelo senhor aqui nesta página, poderia por favor enviar por e-mail este código completo com pelo menos 04 UIDs das tags, para ver se vai dar certo? janderled@hotmail.com

    • Euler Oliveira Autor às 07:14

      Olá Almeida.

      Todo o projeto está disponível neste artigo.

      Basta ler todo o artigo e fazer conforme eu expliquei e usar os códigos que disponibilizei.

  1. Cristian Lopes às 22:42

    Olá Euler, que maravilha!

    Sou bem iniciante no Arduino e seu projeto me cativou! Funcionou perfeitamente!

    Tanto que gostaria de incrementar com leitor Rfid 900mhz com alcance de 6 metros;

    Existe possibilidade de mesclar os códigos? Consigo acionar o RL ao ler uma tag, mas não consigo fazer com que confira se a tag é cadastrada ou não! Pode me dar uma Luz? Desde já agradeço!

  2. Cristian Lopes às 22:43

    Descrição:
    Controle de um porta de garagwem com antena RFID, arduino e uma Central Rossi MX30.

    Este código utiliza a biblioteca SoftwareSerial.h para enviar e receber dados de uma
    antena de RFID nos pinos D2 e D3.
    Usa a serial standard nos pinos 0 e 1 para o monitor serial.

    A antena, ao detetar uma tag, envia a informação para o arduino.
    O arduino a receber esta informação sinalisa a central para
    abir o portão para o carro passar.
    Aguarda 8 minutos, e após isto fecha o portão.

    Se durante estes 5 minutos receber outra tag, 5 minutos serão acescentado
    para manter o potão aberto por mais tempo.
    */
    // —————————– definicoes —————————-
    // #include “Arduino.h”
    #include // Bibioteca para a serial via software

    SoftwareSerial mySerial (2,3); // Definição dos pinos para o software serial
    unsigned char incomingByte; // Variavel para receber dados da antena de RFID
    byte Portao_Flag; // Flag para dizer se existe carro no portao
    byte Tag_Flag; // Flag para dizer o “status’do portao
    // —————————– sendIdentifyCmd —————————-
    void sendIdentifyCmd () // Funcao para comando de leitura de tag
    {
    mySerial.write (0x7c); // Sequencia de comandos para ler tag
    mySerial.write (0xff); //
    mySerial.write (0xff); //
    mySerial.write (0x01); //
    mySerial.write (0x08); //
    mySerial.write (0x7d); //
    } // Fim do sendIdentifyCmd
    // —————————– setup ————————————
    void setup () // Funcao setup
    {
    Serial.begin (9600); // Inicialisa o monitor
    mySerial.begin (9600); // Inicialisa a software serial
    Serial.println (“begin initial Serial!\n”); // imprime no monitor
    pinMode(13, OUTPUT); // pino 13 usado no rele para abertura e fechamento do portão
    } // Fim do setup
    // —————————– Abre_Fecha —————————————-
    void Abre_Fecha () // Funçao abre ou fecha portao, se tiver aberto fecha , se tiver fechao abre
    {
    digitalWrite(13, HIGH); // liga rele abrindo ou fechando portão
    delay(1000); // tempo do rele
    digitalWrite(13, LOW); // desliga rele
    } // Fim do Abre_Fecha
    // —————————– loop —————————————-
    void loop () // Funçao loop
    {
    sendIdentifyCmd (); // Envia comando de leitura de tag
    delay (2); // Delay
    if(mySerial.available () > 0) // Se houver leitura de tag
    { // Faca
    incomingByte=mySerial.read (); // Leia a tag
    Serial.println (incomingByte,HEX); // imprime no monitor
    Tag_Flag = 1; // Existe carro no portao
    if (Portao_Flag == 0) // Se o porta esta fechado
    { // Faca
    Abre_Fecha (); // Abre portao apos receber uma tag
    Portao_Flag = 1; // informa que o portao esta aberto
    } // Fim do if – Se o portao esta fechado
    Tag_Flag = 0; // Nao existe carro no portao
    delay (480000); // deleay de 8 minutos
    } // Fim do if – Se houver leitura de tag
    else // Se nao houver leitura de tag
    { // Faca
    if (Portao_Flag == 1) // Se o portao esta aberto
    { // Faca
    Abre_Fecha (); // Fecha portao
    Portao_Flag = 0; // informa que o portao esta fechado
    } // Fim do if – Se o portao esta aberto
    } // Fim do else
    delay (1000); // Delay de 1 segundo ??
    } // Fim do loop

  3. AFRANIO às 14:22

    Euler quero adquirir esse projeto essa semana estarei comprando os materiais, tem como eu substituir a cancela quando o carro for negado acesso pelo uso de um dispositivo sonoro tipo uma sirene. Que código usar?

  4. Afranio às 17:38

    Amigo estou com problema no segundo código nessa em negrito

    #include //INCLUSÃO DE BIBLIOTECA
    #include //INCLUSÃO DE BIBLIOTECA

    #define SS_PIN 10 //PINO SDA
    #define RST_PIN 9 //PINO DE RESET

    MFRC522 rfid(SS_PIN, RST_PIN); //PASSAGEM DE PARÂMETROS REFERENTE AOS PINOS

    void setup() {
    Serial.begin(9600); //INICIALIZA A SERIAL
    SPI.begin(); //INICIALIZA O BARRAMENTO SPI
    rfid.PCD_Init(); //INICIALIZA MFRC522
    }

    void loop() {
    if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) //VERIFICA SE O CARTÃO PRESENTE NO LEITOR É DIFERENTE DO ÚLTIMO CARTÃO LIDO. CASO NÃO SEJA, FAZ
    return; //RETORNA PARA LER NOVAMENTE

    /***INICIO BLOCO DE CÓDIGO RESPONSÁVEL POR GERAR A TAG RFID LIDA***/
    String strID = “”;
    for (byte i = 0; i < 4; i++) {
    strID +=
    (rfid.uid.uidByte[i] < 0x10 ? "0" : "") +
    String(rfid.uid.uidByte[i], HEX) +
    (i!=3 ? ":" : "");
    }
    strID.toUpperCase();
    /***FIM DO BLOCO DE CÓDIGO RESPONSÁVEL POR GERAR A TAG RFID LIDA***/

    Serial.print("Identificador (UID) da tag: "); //IMPRIME O TEXTO NA SERIAL
    Serial.println(strID); //IMPRIME NA SERIAL O UID DA TAG RFID

    rfid.PICC_HaltA(); //PARADA DA LEITURA DO CARTÃO
    rfid.PCD_StopCrypto1(); //PARADA DA CRIPTOGRAFIA NO PCD
    }
    #include //INCLUSÃO DE BIBLIOTECA
    #include //INCLUSÃO DE BIBLIOTECA
    #include //INCLUSÃO DE BIBLIOTECA
    #include //INCLUSÃO DE BIBLIOTECA
    #include //INCLUSÃO DE BIBLIOTECA
    #include //INCLUSÃO DE BIBLIOTECA

    Adafruit_SSD1306 display = Adafruit_SSD1306(); //OBJETO DO TIPO Adafruit_SSD1306

    #define SS_PIN 10 //PINO SDA
    #define RST_PIN 9 //PINO DE RESET

    MFRC522 rfid(SS_PIN, RST_PIN); //PASSAGEM DE PARÂMETROS REFERENTE AOS PINOS

    Servo s; //OBJETO DO TIPO SERVO
    int pos; //POSIÇÃO DO SERVO

    const int pinoLedVerde = 2; //PINO DIGITAL REFERENTE AO LED VERDE
    const int pinoLedVermelho = 3; //PINO DIGITAL REFERENTE AO LED VERMELHO
    const int pinoServo = 6; // PINO DIGITAL REFERENTE AO SERVO MOTOR

    byte anguloCancelaFechada = 74; //VALOR DO ÂNGULO PARA CANCELA FECHADA
    byte anguloCancelaAberta = 174; //VALOR DO ÂNGULO PARA CANCELA ABERTA

    void setup(){

    Wire.begin(); //INICIALIZA A BIBLIOTECA WIRE
    display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //INICIALIZA O DISPLAY COM ENDEREÇO I2C 0x3C
    display.setTextColor(WHITE); //DEFINE A COR DO TEXTO
    display.setTextSize(1); //DEFINE O TAMANHO DA FONTE DO TEXTO
    display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
    display.setCursor(14,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“MasterWalker Shop”); //ESCREVE O TEXTO NO DISPLAY
    display.display(); //EFETIVA A ESCRITA NO DISPLAY

    SPI.begin(); //INICIALIZA O BARRAMENTO SPI
    rfid.PCD_Init(); //INICIALIZA MFRC522

    s.attach(pinoServo); //ASSOCIAÇÃO DO PINO DIGITAL AO OBJETO DO TIPO SERVO
    s.write(74); //INICIA O MOTOR NA POSIÇÃO 0º

    pinMode(pinoLedVerde, OUTPUT); //DEFINE O PINO COMO SAÍDA
    pinMode(pinoLedVermelho, OUTPUT); //DEFINE O PINO COMO SAÍDA

    digitalWrite(pinoLedVerde, LOW); //LED INICIA DESLIGADO
    digitalWrite(pinoLedVermelho, LOW); //LED INICIA DESLIGADO
    }

    void loop() {
    leituraRfid(); //CHAMA A FUNÇÃO RESPONSÁVEL PELA VALIDAÇÃO DA TAG RFID
    }

    //FUNÇÃO DE VALIDAÇÃO DA TAG RFID
    void leituraRfid(){
    if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) //VERIFICA SE O CARTÃO PRESENTE NO LEITOR É DIFERENTE DO ÚLTIMO CARTÃO LIDO. CASO NÃO SEJA, FAZ
    return; //RETORNA PARA LER NOVAMENTE

    display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
    display.setCursor(40,0); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“Aguarde”); //ESCREVE O TEXTO NO DISPLAY
    display.setCursor(50,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“por”); //ESCREVE O TEXTO NO DISPLAY
    display.setCursor(30,20); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“favor…”); //ESCREVE O TEXTO NO DISPLAY
    display.display(); //EFETIVA A ESCRITA NO DISPLAY
    delay(4000); //INTERVALO DE 4 SEGUNDOS

    /***INICIO BLOCO DE CÓDIGO RESPONSÁVEL POR GERAR A TAG RFID LIDA***/
    String strID = “”;
    for (byte i = 0; i < 4; i++) {
    strID +=
    (rfid.uid.uidByte[i] = 0) { //SE O ENDEREÇO DA TAG LIDA FOR IGUAL AO ENDEREÇO INFORMADO, FAZ
    digitalWrite(pinoLedVerde, HIGH); //LIGA O LED VERDE
    display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
    display.setCursor(45,5); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“Acesso”); //ESCREVE O TEXTO NO DISPLAY
    display.setCursor(35,15); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“Autorizado”); //ESCREVE O TEXTO NO DISPLAY
    display.display(); //EFETIVA A ESCRITA NO DISPLAY
    delay(4000); //INTERVALO DE 4 SEGUNDOS
    abrirCancela(); //CHAMA A FUNÇÃO RESPONSÁVEL POR ABRIR A CANCELA
    delay(6000); //INTERVALO DE 6 SEGUNDOS
    fecharCancela(); //CHAMA A FUNÇÃO RESPONSÁVEL POR FECHAR A CANCELA
    digitalWrite(pinoLedVerde, LOW); //DESLIGA O LED VERDE
    }else{ //SENÃO, FAZ (CASO A TAG LIDA NÃO SEJÁ VÁLIDA)
    digitalWrite(pinoLedVermelho, HIGH); //LIGA O LED VERMELHO
    display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
    display.setCursor(45,5); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“Acesso”); //ESCREVE O TEXTO NO DISPLAY
    display.setCursor(45,15); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“Negado”); //ESCREVE O TEXTO NO DISPLAY
    display.display(); //EFETIVA A ESCRITA NO DISPLAY
    delay(6000); ////INTERVALO DE 6 SEGUNDOS
    digitalWrite(pinoLedVermelho, LOW); //DESLIGA O LED VERDE
    display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
    display.setCursor(14,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“MasterWalker Shop”); //ESCREVE O TEXTO NO DISPLAY
    display.display(); //EFETIVA A ESCRITA NO DISPLAY
    }

    rfid.PICC_HaltA(); //PARADA DA LEITURA DO CARTÃO
    rfid.PCD_StopCrypto1(); //PARADA DA CRIPTOGRAFIA NO PCD
    }

    //FUNÇÃO PARA ABRIR A CANCELA
    void abrirCancela(){
    for(pos = anguloCancelaFechada; pos = anguloCancelaFechada; pos–){ //PARA “pos” IGUAL A “anguloCancelaAberta”,
    //ENQUANTO “pos” MAIOR OU IGUAL “anguloCancelaFechada”, DECREMENTA “pos”
    s.write(pos); //ESCREVE O VALOR DA POSIÇÃO QUE O SERVO DEVE GIRAR
    delay(15); //INTERVALO DE 15 MILISEGUNDOS
    }
    display.clearDisplay(); //LIMPA AS INFORMAÇÕES DO DISPLAY
    display.setCursor(14,10); //POSIÇÃO EM QUE O CURSOR IRÁ FAZER A ESCRITA
    display.print(“MasterWalker Shop”); //ESCREVE O TEXTO NO DISPLAY
    display.display(); //EFETIVA A ESCRITA NO DISPLAY
    }

    • Euler Oliveira Autor às 11:49

      Olá Afranio.

      Recomendo que verifique se instalou as bibliotecas corretamente, pois este código é o mesmo que usei para demonstração final do projeto.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *