Pular para o conteúdo principal

Laboratório 04

Checklist — Wi-Fi e MQTT no ESP32​

  • Projeto PlatformIO com plataforma e PubSubClient em versões fixas, diagram.json com o LED no GPIO2 e wokwi.toml (T1)
  • Varredura das redes Wi-Fi no monitor serial (T2)
  • Conexão Wi-Fi em modo estação, com IP e RSSI no serial (T3)
  • Conexão ao broker público com client ID único (T4)
  • Conexão ao broker privado com usuário e senha (T5)
  • Telemetria em JSON a cada 2 s, sem delay() (T6)
  • Comando .../cmd/led ligando e desligando o LED, com reconexão de Wi-Fi e MQTT no loop() (T7)
  • Workflow de CI compilando o firmware a cada push (T8)
  • Nenhum push --force; cada tarefa num commit Tn:
  • Logout do Git e do gh no computador do laboratório
Pontuação

T1…T8 = 100 pts (esta aula não tem desafios): T1 10 · T2 10 · T3 15 · T4 15 · T5 10 · T6 15 · T7 15 · T8 10. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.

Antes de começar

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

Verificação rápida das versões instaladas:

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

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

git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"

Adicionar o comando git conferir:

git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"

Configuração do ambiente de desenvolvimento​

O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.

  • O Git é um sistema de controle de versão distribuído gratuito e de código aberto, projetado para lidar com tudo, desde projetos pequenos até muito grandes, com rapidez e eficiência.

    winget install --id Git.Git -e --source winget
  • Configurações do git:

    git config --list --show-origin

Até o Lab 03 o ESP32 só falava com o monitor serial. Nesta aula ele entra na rede: conecta ao Wi-Fi, fala com um broker MQTT, publica telemetria e recebe um comando para ligar e desligar um LED. É a base de todos os labs seguintes: do Lab 05 em diante, o mesmo padrão ganha um sensor, um temporizador, o Node-RED e um banco de dados.

Objetivos​

  • Conectar o ESP32 a uma rede Wi-Fi (modo estação) e obter o IP.
  • Conectar-se a um broker MQTT por host e porta, com e sem usuário e senha.
  • 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 de Wi-Fi e MQTT no loop().
  • Rodar o mesmo código no simulador Wokwi e no ESP32 físico, entendendo a diferença entre broker público e local.

Material​

  • 1 × ESP32 (ex.: DevKit v1) ou o simulador Wokwi.
  • 1 × LED + resistor de 220 Ω (para o comando remoto).
  • Uma rede Wi-Fi (real, para o ESP32 físico; no Wokwi, a Wokwi-GUEST).
  • Um broker MQTT:
    • Público (para o Wokwi): broker.hivemq.com:1883.
    • Privado (para o Wokwi): mqtt.adrianoruseler.com:1883, com usuário e senha fornecidos pelo professor.
    • Local (para o ESP32 físico): o Mosquitto do stack Docker do curso, no IP da sua máquina na rede (ex.: 192.168.0.10:1883). O Wokwi não alcança um broker local.

Clonar o repositório do grupo​

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

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

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

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

3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:

cd /d "%USERPROFILE%\ELT73AS22\lab04-grupo-a" && code . --profile "ESP32IO"

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

  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.

Suba os containers​

Antes de começar

Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.

docker desktop start

Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:

for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down

Disciplina: ELT73A - Sistemas Microcontrolados.

1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):

set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab04-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-a"

2. Gere o LAB IoT do grupo em docker\lab04-a:

py "%IOT_GEN%" --disciplina elt73a --lab lab04 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"

3. Suba os containers (a primeira vez demora):

cd /d "%IOT_DIR%" && docker compose up -d --build

4. Abra o Portal: http://localhost/

start http://localhost/

5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):

(cd /d "%IOT_DIR%" && docker compose stop lab04-a-nodered && (del /q "data\lab04-a\flows.json" "data\lab04-a\flows_cred.json" "data\lab04-a\.flows*.backup" 2>nul & docker compose start lab04-a-nodered))
Precisa de mais?

Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.


Mapa de tarefas — 8 tarefas · 100 pts
Estrutura de Arquivos do Projeto (no fim da aula)
📂 lab04-grupo-x/
  • ├── 🔧platformio.ini👈 Criar Aqui
  • ├── 📂src
    • └── 📄main.cpp👈 Criar Aqui
  • ├── 🔧diagram.json👈 Criar Aqui
  • ├── 🔧wokwi.toml👈 Criar Aqui
  • ├── 📂.github
    • └── 📂workflows
      • └── 🚀ci.yml👈 Criar Aqui
  • └── 📝README.md👈 Edite Aqui
Tópicos do Lab 04

Tudo fica sob elt73a/lab04/grupo-x/. Troque o x (e o #define GRUPO) pela letra do seu grupo.

TópicoSentidoPayload
.../telemetriaESP32 → broker{"n":7,"temp":32.00} (T6)
.../cmd/ledbroker → ESP32on/off ou 1/0 (T7)

Parte 1 — Projeto PlatformIO e Wokwi​

Suba o stack do LAB04!

Execute os comandos para subir o stack do LAB04!

1.1 Criar o projeto​

Na raiz do repositório, como no Lab 02:

Terminal do VS Code (cmd)
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --sample-code

O --sample-code cria um src/main.cpp de exemplo: o projeto já compila no commit da T1, e na T2 você o substitui.

A biblioteca WiFi.h já vem no core do ESP32. Fixe a plataforma (como no Lab 02) e acrescente o cliente MQTT (PubSubClient), também com versão fixa:

📂 lab04-grupo-x/
  • └── 🔧platformio.ini👈 Criar Aqui
git conferir platformio.ini
platformio.ini
[env:esp32dev]
platform = espressif32@6.9.0 ; versão fixa (Lab 02)
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
knolleary/PubSubClient@2.8

1.2 Circuito no Wokwi (LED do comando)​

O circuito é o do Lab 02: LED no GPIO2 com um resistor de 220 Ω. Ele só será usado na T7.

📂 lab04-grupo-x/
  • ├── 🔧diagram.json👈 Criar Aqui
  • └── 🔧wokwi.toml👈 Criar Aqui
git conferir diagram.json wokwi.toml
diagram.json
{
"version": 1,
"author": "elt73a - Lab 04",
"editor": "wokwi",
"parts": [
{
"type": "board-esp32-devkit-c-v4",
"id": "esp",
"top": 0,
"left": 0,
"attrs": {}
},
{
"type": "wokwi-resistor",
"id": "r1",
"top": 130,
"left": 120,
"attrs": { "value": "220" }
},
{
"type": "wokwi-led",
"id": "led1",
"top": 80,
"left": 220,
"attrs": { "color": "red", "label": "GPIO2" }
}
],
"connections": [
["esp:TX", "$serialMonitor:RX", "", []],
["esp:RX", "$serialMonitor:TX", "", []],
["esp:2", "r1:1", "green", []],
["r1:2", "led1:A", "green", []],
["led1:C", "esp:GND.2", "black", []]
],
"dependencies": {}
}

1.3 Validar o diagrama​

O wokwi-cli não fica instalado no Windows: ele roda na imagem Docker que você montou no Lab 02. Na raiz do repositório:

Terminal do VS Code (cmd)
docker run --rm -v "%cd%:/projeto" -w /projeto elt73a/esp32-dev:lab02 wokwi-cli lint .

Se o Docker responder que a imagem não existe, rode docker compose build na pasta do repositório do Lab 02 e tente de novo.

Ponto de commit · T1 (10 pts) #

Projeto PlatformIO e Wokwi

1. Conferir os arquivos
git conferir platformio.ini src/main.cpp diagram.json wokwi.toml
2. Commit T1 e push
git add platformio.ini src/main.cpp diagram.json wokwi.toml && git commit -m "T1: Projeto PlatformIO e Wokwi" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.


Parte 2 — Varredura das redes Wi-Fi​

📂 lab04-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Criar Aqui
git conferir src/main.cpp
src/main.cpp (T2)
/* 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);
}

Compile (pio run) e rode Wokwi: Start Simulator: a Wokwi-GUEST aparece na lista.

Ponto de commit · T2 (10 pts) #

Varredura das redes Wi-Fi

1. Conferir os arquivos
git conferir src/main.cpp
2. Commit T2 e push
git add src/main.cpp && git commit -m "T2: Varredura das redes Wi-Fi" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.


Parte 3 — Conectar ao Wi-Fi​

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

📂 lab04-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
src/main.cpp (T3)
#include <Arduino.h>
#include <WiFi.h>

const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
// placa física: troque pela rede real
// const char *WIFI_SSID = "IoT-Broker";
// const char *WIFI_SENHA = "ESP32IoTLab";

void conectaWiFi() {
Serial.print("Conectando a "); Serial.println(WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA);
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 e o RSSI variam):

Monitor serial
Conectando a Wokwi-GUEST
....
Conectado! IP: 10.13.37.2
RSSI: -30
Ponto de commit · T3 (15 pts) #

Conexao Wi-Fi

1. Conferir os arquivos
git conferir src/main.cpp
2. Commit T3 e push
git add src/main.cpp && git commit -m "T3: Conexao Wi-Fi" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.


Parte 4 — Conectar ao broker MQTT​

O PubSubClient usa um WiFiClient por baixo. Definimos o servidor e tentamos conectar com um client id único: dois clientes com o mesmo ID no mesmo broker se derrubam mutuamente.

📂 lab04-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
src/main.cpp (T4)
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>

const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;

WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);

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

void conectaMQTT() {
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();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
conectaMQTT();
}

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

Saída esperada:

Monitor serial
....
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.

Placa física com broker local

Na placa física, troque o SSID e a senha pela rede real e o MQTT_HOST pelo IP da máquina onde o stack do curso roda (o Mosquitto escuta na porta 1883). O computador e o ESP32 precisam estar na mesma rede.

Ponto de commit · T4 (15 pts) #

Conexao ao broker MQTT

1. Conferir os arquivos
git conferir src/main.cpp
2. Commit T4 e push
git add src/main.cpp && git commit -m "T4: Conexao ao broker MQTT" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.


Parte 5 — Broker MQTT com usuário e senha​

O broker privado do curso pede usuário e senha. Muda só o connect(), que passa a receber as credenciais. Use o usuário e a senha fornecidos pelo professor (nunca a senha de uma conta sua).

📂 lab04-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
src/main.cpp (T5: o que muda em relação à T4)
const char *MQTT_HOST = "mqtt.adrianoruseler.com";
const uint16_t MQTT_PORTA = 1883;

// credenciais do broker (fornecidas pelo professor)
const char *MQTT_USER = "seu_usuario";
const char *MQTT_PASS = "sua_senha";

// em conectaMQTT():
if (mqtt.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {

Saída esperada: a mesma da T4. Com a senha errada, o rc é 5 (não autorizado).

Ponto de commit · T5 (10 pts) #

Broker MQTT com usuario e senha

1. Conferir os arquivos
git conferir src/main.cpp
2. Commit T5 e push
git add src/main.cpp && git commit -m "T5: Broker MQTT com usuario e senha" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T5.


Parte 6 — Publicar telemetria​

Publique uma mensagem a cada 2 s, sem delay() bloqueante (usando millis(), como no Lab 02). Use o código da T4 (broker público) e acrescente o tópico, trocando o grupo pelo seu:

const char *TOPICO_TELEMETRIA = "elt73a/lab04/grupo-a/telemetria"; // troque 'grupo-a'!

E use este loop():

src/main.cpp (T6: 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

char payload[64];
snprintf(payload, sizeof(payload), "{\"n\":%d,\"temp\":%.2f}", n, temp);
mqtt.publish(TOPICO_TELEMETRIA, payload);
Serial.print("Publicado: "); Serial.println(payload);
}
}

Saída esperada (a cada 2 s):

Monitor serial
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 do stack (http://localhost:3000, conectado a broker.hivemq.com:1883) ou pelo terminal:

Terminal — assinar via Docker
docker run --rm eclipse-mosquitto:2 mosquitto_sub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/#" -v
Ponto de commit · T6 (15 pts) #

Telemetria periodica

1. Conferir os arquivos
git conferir src/main.cpp
2. Commit T6 e push
git add src/main.cpp && git commit -m "T6: Telemetria periodica" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T6.


Parte 7 — Comando remoto do LED​

Agora o ESP32 também assina um tópico. Quando chega uma mensagem, o PubSubClient chama uma função sua (o callback) dentro do mqtt.loop(). Dois cuidados:

  • o payload não termina com '\0': copie para um buffer e termine a string antes de comparar;
  • assine dentro de conectaMQTT(): a sessão é limpa, então depois de uma reconexão o broker não lembra das assinaturas antigas.

E a conexão fica robusta: o loop() confere o Wi-Fi e o MQTT a cada volta e reconecta o que caiu.

📂 lab04-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
src/main.cpp (T7: código completo)
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>

#define GRUPO "a" // troque pela letra do seu grupo
#define LED_PIN 2

const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;

const char *TOPICO_TELEMETRIA = "elt73a/lab04/grupo-" GRUPO "/telemetria";
const char *TOPICO_CMD_LED = "elt73a/lab04/grupo-" GRUPO "/cmd/led";

WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);

// chamada pelo PubSubClient, dentro de mqtt.loop(), a cada mensagem num tópico assinado
void aoReceberMensagem(char *topico, byte *payload, unsigned int tam) {
char txt[8];
size_t n = tam < sizeof(txt) - 1 ? tam : sizeof(txt) - 1;
memcpy(txt, payload, n);
txt[n] = '\0'; // o payload não termina em '\0'
Serial.printf("[CMD] %s <- '%s'\r\n", topico, txt);

if (strcmp(txt, "on") == 0 || strcmp(txt, "1") == 0) {
digitalWrite(LED_PIN, HIGH);
} else if (strcmp(txt, "off") == 0 || strcmp(txt, "0") == 0) {
digitalWrite(LED_PIN, LOW);
} else {
Serial.println("[CMD] use on/off ou 1/0");
}
}

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

void conectaMQTT() {
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!");
mqtt.subscribe(TOPICO_CMD_LED); // (re)assina a cada conexão
} else {
Serial.print("falhou (rc="); Serial.print(mqtt.state());
Serial.println("), nova tentativa em 2s");
delay(2000);
}
}
}

void setup() {
Serial.begin(115200);
delay(1000);
pinMode(LED_PIN, OUTPUT);
conectaWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
mqtt.setCallback(aoReceberMensagem);
conectaMQTT();
}

void loop() {
if (WiFi.status() != WL_CONNECTED) conectaWiFi(); // reconexão do Wi-Fi
if (!mqtt.connected()) conectaMQTT(); // reconexão do MQTT
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
char payload[64];
snprintf(payload, sizeof(payload), "{\"n\":%d,\"temp\":%.2f}", n, temp);
mqtt.publish(TOPICO_TELEMETRIA, payload);
Serial.print("Publicado: "); Serial.println(payload);
}
}

Com a simulação rodando, mande os comandos pelo terminal e veja o LED no Wokwi:

Terminal — ligar e desligar o LED via Docker
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/cmd/led" -m on
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/cmd/led" -m off
docker run --rm eclipse-mosquitto:2 mosquitto_pub -h broker.hivemq.com -t "elt73a/lab04/grupo-a/cmd/led" -m talvez
Monitor serial (trecho)
Publicado: {"n":7,"temp":32.00}
[CMD] elt73a/lab04/grupo-a/cmd/led <- 'on'
Publicado: {"n":8,"temp":33.00}
[CMD] elt73a/lab04/grupo-a/cmd/led <- 'off'
[CMD] elt73a/lab04/grupo-a/cmd/led <- 'talvez'
[CMD] use on/off ou 1/0
Ponto de commit · T7 (15 pts) #

Comando remoto do LED

1. Conferir os arquivos
git conferir src/main.cpp
2. Commit T7 e push
git add src/main.cpp && git commit -m "T7: Comando remoto do LED" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T7.


Parte 8 — CI no GitHub Actions​

Um workflow que compila o firmware a cada push. Se o código parar de compilar, a execução fica vermelha na aba Actions. O Lab 10 completa este pipeline com testes, simulação e release.

📂 lab04-grupo-x/
  • ├── 📂.github
    • └── 📂workflows
      • └── 🚀ci.yml👈 Criar Aqui
  • ├── 📄...
  • └── 📂src
    • └── 📄main.cpp
git conferir .github/workflows/ci.yml
.github/workflows/ci.yml
name: CI

on: [push, pull_request]

env:
PLATFORMIO_VERSAO: "6.2.0" # versão fixa, como a plataforma no platformio.ini

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

- uses: actions/setup-python@v7
with:
python-version: "3.12"

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

- name: Instala o PlatformIO
run: pip install "platformio==${PLATFORMIO_VERSAO}"

- name: Compila o firmware
run: pio run
Por que ci.yml?

O nome ci.yml é o mesmo do Lab 10 e não se confunde com o workflow do autograder que vem no template do repositório. Não apague nem renomeie os arquivos que já estão em .github/.

Ponto de commit · T8 (10 pts) #

CI no GitHub Actions

1. Conferir os arquivos
git conferir .github/workflows/ci.yml
2. Commit T8 e push
git add .github/workflows/ci.yml && git commit -m "T8: CI no GitHub Actions" && git push
3. Conferir o commit e o envio
git status -sb && git log -1 --stat --oneline

Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T8.


Logout do seu ambiente dev, git e gh​

Ao terminar — máquina de laboratório

Antes de sair, faça logout para não deixar sua conta do GitHub ativa nesta máquina. Rode os comandos abaixo no Prompt de Comando (cmd), não no PowerShell.

1. Apague a credencial do GitHub salva pelo git, encerre a sessão do gh e remova seu nome e e-mail da configuração global:

(echo protocol=https&echo host=github.com) | git credential reject
gh auth logout --hostname github.com
git config --global --unset user.name
git config --global --unset user.email

Para conferir, este comando não deve mostrar nada:

cmdkey /list | findstr /i github

2. Pare os containers do lab:

for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down

3. No navegador, saia da sua conta em github.com e feche todas as janelas.