Fazendo uma chamada para uma API para validar entrada usando ESP32 e RFID
Hoje vamos criar um prototipo de um sistema que faz a leitura de uma tag/cartão com rfid e envia o código para uma API para verificar se o mesmo é válido.
|
Hoje vamos criar um prototipo de um sistema que faz a leitura de uma tag/cartão com rfid e envia o código para uma API para verificar se o mesmo é válido.
Bora lá
Para este exemplo iremos usar os ambientes de desenvolvimento:
E de hardware:
- Esp32 - Placa Arduino que já possui Wifi e bluetooth, facilita bastante no desenvolvimento de soluções IOT
- RFID-RC522 - Faz a leitura e gravação de cartões RFID
- Protoboard - Placa para ligação da ESP32 com RC522
Primeiro passo vamos desenvolver nossa API, neste caso será bem simples, iremos criar somente um endpoint Post que irá receber a tag do cartão e validar se é uma tag valida ou não.
Abra o seu Visual Studio Code e o seu terminal "ctrl + `"
|
Primeiro passo vamos ver se o .Net 6 esta instalado, caso não tenha em sua máquina baixe o mesmo pelo link
|
Com o .Net 6 instalado vamos constuir nossa API
No terminal digite dotnet new webapi --name esp32rfid
|
Projeto criado.
|
Para abrir seu projeto no Visual Studio Code acesse o diretório do projeto e digite "code ."
|
Vai ser aberto o Visual Studio Code com seu projeto
|
Apague a classe WeatherForecast e WeatherForecastController
|
Agora crie uma pasta DTO, clique no menu do projeto em new folder como a imagem abaixo e de o nome de DTO.
|
Clique com o botão direito na pasta DTO e crie uma classe com o nome TagDto
|
Nossa classe TagDto será bem simples, irá conter uma propriedade referente ao código da tag e uma propriedade para pegar o código da placa esp32
namespace esp32rfi.DTO
{
public class TagDto
{
public string Tag { get; set; }
public int CodigoEsp32 { get; set; }
}
}Agora crie uma Classe na pasta Controllers, clique com o botão direito na pasta e new class com o nome TagController
O Código da nossa API esta abaixo
using Microsoft.AspNetCore.Mvc;
namespace esp32rfi.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class TagController : ControllerBase
{
[HttpPost]
public async Task<IActionResult> Post([FromBody] DTO.TagDto request, CancellationToken cancellationToken)
{
return Ok(new
{
tag = request.Tag
});
}
}
}De forma simples ele irá receber os dados enviados pelo Esp32 e irá tratar os mesmos podendo validar a tag em um banco de dados, no exemplo iremos fazer de forma simples fixando o mesmo no código como abaixo.
using Microsoft.AspNetCore.Mvc;
namespace esp32rfi.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class TagController : ControllerBase
{
[HttpPost]
public async Task<IActionResult> Post([FromBody] DTO.TagDto request, CancellationToken cancellationToken)
{
if(request.Tag == " a1 07 66 1b")
{
return Ok(new
{
tag = request.Tag,
valido = true
});
}
else
{
return BadRequest(new
{
tag = request.Tag,
valido = false
});
}
}
}
}Em nosso exemplo ao receber o código da Tag ele verifica se é " a1 07 66 1b", caso seja ele retorna Ok e válido como true, caso contrário ele retorna uma BadRequest com o válido igual a false, simples assim.
Antes de rodar sua API altere o endereço de localhost para o ip da sua máquina pois caso contrário o esp32 não irá encontrar sua API, para saber o ip da sua máquina acesse o cmd e digite ipconfig e veja o ip, no caso o IPv4 Address.
|
Após sabe o seu ip vá na pasta properties e no arquivo launchSettings.json mude onde esta local host para o ip da sua maquina.
|
Execute a sua API e faça um teste com o swagger para ver se esta tudo ok.
|
Ao enviar os dados com o código informado anteriormente como abaixo recebemos uma resposta OK
|
Caso enviarmos no body uma Tag diferente recebemos um BadRequest e valido como false.
|
Nossa API esta pronta para ser usada pelo nosso Esp32, vamos lá.
Primeiro é preciso montar o seu circuito na protoboard como a figura abaixo.
|
Instale o driver da placa esp32 em seu computador e o mesmo deve ser configurado, pode seguir o tutorial caso tenha alguma dúvida ou me manda mensagem.
|
Baixe a IDE do Arduino e vamos configurar para utilizar o Esp32
Vai em file -> preferences
|
Na tela que ira abrir informe no campo Aditional Boards Manager Urls a url https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json, somente isto e clique em ok
Agora no menu Sketch -> Include Library -> Manage Libraries para baixar as bibliotecas que iremos utilizar, no caso a Biblioteca Wifi e MFRC522 e Easy MFRC522
|
E por último mas não menos importante vamos selecionar a board que iremos trabalhar.
No caso estamos usando a ESP32-WROOM-DA Module
|
Feito isto bora codar nosso esp32
#include <Arduino.h>
#include <MFRC522.h> //biblioteca responsável pela comunicação com o módulo RFID-RC522
#include <SPI.h> //biblioteca para comunicação do barramento SPI
#include <HTTPClient.h>
#include <WiFi.h>
HTTPClient http;
#define SS_PIN 21
#define RST_PIN 22
#define SIZE_BUFFER 18
#define MAX_SIZE_BLOCK 16
// Informe as credencias da sua rede wifi
const char* ssid = "";
const char* password = "";
//esse objeto 'chave' é utilizado para autenticação
MFRC522::MIFARE_Key key;
//código de status de retorno da autenticação
MFRC522::StatusCode status;
// Definicoes pino modulo RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);
int LED_BUILTIN = 2;
void setup() {
Serial.begin(115200);
delay(3000);
WiFi.begin(ssid, password);
Serial.println("Conectando no wifi...");
// Aguardando para conectar no wifi
uint32_t notConnectedCounter = 0;
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Conectando Wifi...");
notConnectedCounter++;
if(notConnectedCounter > 50) { // Após 5 segundos nossa placa é resetada
Serial.println("Reiniciando placa...");
ESP.restart();
}
}
Serial.println("Wifi conectado, IP address: ");
Serial.println(WiFi.localIP());
SPI.begin(); // Init SPI bus
pinMode (LED_BUILTIN, OUTPUT);
Serial.println("Aproxime o seu cartao do leitor...");
// Inicia MFRC522
mfrc522.PCD_Init();
// Mensagens iniciais no serial monitor
Serial.println();
}
void loop() {
// Aguarda a aproximacao do cartao
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
// Seleciona um dos cartoes
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
String conteudo= "";
byte letra;
for (byte i = 0; i < mfrc522.uid.size; i++)
{
//Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
//Serial.print(mfrc522.uid.uidByte[i], HEX);
conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println("Tag : " + String(conteudo));
Serial.println("Call Api: https://192.168.0.20:7267/api/tag/");
http.begin("https://192.168.0.20:7267/api/tag/");
http.addHeader("Content-Type", "application/json");
String httpRequestData = "{\"tag\":\"" + String(conteudo) + "\"}";
int httpResponseCode = http.POST(httpRequestData);
if (httpResponseCode>0) {
Serial.print("HTTP Response code: ");
Serial.println(httpResponseCode);
String payload = http.getString();
Serial.println(payload);
}
else {
Serial.print("Error code: ");
Serial.println(httpResponseCode);
}
// instrui o PICC quando no estado ACTIVE a ir para um estado de "parada"
mfrc522.PICC_HaltA();
// "stop" a encriptação do PCD, deve ser chamado após a comunicação com autenticação, caso contrário novas comunicações não poderão ser iniciadas
mfrc522.PCD_StopCrypto1();
}
Faça o upload para a sua placa e teste.
|
No serial Monitor conseguido ver todos os passos.
Espero que tenha gostado
Código fonte do Projeto
Para receber mais conteúdo inscreva-se no canal e siga nas redes sociais
Vamos que vamos