Laboratório 04
Checklist — Wi-Fi e MQTT no ESP32
- Varredura das redes Wi-Fi com logs, e o custo de uma chamada bloqueante (T1)
- Conexão ao Wi-Fi por eventos, com os detalhes da rede e o LED de estado (T2)
- MQTT: telemetria a cada 5 s, comando do LED e
statuscom LWT, conferidos pelo terminal (T3) - Rede robusta: reconexão do Wi-Fi e do MQTT com backoff, testada com quedas forçadas (T4)
- O mesmo firmware em dois ambientes,
wokwielab, com os segredos fora do Git (T5) - 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…T5 = 100 pts (esta aula não tem desafios): T1 15 · T2 20 · T3 20 · T4 20 · T5 25. 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\lab04-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-a"
2. Gere o LAB IoT do grupo em docker\lab04-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-a-nodered && (del /q "data\lab04-a\flows.json" "data\lab04-a\flows_cred.json" "data\lab04-a\.flows*.backup" 2>nul & docker compose start lab04-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-b"
2. Gere o LAB IoT do grupo em docker\lab04-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-b-nodered && (del /q "data\lab04-b\flows.json" "data\lab04-b\flows_cred.json" "data\lab04-b\.flows*.backup" 2>nul & docker compose start lab04-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-c"
2. Gere o LAB IoT do grupo em docker\lab04-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-c-nodered && (del /q "data\lab04-c\flows.json" "data\lab04-c\flows_cred.json" "data\lab04-c\.flows*.backup" 2>nul & docker compose start lab04-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-d"
2. Gere o LAB IoT do grupo em docker\lab04-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-d-nodered && (del /q "data\lab04-d\flows.json" "data\lab04-d\flows_cred.json" "data\lab04-d\.flows*.backup" 2>nul & docker compose start lab04-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-e"
2. Gere o LAB IoT do grupo em docker\lab04-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-e-nodered && (del /q "data\lab04-e\flows.json" "data\lab04-e\flows_cred.json" "data\lab04-e\.flows*.backup" 2>nul & docker compose start lab04-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-f"
2. Gere o LAB IoT do grupo em docker\lab04-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-f-nodered && (del /q "data\lab04-f\flows.json" "data\lab04-f\flows_cred.json" "data\lab04-f\.flows*.backup" 2>nul & docker compose start lab04-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-g"
2. Gere o LAB IoT do grupo em docker\lab04-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-g-nodered && (del /q "data\lab04-g\flows.json" "data\lab04-g\flows_cred.json" "data\lab04-g\.flows*.backup" 2>nul & docker compose start lab04-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-h"
2. Gere o LAB IoT do grupo em docker\lab04-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-h-nodered && (del /q "data\lab04-h\flows.json" "data\lab04-h\flows_cred.json" "data\lab04-h\.flows*.backup" 2>nul & docker compose start lab04-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-i"
2. Gere o LAB IoT do grupo em docker\lab04-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-i-nodered && (del /q "data\lab04-i\flows.json" "data\lab04-i\flows_cred.json" "data\lab04-i\.flows*.backup" 2>nul & docker compose start lab04-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-j"
2. Gere o LAB IoT do grupo em docker\lab04-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-j-nodered && (del /q "data\lab04-j\flows.json" "data\lab04-j\flows_cred.json" "data\lab04-j\.flows*.backup" 2>nul & docker compose start lab04-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-k"
2. Gere o LAB IoT do grupo em docker\lab04-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-k-nodered && (del /q "data\lab04-k\flows.json" "data\lab04-k\flows_cred.json" "data\lab04-k\.flows*.backup" 2>nul & docker compose start lab04-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-l"
2. Gere o LAB IoT do grupo em docker\lab04-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-l-nodered && (del /q "data\lab04-l\flows.json" "data\lab04-l\flows_cred.json" "data\lab04-l\.flows*.backup" 2>nul & docker compose start lab04-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-m"
2. Gere o LAB IoT do grupo em docker\lab04-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-m-nodered && (del /q "data\lab04-m\flows.json" "data\lab04-m\flows_cred.json" "data\lab04-m\.flows*.backup" 2>nul & docker compose start lab04-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab04-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab04-x"
2. Gere o LAB IoT do grupo em docker\lab04-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab04 --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 lab04-x-nodered && (del /q "data\lab04-x\flows.json" "data\lab04-x\flows_cred.json" "data\lab04-x\.flows*.backup" 2>nul & docker compose start lab04-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Nesta aula o ESP32 entra na rede pela primeira vez. A forma mais comum de conectar, a dos
exemplos que circulam na internet, tem dois defeitos que não aparecem num teste rápido: ela
para tudo enquanto o Wi-Fi ou o broker não respondem (um while esperando a conexão), e
costuma funcionar só na rede em que foi escrita.
Aqui você monta a conexão do zero, peça por peça, olhando por dentro com os logs do
Lab 03: a varredura, os eventos do Wi-Fi, a conexão ao broker, a telemetria e os comandos.
Depois, derruba a rede de propósito e faz o firmware se recuperar sozinho, sem travar o
loop(). No fim, o mesmo código compila para o Wokwi e para a placa real no laboratório, com
as senhas fora do repositório.
O Lab 05 acrescenta o sensor DHT22 e o Node-RED. Para manter o foco neles, ele usa uma conexão
simplificada, com while; a conexão robusta, para um firmware de campo, é a desta aula.
Objetivos
- Varrer as redes Wi-Fi e entender o custo de uma chamada bloqueante.
- Conectar ao Wi-Fi por eventos (
WiFi.onEvent), semwhilede espera. - Publicar telemetria em JSON, assinar comandos e usar
statuscom LWT. - Reconectar o Wi-Fi e o MQTT com backoff exponencial, com o
loop()sempre rodando. - Separar a configuração (rede, broker, senhas) do código, com ambientes do PlatformIO e um
segredos.hfora do Git.
Material
- O ambiente dos Labs 01 a 03: Windows 11, VS Code no perfil
ESP32IOcom o terminal no Prompt de Comando (cmd), PlatformIO, Wokwi e Docker Desktop aberto. - Opcional: um ESP32 DevKit, para a placa real no laboratório (T5).
No Wokwi, tudo fica sob elt85b/lab04/grupo-X/, no broker público broker.hivemq.com. Troque
o X (e o #define GRUPO) pela letra do seu grupo. O broker é público: não publique nada
que não possa ser público.
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/lab04-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-a/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-a.git && cd lab04-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-b/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-b.git && cd lab04-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-c/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-c.git && cd lab04-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-d/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-d.git && cd lab04-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-e/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-e.git && cd lab04-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-f/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-f.git && cd lab04-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-g/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-g.git && cd lab04-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-h/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-h.git && cd lab04-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-i/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-i.git && cd lab04-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-j/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-j.git && cd lab04-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-k/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-k.git && cd lab04-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-l/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-l.git && cd lab04-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-m/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-m.git && cd lab04-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-x/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-x.git && cd lab04-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-p/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-p.git && cd lab04-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab04-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab04-grupo-n/commits/main/
- Acessos: ACESSO-LAB04.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/lab04-grupo-n.git && cd lab04-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab04-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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 04:
- 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 — 5 tarefas · 100 pts
- T1 — Varredura das redes · 15 pts
- T2 — Conexão por eventos · 20 pts
- T3 — MQTT nos dois sentidos · 20 pts
- T4 — Rede robusta · 20 pts
- T5 — Wokwi e laboratório no mesmo firmware · 25 pts
O repositório nasce do lab04-template, com o README.md, o .gitignore, o
.vscode/settings.json e o circuito do Lab 03 (diagram.json, o LED no GPIO2):
Estrutura de Arquivos do Projeto (no fim da aula)
- ├── 📄.gitignore👈 Edite Aqui
- ├── 📂.vscode
- └── 🔧settings.json👈 Verificar
- ├── 📝README.md👈 Edite Aqui
- ├── 🔧diagram.json👈 Verificar
- ├── 🔧platformio.ini👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Criar Aqui
- ├── 📂include
- ├── 📄config.h👈 Criar Aqui
- └── 📄segredos.exemplo.h👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Criar Aqui
- └── 📂evidencias
- ├── 📄t1-serial.txt👈 Criar Aqui
- ├── 📄t2-serial.txt👈 Criar Aqui
- ├── 📄t3-mqtt.txt👈 Criar Aqui
- ├── 📄t3-serial.txt👈 Criar Aqui
- ├── 📄t4-backoff.txt👈 Criar Aqui
- ├── 📄t4-quedas.txt👈 Criar Aqui
- ├── 📄t4-mqtt.txt👈 Criar Aqui
- ├── 📄t5-build.txt👈 Criar Aqui
- └── 📄t5-mqtt.txt👈 Criar Aqui
Parte 1 — Varredura das redes
1.1 Projeto
No terminal do VS Code (cmd), na raiz do repositório:
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200"
if not exist evidencias mkdir evidencias
Troque o platformio.ini por um ambiente chamado wokwi, com os logs até o nível DEBUG (o
core mostra o que o Wi-Fi faz por dentro), e aponte o wokwi.toml para ele:
[platformio]
default_envs = wokwi
[env:wokwi]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
build_flags =
-DCORE_DEBUG_LEVEL=4
[wokwi]
version = 1
firmware = '.pio/build/wokwi/firmware.bin'
elf = '.pio/build/wokwi/firmware.elf'
A biblioteca WiFi.h faz parte do core do ESP32: não precisa de lib_deps.
1.2 Varrer
// ELT85B - Lab 04 (T1): varredura das redes Wi-Fi
#include <Arduino.h>
#include <WiFi.h>
#define LED_PIN 2
#define VARRER_MS 15000 // uma varredura a cada 15 s
const char *nomeSeguranca(wifi_auth_mode_t m) {
switch (m) {
case WIFI_AUTH_OPEN: return "aberta";
case WIFI_AUTH_WEP: return "WEP";
case WIFI_AUTH_WPA_PSK: return "WPA";
case WIFI_AUTH_WPA2_PSK: return "WPA2";
case WIFI_AUTH_WPA_WPA2_PSK: return "WPA/WPA2";
case WIFI_AUTH_WPA3_PSK: return "WPA3";
default: return "outra";
}
}
void varrer() {
log_i("Varrendo as redes...");
unsigned long t0 = millis();
int total = WiFi.scanNetworks(); // bloqueia ate terminar
log_i("%d rede(s) em %lu ms", total, millis() - t0);
for (int i = 0; i < total; i++) {
log_i("%2d: %-16s canal %2ld %4ld dBm %s", i + 1, WiFi.SSID(i).c_str(), (long)WiFi.channel(i),
(long)WiFi.RSSI(i), nomeSeguranca(WiFi.encryptionType(i)));
}
WiFi.scanDelete(); // devolve a memoria da lista
}
unsigned long tVarredura = 0, tLed = 0;
bool ledAceso = false;
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
Serial.println("=== Lab 04 - Wi-Fi e MQTT ===");
WiFi.mode(WIFI_STA); // estacao (cliente), nao ponto de acesso
WiFi.disconnect();
varrer();
tVarredura = millis();
}
void loop() {
unsigned long agora = millis();
if (agora - tLed >= 250) { // o LED mostra se o loop() esta rodando
tLed = agora;
ledAceso = !ledAceso;
digitalWrite(LED_PIN, ledAceso ? HIGH : LOW);
}
if (agora - tVarredura >= VARRER_MS) {
varrer();
tVarredura = millis();
}
}
WiFi.mode(WIFI_STA) põe o rádio no modo estação (cliente de um ponto de acesso), e o
WiFi.disconnect() garante que ele não tente se conectar a uma rede guardada na flash.
pio run
F1 → Wokwi: Start Simulator:
=== Lab 04 - Wi-Fi e MQTT ===
[ 512][D][WiFiGeneric.cpp:1040] _eventCallback(): Arduino Event: 0 - WIFI_READY
[ 601][D][WiFiGeneric.cpp:1040] _eventCallback(): Arduino Event: 2 - STA_START
[ 602][I][main.cpp:21] varrer(): Varrendo as redes...
[ 4710][D][WiFiGeneric.cpp:1040] _eventCallback(): Arduino Event: 1 - SCAN_DONE
[ 4711][I][main.cpp:24] varrer(): 1 rede(s) em 4109 ms
[ 4712][I][main.cpp:26] varrer(): 1: Wokwi-GUEST canal 6 -54 dBm aberta
As linhas [D][WiFiGeneric.cpp...] são do core: com o CORE_DEBUG_LEVEL=4 do Lab 03, você
vê cada evento do Wi-Fi. A rede do simulador é a Wokwi-GUEST: aberta, no canal 6.
P1: (a) o LED pisca a cada 250 ms pelo millis(). O que acontece com ele durante a
varredura, a cada 15 s? Por quê? O que isso diria de um firmware que precisasse ler um sensor a
cada 100 ms? (b) A varredura passa por todos os canais. Na T2, o WiFi.begin() recebe o canal
6: quanto tempo isso deve economizar na conexão? Confira na T2.
Copie o monitor (duas varreduras) para evidencias/t1-serial.txt.
git add platformio.ini wokwi.toml src evidencias/t1-serial.txt
git commit -m "T1: varredura das redes Wi-Fi"
git push
- ├── 🔧platformio.ini👈 Criar Aqui
- ├── 🔧wokwi.toml👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Criar Aqui
- └── 📂evidencias
- └── 📄t1-serial.txt👈 Criar Aqui
git conferir platformio.ini wokwi.toml src/main.cpp evidencias/t1-serial.txt
Varredura das redes
git conferir platformio.ini wokwi.toml src/main.cpp evidencias/t1-serial.txt
git add platformio.ini wokwi.toml src/main.cpp evidencias/t1-serial.txt && git commit -m "T1: Varredura das redes" && 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 — Conexão por eventos
2.1 A configuração num arquivo só
Rede, broker e tópicos não são "código": mudam conforme onde o firmware roda. Eles vão para
include/config.h (a pasta include/ já está no caminho de busca do PlatformIO):
// ELT85B - Lab 04: rede e broker (T2-T4: so o Wokwi)
#pragma once
#define GRUPO "x" // troque pela letra do seu grupo
#define WIFI_SSID "Wokwi-GUEST"
#define WIFI_SENHA ""
#define WIFI_CANAL 6 // o AP do Wokwi fica no canal 6
#define MQTT_HOST "broker.hivemq.com"
#define MQTT_PORTA 1883
#define MQTT_USUARIO "" // broker publico: sem login
#define MQTT_SENHA ""
#define TOPICO_BASE "elt85b/lab04/grupo-" GRUPO
O TOPICO_BASE junta textos pelo pré-processador: "elt85b/lab04/grupo-" "x" vira
"elt85b/lab04/grupo-x". A T3 usa os dados do broker.
2.2 Eventos em vez de while
A forma ingênua espera o Wi-Fi assim:
while (WiFi.status() != WL_CONNECTED) { delay(250); } // o ESP32 fica PARADO aqui
Aqui, o WiFi.begin() só inicia a conexão e volta na hora. O core avisa quando algo
acontece, chamando uma função sua:
volatile bool wifiOk = false; // escrito no callback de eventos (outra task)
unsigned long tInicioWiFi = 0, tTentativaWiFi = 0;
void aoEventoWiFi(WiFiEvent_t evento, WiFiEventInfo_t info) {
switch (evento) {
case ARDUINO_EVENT_WIFI_STA_CONNECTED:
log_i("Wi-Fi: associado ao AP (canal %d)", info.wifi_sta_connected.channel);
break;
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
wifiOk = true;
log_i("Wi-Fi: IP %s em %lu ms", IPAddress(info.got_ip.ip_info.ip.addr).toString().c_str(),
millis() - tInicioWiFi);
break;
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
wifiOk = false;
log_w("Wi-Fi: desconectado (motivo %d)", info.wifi_sta_disconnected.reason);
break;
default:
break;
}
}
void iniciarWiFi() {
log_i("Wi-Fi: conectando a %s", WIFI_SSID);
tInicioWiFi = tTentativaWiFi = millis();
WiFi.begin(WIFI_SSID, WIFI_SENHA, WIFI_CANAL);
}
void detalhesRede() {
log_i("IP %s mascara %s gateway %s DNS %s", WiFi.localIP().toString().c_str(),
WiFi.subnetMask().toString().c_str(), WiFi.gatewayIP().toString().c_str(),
WiFi.dnsIP().toString().c_str());
log_i("MAC %s RSSI %d dBm canal %d", WiFi.macAddress().c_str(), WiFi.RSSI(), WiFi.channel());
}
O aoEventoWiFi() não é chamado pelo loop(), e sim pela task de eventos do Wi-Fi do core. Por
isso ele só registra e marca (wifiOk), e o trabalho de verdade fica no loop(). O
volatile avisa ao compilador que a variável muda "por fora" do loop().
O setup() registra o callback e inicia a conexão. O loop() mostra o estado no LED (pisca
rápido sem Wi-Fi, aceso com Wi-Fi) e imprime os detalhes uma vez por conexão:
bool redeDetalhada = false;
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
Serial.println("=== Lab 04 - Wi-Fi e MQTT ===");
WiFi.mode(WIFI_STA);
WiFi.disconnect();
varrer();
WiFi.onEvent(aoEventoWiFi);
iniciarWiFi();
}
void loop() {
unsigned long agora = millis();
// LED de estado: pisca rapido sem Wi-Fi, aceso com Wi-Fi
digitalWrite(LED_PIN, wifiOk ? HIGH : (agora / 100) % 2);
if (wifiOk && !redeDetalhada) { // uma vez por conexao
redeDetalhada = true;
detalhesRede();
} else if (!wifiOk) {
redeDetalhada = false;
}
}
No começo do arquivo, inclua o config.h (#include "config.h") e mantenha o varrer() da T1,
agora chamado só uma vez, no setup(), e tire o pisca da T1 (o LED passa a mostrar o estado da rede). O arquivo completo, já com tudo até a T4, está no fim da Parte 4.
[ 4712][I][main.cpp:29] varrer(): 1: Wokwi-GUEST canal 6 -54 dBm aberta
[ 4713][I][main.cpp:56] iniciarWiFi(): Wi-Fi: conectando a Wokwi-GUEST
[ 5240][D][WiFiGeneric.cpp:1040] _eventCallback(): Arduino Event: 4 - STA_CONNECTED
[ 5241][I][main.cpp:39] aoEventoWiFi(): Wi-Fi: associado ao AP (canal 6)
[ 6105][D][WiFiGeneric.cpp:1040] _eventCallback(): Arduino Event: 7 - STA_GOT_IP
[ 6107][I][main.cpp:43] aoEventoWiFi(): Wi-Fi: IP 10.10.0.2 em 1394 ms
[ 6110][I][main.cpp:62] detalhesRede(): IP 10.10.0.2 mascara 255.255.255.0 gateway 10.10.0.1 DNS 10.10.0.1
[ 6111][I][main.cpp:65] detalhesRede(): MAC 24:0A:C4:xx:xx:xx RSSI -54 dBm canal 6
Repare na ordem: associado (a camada de rádio) e só depois IP (o DHCP). Sem IP, não há como falar com o broker.
Evidência: o monitor em evidencias/t2-serial.txt, e no README.md o tempo até o IP com
WIFI_CANAL 6 e com WIFI_CANAL 0 (0 = procurar em todos os canais).
git add include/config.h src/main.cpp evidencias/t2-serial.txt README.md
git commit -m "T2: conexao ao Wi-Fi por eventos"
git push
- ├── 📂include
- └── 📄config.h👈 Criar Aqui
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 📂evidencias
- └── 📄t2-serial.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir include/config.h src/main.cpp evidencias/t2-serial.txt README.md
Conexão por eventos
git conferir include/config.h src/main.cpp evidencias/t2-serial.txt README.md
git add include/config.h src/main.cpp evidencias/t2-serial.txt README.md && git commit -m "T2: Conexão por eventos" && 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 — MQTT nos dois sentidos
3.1 Biblioteca e tópicos
Acrescente ao [env:wokwi] do platformio.ini:
lib_deps =
knolleary/PubSubClient
| Tópico | Sentido | Conteúdo |
|---|---|---|
.../status | ESP32 → | online ao conectar; offline pelo broker (LWT) se o ESP32 sumir. Retido |
.../telemetria | ESP32 → | JSON a cada 5 s |
.../cmd/led | → ESP32 | on, off ou auto (o LED volta a mostrar o estado da rede) |
#include <PubSubClient.h>
#define TELEMETRIA_MS 5000 // uma telemetria a cada 5 s
#define ESPERA_MQTT_MS 5000 // sem MQTT: nova tentativa a cada 5 s
const char *TOPICO_STATUS = TOPICO_BASE "/status"; // online / offline (retido, LWT)
const char *TOPICO_TELEMETRIA = TOPICO_BASE "/telemetria"; // JSON a cada 5 s
const char *TOPICO_CMD_LED = TOPICO_BASE "/cmd/led"; // on | off | auto
WiFiClient wifiClient; // o TCP
PubSubClient mqtt(wifiClient); // o MQTT, por cima do TCP
char clientId[24];
uint32_t conexoesMQTT = 0, falhasMQTT = 0, n = 0;
unsigned long tTentativaMQTT = 0, tTelemetria = 0;
enum ModoLed { LED_AUTO, LED_LIGADO, LED_DESLIGADO };
ModoLed modoLed = LED_AUTO;
3.2 Conectar, publicar e receber
void aoReceberMensagem(char *topico, byte *payload, unsigned int tam) {
char txt[16];
size_t k = tam < sizeof(txt) - 1 ? tam : sizeof(txt) - 1;
memcpy(txt, payload, k);
txt[k] = '\0'; // o payload NAO termina com '\0'
log_i("MQTT: %s <- '%s'", topico, txt);
if (strcmp(txt, "on") == 0) modoLed = LED_LIGADO;
else if (strcmp(txt, "off") == 0) modoLed = LED_DESLIGADO;
else if (strcmp(txt, "auto") == 0) modoLed = LED_AUTO;
else log_w("cmd/led: use on, off ou auto");
}
bool tentarMQTT() { // UMA tentativa; quem repete e o loop()
log_i("MQTT: conectando a %s:%d como %s", MQTT_HOST, MQTT_PORTA, clientId);
const char *usuario = strlen(MQTT_USUARIO) ? MQTT_USUARIO : nullptr;
const char *senha = strlen(MQTT_SENHA) ? MQTT_SENHA : nullptr;
unsigned long t0 = millis();
// LWT: se o ESP32 sumir sem avisar, o broker publica "offline" (retido) no lugar dele
bool ok = mqtt.connect(clientId, usuario, senha, TOPICO_STATUS, 1, true, "offline");
if (!ok) {
falhasMQTT++;
log_w("MQTT: falhou (rc=%d) em %lu ms", mqtt.state(), millis() - t0);
return false;
}
conexoesMQTT++;
log_i("MQTT: conectado em %lu ms (conexao %lu)", millis() - t0, (unsigned long)conexoesMQTT);
mqtt.publish(TOPICO_STATUS, "online", true);
mqtt.subscribe(TOPICO_CMD_LED); // (re)assina a cada conexao
return true;
}
void publicarTelemetria(unsigned long agora) {
char json[96];
snprintf(json, sizeof(json), "{\"n\":%lu,\"uptime_s\":%lu,\"rssi\":%d,\"heap\":%lu}",
(unsigned long)++n, agora / 1000, WiFi.RSSI(), (unsigned long)ESP.getFreeHeap());
bool ok = mqtt.publish(TOPICO_TELEMETRIA, json);
if (ok) log_i("PUB %s %s", TOPICO_TELEMETRIA, json);
else log_e("PUB falhou: %s", TOPICO_TELEMETRIA);
}
void cuidarDoLed(unsigned long agora) {
bool aceso;
if (modoLed == LED_LIGADO) aceso = true;
else if (modoLed == LED_DESLIGADO) aceso = false;
else if (!wifiOk) aceso = (agora / 100) % 2;
else if (!mqtt.connected()) aceso = (agora / 500) % 2;
else aceso = true;
digitalWrite(LED_PIN, aceso ? HIGH : LOW);
}
O tentarMQTT() faz uma tentativa e volta: quem repete é o loop(), a cada 5 s. O
client id identifica o ESP32 no broker. Dois clientes com o mesmo id derrubam um ao
outro (o broker fecha a sessão antiga quando a nova chega), por isso ele leva um sufixo
aleatório. No Wokwi isso importa: dois integrantes simulando o mesmo firmware ao mesmo tempo.
No setup(), depois do varrer(), e no loop():
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
Serial.println("=== Lab 04 - Wi-Fi e MQTT ===");
// sufixo aleatorio: dois ESP32 com o mesmo client id derrubam um ao outro no broker
snprintf(clientId, sizeof(clientId), "lab04-%s-%04lX", GRUPO, (unsigned long)(esp_random() & 0xFFFF));
log_i("Topicos em %s/ (cliente %s)", TOPICO_BASE, clientId);
WiFi.mode(WIFI_STA);
WiFi.disconnect();
varrer();
WiFi.onEvent(aoEventoWiFi);
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
mqtt.setCallback(aoReceberMensagem);
iniciarWiFi();
}
void loop() {
unsigned long agora = millis();
if (wifiOk) {
if (mqtt.connected()) {
mqtt.loop(); // processa a rede e chama o callback
} else if (agora - tTentativaMQTT >= ESPERA_MQTT_MS) {
tTentativaMQTT = agora;
tentarMQTT();
}
}
cuidarDoLed(agora);
if (wifiOk && !redeDetalhada) {
redeDetalhada = true;
detalhesRede();
} else if (!wifiOk) {
redeDetalhada = false;
}
if (agora - tTelemetria >= TELEMETRIA_MS) {
tTelemetria = agora;
if (mqtt.connected()) publicarTelemetria(agora);
}
}
mqtt.state() | Significado | Causa provável |
|---|---|---|
-4 | sem resposta do broker a tempo | rede lenta, broker parado |
-3 | conexão perdida | caiu o Wi-Fi, ou o broker fechou a conexão |
-2 | a conexão TCP falhou | host ou porta errados, DNS, sem rede |
-1 | desconectado (normal) | mqtt.disconnect() |
0 | conectado | |
2 | client id recusado | id vazio ou inválido |
4 / 5 | usuário ou senha errados / sem autorização | credenciais do broker (T5) |
3.3 Conferir pelo terminal
O assinante roda em segundo plano (-d), e o docker logs mostra e grava o que chegou.
Assine antes de iniciar a simulação.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-a/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-a/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-a/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-a/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-b/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-b/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-b/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-b/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-c/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-c/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-c/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-c/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-d/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-d/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-d/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-d/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-e/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-e/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-e/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-e/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-f/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-f/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-f/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-f/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-g/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-g/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-g/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-g/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-h/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-h/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-h/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-h/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-i/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-i/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-i/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-i/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-j/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-j/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-j/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-j/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-k/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-k/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-k/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-k/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-l/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-l/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-l/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-l/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-m/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-m/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-m/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-m/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-x/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-x/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-x/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-x/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-p/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-p/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-p/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-p/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
1. 1. Assinar:
docker run -d --name sub-lab04 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab04/grupo-n/#" -v
docker logs -f sub-lab04
2. 2. Comandar o LED:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-n/cmd/led" -m off
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-n/cmd/led" -m on
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-n/cmd/led" -m auto
3. 3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab04
elt85b/lab04/grupo-x/status online
elt85b/lab04/grupo-x/telemetria {"n":1,"uptime_s":10,"rssi":-54,"heap":228184}
elt85b/lab04/grupo-x/cmd/led off
elt85b/lab04/grupo-x/telemetria {"n":2,"uptime_s":15,"rssi":-54,"heap":228184}
elt85b/lab04/grupo-x/cmd/led on
elt85b/lab04/grupo-x/cmd/led auto
elt85b/lab04/grupo-x/status offline
O offline do fim não foi enviado pelo ESP32: foi o broker, pouco depois de a simulação
parar (até ~25 s), cumprindo o LWT (Last Will and Testament) registrado no connect().
P2: (a) com a simulação rodando, rode outro mosquitto_sub (sem -d, Ctrl+C para
sair). A primeira linha é o status online, mesmo que ele tenha sido publicado minutos antes.
Por quê? E a telemetria antiga, também aparece? (b) O aoReceberMensagem() copia o payload
para um vetor e põe '\0' no fim. O que daria errado num strcmp(payload, "on") direto? (c)
O offline chegou na hora em que a simulação parou, ou alguns segundos depois? Do que isso
depende? Pense nas duas formas de o broker perceber que um cliente sumiu: a conexão TCP fechada
ou o keepalive de 15 s do PubSubClient vencido (1,5 × 15 s).
Evidências: evidencias/t3-mqtt.txt (do docker logs) e o monitor serial em
evidencias/t3-serial.txt.
git add platformio.ini src/main.cpp evidencias/t3-mqtt.txt evidencias/t3-serial.txt
git commit -m "T3: MQTT com telemetria, comando e LWT"
git push
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t3-mqtt.txt👈 Criar Aqui
- └── 📄t3-serial.txt👈 Criar Aqui
git conferir platformio.ini src/main.cpp evidencias/t3-mqtt.txt evidencias/t3-serial.txt
MQTT nos dois sentidos
git conferir platformio.ini src/main.cpp evidencias/t3-mqtt.txt evidencias/t3-serial.txt
git add platformio.ini src/main.cpp evidencias/t3-mqtt.txt evidencias/t3-serial.txt && git commit -m "T3: MQTT nos dois sentidos" && 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 — Rede robusta
A T3 já reconecta o MQTT, mas tenta a cada 5 s para sempre e não cuida do Wi-Fi. Um firmware de campo precisa de mais:
- Wi-Fi: se cair, tentar de novo a cada 10 s. O core só reconecta sozinho em algumas
quedas, e nunca depois de um
WiFi.disconnect()voluntário. - MQTT com backoff exponencial: esperar 1 s, 2 s, 4 s… até 30 s entre as tentativas. Um broker fora do ar não deve receber centenas de tentativas por minuto de cada ESP32.
- Contadores na telemetria: quedas do Wi-Fi, conexões e falhas do MQTT.
- Testes: um tópico
cmd/redeque derruba o MQTT (cai-mqtt) ou o Wi-Fi (cai-wifi).
#define ESPERA_WIFI_MS 10000 // sem Wi-Fi: nova tentativa a cada 10 s
#define ESPERA_MQTT_MAX 30000 // backoff do MQTT: no máximo 30 s
const char *TOPICO_CMD_REDE = TOPICO_BASE "/cmd/rede"; // cai-mqtt | cai-wifi
volatile uint32_t quedasWiFi = 0; // contado no aoEventoWiFi (if (wifiOk) quedasWiFi++;)
unsigned long esperaMQTT = 1000; // a espera atual do backoff
bool pedidoCaiWiFi = false, pedidoCaiMQTT = false;
void cuidarDaRede(unsigned long agora) {
if (pedidoCaiWiFi) { // teste: derruba o Wi-Fi
pedidoCaiWiFi = false;
log_w("TESTE: derrubando o Wi-Fi");
WiFi.disconnect(); // queda voluntaria: o core NAO reconecta sozinho
tTentativaWiFi = agora;
}
if (pedidoCaiMQTT) { // teste: derruba so o MQTT
pedidoCaiMQTT = false;
log_w("TESTE: derrubando o MQTT");
mqtt.publish(TOPICO_STATUS, "offline", true); // saida educada: o LWT nao dispara
mqtt.disconnect();
tTentativaMQTT = agora;
}
if (!wifiOk) {
if (mqtt.connected()) mqtt.disconnect(); // o TCP antigo morreu com o Wi-Fi: fecha
if (agora - tTentativaWiFi >= ESPERA_WIFI_MS) iniciarWiFi();
return; // sem Wi-Fi, nem tenta o MQTT
}
if (mqtt.connected()) {
mqtt.loop(); // processa a rede e chama o callback
return;
}
if (agora - tTentativaMQTT >= esperaMQTT) {
tTentativaMQTT = millis();
if (tentarMQTT()) {
esperaMQTT = 1000;
} else {
esperaMQTT = min(esperaMQTT * 2, (unsigned long)ESPERA_MQTT_MAX);
log_i("MQTT: proxima tentativa em %lu s", esperaMQTT / 1000);
}
}
}
O aoReceberMensagem() ganha o cmd/rede: ele só marca o pedido, e quem derruba a rede é o
cuidarDaRede(), fora do callback. O tentarMQTT() passa a assinar os dois tópicos de comando,
e a telemetria ganha os contadores. No setup(), mqtt.setSocketTimeout(5) limita a espera
pela resposta do broker a 5 s (o padrão é 15 s). E o loop() fica curto:
void loop() {
unsigned long agora = millis();
cuidarDaRede(agora);
cuidarDoLed(agora);
if (wifiOk && !redeDetalhada) { // uma vez por conexao
redeDetalhada = true;
detalhesRede();
} else if (!wifiOk) {
redeDetalhada = false;
}
if (agora - tTelemetria >= TELEMETRIA_MS) {
tTelemetria = agora;
if (mqtt.connected()) publicarTelemetria(agora);
else log_d("Telemetria adiada: sem MQTT");
}
}
src/main.cpp completo (T4, e também o da T5)
// ELT85B - Lab 04 (final, T1-T5): Wi-Fi e MQTT robustos, em dois ambientes
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include "config.h"
#define LED_PIN 2
#define TELEMETRIA_MS 5000 // uma telemetria a cada 5 s
#define ESPERA_WIFI_MS 10000 // sem Wi-Fi: nova tentativa a cada 10 s
#define ESPERA_MQTT_MAX 30000 // backoff do MQTT: no maximo 30 s
const char *TOPICO_STATUS = TOPICO_BASE "/status"; // online / offline (retido, LWT)
const char *TOPICO_TELEMETRIA = TOPICO_BASE "/telemetria"; // JSON a cada 5 s
const char *TOPICO_CMD_LED = TOPICO_BASE "/cmd/led"; // on | off | auto
const char *TOPICO_CMD_REDE = TOPICO_BASE "/cmd/rede"; // cai-mqtt | cai-wifi
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
char clientId[24];
// ---------- estado ----------
volatile bool wifiOk = false; // escrito no callback de eventos (outra task)
volatile uint32_t quedasWiFi = 0;
unsigned long tInicioWiFi = 0, tTentativaWiFi = 0;
uint32_t conexoesMQTT = 0, falhasMQTT = 0;
unsigned long esperaMQTT = 1000, tTentativaMQTT = 0;
enum ModoLed { LED_AUTO, LED_LIGADO, LED_DESLIGADO };
ModoLed modoLed = LED_AUTO;
bool pedidoCaiWiFi = false, pedidoCaiMQTT = false;
uint32_t n = 0;
// ---------- T1: varredura ----------
const char *nomeSeguranca(wifi_auth_mode_t m) {
switch (m) {
case WIFI_AUTH_OPEN: return "aberta";
case WIFI_AUTH_WEP: return "WEP";
case WIFI_AUTH_WPA_PSK: return "WPA";
case WIFI_AUTH_WPA2_PSK: return "WPA2";
case WIFI_AUTH_WPA_WPA2_PSK: return "WPA/WPA2";
case WIFI_AUTH_WPA3_PSK: return "WPA3";
default: return "outra";
}
}
void varrer() {
log_i("Varrendo as redes...");
unsigned long t0 = millis();
int total = WiFi.scanNetworks(); // bloqueia ate terminar
log_i("%d rede(s) em %lu ms", total, millis() - t0);
for (int i = 0; i < total; i++) {
log_i("%2d: %-16s canal %2ld %4ld dBm %s", i + 1, WiFi.SSID(i).c_str(), (long)WiFi.channel(i),
(long)WiFi.RSSI(i), nomeSeguranca(WiFi.encryptionType(i)));
}
WiFi.scanDelete();
}
// ---------- T2: eventos do Wi-Fi (rodam na task de eventos, nao no loop) ----------
void aoEventoWiFi(WiFiEvent_t evento, WiFiEventInfo_t info) {
switch (evento) {
case ARDUINO_EVENT_WIFI_STA_CONNECTED:
log_i("Wi-Fi: associado ao AP (canal %d)", info.wifi_sta_connected.channel);
break;
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
wifiOk = true;
log_i("Wi-Fi: IP %s em %lu ms", IPAddress(info.got_ip.ip_info.ip.addr).toString().c_str(),
millis() - tInicioWiFi);
break;
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
if (wifiOk) quedasWiFi++;
wifiOk = false;
log_w("Wi-Fi: desconectado (motivo %d)", info.wifi_sta_disconnected.reason);
break;
default:
break;
}
}
void iniciarWiFi() {
log_i("Wi-Fi: conectando a %s", WIFI_SSID);
tInicioWiFi = tTentativaWiFi = millis();
WiFi.begin(WIFI_SSID, WIFI_SENHA, WIFI_CANAL);
}
void detalhesRede() {
log_i("IP %s mascara %s gateway %s DNS %s", WiFi.localIP().toString().c_str(),
WiFi.subnetMask().toString().c_str(), WiFi.gatewayIP().toString().c_str(),
WiFi.dnsIP().toString().c_str());
log_i("MAC %s RSSI %d dBm canal %d", WiFi.macAddress().c_str(), WiFi.RSSI(), WiFi.channel());
}
// ---------- T3: MQTT ----------
void aoReceberMensagem(char *topico, byte *payload, unsigned int tam) {
char txt[16];
size_t k = tam < sizeof(txt) - 1 ? tam : sizeof(txt) - 1;
memcpy(txt, payload, k);
txt[k] = '\0'; // o payload NAO termina com '\0'
log_i("MQTT: %s <- '%s'", topico, txt);
if (strcmp(topico, TOPICO_CMD_LED) == 0) {
if (strcmp(txt, "on") == 0) modoLed = LED_LIGADO;
else if (strcmp(txt, "off") == 0) modoLed = LED_DESLIGADO;
else if (strcmp(txt, "auto") == 0) modoLed = LED_AUTO;
else log_w("cmd/led: use on, off ou auto");
} else if (strcmp(topico, TOPICO_CMD_REDE) == 0) {
// so marca o pedido: derrubar a rede DENTRO do callback do mqtt.loop() seria pedir problema
if (strcmp(txt, "cai-mqtt") == 0) pedidoCaiMQTT = true;
else if (strcmp(txt, "cai-wifi") == 0) pedidoCaiWiFi = true;
else log_w("cmd/rede: use cai-mqtt ou cai-wifi");
}
}
bool tentarMQTT() { // UMA tentativa; quem repete e o loop()
log_i("MQTT: conectando a %s:%d como %s", MQTT_HOST, MQTT_PORTA, clientId);
const char *usuario = strlen(MQTT_USUARIO) ? MQTT_USUARIO : nullptr;
const char *senha = strlen(MQTT_SENHA) ? MQTT_SENHA : nullptr;
unsigned long t0 = millis();
// LWT: se o ESP32 sumir sem avisar, o broker publica "offline" (retido) no lugar dele
bool ok = mqtt.connect(clientId, usuario, senha, TOPICO_STATUS, 1, true, "offline");
if (!ok) {
falhasMQTT++;
log_w("MQTT: falhou (rc=%d) em %lu ms", mqtt.state(), millis() - t0);
return false;
}
conexoesMQTT++;
log_i("MQTT: conectado em %lu ms (conexao %lu)", millis() - t0, (unsigned long)conexoesMQTT);
mqtt.publish(TOPICO_STATUS, "online", true);
mqtt.subscribe(TOPICO_CMD_LED); // (re)assina a cada conexao
mqtt.subscribe(TOPICO_CMD_REDE);
return true;
}
void publicarTelemetria(unsigned long agora) {
char json[160];
snprintf(json, sizeof(json),
"{\"n\":%lu,\"uptime_s\":%lu,\"rssi\":%d,\"heap\":%lu,\"quedas_wifi\":%lu,"
"\"conexoes_mqtt\":%lu,\"falhas_mqtt\":%lu}",
(unsigned long)++n, agora / 1000, WiFi.RSSI(), (unsigned long)ESP.getFreeHeap(),
(unsigned long)quedasWiFi, (unsigned long)conexoesMQTT, (unsigned long)falhasMQTT);
bool ok = mqtt.publish(TOPICO_TELEMETRIA, json);
if (ok) log_i("PUB %s %s", TOPICO_TELEMETRIA, json);
else log_e("PUB falhou: %s", TOPICO_TELEMETRIA);
}
// ---------- T4: rede robusta ----------
void cuidarDaRede(unsigned long agora) {
if (pedidoCaiWiFi) { // teste: derruba o Wi-Fi
pedidoCaiWiFi = false;
log_w("TESTE: derrubando o Wi-Fi");
WiFi.disconnect(); // queda voluntaria: o core NAO reconecta sozinho
tTentativaWiFi = agora;
}
if (pedidoCaiMQTT) { // teste: derruba so o MQTT
pedidoCaiMQTT = false;
log_w("TESTE: derrubando o MQTT");
mqtt.publish(TOPICO_STATUS, "offline", true); // saida educada: o LWT nao dispara
mqtt.disconnect();
tTentativaMQTT = agora;
}
if (!wifiOk) {
if (mqtt.connected()) mqtt.disconnect(); // o TCP antigo morreu com o Wi-Fi: fecha
if (agora - tTentativaWiFi >= ESPERA_WIFI_MS) iniciarWiFi();
return; // sem Wi-Fi, nem tenta o MQTT
}
if (mqtt.connected()) {
mqtt.loop(); // processa a rede e chama o callback
return;
}
if (agora - tTentativaMQTT >= esperaMQTT) {
tTentativaMQTT = millis();
if (tentarMQTT()) {
esperaMQTT = 1000;
} else {
esperaMQTT = min(esperaMQTT * 2, (unsigned long)ESPERA_MQTT_MAX);
log_i("MQTT: proxima tentativa em %lu s", esperaMQTT / 1000);
}
}
}
// LED de estado: rapido = sem Wi-Fi, lento = sem MQTT, aceso = tudo ok
void cuidarDoLed(unsigned long agora) {
bool aceso;
if (modoLed == LED_LIGADO) aceso = true;
else if (modoLed == LED_DESLIGADO) aceso = false;
else if (!wifiOk) aceso = (agora / 100) % 2;
else if (!mqtt.connected()) aceso = (agora / 500) % 2;
else aceso = true;
digitalWrite(LED_PIN, aceso ? HIGH : LOW);
}
// ---------- setup / loop ----------
unsigned long tTelemetria = 0;
bool redeDetalhada = false;
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
Serial.println("=== Lab 04 - Wi-Fi e MQTT ===");
// sufixo aleatorio: dois ESP32 com o mesmo client id derrubam um ao outro no broker
snprintf(clientId, sizeof(clientId), "lab04-%s-%04lX", GRUPO, (unsigned long)(esp_random() & 0xFFFF));
log_i("Topicos em %s/ (cliente %s)", TOPICO_BASE, clientId);
WiFi.mode(WIFI_STA);
WiFi.disconnect();
varrer();
WiFi.onEvent(aoEventoWiFi);
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
mqtt.setCallback(aoReceberMensagem);
mqtt.setSocketTimeout(5); // espera do CONNACK: 5 s, e nao 15
iniciarWiFi();
}
void loop() {
unsigned long agora = millis();
cuidarDaRede(agora);
cuidarDoLed(agora);
if (wifiOk && !redeDetalhada) { // uma vez por conexao
redeDetalhada = true;
detalhesRede();
} else if (!wifiOk) {
redeDetalhada = false;
}
if (agora - tTelemetria >= TELEMETRIA_MS) {
tTelemetria = agora;
if (mqtt.connected()) publicarTelemetria(agora);
else log_d("Telemetria adiada: sem MQTT");
}
}
4.1 Teste 1 — broker inexistente
Troque, temporariamente, o MQTT_HOST do config.h por um nome que não existe (o domínio
.invalid é reservado para isso), compile e simule por ~1 min:
#define MQTT_HOST "broker.lab04.invalid"
[ 6120][I][main.cpp:115] tentarMQTT(): MQTT: conectando a broker.lab04.invalid:1883 como lab04-x-3F2A
[ 6188][W][main.cpp:123] tentarMQTT(): MQTT: falhou (rc=-2) em 68 ms
[ 6189][I][main.cpp:178] cuidarDaRede(): MQTT: proxima tentativa em 2 s
[ 8189][I][main.cpp:115] tentarMQTT(): MQTT: conectando a broker.lab04.invalid:1883 como lab04-x-3F2A
[ 8240][W][main.cpp:123] tentarMQTT(): MQTT: falhou (rc=-2) em 51 ms
[ 8241][I][main.cpp:178] cuidarDaRede(): MQTT: proxima tentativa em 4 s
...
[ 36400][I][main.cpp:178] cuidarDaRede(): MQTT: proxima tentativa em 30 s
Durante todo o teste, o LED pisca lento (Wi-Fi ok, MQTT não). Guarde o trecho em
evidencias/t4-backoff.txt e volte o MQTT_HOST para broker.hivemq.com.
4.2 Teste 2 — quedas forçadas
Suba de novo o assinante da T3 (docker run -d --name sub-lab04 ... e docker logs -f sub-lab04) e, com a simulação rodando, mande:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-a/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-a/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-b/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-b/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-c/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-c/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-d/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-d/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-e/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-e/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-f/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-f/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-g/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-g/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-h/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-h/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-i/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-i/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-j/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-j/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-k/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-k/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-l/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-l/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-m/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-m/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-x/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-x/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-p/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-p/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
1. Derrubar o MQTT:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-n/cmd/rede" -m cai-mqtt
2. Derrubar o Wi-Fi:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab04/grupo-n/cmd/rede" -m cai-wifi
3. Gravar e encerrar:
docker logs sub-lab04 > evidencias\t4-mqtt.txt 2>&1
type evidencias\t4-mqtt.txt
docker rm -f sub-lab04
[ 40210][I][main.cpp:99] aoReceberMensagem(): MQTT: elt85b/lab04/grupo-x/cmd/rede <- 'cai-mqtt'
[ 40215][W][main.cpp:156] cuidarDaRede(): TESTE: derrubando o MQTT
[ 41216][I][main.cpp:115] tentarMQTT(): MQTT: conectando a broker.hivemq.com:1883 como lab04-x-3F2A
[ 41790][I][main.cpp:127] tentarMQTT(): MQTT: conectado em 574 ms (conexao 2)
...
[ 71030][I][main.cpp:99] aoReceberMensagem(): MQTT: elt85b/lab04/grupo-x/cmd/rede <- 'cai-wifi'
[ 71033][W][main.cpp:150] cuidarDaRede(): TESTE: derrubando o Wi-Fi
[ 71040][W][WiFiGeneric.cpp:1062] _eventCallback(): Reason: 8 - ASSOC_LEAVE
[ 71041][W][main.cpp:73] aoEventoWiFi(): Wi-Fi: desconectado (motivo 8)
[ 81034][I][main.cpp:81] iniciarWiFi(): Wi-Fi: conectando a Wokwi-GUEST
[ 82410][I][main.cpp:67] aoEventoWiFi(): Wi-Fi: IP 10.10.0.2 em 1376 ms
[ 82420][I][main.cpp:115] tentarMQTT(): MQTT: conectando a broker.hivemq.com:1883 como lab04-x-3F2A
[ 83002][I][main.cpp:127] tentarMQTT(): MQTT: conectado em 582 ms (conexao 3)
O motivo 8 (ASSOC_LEAVE) é a saída voluntária: por isso o core não reconecta, e quem
chama o iniciarWiFi() 10 s depois é o seu cuidarDaRede(). A telemetria seguinte mostra
"quedas_wifi":1,"conexoes_mqtt":3.
P3: (a) no teste 1, cada tentativa falha em poucos ms. Se o host existisse, mas não
respondesse, o connect() do TCP esperaria até ~3 s, e o do MQTT até o setSocketTimeout. O
que o LED e a telemetria fariam nesse tempo? Por que isso ainda é bem melhor que um while de
espera? (b) No cai-mqtt, o firmware publica offline antes do disconnect(). Por que o
LWT não dispararia sozinho nesse caso? (c) No cai-wifi, o broker vê o ESP32 sumir sem
DISCONNECT. O que aparece no status e quando?
Evidências: evidencias/t4-backoff.txt (teste 1), evidencias/t4-quedas.txt (o monitor
serial do teste 2) e evidencias/t4-mqtt.txt (o docker logs do teste 2).
git add include/config.h src/main.cpp evidencias/t4-backoff.txt evidencias/t4-quedas.txt evidencias/t4-mqtt.txt
git commit -m "T4: reconexao com backoff e quedas forcadas"
git push
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t4-backoff.txt👈 Criar Aqui
- ├── 📄t4-quedas.txt👈 Criar Aqui
- └── 📄t4-mqtt.txt👈 Criar Aqui
git conferir src/main.cpp evidencias/t4-backoff.txt evidencias/t4-quedas.txt evidencias/t4-mqtt.txt
Rede robusta
git conferir include/config.h src/main.cpp evidencias/t4-backoff.txt evidencias/t4-quedas.txt evidencias/t4-mqtt.txt
git add include/config.h src/main.cpp evidencias/t4-backoff.txt evidencias/t4-quedas.txt evidencias/t4-mqtt.txt && git commit -m "T4: Rede robusta" && 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.
Projeto integrador — Wokwi e laboratório no mesmo firmware
No laboratório, a placa real usa a rede IoT-Broker e o broker do LAB IoT, que exige
usuário e senha do grupo. Os dados estão na página de acesso do grupo. O firmware é o mesmo:
muda só a configuração, escolhida pelo ambiente do PlatformIO (Lab 03). E as senhas não
podem ir para o GitHub.
Requisitos
-
Dois ambientes no
platformio.ini. Owokwicontinua sendo o padrão (é o que o autograder compila):platformio.ini (T5); ELT85B - Lab 04 (final): o mesmo firmware para o Wokwi e para o laboratorio[platformio]default_envs = wokwi ; o "pio run" (e o autograder) compila so este[env]platform = espressif32board = esp32devframework = arduinomonitor_speed = 115200lib_deps =knolleary/PubSubClient[env:wokwi] ; simulador: Wokwi-GUEST + broker publicobuild_flags =-DCORE_DEBUG_LEVEL=4-DREDE_WOKWI[env:lab] ; placa real: rede e broker do laboratoriobuild_flags =-DCORE_DEBUG_LEVEL=3-DREDE_LABE o
wokwi.tomlcontinua apontando para.pio/build/wokwi/. -
include/config.hescolhe a rede pelo ambiente:include/config.h (T5)// ELT85B - Lab 04: rede e broker de cada ambiente do platformio.ini#pragma once#define GRUPO "x" // troque pela letra do seu grupo#if defined(REDE_LAB)// ---- [env:lab]: Wi-Fi e broker do laboratorio, com placa real ----#if __has_include("segredos.h")#include "segredos.h" // NAO vai para o Git (.gitignore)#else#error "Falta include/segredos.h: copie include/segredos.exemplo.h e preencha (Lab 04, T5)"#endif// a ACL do broker do lab so libera os topicos <usuario>/# para cada grupo#define TOPICO_BASE MQTT_USUARIO#else// ---- [env:wokwi]: rede do simulador e broker publico ----#define WIFI_SSID "Wokwi-GUEST"#define WIFI_SENHA ""#define WIFI_CANAL 6 // o AP do Wokwi fica no canal 6#define MQTT_HOST "broker.hivemq.com"#define MQTT_PORTA 1883#define MQTT_USUARIO "" // broker publico: sem login#define MQTT_SENHA ""#define TOPICO_BASE "elt85b/lab04/grupo-" GRUPO#endif -
Os segredos fora do Git. O
segredos.exemplo.hvai para o repositório, como modelo. Osegredos.hde verdade, só no seu computador:include/segredos.exemplo.h// ELT85B - Lab 04: modelo dos segredos do [env:lab]// Copie para include/segredos.h (que o .gitignore ignora) e preencha com os dados da// pagina de acesso do seu grupo no LAB IoT. Nunca faca commit do segredos.h.#pragma once#define WIFI_SSID "IoT-Broker"#define WIFI_SENHA "ESP32IoTLab"#define WIFI_CANAL 0 // 0 = procura o AP em todos os canais#define MQTT_HOST "192.168.0.10" // o "IP do lab" da pagina de acesso#define MQTT_PORTA 1883#define MQTT_USUARIO "lab04-x" // o usuario do grupo#define MQTT_SENHA "senha-do-grupo" // a senha do grupo.gitignore (acrescente a linha)include/segredos.hTerminal do VS Code (cmd)copy include\segredos.exemplo.h include\segredos.hcode include\segredos.hgit statusPreencha o
segredos.hcom os dados da página de acesso. Ogit statusnão pode mostrar osegredos.h. Se mostrar, o.gitignoreestá errado: corrija antes de qualquergit add.Senha no GitHubUma senha que foi para o GitHub vazou, mesmo que um commit seguinte a apague: ela continua no histórico. Se acontecer, avise o professor para trocar a senha do grupo, e tire o arquivo do repositório com
git rm --cached include/segredos.h. -
Os dois ambientes compilam:
Terminal do VS Code (cmd)pio run -e wokwi -e lab > evidencias\t5-build.txt 2>&1type evidencias\t5-build.txtSem o
segredos.h, olabpara com a mensagem do#error: é o que acontece no computador de um colega que clonou o repositório e ainda não criou o arquivo. -
Wokwi: simule o
wokwicom o assinante da T3 e graveevidencias/t5-mqtt.txtcom ostatus online, três telemetrias e um comando. -
Placa real (opcional, no laboratório): grave o ambiente
labe acompanhe pelo monitor. Os tópicos ficam soblab04-x/(o usuário do grupo), e o MQTT Explorer do LAB IoT mostra as mensagens.Terminal do VS Code (cmd)pio run -e lab -t uploadpio device monitor -e lab -
No
README.md: as respostas de P1 a P4.Terminal do VS Code (cmd)git statusgit add .gitignore platformio.ini include/config.h include/segredos.exemplo.h evidencias/t5-build.txt evidencias/t5-mqtt.txt README.mdgit commit -m "T5: o mesmo firmware no Wokwi e no laboratorio"git push
P4: (a) no broker do laboratório, cada grupo só pode publicar e assinar em <usuário>/#
(ACL). Se o TOPICO_BASE do lab fosse elt85b/lab04/grupo-x, o connect() funcionaria? E o
publish(), retornaria true? A mensagem chegaria a alguém? (b) Por que o config.h vai para
o Git e o segredos.h não? (c) A senha do Wi-Fi do laboratório está no segredos.exemplo.h.
Isso é um problema? Que diferença há entre ela e a senha do MQTT do grupo?
- ├── 📄.gitignore👈 Edite Aqui
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📂include
- ├── 📄config.h👈 Edite Aqui
- └── 📄segredos.exemplo.h👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t5-build.txt👈 Criar Aqui
- └── 📄t5-mqtt.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
git conferir .gitignore platformio.ini include/config.h include/segredos.exemplo.h evidencias/t5-build.txt evidencias/t5-mqtt.txt README.md
Wokwi e laboratório no mesmo firmware
git conferir .gitignore platformio.ini include/config.h include/segredos.exemplo.h evidencias/t5-build.txt evidencias/t5-mqtt.txt README.md
git add .gitignore platformio.ini include/config.h include/segredos.exemplo.h evidencias/t5-build.txt evidencias/t5-mqtt.txt README.md && git commit -m "T5: Wokwi e laboratório no mesmo firmware" && 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.
O Wokwi só alcança a internet pelo gateway público: ele não enxerga um broker rodando no seu
computador. Com uma placa real, sim: suba o LAB IoT (guia LAB IoT na sua máquina) ou só um
broker, e ponha o IP do seu PC (ipconfig, Endereço IPv4) no MQTT_HOST do segredos.h.
docker run -d --name broker -p 1883:1883 eclipse-mosquitto mosquitto -c /mosquitto-no-auth.conf
Nesse caso, sem login, deixe MQTT_USUARIO e MQTT_SENHA vazios e mude o TOPICO_BASE do
lab para "elt85b/lab04/grupo-" GRUPO.
Referência rápida
| Para… | Código |
|---|---|
| Modo estação | WiFi.mode(WIFI_STA) |
| Iniciar a conexão (não bloqueia) | WiFi.begin(ssid, senha, canal) |
| Ser avisado dos eventos | WiFi.onEvent(funcao) |
| Endereços | WiFi.localIP(), gatewayIP(), dnsIP(), subnetMask(), macAddress(), RSSI() |
| Conectar ao broker com LWT | mqtt.connect(id, usuario, senha, topicoWill, qos, retido, "offline") |
| Publicar (retido) | mqtt.publish(topico, texto, true) |
| Assinar | mqtt.subscribe(topico) (a cada conexão) |
| Processar a rede | mqtt.loop() em todo loop() |
| Problema | O que fazer |
|---|---|
Wi-Fi: conectando... e nada | o SSID tem de ser exatamente Wokwi-GUEST, senha vazia |
rc=-2 sempre | MQTT_HOST ou porta errados, ou sem Wi-Fi |
rc=5 no laboratório | usuário ou senha do grupo errados no segredos.h |
| Conecta e cai a cada poucos segundos | outro cliente com o mesmo client id |
Publica, mas nada chega no mosquitto_sub | tópico diferente (maiúsculas, grupo-x × grupo-X) ou, no laboratório, fora da ACL (P4) |
Falta include/segredos.h ao compilar o lab | copy include\segredos.exemplo.h include\segredos.h e preencha |
The container name "/sub-lab04" is already in use | docker rm -f sub-lab04 |
O LED não muda com cmd/led | o subscribe só vale depois da conexão: confira o MQTT: conectado no monitor |
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.