




A identificação por radiofrequência, conhecida como RFID (Radio Frequency Identification), permite reconhecer cartões e chaveiros por aproximação, sendo utilizada em aplicações como controle de acesso, identificação de produtos e automação. Com um microcontrolador e um leitor RFID, podemos explorar essa tecnologia para construir um sistema que identifica uma credencial e aciona uma trava elétrica quando o acesso é autorizado.
Neste projeto, utilizaremos um ESP32-C3 e um leitor RFID RC522 para desenvolver um controle de acesso com interface Web autenticada, acessível pelo navegador de um computador ou celular. Por essa interface, será possível cadastrar e remover cartões, acompanhar as leituras e comandar a liberação da trava, sem instalar um aplicativo específico ou modificar o código a cada novo cadastro.
A proposta complementa os projetos sobre RFID já publicados no Blog da Eletrogate ao integrar o gerenciamento de cartões à conectividade Wi-Fi do ESP32-C3. Os identificadores autorizados serão armazenados em LittleFS, preservando os cadastros após o desligamento. A validação dos cartões será realizada pelo próprio dispositivo, permitindo o acionamento da trava mesmo sem conexão com a internet ou com a interface Web aberta.
Também exploraremos a atualização da interface por WebSocket, a exibição do último acesso autorizado de cada cartão e a sincronização de horário por NTP ou pelo navegador. O acesso à aplicação poderá ocorrer pela rede Wi-Fi existente ou diretamente pela rede criada pelo ESP32-C3.
Ao longo do artigo, apresentaremos os componentes, as ligações elétricas, a configuração do firmware e a operação da interface, construindo um protótipo que reúne identificação, acionamento e administração local em uma mesma solução.
Em um projeto de controle de acesso, reconhecer um cartão e acionar uma trava é apenas parte da solução. Também é necessário administrar as credenciais: incluir novos cartões, remover aqueles que não devem mais permitir o acesso e acompanhar sua utilização. Realizar essas tarefas diretamente pelo navegador torna a operação mais prática e dispensa alterações no firmware a cada mudança na lista de cartões autorizados.
Essa necessidade motivou o desenvolvimento de um sistema que reúne controle de acesso e administração local no próprio ESP32-C3. O leitor RFID identifica os cartões, enquanto a interface Web permite gerenciar os cadastros e liberar a trava manualmente. A comunicação por WebSocket apresenta as leituras e atualizações na tela sem que o usuário precise recarregar a página.
Outro aspecto considerado foi a independência de uma conexão com a internet. A lista de cartões permanece armazenada no dispositivo, e a validação das credenciais ocorre localmente. Além disso, o modo ponto de acesso permite conectar um computador ou celular diretamente ao ESP32-C3 para administrar o sistema mesmo onde não existe uma rede Wi-Fi disponível.
A exibição do último acesso autorizado de cada cartão acrescenta uma informação útil à administração. Para associar esse acesso à data e ao horário, o projeto oferece sincronização por NTP quando há conectividade com o servidor de horário e, como alternativa, sincronização pelo navegador durante a operação local.
Com essa proposta, buscamos oferecer à comunidade uma experiência prática de integração entre RFID, armazenamento persistente, comunicação Web e acionamento de uma carga elétrica. O protótipo também serve como base para explorar novas funcionalidades e adaptar os conhecimentos apresentados a outras aplicações de automação.
O sistema é composto por um ESP32-C3, um leitor RFID RC522 e uma trava elétrica acionada por um módulo relé. O ESP32-C3 realiza a leitura dos cartões, consulta a lista de identificadores autorizados e controla o acionamento da trava. Também hospeda a interface Web utilizada para operar e configurar o dispositivo.
Ao aproximar um cartão ou chaveiro do leitor, seu identificador, denominado UID, é comparado com os cadastros armazenados no dispositivo. Se estiver autorizado, o relé é acionado durante o intervalo definido no firmware, energizando a trava para liberar a abertura. Ao término desse intervalo, o relé é desativado. Cartões não cadastrados têm sua leitura apresentada na interface, mas não provocam a liberação da trava.
A Tela Operação reúne as funções de uso diário: visualizar o identificador lido, adicionar e remover cartões da lista autorizada e liberar a trava manualmente. Ela também apresenta informações do leitor RFID, da conexão de rede e do relógio do dispositivo, além do último acesso autorizado de cada cartão.

Figura 1 - Tela Operação: gerenciamento dos cartões RFID e acionamento manual da trava.
O cadastro pode ser realizado aproximando o cartão do leitor e utilizando o identificador recebido na interface. Após a inclusão, o cartão passa a permitir o acionamento da trava. Sua remoção revoga essa autorização. Os cadastros são gravados em LittleFS, mantendo a lista disponível após o desligamento ou reinício do ESP32-C3.
A comunicação entre o navegador e o dispositivo utiliza WebSocket, permitindo apresentar novas leituras, mensagens e alterações de estado sem recarregar a página. O navegador funciona como ferramenta de administração; a leitura e a autorização dos cartões continuam sendo executadas pelo ESP32-C3 mesmo quando a página está fechada.
Para acessar a aplicação, o usuário pode conectar-se diretamente à rede Wi-Fi criada pelo dispositivo, no modo AP, ou utilizar sua conexão com uma rede existente, no modo STA. A Tela Configuração permite ajustar os parâmetros de rede, as credenciais de administração e as opções de horário. O acesso às páginas e aos comandos de administração exige autenticação.
Nas próximas seções, apresentaremos as ligações do circuito, a preparação do firmware e os procedimentos de configuração e operação, utilizando o diagrama de montagem e as telas da aplicação como referência.
A montagem reúne três partes: o ESP32-C3, responsável pelo processamento e pela interface Web; o leitor RFID RC522, responsável pela identificação dos cartões; e o conjunto relé e trava elétrica, responsável pela liberação do acesso. O diagrama a seguir apresenta as conexões utilizadas no protótipo.

Figura 2 - Diagrama do circuito: conexões entre ESP32-C3, leitor RFID RC522, módulo relé e trava elétrica.
O leitor RC522 comunica-se com o ESP32-C3 por meio do barramento SPI. Além das linhas de comunicação, são utilizados um pino para seleção do leitor e outro para seu reinício. A tabela abaixo apresenta o mapeamento definido no firmware.
| Pino do RC522 | Conexão no ESP32-C3 | Função |
|---|---|---|
| VCC / 3.3V | 3V3 | Alimentação do leitor |
| GND | GND | Referência elétrica |
| SDA / SS | GPIO10 | Seleção do dispositivo SPI |
| SCK | GPIO4 | Clock da comunicação SPI |
| MISO | GPIO5 | Dados do leitor para o ESP32-C3 |
| MOSI | GPIO6 | Dados do ESP32-C3 para o leitor |
| RST | GPIO9 | Reinício do leitor |
| IRQ | Não conectado | Não utilizado neste projeto |
Atenção: o RC522 deve ser alimentado pela saída de 3,3 V. O terminal identificado como SDA no módulo exerce a função de seleção SS nesta montagem; a comunicação utilizada é SPI.
O comando do módulo relé está conectado ao GPIO7 do ESP32-C3. Sua alimentação deve respeitar a tensão especificada para o módulo, e a entrada de comando deve ser compatível com a lógica de 3,3 V do microcontrolador. Na montagem utilizada, o GND do módulo relé é conectado ao GND do ESP32-C3.
O firmware permite definir os níveis de acionamento por meio das constantes RELE_ON e RELE_OFF. Na versão apresentada, o nível LOW aciona o relé e o nível HIGH desativa. Caso seja utilizado um módulo com acionamento em nível baixo, essas definições devem ser invertidas.
A trava recebe alimentação por meio dos contatos do relé, sem passar pelos pinos do ESP32-C3. Para o modelo utilizado, que libera a abertura quando energizado, o positivo da fonte é conectado ao terminal COM do relé. O terminal NA, normalmente aberto, é conectado ao positivo da trava, enquanto o negativo da trava retorna diretamente ao negativo da fonte.
Quando o relé é acionado, os contatos COM e NA fecham o circuito e energizam a trava. Ao término do tempo de liberação, o relé é desativado e interrompe sua alimentação. A fonte deve atender à tensão e à corrente exigidas pela trava; no modelo utilizado no projeto, a faixa informada é de 7 a 12 V, com corrente aproximada de 0,8 A.
Para proteger o circuito contra o transiente produzido no desligamento da bobina da trava, é utilizado um diodo 1N4007 em paralelo com seus terminais. O cátodo, identificado pela faixa no corpo do componente, deve ser conectado ao positivo da trava, e o ânodo ao negativo. O diodo deve ficar próximo à trava.
Durante a alimentação normal, o diodo permanece polarizado reversamente. Quando o relé interrompe a corrente, ele oferece um caminho para a corrente residual da bobina. Esse componente protege o circuito da trava e é adicional ao diodo que eventualmente já existe no módulo para proteger a bobina do próprio relé.
Antes de energizar a montagem, confira as ligações e a polaridade do diodo. A trava deve permanecer desenergizada em repouso e receber alimentação somente durante o comando de liberação.
O firmware foi desenvolvido em C++ utilizando a Arduino IDE. Antes de gravá-lo no ESP32-C3, é necessário instalar o suporte às placas ESP32 e as bibliotecas utilizadas pelo projeto.
No Gerenciador de Placas da Arduino IDE, instale o pacote esp32, da Espressif Systems. Em seguida, selecione a placa correspondente ao modelo utilizado. Para o ESP32-C3 SuperMini, a opção utilizada é ESP32C3 Dev Module. Selecione também a porta USB atribuída ao dispositivo.
O projeto utiliza as seguintes bibliotecas adicionais:
A versão do código apresentada utiliza a sintaxe da ArduinoJson 7. As bibliotecas ESPAsyncWebServer e AsyncTCP devem ser de versões compatíveis entre si e com o pacote ESP32 instalado.
As bibliotecas WiFi, ESPmDNS, SPI e LittleFS são fornecidas pelo pacote ESP32. Elas permitem conectar o dispositivo à rede, disponibilizar seu nome local, comunicar-se com o leitor e armazenar os dados na memória flash.
O código está organizado em um arquivo principal com extensão .ino e dois arquivos de interface: html_main.h e html_config.h. Os três arquivos devem permanecer na mesma pasta do sketch, cujo nome deve corresponder ao nome do arquivo principal.
Ao abrir o arquivo principal na Arduino IDE, os arquivos de interface presentes na pasta ficam disponíveis como abas. As páginas estão incorporadas ao firmware, dispensando o envio separado de arquivos HTML para o dispositivo.
O projeto utiliza o LittleFS para armazenar dois arquivos: config.json, com os parâmetros de configuração, e cartoes.json, com os cartões cadastrados e o horário do último acesso autorizado de cada um.
Selecione um esquema de particionamento que reserve espaço para o sistema de arquivos. No primeiro funcionamento, o firmware cria os arquivos necessários, sem exigir o envio prévio de uma pasta de dados. Nas inicializações seguintes, os dados gravados são carregados automaticamente.
Com a placa, a porta e as bibliotecas configuradas, compile o sketch e faça a gravação pelo cabo USB. Depois, abra o Monitor Serial em 115200 baud para acompanhar a inicialização.
O Monitor Serial apresenta informações como a detecção e a versão do leitor RFID, o endereço IP da rede criada pelo dispositivo e a quantidade de cartões carregados. Essas mensagens auxiliam na conferência inicial antes do acesso à interface Web.
Na configuração utilizada neste projeto, mantenha a opção USB CDC On Boot: Enabled para acompanhar as mensagens do firmware pelo Monitor Serial através da conexão USB nativa do ESP32-C3. A imagem a seguir apresenta as opções utilizadas na compilação e gravação do protótipo.

Figura 3 - Configuração da placa na Arduino IDE, com destaque para USB CDC On Boot habilitado.
Após a gravação do firmware, o ESP32-C3 inicia sua própria rede Wi-Fi, permitindo acessar a aplicação antes de configurar uma conexão com o roteador. Esse modo de funcionamento é denominado AP (Access Point, ou ponto de acesso).
No computador ou celular, procure a rede RFID-Porta e conecte-se utilizando a senha inicial 12345678. Como essa rede permite comunicação local com o ESP32-C3, o sistema operacional poderá informar que ela não possui acesso à internet. Mantenha a conexão para acessar a aplicação.
Abra o navegador e digite http://192.168.4.1. Quando solicitado, informe o usuário admin e a senha admin. Esses são os valores iniciais definidos no firmware e podem ser alterados na Tela Configuração.
Se o dispositivo já tiver sido configurado anteriormente, utilize o nome de rede e as credenciais que foram salvos, pois os parâmetros permanecem armazenados após o reinício.
Na Tela Operação, acesse a opção Configuração. Essa página reúne os parâmetros de identificação do dispositivo, autenticação, redes Wi-Fi e sincronização de horário.

Figura 4 - Tela Configuração Parte 1: identificação do dispositivo, credenciais de administração, redes Wi-Fi e parâmetros de horário.

Figura 5 - Tela Configuração Parte 2
Na configuração inicial, o servidor NTP é pool.ntp.org e o fuso horário é <-03>3, correspondente a UTC−3, sem ajuste de horário de verão. O campo utiliza o formato de configuração de fuso horário aceito pelo firmware.
Altere as credenciais iniciais de administração e a senha do AP antes de utilizar o protótipo. Nos campos de senha, deixar o valor vazio mantém a senha já armazenada. A senha da rede AP deve possuir pelo menos oito caracteres.
Após preencher os campos, salve a configuração e utilize o botão de reinício para aplicar os parâmetros. Se o nome ou a senha da rede AP tiver sido alterado, reconecte o computador ou celular utilizando os novos dados. Se as credenciais de administração forem modificadas, o navegador poderá solicitar uma nova autenticação.
Quando um SSID de rede existente é configurado, o ESP32-C3 tenta conectar-se ao roteador no modo STA (Station). A rede AP permanece disponível, permitindo manter uma alternativa de acesso direto ao dispositivo.
Com o computador ou celular conectado à mesma rede do ESP32-C3, abra no navegador o endereço IP STA apresentado na Tela Operação ou no Monitor Serial. Também é possível utilizar http://rfid-porta.local, considerando o nome inicial do dispositivo e o suporte a mDNS no equipamento utilizado. Se o nome for alterado, o endereço passa a utilizar o novo nome seguido de .local.
A conexão ao roteador facilita o acesso pela rede local e permite a sincronização por NTP quando o servidor está acessível. Entretanto, a leitura dos cartões e a validação dos cadastros continuam sendo realizadas localmente, independentemente da disponibilidade de internet.
Após configurar o dispositivo, acesse a Tela Operação para administrar os cartões e acompanhar as leituras do RFID. A página apresenta a lista de identificadores cadastrados, o campo de UID lido ou selecionado e os botões Adicionar, Remover e Abrir trava.
Para cadastrar uma credencial, aproxime o cartão ou chaveiro do leitor RC522. Seu UID será apresentado automaticamente no campo da interface. Se ainda não estiver cadastrado, a página exibirá a mensagem Cartão não cadastrado, sem liberar a trava.
Confira o identificador e clique em Adicionar. O UID será incluído na lista de cartões autorizados, e a interface apresentará a confirmação. A partir desse momento, uma nova aproximação da credencial permitirá o acionamento da trava.
Também é possível informar um UID diretamente no campo de texto. Entretanto, a leitura por aproximação facilita o cadastro e evita erros de digitação. O firmware impede a inclusão de identificadores duplicados e permite cadastrar até 100 cartões.
Ao identificar um cartão cadastrado, o ESP32-C3 aciona a liberação e apresenta a mensagem Cartão autorizado na interface. Na configuração do firmware apresentado, o tempo de acionamento é de 1,5 segundo, definido pela constante TEMPO_ABERTURA_TRAVA_MS.
A temporização é realizada sem uma espera bloqueante durante todo o intervalo, permitindo que o dispositivo continue atendendo às demais tarefas. Ao término do tempo, a saída de acionamento é desativada automaticamente.
A interface Web não precisa permanecer aberta para o acesso por RFID. A leitura, a consulta à lista de cartões e o comando de liberação são executados localmente pelo ESP32-C3.
Selecione um cartão na lista para visualizar seu UID e consultar o último acesso autorizado. Quando o relógio está sincronizado, a interface apresenta a data, o horário e o tempo decorrido desde esse acesso. Se o cartão ainda não tiver sido utilizado, será exibida uma mensagem indicando a ausência de registro.
Esse recurso armazena somente o último acesso autorizado de cada cartão. As leituras de credenciais não cadastradas são apresentadas na interface, mas não constituem um histórico persistente de tentativas de acesso.
Para revogar uma autorização, selecione o cartão na lista e clique em Remover. Após confirmar a operação, o UID será excluído dos cadastros. Nas próximas leituras, essa credencial será tratada como não cadastrada e não permitirá a liberação da trava.
O botão Abrir trava permite comandar a liberação pelo navegador, sem aproximar uma credencial do leitor. Após a confirmação, o dispositivo realiza o acionamento pelo mesmo intervalo utilizado no acesso por RFID.
Esse comando exige acesso autenticado à aplicação. Como a liberação manual não está associada a um cartão, ela não altera o registro de último acesso das credenciais cadastradas.
As alterações dos cadastros e dos registros de acesso são gravadas em LittleFS após um intervalo de aproximadamente 1,5 segundo sem novas alterações. Essa estratégia agrupa atualizações próximas e reduz a quantidade de gravações na memória flash. Aguarde esse intervalo antes de desligar a alimentação para permitir a persistência dos dados.
A seção Estado apresenta a conexão WebSocket, as informações do relógio e o estado comandado da trava. A indicação de liberação corresponde ao acionamento da saída; o protótipo não possui sensor para confirmar a posição física da trava ou da porta.
Durante o modo de atualização do firmware, a operação fica suspensa e novos acionamentos são bloqueados. Após o reinício do dispositivo, o funcionamento normal é retomado.
O sistema registra o último acesso autorizado de cada cartão. Para apresentar esse registro com data e horário, o relógio do ESP32-C3 precisa estar sincronizado. O projeto oferece duas alternativas: sincronização por NTP e sincronização pelo navegador.
Quando conectado à rede Wi-Fi no modo STA, o dispositivo pode obter o horário de um servidor NTP (Network Time Protocol). Para isso, o servidor configurado deve estar acessível pela rede. Na configuração inicial, é utilizado pool.ntp.org.
Após a sincronização, as telas da aplicação apresentam o horário local e indicam NTP como sua origem. O fuso horário definido na Tela Configuração determina como as datas são exibidas; o valor inicial <-03>3 corresponde a UTC−3, sem ajuste de horário de verão.
No modo AP, é possível administrar o dispositivo diretamente, mesmo sem acesso à internet. Nesse caso, abra a Tela Configuração e clique em Sincronizar com o horário do navegador. O navegador envia o horário do computador ou celular ao ESP32-C3, que ajusta seu relógio e identifica a origem como Navegador.
Antes de utilizar essa opção, confira se a data e o horário do computador ou celular estão corretos. O horário recebido será apresentado de acordo com o fuso configurado no dispositivo.
A ausência de horário sincronizado não impede a validação dos cartões ou o acionamento da trava. Se um acesso autorizado ocorrer nessa condição, o firmware registra o instante relativo à inicialização, permitindo à interface apresentar há quanto tempo ele ocorreu durante aquela sessão de funcionamento.
Se o relógio for sincronizado posteriormente, ainda na mesma inicialização, o firmware utiliza o tempo decorrido para estimar a data e o horário desse acesso. Essa informação passa então a integrar o registro persistente do cartão.
Os registros que já possuem data e horário são armazenados em LittleFS e carregados após o reinício. Entretanto, o relógio do dispositivo precisa ser sincronizado novamente para calcular corretamente o tempo decorrido desde o último acesso.
O protótipo não utiliza um relógio externo com bateria. Portanto, se um acesso ocorrer sem sincronização e o dispositivo for reiniciado antes de receber um horário válido, a referência temporal daquele acesso não poderá ser recuperada. Para manter os registros com data e horário, sincronize o relógio após cada inicialização, por NTP ou pelo navegador.
O projeto utiliza a biblioteca AsyncElegantOTA para atualizar o firmware pelo navegador, sem conectar o ESP32-C3 ao computador por cabo USB. Esse recurso, conhecido como OTA (Over-The-Air), facilita a manutenção do dispositivo após sua instalação. O computador ou celular deve conseguir acessar o ESP32-C3 pela rede AP ou pela rede Wi-Fi existente.
Na Arduino IDE, mantenha a placa e as opções utilizadas na gravação inicial e selecione Sketch > Exportar Binário Compilado. Localize o arquivo .bin correspondente à aplicação entre os arquivos gerados. Não utilize os binários de bootloader, tabela de partições ou imagem combinada, identificada como merged.
A atualização OTA exige um esquema de particionamento com espaço reservado para duas aplicações. Esse esquema deve estar definido desde a gravação inicial por USB. Para preservar os dados do projeto, mantenha o mesmo particionamento nas atualizações seguintes.
Na Tela Configuração, clique em Atualizar firmware e confirme a entrada no modo de atualização. A página utiliza as credenciais de administração do dispositivo e também pode ser acessada pelo endereço IP seguido de /update.
Ao acessar esse endereço com autenticação válida, o firmware salva os cadastros pendentes, desenergiza a saída de acionamento da trava e entra em modo de manutenção. Nesse modo, a leitura RFID e os comandos de alteração de cartões, sincronização pelo navegador e abertura manual ficam bloqueados. As alterações de configuração também ficam suspensas.

Figura 6 - Autenticação para acesso à atualização OTA, utilizando as credenciais de administração do dispositivo.
Na página de atualização, selecione Firmware, escolha o arquivo .bin da aplicação e inicie o envio. Mantenha a alimentação e a conexão de rede durante o processo. Ao concluir o processamento do upload, a biblioteca executa o reinício do dispositivo; confira a indicação de sucesso antes de verificar a nova versão.
Não utilize a opção Filesystem. Ela se destina à atualização do sistema de arquivos e pode substituir os arquivos que armazenam os cartões e a configuração. Para atualizar este projeto, envie somente o firmware da aplicação.

Figura 7 - Página de atualização OTA: seleção da opção Firmware e do arquivo .bin da aplicação.

Figura 8 - Seleção da Imagem do Firmware.
Após o reinício, o ESP32-C3 carrega os cadastros e as configurações armazenados e retoma a operação normal. Atualizar somente a aplicação, mantendo o particionamento e um firmware compatível com os arquivos existentes, preserva os dados em LittleFS.
Se a atualização for cancelada antes do envio, o dispositivo continuará em modo de manutenção. Para voltar à operação, retorne à Tela Configuração e utilize Reiniciar equipamento. Durante um upload em andamento, esse comando de reinício fica bloqueado.
Após atualizar, confira o acesso à interface, a lista de cartões e o funcionamento de uma credencial cadastrada. A atualização OTA, o bloqueio dos comandos durante a manutenção e a preservação dos dados foram verificados nos testes de bancada deste protótipo.
O firmware está organizado em blocos responsáveis pela leitura RFID, validação dos cartões, acionamento da trava, armazenamento dos dados, sincronização de horário e comunicação com o navegador. Essa divisão facilita a compreensão do código e a realização de ajustes.
A função setup() configura a comunicação serial e coloca a saída de acionamento da trava no estado desativado. Em seguida, inicializa o LittleFS e carrega os parâmetros de configuração e a lista de cartões armazenados.
Depois, são inicializados o barramento SPI e o leitor RC522. O firmware consulta o registrador de versão do leitor e apresenta o resultado no Monitor Serial e na interface Web. Por fim, configura as conexões de rede, o serviço mDNS, o relógio e as rotas do servidor.
A rotina serviceRfid() verifica a presença de uma credencial e realiza a leitura de seu UID. A função uidFromReader() converte os bytes recebidos em uma sequência hexadecimal, que é consultada na lista de cartões pela função findCard().
Quando o UID está cadastrado, o firmware atualiza o registro de último acesso, solicita a gravação dos dados e chama activateLock(). Se o identificador não estiver autorizado, apenas comunica a leitura à interface, sem acionar a saída.
A função activateLock() ativa a saída e registra o instante de início utilizando millis(). A rotina serviceLock() compara o tempo decorrido com o intervalo definido em TEMPO_ABERTURA_TRAVA_MS e desativa a saída quando esse intervalo termina.
Essa estratégia dispensa uma pausa bloqueante durante o período de liberação. Se um novo comando de acionamento for recebido enquanto a saída estiver ativa, o instante inicial será atualizado, renovando o intervalo de liberação.
Os parâmetros do dispositivo são armazenados no arquivo config.json. Já o arquivo cartoes.json contém os UIDs cadastrados e os respectivos registros de último acesso com data e horário. A biblioteca ArduinoJson realiza a conversão entre as estruturas utilizadas pelo programa e o formato JSON dos arquivos.
A função markCardsDirty() indica que existem alterações pendentes. A rotina servicePersistence() aguarda o intervalo definido em ATRASO_GRAVACAO_MS antes de chamar saveCards(), agrupando alterações próximas em uma única gravação.
O servidor disponibiliza a Tela Operação no endereço / e a Tela Configuração em /config. As páginas estão incorporadas ao firmware nos arquivos html_main.h e html_config.h.
A conexão WebSocket utiliza o endereço /ws. Por ela, o navegador envia comandos para cadastrar e remover cartões, liberar a trava, sincronizar o horário e consultar o estado do dispositivo. O firmware responde com mensagens JSON contendo os dados e os eventos da aplicação.
A função sendState() envia informações como a lista de cartões, o relógio, os endereços de rede e o estado de acionamento. A função sendEvent() comunica eventos e mensagens, incluindo leituras RFID e resultados das operações. As páginas e a conexão WebSocket utilizam autenticação administrativa.
A integração com AsyncElegantOTA inclui um filtro denominado OtaMaintenanceGate. Antes de permitir o acesso autenticado à atualização, ele coloca o dispositivo em manutenção, desativa a saída da trava e tenta salvar os cadastros pendentes. Se a gravação falhar, a atualização não é iniciada.
A variável otaMaintenance mantém o bloqueio das operações até o reinício. Esse controle também é aplicado quando o endereço de atualização é acessado diretamente, garantindo o mesmo comportamento do link disponível na Tela Configuração.
A função loop() chama continuamente as rotinas de leitura RFID, temporização da saída, persistência e verificação da sincronização NTP. Também executa a limpeza das conexões WebSocket. O servidor assíncrono atende às requisições e aos comandos por seus próprios eventos, integrando a interface Web às tarefas do dispositivo.
O código-fonte do projeto é composto por três arquivos: controle_acesso_rfid.ino, html_main.h e html_config.h. O arquivo principal contém a lógica do dispositivo, enquanto os dois headers contêm o HTML, o CSS e o JavaScript das telas de operação e configuração.
Para abrir o projeto, grave os três arquivos com seus respectivos nomes na pasta controle_acesso_rfid. Abra o arquivo controle_acesso_rfid.ino na Arduino IDE; os arquivos de interface presentes nessa pasta ficarão disponíveis como abas do editor.
Os arquivos de interface estão formatados e indentados para facilitar a leitura e a personalização. Como as páginas são incorporadas ao firmware, alterações nesses arquivos exigem uma nova compilação e gravação da aplicação, por USB ou OTA.
Antes de compilar, confira as bibliotecas e as opções descritas na seção Preparação do Firmware. Para a atualização OTA, esta versão utiliza AsyncElegantOTA 2.2.7. Mantenha a opção USB CDC On Boot: Enabled para acompanhar as mensagens pela conexão USB nativa do ESP32-C3 e utilize um particionamento com suporte a OTA e espaço para LittleFS.
//---------------------------------------------------------------------------------------------------------
// Projeto : Controle de Acesso Web utilizando RFID
//
// Funções : . Manutenção de um Cadastro de ID de Tags no LittleFS via Web
// . Aceitar acesso via Tag RFID e abrir a Trava Elétrica para Tags cadastradas
// . Funciona nos Modos AP e STA simultaneamente
// . Suporta abertura manual da trava elétrica via Web
// . Permite atualização de Firmware via Web usando a AsyncElegantOTA.h
// . Sincronismo do relógio interno via NTP ou Navegador
// . Disponibilização de Alias mDNS para acesso na Rede Wifi
//
// Autor : Dailton Menezes
//
// Versão : V1.0 Out/2026
//
// Hardwares: . Microcontrolador ESP32C3 Mini
// . Leitor RFID RC522
// . Trava Elétrica 7-12V
// . Módulo Relé 1 Canal 3,3V 10A 250VAC / 10A 125VAC / 10A 30VDC / 10A 28VDC
// . Diodo 1N4007
//---------------------------------------------------------------------------------------------------------
#include <Arduino.h>
#include <WiFi.h>
#include <ESPmDNS.h>
#include <LittleFS.h>
#include <SPI.h>
#include <MFRC522.h>
#include <ESPAsyncWebServer.h>
#include <AsyncTCP.h>
#include <AsyncElegantOTA.h>
#include <ArduinoJson.h>
#include <sys/time.h>
#include <time.h>
#include <vector>
#include "html_main.h"
#include "html_config.h"
//----------------------
// Definição de Pinos
//----------------------
#define PIN_RC522_SS 10
#define PIN_RC522_RST 9
#define PIN_RC522_SCK 4
#define PIN_RC522_MISO 5
#define PIN_RC522_MOSI 6
#define PIN_RELE_TRAVA 7
//--------------------------------------------
// Definição Modo de Operação Relé
// Ajuste conforme o módulo de relé utilizado
//--------------------------------------------
#define RELE_ON LOW
#define RELE_OFF HIGH
//---------------------------
// Definição de Constantes
//---------------------------
constexpr uint32_t TEMPO_ABERTURA_TRAVA_MS = 1500;
constexpr uint32_t ATRASO_GRAVACAO_MS = 1500;
constexpr size_t MAX_CARTOES = 100;
const char *ARQ_CONFIG = "/config.json";
const char *ARQ_CARTOES = "/cartoes.json";
//------------------------
// Definição de Objetos
//------------------------
MFRC522 rfid(PIN_RC522_SS, PIN_RC522_RST);
AsyncWebServer server(80);
AsyncWebSocket ws("/ws");
//----------------------------
// Definição de Estruturas
//----------------------------
enum TimeSource : uint8_t {
TIME_NOT_SYNCED,
TIME_BROWSER,
TIME_NTP
};
struct AppConfig {
String deviceName = "rfid-porta";
String adminUser = "admin";
String adminPass = "admin";
String apSsid = "RFID-Porta";
String apPass = "12345678";
String staSsid;
String staPass;
String ntpServer = "pool.ntp.org";
String timezone = "<-03>3";
};
struct CardItem {
String uid;
time_t lastAccessEpoch = 0;
uint32_t lastAccessMillis = 0;
bool accessedThisBoot = false;
};
//-----------------------
// Variáveis Globais
//-----------------------
AppConfig config;
std::vector<CardItem> cards;
TimeSource timeSource = TIME_NOT_SYNCED;
byte rc522Version = 0;
bool readerDetected = false;
bool lockActive = false;
// Mantido até reiniciar, inclusive se o upload for cancelado.
volatile bool otaMaintenance = false;
uint32_t lockStartedAt = 0;
bool cardsDirty = false;
uint32_t cardsDirtyAt = 0;
//---------------------------
// Prototipação de Rotinas
//---------------------------
bool timeIsValid();
const char *timeSourceText();
String formatLocalDateTime(time_t value);
String hexByte(byte value);
String readerVersionText(byte value);
String normalizeUid(String uid);
String displayUid(const String &normalized);
String uidFromReader();
int findCard(const String &uid);
bool requestAuthenticated(AsyncWebServerRequest *request);
bool saveConfig();
void loadConfig();
bool saveCards();
void loadCards();
void markCardsDirty();
void servicePersistence();
void appendClock(JsonObject target);
void appendCard(JsonObject target, const CardItem &card);
String buildStateJson();
void sendState(AsyncWebSocketClient *client = nullptr);
void sendEvent(const char *eventName, const String &uid, const String &message);
void serviceLock();
void convertBootAccessesToEpoch();
bool syncFromBrowser(int64_t epochMs);
void serviceNtpStatus();
bool addCard(const String &rawUid, String &message);
bool removeCard(const String &rawUid, String &message);
void serviceRfid();
String postValue(AsyncWebServerRequest *request, const char *name, const String &fallback);
void setupRoutes();
void setupNetwork();
void setupReader();
//-----------------------------
// Inicialização do Firmware
//-----------------------------
void setup()
{
Serial.begin(115200);
delay(300);
pinMode(PIN_RELE_TRAVA, OUTPUT);
digitalWrite(PIN_RELE_TRAVA, RELE_OFF);
if (!LittleFS.begin(true)) {
Serial.println("Falha ao montar LittleFS");
return;
}
loadConfig();
loadCards();
setupReader();
setupNetwork();
setupRoutes();
Serial.printf("Sistema iniciado com %u cartão(ões) cadastrado(s)\n", static_cast<unsigned>(cards.size()));
}
//-----------------------------
// Loop Principal do Firmware
//-----------------------------
void loop()
{
serviceRfid();
serviceLock();
servicePersistence();
serviceNtpStatus();
ws.cleanupClients();
delay(2);
}
//-----------------------------
// Verifica se o Time é válido
//-----------------------------
bool timeIsValid()
{
return time(nullptr) >= 1700000000;
}
//--------------------------------
// Converte TimeSource para Texto
//--------------------------------
const char *timeSourceText()
{
switch (timeSource) {
case TIME_BROWSER: return "Navegador";
case TIME_NTP: return "NTP";
default: return "Não sincronizado";
}
}
//---------------------
// Formata o TimeStamp
//---------------------
String formatLocalDateTime(time_t value)
{
if (value <= 0) return "";
struct tm localTm;
if (!localtime_r(&value, &localTm)) return "";
char text[24];
strftime(text, sizeof(text), "%d/%m/%Y %H:%M:%S", &localTm);
return String(text);
}
//----------------------------
// Converte de Byte para Hexa
//----------------------------
String hexByte(byte value)
{
char text[5];
snprintf(text, sizeof(text), "0x%02X", value);
return String(text);
}
//-------------------------
// Monta a Versão do RFID
//-------------------------
String readerVersionText(byte value)
{
switch (value) {
case 0x88: return "Clone";
case 0x90: return "v0.0";
case 0x91: return "v1.0";
case 0x92: return "v2.0";
case 0x00:
case 0xFF: return "Leitor não detectado";
default: return "Versão desconhecida";
}
}
//---------------------------
// Faz a Normalização do ID
//---------------------------
String normalizeUid(String uid)
{
uid.trim();
uid.toUpperCase();
String result;
for (size_t i = 0; i < uid.length(); ++i) {
char c = uid[i];
if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')) result += c;
}
if (result.length() < 4 || (result.length() % 2) != 0 || result.length() > 20) return "";
return result;
}
//---------------------------
// Monta o ID para o Display
//---------------------------
String displayUid(const String &normalized)
{
String result;
for (size_t i = 0; i < normalized.length(); i += 2) {
if (i) result += ' ';
result += normalized.substring(i, i + 2);
}
return result;
}
//---------------
// Obtém o ID
//---------------
String uidFromReader()
{
String result;
for (byte i = 0; i < rfid.uid.size; ++i) {
char pair[3];
snprintf(pair, sizeof(pair), "%02X", rfid.uid.uidByte[i]);
result += pair;
}
return result;
}
//---------------------
// Pesquisa por um ID
//---------------------
int findCard(const String &uid)
{
for (size_t i = 0; i < cards.size(); ++i) {
if (cards[i].uid == uid) return static_cast<int>(i);
}
return -1;
}
//----------------------------
// Checa Autenticação da Rota
//----------------------------
bool requestAuthenticated(AsyncWebServerRequest *request)
{
if (request->authenticate(config.adminUser.c_str(), config.adminPass.c_str())) return true;
request->requestAuthentication();
return false;
}
//------------------------------------
// Persiste os Parâmetros no LittleFS
//------------------------------------
bool saveConfig()
{
JsonDocument doc;
doc["deviceName"] = config.deviceName;
doc["adminUser"] = config.adminUser;
doc["adminPass"] = config.adminPass;
doc["apSsid"] = config.apSsid;
doc["apPass"] = config.apPass;
doc["staSsid"] = config.staSsid;
doc["staPass"] = config.staPass;
doc["ntpServer"] = config.ntpServer;
doc["timezone"] = config.timezone;
File file = LittleFS.open(ARQ_CONFIG, "w");
if (!file) return false;
bool ok = serializeJson(doc, file) > 0;
file.close();
return ok;
}
//------------------------------------
// Carrega os Parâmetros do LittleFS
//------------------------------------
void loadConfig()
{
if (!LittleFS.exists(ARQ_CONFIG)) {
saveConfig();
return;
}
File file = LittleFS.open(ARQ_CONFIG, "r");
if (!file) return;
JsonDocument doc;
DeserializationError error = deserializeJson(doc, file);
file.close();
if (error) return;
config.deviceName = doc["deviceName"] | config.deviceName;
config.adminUser = doc["adminUser"] | config.adminUser;
config.adminPass = doc["adminPass"] | config.adminPass;
config.apSsid = doc["apSsid"] | config.apSsid;
config.apPass = doc["apPass"] | config.apPass;
config.staSsid = doc["staSsid"] | config.staSsid;
config.staPass = doc["staPass"] | config.staPass;
config.ntpServer = doc["ntpServer"] | config.ntpServer;
config.timezone = doc["timezone"] | config.timezone;
}
//-------------------------
// Persiste um ID na Base
//-------------------------
bool saveCards()
{
JsonDocument doc;
JsonArray array = doc.to<JsonArray>();
for (const CardItem &card : cards) {
JsonObject item = array.add<JsonObject>();
item["uid"] = card.uid;
item["lastAccessEpoch"] = static_cast<int64_t>(card.lastAccessEpoch);
}
File file = LittleFS.open(ARQ_CARTOES, "w");
if (!file) return false;
bool ok = serializeJson(doc, file) > 0;
file.close();
if (ok) cardsDirty = false;
return ok;
}
//------------------------
// Carrega um Id da Base
//-------------------------
void loadCards()
{
cards.clear();
if (!LittleFS.exists(ARQ_CARTOES)) {
saveCards();
return;
}
File file = LittleFS.open(ARQ_CARTOES, "r");
if (!file) return;
JsonDocument doc;
DeserializationError error = deserializeJson(doc, file);
file.close();
if (error || !doc.is<JsonArray>()) return;
for (JsonObject item : doc.as<JsonArray>()) {
if (cards.size() >= MAX_CARTOES) break;
String uid = normalizeUid(item["uid"] | "");
if (uid.isEmpty() || findCard(uid) >= 0) continue;
CardItem card;
card.uid = uid;
card.lastAccessEpoch = static_cast<time_t>(item["lastAccessEpoch"] | 0LL);
cards.push_back(card);
}
}
//---------------------------
// Marca o ID como expirado
//---------------------------
void markCardsDirty()
{
cardsDirty = true;
cardsDirtyAt = millis();
}
//------------------------------------
// Verifica se deve persistir o Card
//------------------------------------
void servicePersistence()
{
if (cardsDirty && millis() - cardsDirtyAt >= ATRASO_GRAVACAO_MS) saveCards();
}
//---------------------------
// Apenda o último acesso
//---------------------------
void appendClock(JsonObject target)
{
target["valid"] = timeIsValid();
target["source"] = timeSourceText();
target["epoch"] = timeIsValid() ? static_cast<int64_t>(time(nullptr)) : 0;
target["local"] = timeIsValid() ? formatLocalDateTime(time(nullptr)) : "";
}
//---------------------------
// Apenda o Card
//---------------------------
void appendCard(JsonObject target, const CardItem &card)
{
target["uid"] = displayUid(card.uid);
target["epoch"] = static_cast<int64_t>(card.lastAccessEpoch);
target["local"] = formatLocalDateTime(card.lastAccessEpoch);
target["thisBoot"] = card.accessedThisBoot;
target["uptimeMs"] = card.accessedThisBoot ? card.lastAccessMillis : 0;
}
//---------------------------
// Gera JSON para Interface
//---------------------------
String buildStateJson()
{
JsonDocument doc;
doc["type"] = "state";
JsonArray list = doc["cards"].to<JsonArray>();
for (const CardItem &card : cards) appendCard(list.add<JsonObject>(), card);
JsonObject reader = doc["reader"].to<JsonObject>();
reader["chip"] = "MFRC522";
reader["firmwareHex"] = hexByte(rc522Version);
reader["firmwareVersion"] = readerVersionText(rc522Version);
reader["detected"] = readerDetected;
JsonObject clock = doc["clock"].to<JsonObject>();
appendClock(clock);
doc["deviceName"] = config.deviceName;
doc["apIp"] = WiFi.softAPIP().toString();
doc["staConnected"] = WiFi.status() == WL_CONNECTED;
doc["staIp"] = WiFi.status() == WL_CONNECTED ? WiFi.localIP().toString() : "";
doc["lockActive"] = lockActive;
doc["otaMaintenance"] = otaMaintenance;
doc["deviceUptimeMs"] = millis();
String output;
serializeJson(doc, output);
return output;
}
//-------------------------------
// Envia o Estado para Interface
//-------------------------------
void sendState(AsyncWebSocketClient *client)
{
String message = buildStateJson();
if (client) client->text(message);
else ws.textAll(message);
}
//------------------------
// Envia Evento WebSocket
//------------------------
void sendEvent(const char *eventName, const String &uid, const String &message)
{
JsonDocument doc;
doc["type"] = "event";
doc["event"] = eventName;
doc["uid"] = uid.isEmpty() ? "" : displayUid(uid);
doc["message"] = message;
String output;
serializeJson(doc, output);
ws.textAll(output);
}
//------------------------
// Ativa o Lock da Trava
//------------------------
void activateLock(const char *origin) {
if (otaMaintenance || Update.isRunning()) return;
digitalWrite(PIN_RELE_TRAVA, RELE_ON);
lockActive = true;
lockStartedAt = millis();
Serial.printf("Trava liberada (%s)\n", origin);
sendEvent("lock", "", "Trava liberada");
}
//------------------------
// Checa o Lock da Trava
//------------------------
void serviceLock()
{
if (!lockActive || millis() - lockStartedAt < TEMPO_ABERTURA_TRAVA_MS) return;
digitalWrite(PIN_RELE_TRAVA, RELE_OFF);
lockActive = false;
Serial.println("Trava novamente bloqueada");
sendEvent("lock", "", "Trava novamente bloqueada");
}
//------------------------------
// Converte o Acesso para Epoch
//------------------------------
void convertBootAccessesToEpoch()
{
if (!timeIsValid()) return;
uint32_t nowMs = millis();
time_t nowEpoch = time(nullptr);
bool changed = false;
for (CardItem &card : cards) {
if (card.accessedThisBoot && card.lastAccessEpoch == 0) {
card.lastAccessEpoch = nowEpoch - static_cast<time_t>((nowMs - card.lastAccessMillis) / 1000UL);
changed = true;
}
}
if (changed) markCardsDirty();
}
//-----------------------------------------------------
// Sincroniza o relógio Interno a partir do Navegador
//-----------------------------------------------------
bool syncFromBrowser(int64_t epochMs)
{
if (epochMs < 1700000000000LL || epochMs > 4102444800000LL) return false;
struct timeval tv;
tv.tv_sec = static_cast<time_t>(epochMs / 1000LL);
tv.tv_usec = static_cast<suseconds_t>((epochMs % 1000LL) * 1000LL);
if (settimeofday(&tv, nullptr) != 0) return false;
timeSource = TIME_BROWSER;
convertBootAccessesToEpoch();
Serial.printf("Horário sincronizado pelo navegador: %s\n", formatLocalDateTime(time(nullptr)).c_str());
return true;
}
//---------------------------------------
// Sincroniza o Relógio Intermno via NTP
//---------------------------------------
void serviceNtpStatus()
{
static bool announced = false;
if (!announced && timeSource == TIME_NOT_SYNCED && WiFi.status() == WL_CONNECTED && timeIsValid()) {
timeSource = TIME_NTP;
announced = true;
convertBootAccessesToEpoch();
Serial.printf("Horário sincronizado por NTP: %s\n", formatLocalDateTime(time(nullptr)).c_str());
sendState();
}
}
//---------------------------
// Adiciona um Card na Base
//---------------------------
bool addCard(const String &rawUid, String &message)
{
String uid = normalizeUid(rawUid);
if (uid.isEmpty()) {
message = "UID inválido";
return false;
}
if (findCard(uid) >= 0) {
message = "UID já cadastrado";
return false;
}
if (cards.size() >= MAX_CARTOES) {
message = "Limite de cartões atingido";
return false;
}
CardItem card;
card.uid = uid;
cards.push_back(card);
markCardsDirty();
message = "UID adicionado";
return true;
}
//---------------------------
// Remove um Card da Base
//---------------------------
bool removeCard(const String &rawUid, String &message)
{
String uid = normalizeUid(rawUid);
int index = findCard(uid);
if (index < 0) {
message = "UID não encontrado";
return false;
}
cards.erase(cards.begin() + index);
markCardsDirty();
message = "UID removido";
return true;
}
//-----------------------
// Checa acesso via RFID
//-----------------------
void serviceRfid()
{
if (otaMaintenance || Update.isRunning()) return;
if (!readerDetected || !rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
String uid = uidFromReader();
int index = findCard(uid);
Serial.printf("Cartão lido: %s - %s\n", displayUid(uid).c_str(), index >= 0 ? "AUTORIZADO" : "NÃO CADASTRADO");
if (index >= 0) {
CardItem &card = cards[index];
card.accessedThisBoot = true;
card.lastAccessMillis = millis();
card.lastAccessEpoch = timeIsValid() ? time(nullptr) : 0;
markCardsDirty();
activateLock("RFID");
sendEvent("rfid", uid, "Cartão autorizado");
} else {
sendEvent("rfid", uid, "Cartão não cadastrado");
}
sendState();
rfid.PICC_HaltA();
rfid.PCD_StopCrypto1();
}
//--------------------------
// Post de Valor no Request
//--------------------------
String postValue(AsyncWebServerRequest *request, const char *name, const String &fallback = "")
{
if (!request->hasParam(name, true)) return fallback;
return request->getParam(name, true)->value();
}
//---------------------------------
// Monta as Rotas do Interface Web
//---------------------------------
void setupRoutes()
{
ws.setAuthentication(config.adminUser.c_str(), config.adminPass.c_str());
ws.onEvent([](AsyncWebSocket *serverSocket, AsyncWebSocketClient *client,
AwsEventType type, void *arg, uint8_t *data, size_t len) {
if (type == WS_EVT_CONNECT) {
Serial.printf("WebSocket conectado: #%u\n", client->id());
sendState(client);
return;
}
if (type != WS_EVT_DATA) return;
AwsFrameInfo *info = reinterpret_cast<AwsFrameInfo *>(arg);
if (!info->final || info->index != 0 || info->len != len || info->opcode != WS_TEXT) return;
JsonDocument doc;
if (deserializeJson(doc, data, len)) return;
String command = doc["type"] | "";
if (otaMaintenance && command != "getState") {
client->text("{\"type\":\"event\",\"event\":\"error\",\"message\":\"Modo de atualização: reinicie para retomar a operação\"}");
return;
}
if (command == "getState") {
sendState(client);
} else if (command == "addCard") {
String message;
String uid = doc["uid"] | "";
bool ok = addCard(uid, message);
sendEvent(ok ? "success" : "error", normalizeUid(uid), message);
sendState();
} else if (command == "removeCard") {
String message;
String uid = doc["uid"] | "";
bool ok = removeCard(uid, message);
sendEvent(ok ? "success" : "error", normalizeUid(uid), message);
sendState();
} else if (command == "openLock") {
activateLock("Web");
sendState();
} else if (command == "syncTime") {
int64_t epochMs = doc["epochMs"] | 0LL;
bool ok = syncFromBrowser(epochMs);
sendEvent(ok ? "success" : "error", "", ok ? "Horário sincronizado" : "Horário recebido é inválido");
sendState();
}
});
server.addHandler(&ws);
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
if (!requestAuthenticated(request)) return;
request->send_P(200, "text/html; charset=utf-8", HTML_MAIN);
});
server.on("/config", HTTP_GET, [](AsyncWebServerRequest *request) {
if (!requestAuthenticated(request)) return;
request->send_P(200, "text/html; charset=utf-8", HTML_CONFIG);
});
server.on("/api/config", HTTP_GET, [](AsyncWebServerRequest *request) {
if (!requestAuthenticated(request)) return;
JsonDocument doc;
doc["deviceName"] = config.deviceName;
doc["adminUser"] = config.adminUser;
doc["apSsid"] = config.apSsid;
doc["staSsid"] = config.staSsid;
doc["ntpServer"] = config.ntpServer;
doc["timezone"] = config.timezone;
String output;
serializeJson(doc, output);
request->send(200, "application/json", output);
});
server.on("/api/config", HTTP_POST, [](AsyncWebServerRequest *request) {
if (!requestAuthenticated(request)) return;
if (otaMaintenance) {
request->send(409, "application/json", "{\"ok\":false,\"message\":\"Reinicie antes de alterar a configuração\"}");
return;
}
String deviceName = postValue(request, "deviceName");
String adminUser = postValue(request, "adminUser");
String adminPass = postValue(request, "adminPass");
String apSsid = postValue(request, "apSsid");
String apPass = postValue(request, "apPass");
String staSsid = postValue(request, "staSsid");
String staPass = postValue(request, "staPass");
String ntpServer = postValue(request, "ntpServer");
String timezone = postValue(request, "timezone");
// Campos de senha vazios significam "manter a senha atual".
if (adminPass.isEmpty()) adminPass = config.adminPass;
if (apPass.isEmpty()) apPass = config.apPass;
if (staPass.isEmpty()) staPass = config.staPass;
deviceName.trim(); adminUser.trim(); apSsid.trim(); staSsid.trim(); ntpServer.trim(); timezone.trim();
if (deviceName.isEmpty() || adminUser.isEmpty() || apSsid.isEmpty() || apPass.length() < 8 || ntpServer.isEmpty() || timezone.isEmpty()) {
request->send(400, "application/json", "{\"ok\":false,\"message\":\"Verifique os campos obrigatórios e a senha do AP\"}");
return;
}
config.deviceName = deviceName;
config.adminUser = adminUser;
config.adminPass = adminPass;
config.apSsid = apSsid;
config.apPass = apPass;
config.staSsid = staSsid;
config.staPass = staPass;
config.ntpServer = ntpServer;
config.timezone = timezone;
if (!saveConfig()) {
request->send(500, "application/json", "{\"ok\":false,\"message\":\"Falha ao gravar a configuração\"}");
return;
}
request->send(200, "application/json", "{\"ok\":true,\"message\":\"Configuração salva. Reinicie o equipamento.\"}");
});
server.on("/api/restart", HTTP_POST, [](AsyncWebServerRequest *request) {
if (!requestAuthenticated(request)) return;
if (Update.isRunning()) {
request->send(409, "application/json", "{\"ok\":false,\"message\":\"Aguarde o término do upload\"}");
return;
}
request->send(200, "application/json", "{\"ok\":true}");
delay(250);
ESP.restart();
});
// AsyncElegantOTA 2.2.7 não possui callbacks onStart/onEnd.
// O filtro entra em manutenção antes de a biblioteca atender /update.
// Não atende o GET: deixa a rota da biblioteca servir sua página autenticada.
class OtaMaintenanceGate : public AsyncWebHandler {
public:
// As versões do servidor diferem quanto ao qualificador const.
bool canHandle(AsyncWebServerRequest *request) {
return static_cast<const OtaMaintenanceGate *>(this)->canHandle(request);
}
bool canHandle(AsyncWebServerRequest *request) const {
if (request->url() != "/update") return false;
if (request->method() != HTTP_GET && request->method() != HTTP_POST) return false;
if (!request->authenticate(config.adminUser.c_str(), config.adminPass.c_str())) return true;
if (!otaMaintenance) {
otaMaintenance = true;
digitalWrite(PIN_RELE_TRAVA, RELE_OFF);
lockActive = false;
if (cardsDirty && !saveCards()) {
otaMaintenance = false;
return true;
}
sendState();
Serial.println("OTA: operação suspensa até reiniciar");
}
return false;
}
void handleRequest(AsyncWebServerRequest *request) override {
if (!requestAuthenticated(request)) return;
request->send(500, "text/plain; charset=utf-8",
"Falha ao salvar os cartões. Atualização não iniciada.");
}
};
server.addHandler(new OtaMaintenanceGate());
AsyncElegantOTA.begin(&server, config.adminUser.c_str(), config.adminPass.c_str());
server.onNotFound([](AsyncWebServerRequest *request) {
if (!requestAuthenticated(request)) return;
request->send(404, "text/plain", "Não encontrado");
});
server.begin();
}
//----------------------------
// Inicializa a Rede AP e STA
//----------------------------
void setupNetwork()
{
WiFi.mode(WIFI_AP_STA);
WiFi.setHostname(config.deviceName.c_str());
WiFi.softAP(config.apSsid.c_str(), config.apPass.c_str());
Serial.printf("AP: %s - IP: %s\n", config.apSsid.c_str(), WiFi.softAPIP().toString().c_str());
if (!config.staSsid.isEmpty()) {
WiFi.begin(config.staSsid.c_str(), config.staPass.c_str());
Serial.printf("Conectando à rede STA: %s\n", config.staSsid.c_str());
}
if (MDNS.begin(config.deviceName.c_str())) {
MDNS.addService("http", "tcp", 80);
Serial.printf("mDNS: http://%s.local\n", config.deviceName.c_str());
} else {
Serial.println("Falha ao iniciar mDNS");
}
setenv("TZ", config.timezone.c_str(), 1);
tzset();
if (!config.staSsid.isEmpty()) configTzTime(config.timezone.c_str(), config.ntpServer.c_str());
}
//--------------------------
// Inicializa o Leitor RFID
//--------------------------
void setupReader()
{
SPI.begin(PIN_RC522_SCK, PIN_RC522_MISO, PIN_RC522_MOSI, PIN_RC522_SS);
rfid.PCD_Init();
delay(4);
rc522Version = rfid.PCD_ReadRegister(MFRC522::VersionReg);
readerDetected = rc522Version != 0x00 && rc522Version != 0xFF;
Serial.println("Leitor RFID MFRC522");
Serial.printf("Firmware Version: %s = %s\n", hexByte(rc522Version).c_str(), readerVersionText(rc522Version).c_str());
Serial.printf("Status: %s\n", readerDetected ? "leitor detectado" : "leitor não detectado");
}
#pragma once
const char HTML_MAIN[] PROGMEM = R"HTML(
<!doctype html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>
Controle de Acesso RFID
</title>
<style>
:root {
--bg: #eef2f7;
--card: #fff;
--ink: #1d2939;
--muted: #667085;
--primary: #1769aa;
--ok: #16803c;
--bad: #b42318;
--line: #d0d5dd
}
* {
box-sizing: border-box
}
body {
margin: 0;
background: var(--bg);
font: 16px Arial, sans-serif;
color: var(--ink)
}
header {
background: #17324d;
color: #fff;
padding: 20px
}
.wrap {
max-width: 820px;
margin: auto;
padding: 18px
}
.tabs {
display: flex;
gap: 8px;
margin-bottom: 16px
}
.tabs a {
padding: 11px 16px;
border-radius: 8px;
text-decoration: none;
background: #dde5ee;
color: #17324d
}
.tabs a.active {
background: var(--primary);
color: #fff
}
.card {
background: var(--card);
padding: 18px;
border-radius: 12px;
box-shadow: 0 2px 10px #0001;
margin-bottom: 16px
}
h1 {
font-size: 22px;
margin: 0;
text-align: center
}
h2 {
font-size: 18px;
margin-top: 0
}
label {
display: block;
font-weight: bold;
margin: 12px 0 6px
}
select,
input {
width: 100%;
padding: 11px;
border: 1px solid var(--line);
border-radius: 8px;
font-size: 16px
}
select {
height: 190px
}
.buttons {
display: grid;
grid-template-columns: repeat(3, 1fr);
gap: 9px;
margin-top: 12px
}
button {
border: 0;
border-radius: 8px;
padding: 12px;
color: white;
background: var(--primary);
font-weight: bold;
cursor: pointer
}
button.remove {
background: var(--bad)
}
button.lock {
background: #7a4e00
}
.status {
padding: 11px;
background: #f8fafc;
border-radius: 8px;
margin-top: 12px
}
.ok {
color: var(--ok)
}
.bad {
color: var(--bad)
}
.muted {
color: var(--muted)
}
@media(max-width:620px) {
.buttons {
grid-template-columns: 1fr
}
header {
padding: 16px
}
.wrap {
padding: 12px
}
}
</style>
</head>
<body>
<header>
<div class="wrap" style="padding:0">
<h1>
Controle de Acesso RFID
</h1>
</div>
</header>
<main class="wrap">
<nav class="tabs">
<a class="active" href="/">
Operação
</a>
<a href="/config">
Configuração
</a>
</nav>
<section class="card">
<h2>
Cartões cadastrados
</h2>
<select id="cards" size="7">
</select>
<label for="uid">
UID lido ou selecionado
</label>
<input id="uid" maxlength="29" placeholder="Ex.: A3 7F 21 9C" autocomplete="off">
<div class="buttons">
<button onclick="addCard()">
Adicionar
</button>
<button class="remove" onclick="removeCard()">
Remover
</button>
<button class="lock" onclick="openLock()">
Abrir trava
</button>
</div>
<div id="lastAccess" class="status muted">
Selecione um cartão para consultar o último acesso.
</div>
<div id="message" class="status muted">
Aguardando leitura...
</div>
</section>
<section class="card">
<h2>
Estado
</h2>
<div id="connection" class="bad">
WebSocket desconectado
</div>
<div id="clock" class="muted">
Relógio não sincronizado
</div>
<div id="lockState">
Trava bloqueada
</div>
</section>
</main>
<script>
let socket, cards = [],
clock = {
valid: false,
epoch: 0
},
deviceUptimeMs = 0;
const $ = id => document.getElementById(id);
function connect() {
const proto = location.protocol === 'https:' ? 'wss' : 'ws';
socket = new WebSocket(`${proto}://${location.host}/ws`);
socket.onopen = () => {
$('connection').textContent = 'WebSocket conectado';
$('connection').className = 'ok';
send({
type: 'getState'
})
};
socket.onclose = () => {
$('connection').textContent = 'WebSocket desconectado — reconectando...';
$('connection').className = 'bad';
setTimeout(connect, 2000)
};
socket.onmessage = e => handle(JSON.parse(e.data))
}
function send(data) {
if (socket && socket.readyState === 1) socket.send(JSON.stringify(data));
else show('Sem conexão com o equipamento', false)
}
function handle(data) {
if (data.type === 'state') {
cards = data.cards || [];
clock = data.clock || clock;
deviceUptimeMs = data.deviceUptimeMs || 0;
renderCards();
$('clock').textContent = clock.valid ? `Relógio: ${clock.local} (${clock.source})` : 'Relógio não sincronizado';
$('lockState').textContent = data.otaMaintenance ? 'Modo de atualização — operação suspensa' : (data.lockActive ? 'Trava liberada' : 'Trava bloqueada')
} else if (data.type === 'event') {
if (data.uid) $('uid').value = data.uid;
show(data.message, data.event !== 'error');
if (data.event === 'rfid' && data.uid) {
const item = cards.find(c => c.uid === data.uid);
if (item) showAccess(item)
}
}
}
function renderCards() {
const selected = $('uid').value;
$('cards').innerHTML = '';
cards.forEach(c => {
const o = document.createElement('option');
o.value = c.uid;
o.textContent = c.uid;
$('cards').appendChild(o)
});
if (selected) {
const item = cards.find(c => c.uid === selected);
if (item) showAccess(item)
}
}
function elapsed(seconds) {
seconds = Math.max(0, Math.floor(seconds));
const d = Math.floor(seconds / 86400);
seconds %= 86400;
const h = Math.floor(seconds / 3600);
seconds %= 3600;
const m = Math.floor(seconds / 60),
s = seconds % 60;
return `${d} dia(s), ${h} hora(s), ${m} minuto(s) e ${s} segundo(s)`
}
function showAccess(c) {
if (c.epoch && clock.valid) $('lastAccess').textContent = `Último acesso: há ${elapsed(clock.epoch-c.epoch)} (${c.local})`;
else if (c.thisBoot) $('lastAccess').textContent = `Último acesso: há ${elapsed((deviceUptimeMs-c.uptimeMs)/1000)} nesta inicialização`;
else if (c.epoch) $('lastAccess').textContent = `Último acesso: ${c.local}. Sincronize o relógio para calcular o tempo decorrido.`;
else $('lastAccess').textContent = 'Este cartão ainda não possui acesso registrado.'
}
$('cards').onchange = () => {
const c = cards[$('cards').selectedIndex];
if (c) {
$('uid').value = c.uid;
showAccess(c)
}
};
function addCard() {
send({
type: 'addCard',
uid: $('uid').value
})
}
function removeCard() {
if (confirm('Remover este UID?')) send({
type: 'removeCard',
uid: $('uid').value
})
}
function openLock() {
if (confirm('Liberar a porta agora?')) send({
type: 'openLock'
})
}
function show(text, ok) {
$('message').textContent = text;
$('message').className = `status ${ok?'ok':'bad'}`
}
connect();
setInterval(() => {
if (socket && socket.readyState === 1) send({
type: 'getState'
})
}, 10000);
</script>
</body>
</html>
)HTML";
#pragma once
const char HTML_CONFIG[] PROGMEM = R"HTML(
<!doctype html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>
Configuração RFID
</title>
<style>
:root {
--bg: #eef2f7;
--card: #fff;
--ink: #1d2939;
--muted: #667085;
--primary: #1769aa;
--ok: #16803c;
--bad: #b42318;
--line: #d0d5dd
}
* {
box-sizing: border-box
}
body {
margin: 0;
background: var(--bg);
font: 16px Arial, sans-serif;
color: var(--ink)
}
header {
background: #17324d;
color: #fff;
padding: 20px
}
.wrap {
max-width: 820px;
margin: auto;
padding: 18px
}
.tabs {
display: flex;
gap: 8px;
margin-bottom: 16px
}
.tabs a {
padding: 11px 16px;
border-radius: 8px;
text-decoration: none;
background: #dde5ee;
color: #17324d
}
.tabs a.active {
background: var(--primary);
color: #fff
}
.card {
background: var(--card);
padding: 18px;
border-radius: 12px;
box-shadow: 0 2px 10px #0001;
margin-bottom: 16px
}
h1 {
font-size: 22px;
margin: 0;
text-align: center
}
h2 {
font-size: 18px;
margin-top: 0
}
.grid {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 12px
}
label {
display: block;
font-weight: bold;
margin-bottom: 5px
}
input {
width: 100%;
padding: 10px;
border: 1px solid var(--line);
border-radius: 8px;
font-size: 16px
}
button {
border: 0;
border-radius: 8px;
padding: 12px 16px;
color: #fff;
background: var(--primary);
font-weight: bold;
cursor: pointer;
margin: 8px 5px 0 0
}
button.restart {
background: #7a4e00
}
.status {
padding: 11px;
background: #f8fafc;
border-radius: 8px;
margin-top: 12px
}
.ok {
color: var(--ok)
}
.bad {
color: var(--bad)
}
table {
width: 100%;
border-collapse: collapse
}
td {
padding: 8px;
border-bottom: 1px solid #e5e7eb
}
td:first-child {
font-weight: bold;
width: 42%
}
@media(max-width:620px) {
.grid {
grid-template-columns: 1fr
}
header {
padding: 16px
}
.wrap {
padding: 12px
}
}
</style>
</head>
<body>
<header>
<div class="wrap" style="padding:0">
<h1>
Configuração RFID
</h1>
</div>
</header>
<main class="wrap">
<nav class="tabs">
<a href="/">
Operação
</a>
<a class="active" href="/config">
Configuração
</a>
</nav>
<section class="card">
<h2>
Rede e acesso
</h2>
<form id="form">
<div class="grid">
<div>
<label>
Dispositivo / mDNS
</label>
<input name="deviceName" required>
</div>
<div>
<label>
Usuário administrativo
</label>
<input name="adminUser" required>
</div>
<div>
<label>
Nova senha administrativa
</label>
<input name="adminPass" type="password" placeholder="Deixe vazia para manter">
</div>
<div>
<label>
SSID do AP
</label>
<input name="apSsid" required>
</div>
<div>
<label>
Nova senha do AP
</label>
<input name="apPass" type="password" minlength="8" placeholder="Deixe vazia para manter">
</div>
<div>
<label>
SSID da rede Wi-Fi (STA)
</label>
<input name="staSsid">
</div>
<div>
<label>
Nova senha da rede Wi-Fi
</label>
<input name="staPass" type="password" placeholder="Deixe vazia para manter">
</div>
<div>
<label>
Servidor NTP
</label>
<input name="ntpServer" required>
</div>
<div>
<label>
Timezone POSIX
</label>
<input name="timezone" required placeholder="<-03>3">
</div>
</div>
<button type="submit">
Salvar configuração
</button>
<button type="button" class="restart" onclick="restartDevice()">
Reiniciar equipamento
</button>
</form>
<div id="formMessage" class="status">
Alterações de rede e autenticação entram em vigor após reiniciar.
</div>
</section>
<section class="card">
<h2>
Relógio
</h2>
<table>
<tr>
<td>
Data e hora
</td>
<td id="clock">
Não sincronizado
</td>
</tr>
<tr>
<td>
Origem
</td>
<td id="source">
—
</td>
</tr>
</table>
<button onclick="syncTime()">
Sincronizar com o horário do navegador
</button>
<div id="syncMessage" class="status">
Use este botão quando o equipamento estiver operando somente como AP.
</div>
</section>
<section class="card">
<h2>
Informações do equipamento
</h2>
<table>
<tr>
<td>
Controlador
</td>
<td>
ESP32-C3
</td>
</tr>
<tr>
<td>
Leitor
</td>
<td id="reader">
MFRC522
</td>
</tr>
<tr>
<td>
Firmware do leitor
</td>
<td id="firmware">
—
</td>
</tr>
<tr>
<td>
Estado do leitor
</td>
<td id="readerState">
—
</td>
</tr>
<tr>
<td>
mDNS
</td>
<td id="mdns">
—
</td>
</tr>
<tr>
<td>
IP do AP
</td>
<td id="apIp">
—
</td>
</tr>
<tr>
<td>
IP STA
</td>
<td id="staIp">
Desconectado
</td>
</tr>
</table>
</section>
<section class="card">
<h2>
Atualização do firmware
</h2>
<p>
Ao abrir a atualização, a operação será suspensa até o reinício. Selecione Firmware e envie o arquivo .bin do sketch. Não envie imagem de filesystem: ela pode substituir os cadastros e a configuração.
</p>
<p>
<a href="/update" onclick="return confirm('Suspender a operação e abrir a atualização? Reinicie o equipamento para voltar à operação, mesmo se cancelar o upload.')">
Atualizar firmware
</a>
</p>
<div id="otaState" class="status">
Operação normal.
</div>
</section>
</main>
<script>
let socket;
const $ = id => document.getElementById(id);
const form = $('form');
async function loadConfig() {
const r = await fetch('/api/config');
if (!r.ok) return;
const c = await r.json();
for (const [k, v] of Object.entries(c)) {
if (form.elements[k]) form.elements[k].value = v || ''
}
}
function connect() {
const proto = location.protocol === 'https:' ? 'wss' : 'ws';
socket = new WebSocket(`${proto}://${location.host}/ws`);
socket.onopen = () => send({
type: 'getState'
});
socket.onclose = () => setTimeout(connect, 2000);
socket.onmessage = e => handle(JSON.parse(e.data))
}
function send(data) {
if (socket && socket.readyState === 1) socket.send(JSON.stringify(data))
}
function handle(d) {
if (d.type === 'state') {
const r = d.reader || {},
c = d.clock || {};
$('otaState').textContent = d.otaMaintenance ? 'Modo de atualização ativo. Reinicie para retomar a operação.' : 'Operação normal.';
$('reader').textContent = r.chip || 'MFRC522';
$('firmware').textContent = `${r.firmwareHex||'—'} = ${r.firmwareVersion||'—'}`;
$('readerState').textContent = r.detected ? 'Detectado' : 'Não detectado';
$('clock').textContent = c.valid ? c.local : 'Não sincronizado';
$('source').textContent = c.source || '—';
$('mdns').textContent = `${d.deviceName}.local`;
$('apIp').textContent = d.apIp;
$('staIp').textContent = d.staConnected ? d.staIp : 'Desconectado'
} else if (d.type === 'event' && (d.event === 'success' || d.event === 'error')) {
$('syncMessage').textContent = d.message;
$('syncMessage').className = `status ${d.event==='success'?'ok':'bad'}`
}
}
function syncTime() {
send({
type: 'syncTime',
epochMs: Date.now()
})
}
form.onsubmit = async e => {
e.preventDefault();
const body = new URLSearchParams(new FormData(form));
const r = await fetch('/api/config', {
method: 'POST',
body
});
const d = await r.json();
$('formMessage').textContent = d.message;
$('formMessage').className = `status ${r.ok?'ok':'bad'}`
};
async function restartDevice() {
if (!confirm('Reiniciar o equipamento agora?')) return;
const r = await fetch('/api/restart', {
method: 'POST'
});
if (!r.ok) {
const d = await r.json();
$('formMessage').textContent = d.message;
return;
}
$('formMessage').textContent = 'Reiniciando...';
$('formMessage').className = 'status ok'
}
loadConfig();
connect();
setInterval(() => send({
type: 'getState'
}), 10000);
</script>
</body>
</html>
)HTML";
Neste projeto, integramos um ESP32-C3, um leitor RFID RC522 e uma interface Web para construir um protótipo de controle de acesso com administração local. Além da identificação de cartões e do acionamento da trava, a aplicação permite cadastrar e remover credenciais pelo navegador, sem modificar o firmware a cada alteração na lista de autorizados.
O armazenamento em LittleFS preserva os cadastros após o desligamento, enquanto a validação local permite utilizar as credenciais sem depender de internet ou manter a interface aberta. Os modos AP e STA oferecem alternativas de acesso à aplicação, e a comunicação por WebSocket apresenta leituras e atualizações diretamente na tela.
A sincronização de horário por NTP ou pelo navegador possibilita associar data e horário ao último acesso autorizado de cada cartão. Já a atualização OTA facilita a manutenção do firmware, com um modo específico que suspende os acionamentos durante esse procedimento.
Como protótipo didático, o projeto também permite compreender seus limites: a autorização utiliza a comparação do UID, o registro mantém somente o último acesso por cartão e a indicação da trava representa o comando elétrico, sem confirmar a posição física da porta. Essas características devem ser consideradas ao adaptar a proposta para outras aplicações.
Entre as possibilidades de evolução estão a associação de nomes às credenciais, a criação de um histórico de eventos, a inclusão de um sensor de abertura e a implementação de permissões por horário. Com esta publicação, buscamos incentivar a comunidade a explorar a integração entre identificação RFID, interfaces Web e sistemas embarcados, utilizando o conhecimento apresentado como base para seus próprios projetos.
Neste projeto, utilizaremos um ESP32-C3 e um leitor RFID RC522 para desenvolver um controle de acesso com interface Web autenticada, acessível pelo navegador de um computador ou celular.
Encontre tudo na Loja Eletrogate com frete grátis para compras acima de R$ 200