Pular para o conteúdo principal

Laboratório 05

Checklist — DHT22, temporizador e MQTT com Node-RED​

  • platformio.ini com DHT, Unified Sensor e PubSubClient; diagram.json com DHT22 no GPIO15 (T1)
  • Leituras periódicas via Ticker + flag volatile, NaN descartado (T2)
  • Conexão Wi-Fi com reconexão no loop() (T3)
  • JSON publicado em elt73a/lab05/grupo-x/dht a cada 5 s, client ID único (T4)
  • Node-RED: mqtt in (JSON) → debug, fluxo exportado (T5)
  • LWT offline + online retidos em .../status, visíveis no Node-RED (T6)
  • Previsões P1–P4 respondidas no README.md
  • Nenhum push --force; cada tarefa num commit Tn:
  • Logout do Git e do gh no computador do laboratório
Pontuação

T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 15 · T4 20 · T5 15 · T6 20. 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

Nesta aula o ESP32 vira um nó de telemetria: um temporizador dispara leituras periódicas do DHT22, o firmware publica cada leitura em JSON via MQTT, e o Node-RED assina o tópico e mostra as mensagens no painel debug. No projeto integrador o nó passa a anunciar se está online ou offline usando LWT.

Continua no Lab 06

No Lab 06 o mesmo firmware é reaproveitado: ganha um display OLED e passa a receber comandos pelo MQTT, como o intervalo de leitura. Gravar as leituras num banco (SQLite) fica para o Lab 08.

Objetivos​

  • Ler temperatura e umidade do DHT22 e tratar leituras inválidas (NaN).
  • Usar um temporizador (Ticker) para disparar ações periódicas sem delay() e sem bloquear o loop().
  • Conectar o ESP32 ao Wi-Fi e a um broker MQTT, publicando leituras em JSON.
  • No Node-RED, assinar o tópico, receber o JSON já convertido em objeto e inspecionar os campos no debug.
  • (Integrador) Publicar o status do nó com LWT (Last Will and Testament).

Material​

  • VS Code + PlatformIO + extensão Wokwi (ESP32 simulado — sem placa física).
  • Stack Docker do curso (Mosquitto + Node-RED + MQTT Explorer) — nesta aula usamos o Node-RED e o MQTT Explorer.
  • Bibliotecas (baixadas pelo PlatformIO): adafruit/DHT sensor library, adafruit/Adafruit Unified Sensor, knolleary/PubSubClient. O Ticker já vem com o core Arduino do ESP32.
Por que Wokwi (e não placa física)?

Conferindo a matriz de simulação: GPIO (o DHT22 usa um único pino digital) e Wi-Fi são ✔️ no ESP32 clássico — então a aula roda inteira no Wokwi. O mesmo firmware funciona numa placa física trocando só SSID/senha e o endereço do broker (veja a aba "Placa física" na T3).

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/lab05-grupo-a.git && cd lab05-grupo-a

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

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

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

  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\lab05-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-a"

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

py "%IOT_GEN%" --disciplina elt73a --lab lab05 --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 lab05-a-nodered && (del /q "data\lab05-a\flows.json" "data\lab05-a\flows_cred.json" "data\lab05-a\.flows*.backup" 2>nul & docker compose start lab05-a-nodered))
Precisa de mais?

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


Mapa de tarefas — 6 tarefas · 100 pts

O repositório do grupo nasce do lab05-template:

Estrutura de Arquivos do Projeto
📂 lab05-grupo-x/
  • ├── 🔧platformio.ini👈 Edite Aqui
  • ├── 📂src
    • └── 📄main.cpp👈 Edite Aqui
  • ├── 🔧diagram.json👈 Edite Aqui
  • ├── 🔧wokwi.toml👈 Verificar
  • ├── 📄.gitignore👈 Verificar
  • ├── 📂.vscode
    • └── 🔧extensions.json👈 Verificar
  • ├── 📂nodered
    • └── 🔧flows-lab05.json👈 Criar Aqui
  • ├── 📂evidencias
    • ├── 📄t2-serial.txt👈 Criar Aqui
    • ├── 📄t3-wifi.txt👈 Criar Aqui
    • ├── 📄t4-mqtt.txt👈 Criar Aqui
    • ├── 📄t5-debug.txt👈 Criar Aqui
    • └── 📄t6-status.txt👈 Criar Aqui
  • └── 📝README.md👈 Edite Aqui
setup() × loop() nesta aula
  • setup() — o que acontece uma vez: iniciar Serial e DHT, conectar Wi-Fi e MQTT, armar o temporizador.
  • loop() — o comportamento contínuo: manter Wi-Fi/MQTT vivos (mqtt.loop()), e consumir a flag do temporizador (ler + publicar).
  • callback do temporizador — não é nem um nem outro: roda em outro contexto (a tarefa do esp_timer). Por isso ele só faz leituraPendente = true e mais nada.

Parte 1 — Circuito e dependências​

1.1 Circuito no Wokwi​

O DHT22 do Wokwi tem 4 pinos: VCC, SDA (dados), NC e GND. Ligue VCC → 3V3, GND → GND e SDA → GPIO15. O template já traz o ESP32; acrescente o sensor no diagram.json:

📂 lab05-grupo-x/
  • └── 🔧diagram.json👈 Edite Aqui
git conferir diagram.json
diagram.json
{
"version": 1,
"author": "elt73a - Lab 05",
"editor": "wokwi",
"parts": [
{
"type": "board-esp32-devkit-c-v4",
"id": "esp",
"top": 0,
"left": 0,
"attrs": {}
},
{
"type": "wokwi-dht22",
"id": "dht1",
"top": -76.5,
"left": 157.8,
"attrs": { "temperature": "24.5", "humidity": "55" }
}
],
"connections": [
["esp:TX", "$serialMonitor:RX", "", []],
["esp:RX", "$serialMonitor:TX", "", []],
["dht1:VCC", "esp:3V3", "red", []],
["dht1:GND", "esp:GND.2", "black", []],
["dht1:SDA", "esp:15", "green", []]
],
"dependencies": {}
}
Mudando os valores durante a simulação

Com o simulador rodando, clique no DHT22: aparecem sliders de temperatura e umidade. É assim que você vai "esquentar" o sensor e ver os números mudarem no Node-RED.

1.2 Bibliotecas no platformio.ini​

📂 lab05-grupo-x/
  • └── 🔧platformio.ini👈 Edite 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 =
adafruit/DHT sensor library@1.4.6
adafruit/Adafruit Unified Sensor@1.1.14
knolleary/PubSubClient@2.8

As versões são fixas, como no Lab 02: sem elas, o mesmo commit pode compilar com bibliotecas diferentes em dias diferentes. (O Lab 10 volta a esse ponto, no CI.)

O wokwi.toml do template já aponta para .pio/build/esp32dev/firmware.bin e .elf — por isso o nome do ambiente precisa continuar esp32dev.

Ponto de commit · T1 (10 pts) #

Dependencias e circuito do DHT22

1. Conferir os arquivos
git conferir platformio.ini diagram.json
2. Commit T1 e push
git add platformio.ini diagram.json && git commit -m "T1: Dependencias e circuito do DHT22" && 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 — DHT22 com temporizador​

2.1 Por que um temporizador?​

O jeito ingênuo é ler(); delay(5000);. Funciona até você precisar fazer outra coisa no loop() — como manter a conexão MQTT viva, que exige chamar mqtt.loop() várias vezes por segundo. Com delay(5000) o cliente fica 5 s "surdo".

A solução é deixar um temporizador marcar o tempo e o loop() só reagir:

  • Ticker é o temporizador de software do core ESP32 (baseado no esp_timer, com resolução de microssegundos). attach(segundos, funcao) chama funcao periodicamente.
  • A flag é volatile bool porque é escrita num contexto (timer) e lida em outro (loop()): volatile impede o compilador de "cachear" o valor num registrador.
  • No ESP32, bool ocupa 1 byte e a escrita é atômica — não precisamos de mutex para uma flag.
DHT22 é lento

O DHT22 faz no máximo uma leitura a cada 2 s. A biblioteca da Adafruit respeita isso: se você pedir antes, ela devolve o último valor em cache.

2.2 Código​

📂 lab05-grupo-x/
  • └── 📂src
    • └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
src/main.cpp (T2)
#include <Arduino.h>
#include <Ticker.h>
#include <DHT.h>

#define DHT_PIN 15
#define DHT_TIPO DHT22

DHT dht(DHT_PIN, DHT_TIPO);
Ticker temporizador;

volatile bool leituraPendente = false; // setada pelo temporizador
const float INTERVALO_S = 5.0; // DHT22: minimo 2 s entre leituras
uint32_t seq = 0;

// Roda no contexto do temporizador: NADA de Serial/DHT/MQTT aqui
void aoEstourarTemporizador() {
leituraPendente = true;
}

void setup() {
Serial.begin(115200);
delay(200);
Serial.println("\r\n=== Lab 05 - T2: DHT22 + temporizador ===");
dht.begin();
temporizador.attach(INTERVALO_S, aoEstourarTemporizador);
}

void loop() {
if (leituraPendente) {
leituraPendente = false;
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t) || isnan(h)) {
Serial.println("[DHT] falha na leitura (NaN) - descartada");
return;
}
seq++;
Serial.printf("[DHT] seq=%lu t=%.1f C h=%.1f %% (%lu ms)\r\n",
(unsigned long)seq, t, h, (unsigned long)millis());
}
}

Compile (PlatformIO: Build) e rode Wokwi: Start Simulator.

Saída esperada (os ms variam um pouco):

Monitor serial
=== Lab 05 - T2: DHT22 + temporizador ===
[DHT] seq=1 t=24.5 C h=55.0 % (5204 ms)
[DHT] seq=2 t=24.5 C h=55.0 % (10204 ms)
[DHT] seq=3 t=24.5 C h=55.0 % (15204 ms)
Preveja antes de rodar
  • P1: troque INTERVALO_S para 1.0 e mude o slider do sensor entre duas leituras. Os valores acompanham o slider a cada linha? Por quê?
  • P2: e se você colocasse o Serial.printf dentro de aoEstourarTemporizador()? Pense em quem mais depende da tarefa do esp_timer e no tempo que um printf a 115200 baud leva.

Anote as previsões e o que observou no README.md. Depois volte o intervalo para 5 s.

Salve pelo menos 3 leituras do monitor serial (copie do terminal do Wokwi) em evidencias/t2-serial.txt, incluindo a linha === Lab 05.

📂 lab05-grupo-x/
  • └── 📂evidencias
    • └── 📄t2-serial.txt👈 Criar Aqui
git conferir evidencias/t2-serial.txt
Ponto de commit · T2 (20 pts) #

Leitura do DHT22 com temporizador

1. Conferir os arquivos
git conferir src/main.cpp evidencias/t2-serial.txt
2. Commit T2 e push
git add src/main.cpp evidencias/t2-serial.txt && git commit -m "T2: Leitura do DHT22 com temporizador" && 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 — Wi-Fi​

Acrescente o Wi-Fi ao programa da T2. No Wokwi a rede é Wokwi-GUEST, sem senha; passar o canal 6 no begin() pula a varredura e conecta mais rápido.

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

const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";

void conectarWiFi() {
Serial.printf("[WiFi] conectando a %s", WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA, 6); // canal 6 acelera no Wokwi
while (WiFi.status() != WL_CONNECTED) {
delay(250);
Serial.print('.');
}
Serial.printf("\r\n[WiFi] conectado, IP %s\r\n", WiFi.localIP().toString().c_str());
}

// em setup(), depois de dht.begin():
// conectarWiFi();
// no inicio de loop():
// if (WiFi.status() != WL_CONNECTED) conectarWiFi();

Saída esperada:

Monitor serial
=== Lab 05 ===
[WiFi] conectando a Wokwi-GUEST.....
[WiFi] conectado, IP 10.13.37.2
[DHT] seq=1 t=24.5 C h=55.0 % (6120 ms)
O while do Wi-Fi bloqueia — e tudo bem aqui

Enquanto não há Wi-Fi não há o que publicar, então bloquear na (re)conexão é aceitável nesta aula. Em produção você trocaria por uma máquina de estados não bloqueante.

Salve a saída (com a linha [WiFi] conectado) em evidencias/t3-wifi.txt.

📂 lab05-grupo-x/
  • └── 📂evidencias
    • └── 📄t3-wifi.txt👈 Criar Aqui
git conferir evidencias/t3-wifi.txt
Ponto de commit · T3 (15 pts) #

Conexao Wi-Fi

1. Conferir os arquivos
git conferir src/main.cpp evidencias/t3-wifi.txt
2. Commit T3 e push
git add src/main.cpp evidencias/t3-wifi.txt && 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 — Publicação MQTT periódica​

4.1 Tópico e payload​

Cada grupo publica no seu tópico (troque a pela letra do grupo):

UsoTópicoExemplo de payload
Leituraselt73a/lab05/grupo-x/dht{"grupo":"a","seq":7,"t":24.5,"h":55.0,"uptime_ms":35210}
Status (T6)elt73a/lab05/grupo-x/statusonline / offline (retido)
  • seq é um contador: se chegarem seq 7, 8, 10, a mensagem 9 se perdeu.
  • uptime_ms (de millis()) mostra o instante da leitura do ponto de vista do ESP32.
Broker público

No Wokwi o ESP32 só alcança a internet, por isso usamos broker.hivemq.com:1883 — um broker público e sem senha: qualquer pessoa pode ler e publicar nesses tópicos. Não publique nada sensível. (Broker local no Wokwi exige o IoT Gateway do Wokwi Club.)

4.2 Código completo até aqui​

📂 lab05-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>
#include <Ticker.h>
#include <DHT.h>

#define GRUPO "a" // troque pela letra do seu grupo
#define DHT_PIN 15
#define DHT_TIPO DHT22

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_DADOS = "elt73a/lab05/grupo-" GRUPO "/dht";

DHT dht(DHT_PIN, DHT_TIPO);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
Ticker temporizador;

volatile bool leituraPendente = false;
const float INTERVALO_S = 5.0;
uint32_t seq = 0;
char clientId[32];

void aoEstourarTemporizador() {
leituraPendente = true;
}

void conectarWiFi() {
Serial.printf("[WiFi] conectando a %s", WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA, 6); // canal 6 acelera no Wokwi
while (WiFi.status() != WL_CONNECTED) {
delay(250);
Serial.print('.');
}
Serial.printf("\r\n[WiFi] conectado, IP %s\r\n", WiFi.localIP().toString().c_str());
}

void conectarMQTT() {
while (!mqtt.connected()) {
Serial.printf("[MQTT] conectando a %s como %s ... ", MQTT_HOST, clientId);
if (mqtt.connect(clientId)) {
Serial.println("ok");
} else {
Serial.printf("falhou (rc=%d), nova tentativa em 2 s\r\n", mqtt.state());
delay(2000);
}
}
}

void lerEPublicar() {
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t) || isnan(h)) {
Serial.println("[DHT] falha na leitura (NaN) - descartada");
return;
}
seq++;
char payload[128];
snprintf(payload, sizeof(payload),
"{\"grupo\":\"%s\",\"seq\":%lu,\"t\":%.1f,\"h\":%.1f,\"uptime_ms\":%lu}",
GRUPO, (unsigned long)seq, t, h, (unsigned long)millis());
bool ok = mqtt.publish(TOPICO_DADOS, payload);
Serial.printf("[PUB] %s %s -> %s\r\n", ok ? "ok" : "ERRO", TOPICO_DADOS, payload);
}

void setup() {
Serial.begin(115200);
delay(200);
Serial.println("\r\n=== Lab 05 - T4: DHT22 + MQTT ===");
dht.begin();

uint64_t mac = ESP.getEfuseMac();
snprintf(clientId, sizeof(clientId), "lab05-%s-%04X", GRUPO, (uint16_t)(mac >> 32));

conectarWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
conectarMQTT();

temporizador.attach(INTERVALO_S, aoEstourarTemporizador);
}

void loop() {
if (WiFi.status() != WL_CONNECTED) conectarWiFi();
if (!mqtt.connected()) conectarMQTT();
mqtt.loop();

if (leituraPendente) {
leituraPendente = false;
lerEPublicar();
}
}

Pontos que valem a atenção:

  • "elt73a/lab05/grupo-" GRUPO "/dht" — literais de string adjacentes são concatenados pelo compilador; como GRUPO é um #define de string, o tópico é montado em tempo de compilação.
  • Client ID único: dois clientes com o mesmo ID no mesmo broker se derrubam mutuamente. Por isso o ID leva parte do MAC do chip.
  • %lu + cast para unsigned long: no ESP32 uint32_t e unsigned long têm ambos 4 bytes, mas são tipos diferentes para o printf — o cast deixa o formato correto e sem warnings.
  • O PubSubClient tem buffer padrão de 256 bytes (cabeçalho + tópico + payload). Nosso payload tem ~70 bytes; se um dia passar do limite, publish() devolve false (e o log mostra ERRO) — aí use mqtt.setBufferSize(...).

4.3 Verificando no broker​

Enquanto a simulação roda, assine o tópico. Use o MQTT Explorer da stack (conexão broker.hivemq.com, porta 1883) ou, pelo terminal, um mosquitto_sub descartável em Docker:

Terminal — Assinar via Docker
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-a/#' -v -C 5 | tee /ev/t4-mqtt.txt"

-C 5 encerra depois de 5 mensagens.

Por que o tee roda dentro do container?

O cmd do Windows não tem tee (mostrar na tela e gravar no arquivo). Por isso o comando roda num sh dentro do container, que tem o tee. O -v "%cd%\evidencias:/ev" monta a pasta evidencias do repositório em /ev: o que o container grava ali aparece na sua pasta. O --init faz o Ctrl+C encerrar o container. Rode o comando na raiz do repositório, com a pasta evidencias já criada (if not exist evidencias mkdir evidencias).

Saída esperada:

📂 lab05-grupo-x/
  • └── 📂evidencias
    • └── 📄t4-mqtt.txt👈 Criar Aqui
git conferir evidencias/t4-mqtt.txt
evidencias/t4-mqtt.txt
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
Preveja antes de rodar

P3: o que aparece se você assinar elt73a/lab05/+/dht (com + no lugar do grupo)? E o que aconteceria se dois grupos esquecessem de trocar o GRUPO e ficassem ambos com a?

Ponto de commit · T4 (20 pts) #

Publicacao MQTT periodica em JSON

1. Conferir os arquivos
git conferir src/main.cpp evidencias/t4-mqtt.txt
2. Commit T4 e push
git add src/main.cpp evidencias/t4-mqtt.txt && git commit -m "T4: Publicacao MQTT periodica em JSON" && 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 — Node-RED: receber e visualizar​

Com o stack do Lab 05 rodando (Parte 1), abra o Node-RED em http://localhost:1880. Crie uma aba nova chamada Lab 05 e monte:

  1. mqtt in "leituras DHT22"
    • Server: novo broker broker.hivemq.com, porta 1883 (o mesmo em que o ESP32 publica — não o Mosquitto local, que o Wokwi não alcança).
    • Topic: elt73a/lab05/grupo-x/dht (seu grupo) · QoS 0.
    • Output: a parsed JSON object — o texto do payload vira um objeto JavaScript.
  2. debug "payload" → Output: msg.payload.
  3. debug "temperatura" → Output: msg.payload.t e marque node status (o valor aparece embaixo do nó, no próprio editor).
  4. Deploy. Com o Wokwi rodando, o nó mqtt in deve mostrar connected (verde) e o painel debug (ícone de inseto, à direita) recebe uma mensagem a cada 5 s.

Saída esperada no painel debug (uma mensagem, expandida):

Painel debug do Node-RED
29/09/2026, 18:40:12 node: payload
elt73a/lab05/grupo-x/dht : msg.payload : Object
▼ object
grupo: "a"
seq: 7
t: 24.5
h: 55
uptime_ms: 36288
JSON × texto

Troque temporariamente o Output do mqtt in para a String e faça Deploy: o debug passa a mostrar o payload entre aspas e o debug "temperatura" exibe undefined. Por quê? (Volte para a parsed JSON object antes de continuar.)

Evidências:

📂 lab05-grupo-x/
  • ├── 📂nodered
    • └── 🔧flows-lab05.json👈 Criar Aqui
  • └── 📂evidencias
    • └── 📄t5-debug.txt👈 Criar Aqui
git conferir nodered/flows-lab05.json evidencias/t5-debug.txt
  1. No debug "payload", passe o mouse sobre 3 mensagens → ícone Copy value e cole cada uma numa linha de evidencias/t5-debug.txt:
evidencias/t5-debug.txt
{"grupo":"a","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"a","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"a","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
  1. Selecione a aba Lab 05 → menu (☰) → Export → Current flow → JSON formatado → Download. Salve como nodered/flows-lab05.json.
Ponto de commit · T5 (15 pts) #

Node-RED recebendo as leituras no debug

1. Conferir os arquivos
git conferir nodered/flows-lab05.json evidencias/t5-debug.txt
2. Commit T5 e push
git add nodered/flows-lab05.json evidencias/t5-debug.txt && git commit -m "T5: Node-RED recebendo as leituras no debug" && 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.


Projeto integrador — status do nó com LWT​

Quem olha o Node-RED não tem como saber se o ESP32 caiu ou só está entre duas leituras. O MQTT resolve isso com o LWT (Last Will and Testament): ao conectar, o cliente deixa com o broker uma mensagem-testamento; se a conexão cair sem um DISCONNECT educado, o broker publica essa mensagem por ele.

Requisitos​

  1. Firmware
    • Novo tópico elt73a/lab05/grupo-x/status.
    • Conectar com LWT: mensagem offline, QoS 1, retida.
    • Logo após conectar, publicar online retido no mesmo tópico.
  2. Node-RED
    • Segundo mqtt in em .../status (Output: a String) → debug com node status ligado — o nó mostra online/offline no editor.
    • Exporte o fluxo de novo por cima de nodered/flows-lab05.json.
  3. Evidência — deixe um mosquitto_sub escutando o status, inicie a simulação, espere o online, pare a simulação e espere o offline; aí encerre com Ctrl+C:
Terminal — Assinar via Docker
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-a/status' -v | tee /ev/t6-status.txt"

Dicas de API​

Trechos uteis (PubSubClient)
const char *TOPICO_STATUS = "elt73a/lab05/grupo-" GRUPO "/status";

// connect com LWT: (id, willTopic, willQos, willRetain, willMessage)
if (mqtt.connect(clientId, TOPICO_STATUS, 1, true, "offline")) {
mqtt.publish(TOPICO_STATUS, "online", true); // true = retida
}

Saída esperada:

evidencias/t6-status.txt
elt73a/lab05/grupo-x/status offline
elt73a/lab05/grupo-x/status online
elt73a/lab05/grupo-x/status offline

A primeira linha pode ser offline ou online (ou nem aparecer): é a mensagem retida de uma execução anterior, entregue assim que alguém assina o tópico.

Preveja antes de rodar

P4: depois de parar a simulação, quanto tempo leva para aparecer offline? Há dois caminhos: se a conexão TCP é fechada, o broker publica o testamento na hora; se ela só fica muda (ex.: cabo/Wi-Fi caiu), ele espera 1,5 × keepalive — e o keepalive padrão do PubSubClient é 15 s. Qual dos dois o Wokwi provocou? E o que muda se o firmware chamasse mqtt.disconnect() antes de parar?

📂 lab05-grupo-x/
  • ├── 📂nodered
    • └── 🔧flows-lab05.json👈 Edite Aqui
  • └── 📂evidencias
    • └── 📄t6-status.txt👈 Criar Aqui
git conferir nodered/flows-lab05.json evidencias/t6-status.txt
Ponto de commit · T6 (20 pts) #

Status do no com LWT

1. Conferir os arquivos
git conferir src/main.cpp nodered/flows-lab05.json evidencias/t6-status.txt
2. Commit T6 e push
git add src/main.cpp nodered/flows-lab05.json evidencias/t6-status.txt && git commit -m "T6: Status do no com LWT" && 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.


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.