Laboratório 05
Checklist — DHT22, temporizador e MQTT com Node-RED
-
platformio.inicom DHT, Unified Sensor e PubSubClient;diagram.jsoncom DHT22 no GPIO15 (T1) - Leituras periódicas via
Ticker+ flagvolatile,NaNdescartado (T2) - Conexão Wi-Fi com reconexão no
loop()(T3) - JSON publicado em
elt73a/lab05/grupo-x/dhta cada 5 s, client ID único (T4) - Node-RED:
mqtt in(JSON) →debug, fluxo exportado (T5) - LWT
offline+onlineretidos em.../status, visíveis no Node-RED (T6) - Previsões P1–P4 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T6 = 100 pts (esta aula não tem desafios): T1 10 · T2 20 · T3 15 · T4 20 · T5 15 ·
T6 20. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Nesta aula o ESP32 vira um nó de telemetria: um temporizador dispara leituras periódicas do DHT22, o firmware publica cada leitura em JSON via MQTT, e o Node-RED assina o tópico e mostra as mensagens no painel debug. No projeto integrador o nó passa a anunciar se está online ou offline usando LWT.
No Lab 06 o mesmo firmware é reaproveitado: ganha um display OLED e passa a receber comandos pelo MQTT, como o intervalo de leitura. Gravar as leituras num banco (SQLite) fica para o Lab 08.
Objetivos
- Ler temperatura e umidade do DHT22 e tratar leituras inválidas (
NaN). - Usar um temporizador (
Ticker) para disparar ações periódicas semdelay()e sem bloquear oloop(). - Conectar o ESP32 ao Wi-Fi e a um broker MQTT, publicando leituras em JSON.
- No Node-RED, assinar o tópico, receber o JSON já convertido em objeto e inspecionar os campos no debug.
- (Integrador) Publicar o status do nó com LWT (Last Will and Testament).
Material
- VS Code + PlatformIO + extensão Wokwi (ESP32 simulado — sem placa física).
- Stack Docker do curso (Mosquitto + Node-RED + MQTT Explorer) — nesta aula usamos o Node-RED e o MQTT Explorer.
- Bibliotecas (baixadas pelo PlatformIO):
adafruit/DHT sensor library,adafruit/Adafruit Unified Sensor,knolleary/PubSubClient. OTickerjá vem com o core Arduino do ESP32.
Conferindo a matriz de simulação: GPIO (o DHT22 usa um único pino digital) e Wi-Fi são ✔️ no ESP32 clássico — então a aula roda inteira no Wokwi. O mesmo firmware funciona numa placa física trocando só SSID/senha e o endereço do broker (veja a aba "Placa física" na T3).
Clonar o repositório do grupo
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-a/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-a.git && cd lab05-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-b/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-b.git && cd lab05-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-c/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-c.git && cd lab05-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-d/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-d.git && cd lab05-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-e/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-e.git && cd lab05-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-f/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-f.git && cd lab05-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-g/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-g.git && cd lab05-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-h/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-h.git && cd lab05-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-i/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-i.git && cd lab05-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-j/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-j.git && cd lab05-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-k/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-k.git && cd lab05-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-l/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-l.git && cd lab05-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-m/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-m.git && cd lab05-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-x/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-x.git && cd lab05-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-p/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-p.git && cd lab05-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab05-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab05-grupo-n/commits/main/
- Acessos: ACESSO-LAB05.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-2026-2/lab05-grupo-n.git && cd lab05-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT73AS22\lab05-grupo-n" && code . --profile "ESP32IO"
Envie o link do repositório do seu grupo no Moodle:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
Repositório do Grupo A para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo B para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo C para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo D para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo E para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo F para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo G para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo H para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo I para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo J para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo K para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo L para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo M para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo X para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo P para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo N para Laboratório 05:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.
Suba os containers
Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.
docker desktop start
Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Disciplina: ELT73A - Sistemas Microcontrolados.
- 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%\ELT73AS22\lab05-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-a"
2. Gere o LAB IoT do grupo em docker\lab05-a:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo a --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-a-nodered && (del /q "data\lab05-a\flows.json" "data\lab05-a\flows_cred.json" "data\lab05-a\.flows*.backup" 2>nul & docker compose start lab05-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-b"
2. Gere o LAB IoT do grupo em docker\lab05-b:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo b --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-b-nodered && (del /q "data\lab05-b\flows.json" "data\lab05-b\flows_cred.json" "data\lab05-b\.flows*.backup" 2>nul & docker compose start lab05-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-c"
2. Gere o LAB IoT do grupo em docker\lab05-c:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo c --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-c-nodered && (del /q "data\lab05-c\flows.json" "data\lab05-c\flows_cred.json" "data\lab05-c\.flows*.backup" 2>nul & docker compose start lab05-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-d"
2. Gere o LAB IoT do grupo em docker\lab05-d:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo d --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-d-nodered && (del /q "data\lab05-d\flows.json" "data\lab05-d\flows_cred.json" "data\lab05-d\.flows*.backup" 2>nul & docker compose start lab05-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-e"
2. Gere o LAB IoT do grupo em docker\lab05-e:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo e --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-e-nodered && (del /q "data\lab05-e\flows.json" "data\lab05-e\flows_cred.json" "data\lab05-e\.flows*.backup" 2>nul & docker compose start lab05-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-f"
2. Gere o LAB IoT do grupo em docker\lab05-f:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo f --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-f-nodered && (del /q "data\lab05-f\flows.json" "data\lab05-f\flows_cred.json" "data\lab05-f\.flows*.backup" 2>nul & docker compose start lab05-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-g"
2. Gere o LAB IoT do grupo em docker\lab05-g:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo g --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-g-nodered && (del /q "data\lab05-g\flows.json" "data\lab05-g\flows_cred.json" "data\lab05-g\.flows*.backup" 2>nul & docker compose start lab05-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-h"
2. Gere o LAB IoT do grupo em docker\lab05-h:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo h --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-h-nodered && (del /q "data\lab05-h\flows.json" "data\lab05-h\flows_cred.json" "data\lab05-h\.flows*.backup" 2>nul & docker compose start lab05-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-i"
2. Gere o LAB IoT do grupo em docker\lab05-i:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo i --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-i-nodered && (del /q "data\lab05-i\flows.json" "data\lab05-i\flows_cred.json" "data\lab05-i\.flows*.backup" 2>nul & docker compose start lab05-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-j"
2. Gere o LAB IoT do grupo em docker\lab05-j:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo j --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-j-nodered && (del /q "data\lab05-j\flows.json" "data\lab05-j\flows_cred.json" "data\lab05-j\.flows*.backup" 2>nul & docker compose start lab05-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-k"
2. Gere o LAB IoT do grupo em docker\lab05-k:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo k --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-k-nodered && (del /q "data\lab05-k\flows.json" "data\lab05-k\flows_cred.json" "data\lab05-k\.flows*.backup" 2>nul & docker compose start lab05-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-l"
2. Gere o LAB IoT do grupo em docker\lab05-l:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo l --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-l-nodered && (del /q "data\lab05-l\flows.json" "data\lab05-l\flows_cred.json" "data\lab05-l\.flows*.backup" 2>nul & docker compose start lab05-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-m"
2. Gere o LAB IoT do grupo em docker\lab05-m:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo m --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-m-nodered && (del /q "data\lab05-m\flows.json" "data\lab05-m\flows_cred.json" "data\lab05-m\.flows*.backup" 2>nul & docker compose start lab05-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT73AS22\lab05-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab05-x"
2. Gere o LAB IoT do grupo em docker\lab05-x:
py "%IOT_GEN%" --disciplina elt73a --lab lab05 --grupo x --sem-gitea --sem-microbin --sem-fuxa --sem-ntfy --captura --docs --saida "%IOT_DIR%"
3. Suba os containers (a primeira vez demora):
cd /d "%IOT_DIR%" && docker compose up -d --build
4. Abra o Portal: http://localhost/
start http://localhost/
5. Limpar (voltar ao original) — só os fluxos (mantém os nós instalados e os bancos):
(cd /d "%IOT_DIR%" && docker compose stop lab05-x-nodered && (del /q "data\lab05-x\flows.json" "data\lab05-x\flows_cred.json" "data\lab05-x\.flows*.backup" 2>nul & docker compose start lab05-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Dependencias e circuito do DHT22 · 10 pts
- T2 — Leitura do DHT22 com temporizador · 20 pts
- T3 — Conexao Wi-Fi · 15 pts
- T4 — Publicacao MQTT periodica em JSON · 20 pts
- T5 — Node-RED recebendo as leituras no debug · 15 pts
- T6 — Status do no com LWT · 20 pts
O repositório do grupo nasce do lab05-template:
Estrutura de Arquivos do Projeto
- ├── 🔧platformio.ini👈 Edite Aqui
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 🔧diagram.json👈 Edite Aqui
- ├── 🔧wokwi.toml👈 Verificar
- ├── 📄.gitignore👈 Verificar
- ├── 📂.vscode
- └── 🔧extensions.json👈 Verificar
- ├── 📂nodered
- └── 🔧flows-lab05.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t2-serial.txt👈 Criar Aqui
- ├── 📄t3-wifi.txt👈 Criar Aqui
- ├── 📄t4-mqtt.txt👈 Criar Aqui
- ├── 📄t5-debug.txt👈 Criar Aqui
- └── 📄t6-status.txt👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
setup()— o que acontece uma vez: iniciar Serial e DHT, conectar Wi-Fi e MQTT, armar o temporizador.loop()— o comportamento contínuo: manter Wi-Fi/MQTT vivos (mqtt.loop()), e consumir a flag do temporizador (ler + publicar).- callback do temporizador — não é nem um nem outro: roda em outro contexto
(a tarefa do
esp_timer). Por isso ele só fazleituraPendente = truee mais nada.
Parte 1 — Circuito e dependências
1.1 Circuito no Wokwi
O DHT22 do Wokwi tem 4 pinos: VCC, SDA (dados), NC e GND. Ligue VCC → 3V3,
GND → GND e SDA → GPIO15. O template já traz o ESP32; acrescente o sensor no
diagram.json:
- └── 🔧diagram.json👈 Edite Aqui
git conferir diagram.json
{
"version": 1,
"author": "elt73a - Lab 05",
"editor": "wokwi",
"parts": [
{
"type": "board-esp32-devkit-c-v4",
"id": "esp",
"top": 0,
"left": 0,
"attrs": {}
},
{
"type": "wokwi-dht22",
"id": "dht1",
"top": -76.5,
"left": 157.8,
"attrs": { "temperature": "24.5", "humidity": "55" }
}
],
"connections": [
["esp:TX", "$serialMonitor:RX", "", []],
["esp:RX", "$serialMonitor:TX", "", []],
["dht1:VCC", "esp:3V3", "red", []],
["dht1:GND", "esp:GND.2", "black", []],
["dht1:SDA", "esp:15", "green", []]
],
"dependencies": {}
}
Com o simulador rodando, clique no DHT22: aparecem sliders de temperatura e umidade. É assim que você vai "esquentar" o sensor e ver os números mudarem no Node-RED.
1.2 Bibliotecas no platformio.ini
- └── 🔧platformio.ini👈 Edite Aqui
git conferir platformio.ini
[env:esp32dev]
platform = espressif32@6.9.0 ; versão fixa (Lab 02)
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
adafruit/DHT sensor library@1.4.6
adafruit/Adafruit Unified Sensor@1.1.14
knolleary/PubSubClient@2.8
As versões são fixas, como no Lab 02: sem elas, o mesmo commit pode compilar com bibliotecas diferentes em dias diferentes. (O Lab 10 volta a esse ponto, no CI.)
O wokwi.toml do template já aponta para .pio/build/esp32dev/firmware.bin e .elf —
por isso o nome do ambiente precisa continuar esp32dev.
Dependencias e circuito do DHT22
git conferir platformio.ini diagram.json
git add platformio.ini diagram.json && git commit -m "T1: Dependencias e circuito do DHT22" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.
Parte 2 — DHT22 com temporizador
2.1 Por que um temporizador?
O jeito ingênuo é ler(); delay(5000);. Funciona até você precisar fazer outra coisa
no loop() — como manter a conexão MQTT viva, que exige chamar mqtt.loop() várias vezes
por segundo. Com delay(5000) o cliente fica 5 s "surdo".
A solução é deixar um temporizador marcar o tempo e o loop() só reagir:
Tickeré o temporizador de software do core ESP32 (baseado noesp_timer, com resolução de microssegundos).attach(segundos, funcao)chamafuncaoperiodicamente.- A flag é
volatile boolporque é escrita num contexto (timer) e lida em outro (loop()):volatileimpede o compilador de "cachear" o valor num registrador. - No ESP32,
boolocupa 1 byte e a escrita é atômica — não precisamos de mutex para uma flag.
O DHT22 faz no máximo uma leitura a cada 2 s. A biblioteca da Adafruit respeita isso: se você pedir antes, ela devolve o último valor em cache.
2.2 Código
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#include <Arduino.h>
#include <Ticker.h>
#include <DHT.h>
#define DHT_PIN 15
#define DHT_TIPO DHT22
DHT dht(DHT_PIN, DHT_TIPO);
Ticker temporizador;
volatile bool leituraPendente = false; // setada pelo temporizador
const float INTERVALO_S = 5.0; // DHT22: minimo 2 s entre leituras
uint32_t seq = 0;
// Roda no contexto do temporizador: NADA de Serial/DHT/MQTT aqui
void aoEstourarTemporizador() {
leituraPendente = true;
}
void setup() {
Serial.begin(115200);
delay(200);
Serial.println("\r\n=== Lab 05 - T2: DHT22 + temporizador ===");
dht.begin();
temporizador.attach(INTERVALO_S, aoEstourarTemporizador);
}
void loop() {
if (leituraPendente) {
leituraPendente = false;
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t) || isnan(h)) {
Serial.println("[DHT] falha na leitura (NaN) - descartada");
return;
}
seq++;
Serial.printf("[DHT] seq=%lu t=%.1f C h=%.1f %% (%lu ms)\r\n",
(unsigned long)seq, t, h, (unsigned long)millis());
}
}
Compile (PlatformIO: Build) e rode Wokwi: Start Simulator.
Saída esperada (os ms variam um pouco):
=== Lab 05 - T2: DHT22 + temporizador ===
[DHT] seq=1 t=24.5 C h=55.0 % (5204 ms)
[DHT] seq=2 t=24.5 C h=55.0 % (10204 ms)
[DHT] seq=3 t=24.5 C h=55.0 % (15204 ms)
- P1: troque
INTERVALO_Spara1.0e mude o slider do sensor entre duas leituras. Os valores acompanham o slider a cada linha? Por quê? - P2: e se você colocasse o
Serial.printfdentro deaoEstourarTemporizador()? Pense em quem mais depende da tarefa doesp_timere no tempo que umprintfa 115200 baud leva.
Anote as previsões e o que observou no README.md. Depois volte o intervalo para 5 s.
Salve pelo menos 3 leituras do monitor serial (copie do terminal do Wokwi) em
evidencias/t2-serial.txt, incluindo a linha === Lab 05.
- └── 📂evidencias
- └── 📄t2-serial.txt👈 Criar Aqui
git conferir evidencias/t2-serial.txt
Leitura do DHT22 com temporizador
git conferir src/main.cpp evidencias/t2-serial.txt
git add src/main.cpp evidencias/t2-serial.txt && git commit -m "T2: Leitura do DHT22 com temporizador" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.
Parte 3 — Wi-Fi
Acrescente o Wi-Fi ao programa da T2. No Wokwi a rede é Wokwi-GUEST, sem senha; passar
o canal 6 no begin() pula a varredura e conecta mais rápido.
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
- Wokwi (padrão)
- Placa física
#include <WiFi.h>
const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
void conectarWiFi() {
Serial.printf("[WiFi] conectando a %s", WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA, 6); // canal 6 acelera no Wokwi
while (WiFi.status() != WL_CONNECTED) {
delay(250);
Serial.print('.');
}
Serial.printf("\r\n[WiFi] conectado, IP %s\r\n", WiFi.localIP().toString().c_str());
}
// em setup(), depois de dht.begin():
// conectarWiFi();
// no inicio de loop():
// if (WiFi.status() != WL_CONNECTED) conectarWiFi();
Troque só as constantes (o resto é idêntico). O begin() sem o canal, porque a rede
real pode estar em qualquer canal:
const char *WIFI_SSID = "IoT-Broker";
const char *WIFI_SENHA = "ESP32IoTLab";
// ...
WiFi.begin(WIFI_SSID, WIFI_SENHA);
Saída esperada:
=== Lab 05 ===
[WiFi] conectando a Wokwi-GUEST.....
[WiFi] conectado, IP 10.13.37.2
[DHT] seq=1 t=24.5 C h=55.0 % (6120 ms)
Enquanto não há Wi-Fi não há o que publicar, então bloquear na (re)conexão é aceitável nesta aula. Em produção você trocaria por uma máquina de estados não bloqueante.
Salve a saída (com a linha [WiFi] conectado) em evidencias/t3-wifi.txt.
- └── 📂evidencias
- └── 📄t3-wifi.txt👈 Criar Aqui
git conferir evidencias/t3-wifi.txt
Conexao Wi-Fi
git conferir src/main.cpp evidencias/t3-wifi.txt
git add src/main.cpp evidencias/t3-wifi.txt && git commit -m "T3: Conexao Wi-Fi" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.
Parte 4 — Publicação MQTT periódica
4.1 Tópico e payload
Cada grupo publica no seu tópico (troque a pela letra do grupo):
| Uso | Tópico | Exemplo de payload |
|---|---|---|
| Leituras | elt73a/lab05/grupo-x/dht | {"grupo":"a","seq":7,"t":24.5,"h":55.0,"uptime_ms":35210} |
| Status (T6) | elt73a/lab05/grupo-x/status | online / offline (retido) |
seqé um contador: se chegaremseq7, 8, 10, a mensagem 9 se perdeu.uptime_ms(demillis()) mostra o instante da leitura do ponto de vista do ESP32.
No Wokwi o ESP32 só alcança a internet, por isso usamos broker.hivemq.com:1883 —
um broker público e sem senha: qualquer pessoa pode ler e publicar nesses tópicos.
Não publique nada sensível. (Broker local no Wokwi exige o IoT Gateway do Wokwi Club.)
4.2 Código completo até aqui
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <Ticker.h>
#include <DHT.h>
#define GRUPO "a" // troque pela letra do seu grupo
#define DHT_PIN 15
#define DHT_TIPO DHT22
const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;
const char *TOPICO_DADOS = "elt73a/lab05/grupo-" GRUPO "/dht";
DHT dht(DHT_PIN, DHT_TIPO);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
Ticker temporizador;
volatile bool leituraPendente = false;
const float INTERVALO_S = 5.0;
uint32_t seq = 0;
char clientId[32];
void aoEstourarTemporizador() {
leituraPendente = true;
}
void conectarWiFi() {
Serial.printf("[WiFi] conectando a %s", WIFI_SSID);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_SENHA, 6); // canal 6 acelera no Wokwi
while (WiFi.status() != WL_CONNECTED) {
delay(250);
Serial.print('.');
}
Serial.printf("\r\n[WiFi] conectado, IP %s\r\n", WiFi.localIP().toString().c_str());
}
void conectarMQTT() {
while (!mqtt.connected()) {
Serial.printf("[MQTT] conectando a %s como %s ... ", MQTT_HOST, clientId);
if (mqtt.connect(clientId)) {
Serial.println("ok");
} else {
Serial.printf("falhou (rc=%d), nova tentativa em 2 s\r\n", mqtt.state());
delay(2000);
}
}
}
void lerEPublicar() {
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t) || isnan(h)) {
Serial.println("[DHT] falha na leitura (NaN) - descartada");
return;
}
seq++;
char payload[128];
snprintf(payload, sizeof(payload),
"{\"grupo\":\"%s\",\"seq\":%lu,\"t\":%.1f,\"h\":%.1f,\"uptime_ms\":%lu}",
GRUPO, (unsigned long)seq, t, h, (unsigned long)millis());
bool ok = mqtt.publish(TOPICO_DADOS, payload);
Serial.printf("[PUB] %s %s -> %s\r\n", ok ? "ok" : "ERRO", TOPICO_DADOS, payload);
}
void setup() {
Serial.begin(115200);
delay(200);
Serial.println("\r\n=== Lab 05 - T4: DHT22 + MQTT ===");
dht.begin();
uint64_t mac = ESP.getEfuseMac();
snprintf(clientId, sizeof(clientId), "lab05-%s-%04X", GRUPO, (uint16_t)(mac >> 32));
conectarWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
conectarMQTT();
temporizador.attach(INTERVALO_S, aoEstourarTemporizador);
}
void loop() {
if (WiFi.status() != WL_CONNECTED) conectarWiFi();
if (!mqtt.connected()) conectarMQTT();
mqtt.loop();
if (leituraPendente) {
leituraPendente = false;
lerEPublicar();
}
}
Pontos que valem a atenção:
"elt73a/lab05/grupo-" GRUPO "/dht"— literais de string adjacentes são concatenados pelo compilador; comoGRUPOé um#definede string, o tópico é montado em tempo de compilação.- Client ID único: dois clientes com o mesmo ID no mesmo broker se derrubam mutuamente. Por isso o ID leva parte do MAC do chip.
%lu+ cast paraunsigned long: no ESP32uint32_teunsigned longtêm ambos 4 bytes, mas são tipos diferentes para oprintf— o cast deixa o formato correto e sem warnings.- O
PubSubClienttem buffer padrão de 256 bytes (cabeçalho + tópico + payload). Nosso payload tem ~70 bytes; se um dia passar do limite,publish()devolvefalse(e o log mostraERRO) — aí usemqtt.setBufferSize(...).
4.3 Verificando no broker
Enquanto a simulação roda, assine o tópico. Use o MQTT Explorer da stack (conexão
broker.hivemq.com, porta 1883) ou, pelo terminal, um mosquitto_sub descartável em Docker:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-a/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-b/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-c/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-d/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-e/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-f/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-g/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-h/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-i/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-j/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-k/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-l/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-m/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-x/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-p/#' -v -C 5 | tee /ev/t4-mqtt.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-n/#' -v -C 5 | tee /ev/t4-mqtt.txt"
-C 5 encerra depois de 5 mensagens.
tee roda dentro do container?O cmd do Windows não tem tee (mostrar na tela e gravar no arquivo). Por isso o comando roda
num sh dentro do container, que tem o tee. O -v "%cd%\evidencias:/ev" monta a pasta
evidencias do repositório em /ev: o que o container grava ali aparece na sua pasta. O --init
faz o Ctrl+C encerrar o container. Rode o comando na raiz do repositório, com a pasta
evidencias já criada (if not exist evidencias mkdir evidencias).
Saída esperada:
- └── 📂evidencias
- └── 📄t4-mqtt.txt👈 Criar Aqui
git conferir evidencias/t4-mqtt.txt
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-a/dht {"grupo":"a","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-b/dht {"grupo":"b","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-b/dht {"grupo":"b","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-b/dht {"grupo":"b","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-b/dht {"grupo":"b","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-b/dht {"grupo":"b","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-c/dht {"grupo":"c","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-c/dht {"grupo":"c","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-c/dht {"grupo":"c","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-c/dht {"grupo":"c","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-c/dht {"grupo":"c","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-d/dht {"grupo":"d","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-d/dht {"grupo":"d","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-d/dht {"grupo":"d","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-d/dht {"grupo":"d","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-d/dht {"grupo":"d","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-e/dht {"grupo":"e","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-e/dht {"grupo":"e","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-e/dht {"grupo":"e","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-e/dht {"grupo":"e","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-e/dht {"grupo":"e","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-f/dht {"grupo":"f","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-f/dht {"grupo":"f","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-f/dht {"grupo":"f","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-f/dht {"grupo":"f","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-f/dht {"grupo":"f","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-g/dht {"grupo":"g","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-g/dht {"grupo":"g","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-g/dht {"grupo":"g","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-g/dht {"grupo":"g","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-g/dht {"grupo":"g","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-h/dht {"grupo":"h","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-h/dht {"grupo":"h","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-h/dht {"grupo":"h","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-h/dht {"grupo":"h","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-h/dht {"grupo":"h","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-i/dht {"grupo":"i","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-i/dht {"grupo":"i","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-i/dht {"grupo":"i","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-i/dht {"grupo":"i","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-i/dht {"grupo":"i","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-j/dht {"grupo":"j","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-j/dht {"grupo":"j","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-j/dht {"grupo":"j","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-j/dht {"grupo":"j","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-j/dht {"grupo":"j","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-k/dht {"grupo":"k","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-k/dht {"grupo":"k","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-k/dht {"grupo":"k","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-k/dht {"grupo":"k","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-k/dht {"grupo":"k","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-l/dht {"grupo":"l","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-l/dht {"grupo":"l","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-l/dht {"grupo":"l","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-l/dht {"grupo":"l","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-l/dht {"grupo":"l","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-m/dht {"grupo":"m","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-m/dht {"grupo":"m","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-m/dht {"grupo":"m","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-m/dht {"grupo":"m","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-m/dht {"grupo":"m","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-x/dht {"grupo":"x","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-x/dht {"grupo":"x","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-x/dht {"grupo":"x","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-x/dht {"grupo":"x","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-x/dht {"grupo":"x","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-p/dht {"grupo":"p","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-p/dht {"grupo":"p","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-p/dht {"grupo":"p","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-p/dht {"grupo":"p","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-p/dht {"grupo":"p","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
elt73a/lab05/grupo-n/dht {"grupo":"n","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288}
elt73a/lab05/grupo-n/dht {"grupo":"n","seq":4,"t":24.5,"h":55.0,"uptime_ms":21288}
elt73a/lab05/grupo-n/dht {"grupo":"n","seq":5,"t":31.2,"h":48.0,"uptime_ms":26288}
elt73a/lab05/grupo-n/dht {"grupo":"n","seq":6,"t":31.2,"h":48.0,"uptime_ms":31288}
elt73a/lab05/grupo-n/dht {"grupo":"n","seq":7,"t":31.2,"h":48.0,"uptime_ms":36288}
P3: o que aparece se você assinar elt73a/lab05/+/dht (com + no lugar do grupo)?
E o que aconteceria se dois grupos esquecessem de trocar o GRUPO e ficassem ambos com a?
Publicacao MQTT periodica em JSON
git conferir src/main.cpp evidencias/t4-mqtt.txt
git add src/main.cpp evidencias/t4-mqtt.txt && git commit -m "T4: Publicacao MQTT periodica em JSON" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.
Parte 5 — Node-RED: receber e visualizar
Com o stack do Lab 05 rodando (Parte 1), abra o Node-RED em http://localhost:1880. Crie uma aba
nova chamada Lab 05 e monte:
- mqtt in "leituras DHT22"
- Server: novo broker
broker.hivemq.com, porta1883(o mesmo em que o ESP32 publica — não o Mosquitto local, que o Wokwi não alcança). - Topic:
elt73a/lab05/grupo-x/dht(seu grupo) · QoS0. - Output: a parsed JSON object — o texto do payload vira um objeto JavaScript.
- Server: novo broker
- debug "payload" → Output:
msg.payload. - debug "temperatura" → Output:
msg.payload.te marque node status (o valor aparece embaixo do nó, no próprio editor). - Deploy. Com o Wokwi rodando, o nó
mqtt indeve mostrar connected (verde) e o painel debug (ícone de inseto, à direita) recebe uma mensagem a cada 5 s.
Saída esperada no painel debug (uma mensagem, expandida):
29/09/2026, 18:40:12 node: payload
elt73a/lab05/grupo-x/dht : msg.payload : Object
▼ object
grupo: "a"
seq: 7
t: 24.5
h: 55
uptime_ms: 36288
Troque temporariamente o Output do mqtt in para a String e faça Deploy: o debug
passa a mostrar o payload entre aspas e o debug "temperatura" exibe undefined. Por quê?
(Volte para a parsed JSON object antes de continuar.)
Evidências:
- ├── 📂nodered
- └── 🔧flows-lab05.json👈 Criar Aqui
- └── 📂evidencias
- └── 📄t5-debug.txt👈 Criar Aqui
git conferir nodered/flows-lab05.json evidencias/t5-debug.txt
- No debug "payload", passe o mouse sobre 3 mensagens → ícone Copy value e cole cada
uma numa linha de
evidencias/t5-debug.txt:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
{"grupo":"a","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"a","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"a","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"b","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"b","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"b","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"c","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"c","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"c","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"d","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"d","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"d","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"e","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"e","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"e","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"f","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"f","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"f","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"g","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"g","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"g","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"h","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"h","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"h","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"i","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"i","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"i","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"j","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"j","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"j","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"k","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"k","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"k","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"l","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"l","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"l","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"m","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"m","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"m","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"x","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"x","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"x","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"p","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"p","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"p","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
{"grupo":"n","seq":7,"t":24.5,"h":55,"uptime_ms":36288}
{"grupo":"n","seq":8,"t":24.5,"h":55,"uptime_ms":41288}
{"grupo":"n","seq":9,"t":31.2,"h":48,"uptime_ms":46288}
- Selecione a aba Lab 05 → menu (☰) → Export → Current flow → JSON
formatado → Download. Salve como
nodered/flows-lab05.json.
Node-RED recebendo as leituras no debug
git conferir nodered/flows-lab05.json evidencias/t5-debug.txt
git add nodered/flows-lab05.json evidencias/t5-debug.txt && git commit -m "T5: Node-RED recebendo as leituras no debug" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T5.
Projeto integrador — status do nó com LWT
Quem olha o Node-RED não tem como saber se o ESP32 caiu ou só está entre duas leituras.
O MQTT resolve isso com o LWT (Last Will and Testament): ao conectar, o cliente deixa
com o broker uma mensagem-testamento; se a conexão cair sem um DISCONNECT educado, o
broker publica essa mensagem por ele.
Requisitos
- Firmware
- Novo tópico
elt73a/lab05/grupo-x/status. - Conectar com LWT: mensagem
offline, QoS 1, retida. - Logo após conectar, publicar
onlineretido no mesmo tópico.
- Novo tópico
- Node-RED
- Segundo mqtt in em
.../status(Output: a String) → debug com node status ligado — o nó mostraonline/offlineno editor. - Exporte o fluxo de novo por cima de
nodered/flows-lab05.json.
- Segundo mqtt in em
- Evidência — deixe um
mosquitto_subescutando o status, inicie a simulação, espere oonline, pare a simulação e espere ooffline; aí encerre com Ctrl+C:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-a/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-b/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-c/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-d/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-e/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-f/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-g/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-h/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-i/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-j/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-k/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-l/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-m/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-x/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-p/status' -v | tee /ev/t6-status.txt"
docker run --rm --init -v "%cd%\evidencias:/ev" eclipse-mosquitto:2 sh -c "mosquitto_sub -h broker.hivemq.com -t 'elt73a/lab05/grupo-n/status' -v | tee /ev/t6-status.txt"
Dicas de API
const char *TOPICO_STATUS = "elt73a/lab05/grupo-" GRUPO "/status";
// connect com LWT: (id, willTopic, willQos, willRetain, willMessage)
if (mqtt.connect(clientId, TOPICO_STATUS, 1, true, "offline")) {
mqtt.publish(TOPICO_STATUS, "online", true); // true = retida
}
Saída esperada:
elt73a/lab05/grupo-x/status offline
elt73a/lab05/grupo-x/status online
elt73a/lab05/grupo-x/status offline
A primeira linha pode ser offline ou online (ou nem aparecer): é a mensagem retida de
uma execução anterior, entregue assim que alguém assina o tópico.
P4: depois de parar a simulação, quanto tempo leva para aparecer offline? Há dois
caminhos: se a conexão TCP é fechada, o broker publica o testamento na hora; se ela só
fica muda (ex.: cabo/Wi-Fi caiu), ele espera 1,5 × keepalive — e o keepalive padrão do
PubSubClient é 15 s. Qual dos dois o Wokwi provocou? E o que muda se o firmware chamasse
mqtt.disconnect() antes de parar?
- ├── 📂nodered
- └── 🔧flows-lab05.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t6-status.txt👈 Criar Aqui
git conferir nodered/flows-lab05.json evidencias/t6-status.txt
Status do no com LWT
git conferir src/main.cpp nodered/flows-lab05.json evidencias/t6-status.txt
git add src/main.cpp nodered/flows-lab05.json evidencias/t6-status.txt && git commit -m "T6: Status do no com LWT" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T6.
Logout do seu ambiente dev, git e gh
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.