Pular para o conteúdo principal

Laboratório 04

TarefaTemplateInícioFimConteúdo
LAB0417-09-202624-09-2026Pilha de Protocolos IoT: Enlace e Rede;

Checklist — WiFi e MQTT no ESP32​

  • Verificar git --version
  • Abrir o VS Code
  • Abrir a extensão PlatformIO IDE
  • Criar um projeto ESP32
  • Selecionar o framework Arduino
  • Executar o primeiro Build
  • Criar wokwi.toml
  • Criar diagram.json
  • Executar a simulação
  • Verificar o Serial Monitor
  • Atualizar o repositório no GitHub
  • Executar git push
  • Confirmar que o projeto está disponível no GitHub
  • Logout
Antes de começar

Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):

  1. Instalar as ferramentas — git, GitHub CLI e VS Code
  2. Configurar o git — nome, e-mail e editor padrão (uma vez)
  3. Verificar git, gh e VS Code — deve mostrar as versões e Logged in to github.com

Verificação rápida de versão instalada:

git -v && gh --version && code -v && pio --version && wokwi-cli -V && wsl --version && docker --version

Verificação rápida de autenticação:

git config --get-regexp ^user\. && gh auth status && code --list-extensions --profile "ESP32IO"
Ao terminar — máquina de laboratório

Antes de sair, faça logout para não deixar sua conta do GitHub ativa na máquina (limpa a credencial salva do git e encerra a sessão do gh).

1. Objetivos de aprendizagem​

Ao final desta aula, o aluno será capaz de:

  • Conectar o ESP32 a uma rede WiFi (modo estação) e obter o IP.
  • Conectar-se a um broker MQTT por IP/host e porta.
  • Publicar dados de telemetria periodicamente em um tópico.
  • Assinar um tópico e reagir a comandos recebidos (ligar/desligar um LED).
  • Tornar a conexão robusta com reconexão automática de WiFi e MQTT.
  • Rodar o mesmo código no simulador Wokwi e no ESP32 físico, entendendo a diferença entre broker público e local.
Pontos de commit

Os cartões "Ponto de commit" marcam cada tarefa avaliada. Copie o comando do cartão e faça o commit com a mensagem sugerida.

2. Material necessário​

  • 1 × ESP32 (ex.: DevKit v1) ou o simulador Wokwi.
  • 1 × LED + resistor de 220 Ω (para o comando remoto).
  • Uma rede WiFi (real, para o ESP32 físico).
  • Um broker MQTT:
    • Público (para o Wokwi): broker.hivemq.com:1883.
    • Local (para o ESP32 físico): um Mosquitto em Docker na sua máquina/rede (ver "Broker MQTT local com Docker"), ex.: 192.168.0.10:1883.

Clone o repositório inicial do LAB04​

Escolha o Grupo e entre com o comando abaixo para criar o repositório no GitHub:

1. Crie e entre na pasta-mãe da disciplina:

mkdir "%USERPROFILE%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"

2. Clone e entre no repositório do laboratório:

git clone https://github.com/ELT85B-N21-2026-2/lab04-grupo-a.git && cd lab04-grupo-a

3. Verifique status e abra o conteúdo do repositório no perfil ESP32IO do VS Code :

git status && code . --profile "ESP32IO"

Repositório do Grupo A para Laboratório 04:

ELT85B-N21-2026-2/lab04-grupo-a
  1. Copie o link do repositório acima.
  2. Abra a página de envio da atividade no Moodle (botão abaixo).
  3. Clique em Adicionar envio.
  4. Cole o link no campo Texto online.
  5. Clique em Salvar mudanças.
  6. Confira se o status mudou para Enviado para avaliação.
Abrir envio no Moodle
Avaliação por commits

Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.

Crie um novo projeto no Platform IO​

pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --sample-code
Ponto de commit · T1 (5 pts) #

pio project init

git add . && git commit -m "T1: pio project init" && git push

ESP32 WiFi Networking​

📂 lab04-grupo-x/
  • ├── 📄...
  • └── 📂src
    • └── 📄main.cpp👈 Criar Aqui
/* ESP32 WiFi Scanning example */
#include <Arduino.h>
#include "WiFi.h"

void setup() {
  Serial.begin(115200);
  Serial.println("Initializing WiFi...");
  WiFi.mode(WIFI_STA);
  Serial.println("Setup done!");
}

void loop() {
  Serial.println("Scanning...");

  // WiFi.scanNetworks will return the number of networks found
  int n = WiFi.scanNetworks();
  Serial.println("Scan done!");
  if (n == 0) {
    Serial.println("No networks found.");
  } else {
    Serial.println();
    Serial.print(n);
    Serial.println(" networks found");
    for (int i = 0; i < n; ++i) {
      // Print SSID and RSSI for each network found
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.print(")");
      Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*");
      delay(10);
    }
  }
  Serial.println("");

  // Wait a bit before scanning again
  delay(5000);
}

Setup — PlatformIO e Wokwi​

A biblioteca WiFi.h já vem no core do ESP32. Adicione o cliente MQTT (PubSubClient):

📂 lab04-grupo-x/
  • ├── 📂src
    • └── 📄main.cpp
  • ├── 📄...
  • └── 🔧platformio.ini👈 Edite Aqui
platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
    knolleary/PubSubClient@^2.8
📂 lab04-grupo-x/
  • ├── 📂src
    • └── 📄main.cpp
  • ├── 📄...
  • ├── 🔧diagram.json👈 Criar Aqui
  • └── 🔧wokwi.toml👈 Criar Aqui

Circuito no Wokwi (LED do comando)​

diagram.json
{
  "version": 1,
  "author": "Aluno",
  "editor": "wokwi",
  "parts": [
    {
      "type": "board-esp32-devkit-c-v4",
      "id": "esp",
      "top": 0,
      "left": 0,
      "attrs": {}
    },
    {
      "type": "wokwi-led",
      "id": "led1",
      "top": -48,
      "left": 110,
      "attrs": { "color": "green" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r1",
      "top": 20,
      "left": 110,
      "attrs": { "value": "220" }
    }
  ],
  "connections": [
    ["esp:TX0", "$serialMonitor:RX", "", []],
    ["esp:RX0", "$serialMonitor:TX", "", []],
    ["esp:2", "r1:1", "green", []],
    ["r1:2", "led1:A", "green", []],
    ["led1:C", "esp:GND.1", "black", []]
  ]
}
Ponto de commit · T2 (15 pts) #

ESP32 WiFi Scanning example

git add . && git commit -m "T2: ESP32 WiFi Scanning example" && git push

Conectar ao WiFi​

Modo estação (WIFI_STA), WiFi.begin() e espera até WL_CONNECTED.

📂 lab04-grupo-x/
  • ├── 📂src
    • └── 📄main.cpp👈 Edite Aqui
  • ├── 📄...
  • ├── 🔧platformio.ini
  • ├── 🔧diagram.json
  • └── 🔧wokwi.toml
#include <Arduino.h>
#include <WiFi.h>

const char* WIFI_SSID = "IoT-Broker";
const char* WIFI_PASS = "ESP32IoTLab";

void conectaWiFi() {
  Serial.print("Conectando a "); Serial.println(WIFI_SSID);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(300);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("Conectado! IP: "); Serial.println(WiFi.localIP());
  Serial.print("RSSI: ");           Serial.println(WiFi.RSSI());
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  conectaWiFi();
}

void loop() {}

Saída esperada (o IP varia):

Conectando a IoT-Broker
....
Conectado! IP: 10.13.37.2
RSSI: -30
Ponto de commit · T3 (15 pts) #

conecta ao WiFi e imprime o IP

git add . && git commit -m "T3: conecta ao WiFi e imprime o IP" && git push

Conectar ao broker MQTT​

O PubSubClient usa um WiFiClient por baixo. Definimos o servidor e tentamos conectar com um client id único.

#include <WiFi.h>
#include <PubSubClient.h>

const char* WIFI_SSID = "IoT-Broker";
const char* WIFI_PASS = "ESP32IoTLab";
const char* MQTT_HOST = "broker.hivemq.com";
const int   MQTT_PORT = 1883;

WiFiClient   wifiClient;
PubSubClient mqtt(wifiClient);

void conectaWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) { delay(300); Serial.print("."); }
  Serial.print("\nWiFi OK, IP: "); Serial.println(WiFi.localIP());
}

void conectaMQTT() {
  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  while (!mqtt.connected()) {
    String clientId = "esp32-" + String(random(0xffff), HEX);
    Serial.print("Conectando ao broker MQTT... ");
    if (mqtt.connect(clientId.c_str())) {
      Serial.println("conectado!");
    } else {
      Serial.print("falhou (rc="); Serial.print(mqtt.state());
      Serial.println("), nova tentativa em 2s");
      delay(2000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  conectaWiFi();
  conectaMQTT();
}

void loop() {
  mqtt.loop();
}

Saída esperada:

....
WiFi OK, IP: 10.13.37.2
Conectando ao broker MQTT... conectado!
Código de retorno (rc)

Se falhar, mqtt.state() dá a pista: -2 = não alcançou o servidor (host/porta errados ou sem rede), -4 = timeout, 5 = não autorizado. Muito útil para depurar.

Ponto de commit · T4 (15 pts) #

conecta ao broker MQTT

git add . && git commit -m "T4: conecta ao broker MQTT" && git push

Publicar telemetria​

Publique uma mensagem a cada 2 s, sem delay() bloqueante (usando millis()). Adicione o tópico e troque o prefixo pelo do seu grupo:

const char* TOPIC_TELEMETRIA = "elt85b/grupo-a/telemetria";  // troque 'grupo-a'!

E use este loop():

void loop() {
  if (!mqtt.connected()) conectaMQTT();
  mqtt.loop();

  static unsigned long ultimo = 0;
  if (millis() - ultimo > 2000) {
    ultimo = millis();

    static int n = 0;
    n++;
    float temp = 25.0 + (n % 10);   // leitura simulada

    String payload = String("{\"n\":") + n + ",\"temp\":" + temp + "}";
    mqtt.publish(TOPIC_TELEMETRIA, payload.c_str());
    Serial.print("Publicado: "); Serial.println(payload);
  }
}

Saída esperada (a cada 2 s):

Publicado: {"n":1,"temp":26.00}
Publicado: {"n":2,"temp":27.00}
Publicado: {"n":3,"temp":28.00}

Veja as mensagens chegando: no MQTT Explorer (http://localhost:3000, broker Docker local) ou no HiveMQ Web Client (broker público), assinando elt85b/grupo-a/telemetria.

Ponto de commit · T5 (8 pts) #

publica telemetria periodica num topico

git add . && git commit -m "T5: publica telemetria periodica num topico" && git push

CI workflow​

Example workflow (.github/workflows/grade.yml):

📂 lab04-grupo-x/
  • ├── 📂.github
    • └── 📂workflows
      • └── 🚀grade.yml👈 Criar Aqui
  • ├── 📄...
  • └── 📂src
    • └── 📄main.cpp
.github/workflows/grade.yml
name: Build & Test

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5

      - name: Cache PlatformIO
        uses: actions/cache@v5
        with:
          path: |
            ~/.cache/pip
            ~/.platformio/.cache
            ~/.platformio/packages
          key: ${{ runner.os }}-pio-${{ hashFiles('platformio.ini') }}

      - name: Set up Python
        uses: actions/setup-python@v7
        with:
          python-version: "3.12"

      - name: Install PlatformIO
        run: pip install platformio

      - name: Build project
        run: pio run

      # Uncomment if you want native/unit tests in CI
      # - name: Run tests
      #   run: pio test -e native
Ponto de commit · T6 (15 pts) #

GitHub action

git add .github/workflows/grade.yml && git commit -m "T6: GitHub action" && git push

Logout do seu ambiente dev, git e gh​

Para o git "esquecer" suas informações salvas:

git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
Última atualização em por Adriano Ruseler