Laboratório 05
Checklist — DHT22, temporizador e MQTT com Node-RED
-
platformio.inicom DHT, Unified Sensor e PubSubClient;diagram.jsoncom DHT22 no GPIO15 (T1) - Leituras periódicas via
Ticker+ flagvolatile,NaNdescartado (T2) - Conexão Wi-Fi com reconexão no
loop()(T3) - JSON publicado em
elt85b/lab05/grupo-X/dhta cada 5 s, client ID único (T4) - Node-RED:
mqtt in(JSON) →debug, fluxo exportado (T5) - LWT
offline+onlineretidos em.../status, visíveis no Node-RED (T6) - Previsões P1–P4 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
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.
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
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
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: ELT85B - IoT Industrial.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\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 elt85b --lab lab05 --grupo a --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))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-b"
2. Gere o LAB IoT do grupo em docker\lab05-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo b --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-b-nodered && (del /q "data\lab05-b\flows.json" "data\lab05-b\flows_cred.json" "data\lab05-b\.flows*.backup" 2>nul & docker compose start lab05-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-c"
2. Gere o LAB IoT do grupo em docker\lab05-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo c --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-c-nodered && (del /q "data\lab05-c\flows.json" "data\lab05-c\flows_cred.json" "data\lab05-c\.flows*.backup" 2>nul & docker compose start lab05-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-d"
2. Gere o LAB IoT do grupo em docker\lab05-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo d --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-d-nodered && (del /q "data\lab05-d\flows.json" "data\lab05-d\flows_cred.json" "data\lab05-d\.flows*.backup" 2>nul & docker compose start lab05-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-e"
2. Gere o LAB IoT do grupo em docker\lab05-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo e --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-e-nodered && (del /q "data\lab05-e\flows.json" "data\lab05-e\flows_cred.json" "data\lab05-e\.flows*.backup" 2>nul & docker compose start lab05-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-f"
2. Gere o LAB IoT do grupo em docker\lab05-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo f --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-f-nodered && (del /q "data\lab05-f\flows.json" "data\lab05-f\flows_cred.json" "data\lab05-f\.flows*.backup" 2>nul & docker compose start lab05-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-g"
2. Gere o LAB IoT do grupo em docker\lab05-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo g --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-g-nodered && (del /q "data\lab05-g\flows.json" "data\lab05-g\flows_cred.json" "data\lab05-g\.flows*.backup" 2>nul & docker compose start lab05-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-h"
2. Gere o LAB IoT do grupo em docker\lab05-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo h --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-h-nodered && (del /q "data\lab05-h\flows.json" "data\lab05-h\flows_cred.json" "data\lab05-h\.flows*.backup" 2>nul & docker compose start lab05-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-i"
2. Gere o LAB IoT do grupo em docker\lab05-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo i --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-i-nodered && (del /q "data\lab05-i\flows.json" "data\lab05-i\flows_cred.json" "data\lab05-i\.flows*.backup" 2>nul & docker compose start lab05-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-j"
2. Gere o LAB IoT do grupo em docker\lab05-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo j --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-j-nodered && (del /q "data\lab05-j\flows.json" "data\lab05-j\flows_cred.json" "data\lab05-j\.flows*.backup" 2>nul & docker compose start lab05-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-k"
2. Gere o LAB IoT do grupo em docker\lab05-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo k --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-k-nodered && (del /q "data\lab05-k\flows.json" "data\lab05-k\flows_cred.json" "data\lab05-k\.flows*.backup" 2>nul & docker compose start lab05-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-l"
2. Gere o LAB IoT do grupo em docker\lab05-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo l --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-l-nodered && (del /q "data\lab05-l\flows.json" "data\lab05-l\flows_cred.json" "data\lab05-l\.flows*.backup" 2>nul & docker compose start lab05-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-m"
2. Gere o LAB IoT do grupo em docker\lab05-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo m --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-m-nodered && (del /q "data\lab05-m\flows.json" "data\lab05-m\flows_cred.json" "data\lab05-m\.flows*.backup" 2>nul & docker compose start lab05-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab05-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-x"
2. Gere o LAB IoT do grupo em docker\lab05-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab05 --grupo x --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-x-nodered && (del /q "data\lab05-x\flows.json" "data\lab05-x\flows_cred.json" "data\lab05-x\.flows*.backup" 2>nul & docker compose start lab05-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
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.
No Lab 06 o mesmo firmware é reaproveitado: o Node-RED passa a gravar as leituras em SQLite e a mudar o intervalo do ESP32 remotamente.
Objetivos
- Ler temperatura e umidade do DHT22 e tratar leituras inválidas (
NaN). - Usar um temporizador (
Ticker) para disparar ações periódicas semdelay()e sem bloquear oloop(). - 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).
- O LAB IoT do
lab05-x(gerado pelogen_iot_aluno.py): nesta aula usamos o Node-RED (http://localhost/lab05-x/) e o MQTT Explorer. - Bibliotecas (baixadas pelo PlatformIO):
adafruit/DHT sensor library,adafruit/Adafruit Unified Sensor,knolleary/PubSubClient. OTickerjá vem com o core Arduino do ESP32.
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
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-a/commits/main/
- Acessos: ACESSO-LAB05.md
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/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%\ELT85BN21\lab05-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-b/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-b.git && cd lab05-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-c/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-c.git && cd lab05-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-d/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-d.git && cd lab05-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-e/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-e.git && cd lab05-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-f/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-f.git && cd lab05-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-g/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-g.git && cd lab05-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-h/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-h.git && cd lab05-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-i/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-i.git && cd lab05-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-j/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-j.git && cd lab05-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-k/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-k.git && cd lab05-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-l/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-l.git && cd lab05-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-m/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-m.git && cd lab05-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-x/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-x.git && cd lab05-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-p/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-p.git && cd lab05-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab05-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab05-grupo-n/commits/main/
- Acessos: ACESSO-LAB05.md
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/lab05-grupo-n.git && cd lab05-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab05-grupo-n" && code . --profile "ESP32IO"
Envie o link do repositório do seu grupo no Moodle:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
Repositório do Grupo A para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo B para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo C para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo D para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo E para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo F para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo G para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo H para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo I para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo J para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo K para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo L para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo M para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo X para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo P para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo N para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
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.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Dependências e circuito do DHT22 · 10 pts
- T2 — Leitura do DHT22 com temporizador · 20 pts
- T3 — Conexão Wi-Fi · 15 pts
- T4 — Publicação MQTT periódica em JSON · 20 pts
- T5 — Node-RED recebendo as leituras no debug · 15 pts
- T6 — Status do nó com LWT · 20 pts
O repositório do grupo nasce do lab05-template:
Estrutura de Arquivos do Projeto
- ├── 🔧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()— 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ó fazleituraPendente = truee 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:
- └── 🔧diagram.json👈 Edite Aqui
git conferir diagram.json
{
"version": 1,
"author": "ELT85B - 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": {}
}
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
- └── 🔧platformio.ini👈 Edite Aqui
git conferir platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
adafruit/DHT sensor library
adafruit/Adafruit Unified Sensor
knolleary/PubSubClient
O wokwi.toml do template já aponta para .pio/build/esp32dev/firmware.bin e .elf —
por isso o nome do ambiente precisa continuar esp32dev.
Dependências e circuito do DHT22
git conferir platformio.ini diagram.json
git add platformio.ini diagram.json && git commit -m "T1: Dependências e circuito do DHT22" && git push
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 noesp_timer, com resolução de microssegundos).attach(segundos, funcao)chamafuncaoperiodicamente.- A flag é
volatile boolporque é escrita num contexto (timer) e lida em outro (loop()):volatileimpede o compilador de "cachear" o valor num registrador. - No ESP32,
boolocupa 1 byte e a escrita é atômica — não precisamos de mutex para uma flag.
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
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#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):
=== 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)
- P1: troque
INTERVALO_Spara1.0e 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.printfdentro deaoEstourarTemporizador()? Pense em quem mais depende da tarefa doesp_timere no tempo que umprintfa 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.
- └── 📂evidencias
- └── 📄t2-serial.txt👈 Criar Aqui
git conferir evidencias/t2-serial.txt
Leitura do DHT22 com temporizador
git conferir src/main.cpp evidencias/t2-serial.txt
git add src/main.cpp evidencias/t2-serial.txt && git commit -m "T2: Leitura do DHT22 com temporizador" && git push
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.
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
- Wokwi (padrão)
- Placa física
#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(), troque o titulo para "=== Lab 05 - T3: DHT22 + Wi-Fi ===" e,
// depois de dht.begin():
// conectarWiFi();
// no inicio de loop():
// if (WiFi.status() != WL_CONNECTED) conectarWiFi();
Troque só as constantes (o resto é idêntico). O begin() sem o canal, porque a rede
real pode estar em qualquer canal:
const char* WIFI_SSID = "IoT-Broker";
const char* WIFI_SENHA = "ESP32IoTLab";
// ...
WiFi.begin(WIFI_SSID, WIFI_SENHA);
Saída esperada:
=== Lab 05 - T3: DHT22 + Wi-Fi ===
[WiFi] conectando a Wokwi-GUEST.....
[WiFi] conectado, IP 10.13.37.2
[DHT] seq=1 t=24.5 C h=55.0 % (6120 ms)
Este while bloqueia o loop() até o Wi-Fi voltar: é o defeito que o Lab 04 corrigiu com
eventos (WiFi.onEvent) e backoff. Aqui ele fica para o foco ser o DHT22, o temporizador e o
Node-RED: enquanto não há Wi-Fi, não há o que publicar. Num firmware de campo, use a conexão do
Lab 04.
Salve a saída (com a linha [WiFi] conectado) em evidencias/t3-wifi.txt.
- └── 📂evidencias
- └── 📄t3-wifi.txt👈 Criar Aqui
git conferir evidencias/t3-wifi.txt
Conexão Wi-Fi
git conferir src/main.cpp evidencias/t3-wifi.txt
git add src/main.cpp evidencias/t3-wifi.txt && git commit -m "T3: Conexão Wi-Fi" && git push
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):
| Uso | Tópico | Exemplo de payload |
|---|---|---|
| Leituras | elt85b/lab05/grupo-x/dht | {"grupo":"a","seq":7,"t":24.5,"h":55.0,"uptime_ms":35210} |
| Status (T6) | elt85b/lab05/grupo-x/status | online / offline (retido) |
seqé um contador: se chegaremseq7, 8, 10, a mensagem 9 se perdeu.uptime_ms(demillis()) mostra o instante da leitura do ponto de vista do ESP32.
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
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#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 = "elt85b/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();
// sufixo aleatorio: no Wokwi, todos os ESP32 simulados tem o MESMO MAC
snprintf(clientId, sizeof(clientId), "lab05-%s-%04lX", GRUPO, (unsigned long)(esp_random() & 0xFFFF));
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:
"elt85b/lab05/grupo-" GRUPO "/dht"— literais de string adjacentes são concatenados pelo compilador; comoGRUPOé um#definede 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 um sufixo aleatório (
esp_random()), como no Lab 04 (veja o aviso abaixo). %lu+ cast paraunsigned long: no ESP32uint32_teunsigned longtêm ambos 4 bytes, mas são tipos diferentes para oprintf— o cast deixa o formato correto e sem warnings.- O
PubSubClienttem buffer padrão de 256 bytes (cabeçalho + tópico + payload). Nosso payload tem ~70 bytes; se um dia passar do limite,publish()devolvefalse(e o log mostraERRO) — aí usemqtt.setBufferSize(...).
O padrão desta disciplina é o Wokwi, e no Wokwi todos os ESP32 simulados têm o mesmo
MAC. Um client ID tirado do MAC (ESP.getEfuseMac()) sairia igual para os integrantes do
grupo que simulam ao mesmo tempo, e o broker derrubaria um a cada conexão do outro (o sintoma:
conecta e cai a cada poucos segundos). Por isso o sufixo é aleatório, aqui e nos Labs 06 e 07.
Numa placa real o MAC é único, e um ID tirado dele tem a vantagem de ser sempre o mesmo para
aquela placa; o sufixo aleatório também funciona lá.
4.3 Verificando no broker
Enquanto a simulação roda, assine o tópico. Use o MQTT Explorer do LAB IoT (conexão
broker.hivemq.com, porta 1883) ou, pelo terminal, um mosquitto_sub descartável em Docker:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-a/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-b/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-c/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-d/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-e/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-f/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-g/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-h/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-i/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-j/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-k/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-l/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-m/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-x/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-p/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-n/#" -v -C 5 > evidencias\t4-mqtt.txt
type evidencias\t4-mqtt.txt
-C 5 encerra depois de 5 mensagens (a saída vai direto para o arquivo, e o type a mostra no
fim). Saída esperada:
- └── 📂evidencias
- └── 📄t4-mqtt.txt👈 Criar Aqui
git conferir evidencias/t4-mqtt.txt
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
elt85b/lab05/grupo-a/dht {"grupo":"a","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-a/dht {"grupo":"a","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-a/dht {"grupo":"a","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-a/dht {"grupo":"a","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-a/dht {"grupo":"a","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-b/dht {"grupo":"b","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-b/dht {"grupo":"b","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-b/dht {"grupo":"b","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-b/dht {"grupo":"b","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-b/dht {"grupo":"b","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-c/dht {"grupo":"c","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-c/dht {"grupo":"c","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-c/dht {"grupo":"c","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-c/dht {"grupo":"c","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-c/dht {"grupo":"c","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-d/dht {"grupo":"d","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-d/dht {"grupo":"d","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-d/dht {"grupo":"d","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-d/dht {"grupo":"d","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-d/dht {"grupo":"d","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-e/dht {"grupo":"e","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-e/dht {"grupo":"e","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-e/dht {"grupo":"e","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-e/dht {"grupo":"e","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-e/dht {"grupo":"e","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-f/dht {"grupo":"f","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-f/dht {"grupo":"f","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-f/dht {"grupo":"f","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-f/dht {"grupo":"f","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-f/dht {"grupo":"f","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-g/dht {"grupo":"g","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-g/dht {"grupo":"g","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-g/dht {"grupo":"g","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-g/dht {"grupo":"g","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-g/dht {"grupo":"g","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-h/dht {"grupo":"h","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-h/dht {"grupo":"h","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-h/dht {"grupo":"h","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-h/dht {"grupo":"h","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-h/dht {"grupo":"h","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-i/dht {"grupo":"i","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-i/dht {"grupo":"i","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-i/dht {"grupo":"i","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-i/dht {"grupo":"i","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-i/dht {"grupo":"i","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-j/dht {"grupo":"j","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-j/dht {"grupo":"j","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-j/dht {"grupo":"j","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-j/dht {"grupo":"j","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-j/dht {"grupo":"j","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-k/dht {"grupo":"k","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-k/dht {"grupo":"k","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-k/dht {"grupo":"k","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-k/dht {"grupo":"k","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-k/dht {"grupo":"k","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-l/dht {"grupo":"l","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-l/dht {"grupo":"l","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-l/dht {"grupo":"l","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-l/dht {"grupo":"l","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-l/dht {"grupo":"l","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-m/dht {"grupo":"m","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-m/dht {"grupo":"m","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-m/dht {"grupo":"m","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-m/dht {"grupo":"m","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-m/dht {"grupo":"m","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-x/dht {"grupo":"x","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-x/dht {"grupo":"x","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-x/dht {"grupo":"x","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-x/dht {"grupo":"x","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-x/dht {"grupo":"x","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-p/dht {"grupo":"p","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-p/dht {"grupo":"p","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-p/dht {"grupo":"p","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-p/dht {"grupo":"p","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-p/dht {"grupo":"p","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt85b/lab05/grupo-n/dht {"grupo":"n","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt85b/lab05/grupo-n/dht {"grupo":"n","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt85b/lab05/grupo-n/dht {"grupo":"n","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt85b/lab05/grupo-n/dht {"grupo":"n","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt85b/lab05/grupo-n/dht {"grupo":"n","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
P3: o que aparece se você assinar elt85b/lab05/+/dht (com + no lugar do grupo)?
E o que aconteceria se dois grupos esquecessem de trocar o GRUPO e ficassem ambos com a?
Publicação MQTT periódica em JSON
git conferir src/main.cpp evidencias/t4-mqtt.txt
git add src/main.cpp evidencias/t4-mqtt.txt && git commit -m "T4: Publicação MQTT periódica em JSON" && git push
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
Suba o LAB IoT do lab05-x e abra o Node-RED em http://localhost/lab05-x/. Crie uma aba
nova chamada Lab 05 e monte:
- mqtt in "leituras DHT22"
- Server: novo broker
broker.hivemq.com, porta1883(o mesmo em que o ESP32 publica — não o Mosquitto local, que o Wokwi não alcança). - Topic:
elt85b/lab05/grupo-x/dht(seu grupo) · QoS0. - Output: a parsed JSON object — o texto do payload vira um objeto JavaScript.
- Server: novo broker
- debug "payload" → Output:
msg.payload. - debug "temperatura" → Output:
msg.payload.te marque node status (o valor aparece embaixo do nó, no próprio editor). - Deploy. Com o Wokwi rodando, o nó
mqtt indeve 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):
29/09/2026, 18:40:12 node: payload
elt85b/lab05/grupo-x/dht : msg.payload : Object
▼ object
grupo: "a"
seq: 7
t: 24.5
h: 55
uptime_ms: 36288
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:
- ├── 📂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:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
{"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}
{"grupo":"b","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"b","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"b","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"c","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"c","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"c","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"d","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"d","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"d","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"e","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"e","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"e","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"f","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"f","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"f","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"g","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"g","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"g","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"h","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"h","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"h","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"i","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"i","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"i","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"j","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"j","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"j","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"k","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"k","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"k","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"l","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"l","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"l","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"m","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"m","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"m","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"x","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"x","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"x","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"p","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"p","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"p","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"n","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"n","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"n","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
2. Selecione a aba Lab 05 → menu (☰) → Export → Current flow → JSON
formatado → Download. Salve como nodered/flows-lab05.json.
Node-RED recebendo as leituras no debug
git conferir nodered/flows-lab05.json evidencias/t5-debug.txt
git add nodered/flows-lab05.json evidencias/t5-debug.txt && git commit -m "T5: Node-RED recebendo as leituras no debug" && git push
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), que você já usou no Lab 04: 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
- Firmware
- Novo tópico
elt85b/lab05/grupo-X/status. - Conectar com LWT: mensagem
offline, QoS 1, retida. - Logo após conectar, publicar
onlineretido no mesmo tópico.
- Novo tópico
- Node-RED
- Segundo mqtt in em
.../status(Output: a String) → debug com node status ligado — o nó mostraonline/offlineno editor. - Exporte o fluxo de novo por cima de
nodered/flows-lab05.json.
- Segundo mqtt in em
- Evidência — deixe um
mosquitto_subescutando o status, inicie a simulação, espere oonline, pare a simulação e espere ooffline; aí saia dodocker logs -fcom Ctrl+C e grave a evidência:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-a/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-b/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-c/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-d/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-e/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-f/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-g/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-h/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-i/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-j/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-k/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-l/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-m/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-x/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-p/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
1. 1. Assinar:
docker run -d --name sub-lab05 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab05/grupo-n/status" -v
docker logs -f sub-lab05
2. 2. Gravar e encerrar:
docker logs sub-lab05 > evidencias\t6-status.txt 2>&1
type evidencias\t6-status.txt
docker rm -f sub-lab05
Dicas de API
const char *TOPICO_STATUS = "elt85b/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:
elt85b/lab05/grupo-x/status offline
elt85b/lab05/grupo-x/status online
elt85b/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.
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?
- ├── 📂nodered
- └── 🔧flows-lab05.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t6-status.txt👈 Criar Aqui
git conferir nodered/flows-lab05.json evidencias/t6-status.txt
Status do nó com LWT
git conferir src/main.cpp nodered/flows-lab05.json evidencias/t6-status.txt
git add src/main.cpp nodered/flows-lab05.json evidencias/t6-status.txt && git commit -m "T6: Status do nó com LWT" && git push
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
Para o git "esquecer" suas informações salvas:
git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
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.