Sem categoria

Modulo IOT Preparação

Mauricio Gomes nenhum comentário

Vamos a nossa primeira etapa!

Vamos preparar o ambiente de desenvolvimento:

Instalação da IDE

Baixe a ide do Arduino neste link: ArduinoIDE na publicação deste post a versão era 2.3.4.

Instalação das placas

Abra a ide o Arduino, clique em Arquivo depois em Preferências.

Clique sobre o icone marcado e adicione estas duas URL’s. Importante, como a propria IDE avisa, uma por linha.

https://arduino.esp8266.com/stable/package_esp8266com_index.json
https://dl.espressif.com/dl/package_esp32_index.json

Após inserir as duas clique em OK nas duas janelas.

Agora clique no icone do Board Manager ou Gerenciador de placas:

Na caixa de pesquisa, digite esp8266 e instale a versão, na data do post era a 3.2.1:

No caso da sua ide estará escrito instalar, preferencialmente use a mesma versão que estou usando, este processo demora um pouco.

Após a finalização vamos instalar a placa esp32:

Na caixa de pesquisa, digite esp32 e instale a versão, na data do post era a 3.1.1, instale a versão esp32 por Espressid Systems:

Novamente espere até finalizar, este demora um pouco mais que a anterior.

Instalação das bibliotecas

Para desenvolver este projeto vamos necessitar de algumas bibliotecas externas, porem elas estão na ide disponiveis para baixar.

Clique sobre o Icone do gerenciador de Bibliotecas:

ESPAsyncWebServer V3.7.2

Na caixa de pesquisa digite: ESPAsyncWebServer, no momento deste post esta na versão 3.7.2.

Baixe a versão por ESP32Async.

A biblioteca ESPAsyncWebServer é uma ferramenta poderosa e eficiente para desenvolvedores que trabalham com microcontroladores ESP32 e ESP8266. Ela permite a criação de servidores web assíncronos, o que significa que o servidor é capaz de lidar com múltiplas conexões simultaneamente sem bloquear a execução de outras tarefas no dispositivo. Isso é especialmente útil em aplicações IoT, onde o microcontrolador precisa gerenciar requisições HTTP enquanto realiza outras operações, como leitura de sensores ou controle de atuadores.

Principais características:

  • Assíncrono: Não bloqueia a execução do código principal, permitindo multitarefas.
  • Suporte a WebSockets: Facilita a comunicação bidirecional em tempo real entre o cliente e o servidor.
  • Fácil integração com o ESPAsyncTCP (ESP8266) e AsyncTCP (ESP32): Bibliotecas que gerenciam a conexão TCP de forma assíncrona.
  • Rotas dinâmicas: Permite definir rotas para diferentes URLs e métodos HTTP (GET, POST, etc.).
  • Suporte a upload de arquivos: Ideal para aplicações que necessitam de atualizações de firmware ou envio de dados.

Em resumo, a ESPAsyncWebServer é uma escolha excelente para projetos que exigem um servidor web robusto e responsivo em dispositivos com recursos limitados, como os microcontroladores da família ESP.

ESPAsyncTCP V2.0.0

Na caixa de pesquisa digite: ESPAsyncTCP , no momento deste post esta na versão 2.0.0.

Baixe a versão por ESP32Async.

A biblioteca ESPAsyncTCP é uma implementação assíncrona do protocolo TCP para microcontroladores ESP8266, projetada para trabalhar em conjunto com outras bibliotecas, como a ESPAsyncWebServer. Ela permite que o dispositivo gerencie conexões de rede de forma não bloqueante, ou seja, sem parar a execução de outras tarefas enquanto espera por dados ou processa requisições. Isso é fundamental para aplicações que exigem alta responsividade e multitarefa, como em sistemas IoT.

Principais características:

  • Assíncrona: Gerência as conexões TCP sem bloquear o loop principal do programa, permitindo que o dispositivo execute outras operações simultaneamente.
  • Eficiente: Ideal para dispositivos com recursos limitados, como o ESP8266, pois consome menos memória e processamento em comparação com implementações síncronas.
  • Integração com bibliotecas de alto nível: Funciona como base para bibliotecas como a ESPAsyncWebServer, que dependem de comunicação TCP assíncrona para criar servidores web robustos.
  • Suporte a eventos: Permite a execução de callbacks para eventos como recebimento de dados, desconexão de clientes e erros de conexão.

Em resumo, a ESPAsyncTCP é uma biblioteca essencial para desenvolvedores que precisam de comunicação TCP eficiente e não bloqueante em projetos com ESP8266, especialmente quando combinada com outras bibliotecas assíncronas para criar soluções IoT avançadas e responsivas.

AsyncTCP V3.3.7

Na caixa de pesquisa digite: AsyncTCP, no momento deste post esta na versão 3.3.7.

Baixe a versão por ESP32Async.

A biblioteca AsyncTCP é uma implementação assíncrona do protocolo TCP para o ESP32, projetada para permitir comunicações de rede eficientes e não-bloqueantes. Ela serve como base para outras bibliotecas de alto nível, como a ESPAsyncWebServer, garantindo que o microcontrolador possa lidar com múltiplas conexões simultâneas sem travar a execução de outras tarefas. Essa característica é essencial para projetos IoT que exigem multitarefa, como servidores web, clientes de API ou sistemas em tempo real.

Principais características:

  • Comunicação não-bloqueante: Opera em segundo plano, liberando o loop principal do ESP32 para outras tarefas enquanto gerencia conexões TCP.
  • Alto desempenho: Suporta múltiplas conexões simultâneas com baixo overhead de memória e processamento.
  • Suporte a eventos: Utiliza callbacks para notificar sobre eventos como recebimento de dados (onData), novas conexões (onClient) ou erros (onError), facilitando a programação reativa.
  • Integração com bibliotecas assíncronas: Funciona como base para bibliotecas como ESPAsyncWebServer e AsyncMQTTClient, habilitando servidores web ou clientes MQTT eficientes.
  • Estabilidade: Mais robusta que soluções bloqueantes, evitando travamentos em cenários de alta carga ou conexões instáveis.

Comparação com ESPAsyncTCP:

Enquanto a ESPAsyncTCP é a versão para o ESP8266, a AsyncTCP foi desenvolvida especificamente para o ESP32, aproveitando seu hardware mais potente (como dual-core e maior memória RAM). Ambas seguem o mesmo princípio de operação assíncrona, mas a AsyncTCP é otimizada para as capacidades do ESP32.

ArduinoJson V7.3.0

Na caixa de pesquisa digite: ArduinoJson, no momento deste post esta na versão 7.3.0.

Baixe a versão por Benoit Blanchon.

A biblioteca ArduinoJson é uma ferramenta extremamente popular e eficiente para manipulação de dados no formato JSON (JavaScript Object Notation) em microcontroladores, como Arduino, ESP32 e ESP8266. JSON é um formato leve e de fácil leitura para troca de dados, amplamente utilizado em aplicações IoT e comunicação com APIs web.

Principais características:

  • Leve e eficiente: Projetada para funcionar em dispositivos com recursos limitados, como microcontroladores, sem consumir muita memória ou processamento.
  • Fácil de usar: Oferece uma API intuitiva para serialização (conversão de dados em JSON) e desserialização (conversão de JSON em dados utilizáveis no código).
  • Suporte a diferentes tipos de dados: Trabalha com strings, números, arrays, objetos aninhados e outros tipos de dados comuns em JSON.
  • Compatibilidade com APIs web: Ideal para integrar dispositivos IoT com serviços RESTful, APIs de terceiros ou enviar/receber dados de servidores.
  • Documentação extensa: Possui uma documentação clara e exemplos práticos que facilitam a implementação em projetos.

Em resumo, a ArduinoJson é uma biblioteca essencial para desenvolvedores que precisam manipular dados JSON em projetos com microcontroladores, seja para comunicação com APIs, armazenamento de configurações ou troca de informações entre dispositivos. Sua eficiência e facilidade de uso a tornam uma das bibliotecas mais recomendadas para trabalhar com JSON no ecossistema Arduino e ESP.

Finalmente terminamos nosso ambiente de desenvolvimento.

Vamos para o codigo de teste do arduino:

// bibliotecas especificas de cada placa
#ifdef ESP8266
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESP8266mDNS.h>
#include <FS.h>
#elif defined(ESP32)
#include <Arduino.h>
#include <AsyncTCP.h>
#include <WiFi.h>
#include <ESPmDNS.h>
#include "FS.h"
#endif
// bibliotecas globais
#include <ESPAsyncWebServer.h>
#include <LittleFS.h>
#include <ArduinoJson.h>

// Nome do modulo
char hostname[] = "MODULOCURSO";  
// instancia o servidor
AsyncWebServer server(80);

// roda uma vez, usado na configuração
void setup() {
  // inicializa a serial
  Serial.begin(9600);

  // seta o modo de operação para estação
  WiFi.mode(WIFI_STA);

  // seta o nome do dispositivo na rede, fica mais facil para encontrar no roteador
  WiFi.setHostname(hostname);

  // adiciona a rede e a senha do wifi
  WiFi.begin("SUA REDE WIFI", "SUA SENHA DO WIFI");

  // debug da conexão de wifi
  Serial.println();
  Serial.print("Conectando");
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(".");
  }
  Serial.println("Conectado!");
  Serial.print("IP:");
  Serial.println(WiFi.localIP().toString());
  Serial.print("http://");
  Serial.print(hostname);
  Serial.println(".local");
  Serial.print("http://");
  Serial.println(WiFi.localIP().toString());

  // inicia o sistema de arquivos
  LittleFS.begin();

  // serve os arquivos estaticos
  server.serveStatic("/", LittleFS, "/").setDefaultFile("index.html");

  // rota de teste
  server.on("/teste", HTTP_GET, [](AsyncWebServerRequest* request) {
    request->send(200, "text/html", "<h1>Rota teste funciona!</h1>");
  });

  // rota de teste do json
  server.on("/testejson", HTTP_GET, [](AsyncWebServerRequest* request) {
    AsyncResponseStream* response = request->beginResponseStream("application/json");
    JsonDocument json;
    json["message"] = "Rota testejson funciona!";
    serializeJson(json, *response);
    request->send(response);
  });

  // usando o nome do dispositivo para o mDNS
  MDNS.begin(hostname);

  // adiciona o serviço disponivel
  MDNS.addService("http", "tcp", 80);

  // inicia o servidor
  server.begin();
}

// função main do programa, o loop principal
void loop() {
  MDNS.update();
}

Salve este arquivo com o nome que desejar, depois dentro da pasta dele crie uma pasta com o nome de data, assim mesmo, minusculo.

Crie um arquivo index.html e cole este conteudo dentro dele:

<!DOCTYPE html>
<html lang="pt-BR">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Pagina de teste</title>
</head>

<body>
  <h1>Funciona!</h1>
</body>

</html>

Para enviar este arquivo html para a placa devemos baixar um plugin para a ide do Arduino arduino-littlefs-upload, o manual de instalação esta aqui, resumindo, dentro da pasta do seu usuário, encontre a pasta .arduinoIDE, C:\Users\<username>\.arduinoIDE\plugins\, troque o <username> pelo seu nome de usuário e caso não exista a pasta plugins crie ela e cole o arquivo baixado, após este procedimento deve-se reiniciar a IDE do arduino para que ela encontre o plugin.

Comando para enviar o arquivo html: [Ctrl] + [Shift] + [P], digite na caixa que abriu “Upload LittleFS to Pico/ESP8266/ESP32“, clique sobre ele ou ENTER para que ele comece a enviar o arquivo, caso de um erro de permissão ou porta ocupada feche o terminal serial e refaça o processo.

Com este exemplo podemos testar se as bibliotecas estão funcionando.

Deixe um comentário

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