Laboratório 06
Checklist — SSD1306, MQTT nos dois sentidos, SQLite e dashboard
-
platformio.inicom Adafruit SSD1306 + GFX;diagram.jsoncom o OLED em SDA 21 / SCL 22 (T1) - Tela local desenhada só quando muda (
telaSuja), fora do callback do temporizador (T2) - Intervalo alterado por MQTT (
.../cmd/intervalo, 2–60 s) e tela espelhada em texto em.../oled(T3) - Node-RED grava cada leitura no SQLite (INSERT preparado) e consulta o banco por
inject(T4) - Dashboard: réplica do OLED, gauges, gráfico com histórico do SQLite e slider do intervalo (T5)
- Framebuffer do SSD1306 em
.../oled/fbdesenhado pixel a pixel no dashboard (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 15 · T3 20 · T4 20 · T5 15 ·
T6 20. O autograder normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Precisa do Docker Desktop aberto e do Python 3. Os comandos são para o Prompt de Comando (cmd) do Windows.
docker desktop start
Atenção: desligue tudo o que estiver rodando no Docker (outros LABs, outros projetos), para não haver conflito de portas nem falta de memória:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
Disciplina: ELT85B - IoT Industrial.
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-a"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-a"
2. Gere o LAB IoT do grupo em docker\lab06-a:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo a --sem-gitea --sem-microbin --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 lab06-a-nodered && (del /q "data\lab06-a\flows.json" "data\lab06-a\flows_cred.json" "data\lab06-a\.flows*.backup" 2>nul & docker compose start lab06-a-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-b"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-b"
2. Gere o LAB IoT do grupo em docker\lab06-b:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo b --sem-gitea --sem-microbin --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 lab06-b-nodered && (del /q "data\lab06-b\flows.json" "data\lab06-b\flows_cred.json" "data\lab06-b\.flows*.backup" 2>nul & docker compose start lab06-b-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-c"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-c"
2. Gere o LAB IoT do grupo em docker\lab06-c:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo c --sem-gitea --sem-microbin --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 lab06-c-nodered && (del /q "data\lab06-c\flows.json" "data\lab06-c\flows_cred.json" "data\lab06-c\.flows*.backup" 2>nul & docker compose start lab06-c-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-d"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-d"
2. Gere o LAB IoT do grupo em docker\lab06-d:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo d --sem-gitea --sem-microbin --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 lab06-d-nodered && (del /q "data\lab06-d\flows.json" "data\lab06-d\flows_cred.json" "data\lab06-d\.flows*.backup" 2>nul & docker compose start lab06-d-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-e"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-e"
2. Gere o LAB IoT do grupo em docker\lab06-e:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo e --sem-gitea --sem-microbin --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 lab06-e-nodered && (del /q "data\lab06-e\flows.json" "data\lab06-e\flows_cred.json" "data\lab06-e\.flows*.backup" 2>nul & docker compose start lab06-e-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-f"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-f"
2. Gere o LAB IoT do grupo em docker\lab06-f:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo f --sem-gitea --sem-microbin --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 lab06-f-nodered && (del /q "data\lab06-f\flows.json" "data\lab06-f\flows_cred.json" "data\lab06-f\.flows*.backup" 2>nul & docker compose start lab06-f-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-g"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-g"
2. Gere o LAB IoT do grupo em docker\lab06-g:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo g --sem-gitea --sem-microbin --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 lab06-g-nodered && (del /q "data\lab06-g\flows.json" "data\lab06-g\flows_cred.json" "data\lab06-g\.flows*.backup" 2>nul & docker compose start lab06-g-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-h"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-h"
2. Gere o LAB IoT do grupo em docker\lab06-h:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo h --sem-gitea --sem-microbin --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 lab06-h-nodered && (del /q "data\lab06-h\flows.json" "data\lab06-h\flows_cred.json" "data\lab06-h\.flows*.backup" 2>nul & docker compose start lab06-h-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-i"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-i"
2. Gere o LAB IoT do grupo em docker\lab06-i:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo i --sem-gitea --sem-microbin --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 lab06-i-nodered && (del /q "data\lab06-i\flows.json" "data\lab06-i\flows_cred.json" "data\lab06-i\.flows*.backup" 2>nul & docker compose start lab06-i-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-j"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-j"
2. Gere o LAB IoT do grupo em docker\lab06-j:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo j --sem-gitea --sem-microbin --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 lab06-j-nodered && (del /q "data\lab06-j\flows.json" "data\lab06-j\flows_cred.json" "data\lab06-j\.flows*.backup" 2>nul & docker compose start lab06-j-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-k"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-k"
2. Gere o LAB IoT do grupo em docker\lab06-k:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo k --sem-gitea --sem-microbin --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 lab06-k-nodered && (del /q "data\lab06-k\flows.json" "data\lab06-k\flows_cred.json" "data\lab06-k\.flows*.backup" 2>nul & docker compose start lab06-k-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-l"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-l"
2. Gere o LAB IoT do grupo em docker\lab06-l:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo l --sem-gitea --sem-microbin --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 lab06-l-nodered && (del /q "data\lab06-l\flows.json" "data\lab06-l\flows_cred.json" "data\lab06-l\.flows*.backup" 2>nul & docker compose start lab06-l-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-m"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-m"
2. Gere o LAB IoT do grupo em docker\lab06-m:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo m --sem-gitea --sem-microbin --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 lab06-m-nodered && (del /q "data\lab06-m\flows.json" "data\lab06-m\flows_cred.json" "data\lab06-m\.flows*.backup" 2>nul & docker compose start lab06-m-nodered))
1. Crie os atalhos (valem só nesta janela do cmd; abriu outra, rode de novo):
set "IOT_REPO=%USERPROFILE%\ELT85BN21\lab06-grupo-x"
set "IOT_GEN=%IOT_REPO%\docker\gen_iot_aluno.py"
set "IOT_DIR=%IOT_REPO%\docker\lab06-x"
2. Gere o LAB IoT do grupo em docker\lab06-x:
py "%IOT_GEN%" --disciplina elt85b --lab lab06 --grupo x --sem-gitea --sem-microbin --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 lab06-x-nodered && (del /q "data\lab06-x\flows.json" "data\lab06-x\flows_cred.json" "data\lab06-x\.flows*.backup" 2>nul & docker compose start lab06-x-nodered))
Outros comandos (credenciais, logs, atualizar, limpar paleta/FUXA, zerar tudo) na versão completa.
Esta aula continua o Lab 05: o mesmo nó de telemetria (DHT22 + Ticker + MQTT + LWT)
ganha um display OLED SSD1306. O MQTT passa a funcionar nos dois sentidos: o ESP32
publica as leituras e o conteúdo da tela, e o Node-RED manda comandos de volta, como o
intervalo de leitura. No Node-RED, as leituras são gravadas e consultadas no SQLite, e o
dashboard mostra a tela do OLED de duas formas: como texto e pixel a pixel, a
partir do framebuffer.
Objetivos
- Ligar um display SSD1306 (I2C) ao ESP32 e entender o framebuffer: o desenho acontece
na RAM, e só
display()envia os 1024 bytes pelo barramento. - Atualizar a tela só quando algo muda (flag
telaSuja), sem bloquear oloop(). - Usar MQTT nos dois sentidos: assinar um tópico de comando e mudar o intervalo do temporizador remotamente.
- No Node-RED, injetar (INSERT) e ler (SELECT) dados no SQLite, com statement preparado e validação do que chega do broker.
- Visualizar o SSD1306 no dashboard do Node-RED: réplica em texto (T5) e réplica fiel, pixel a pixel, a partir do framebuffer (T6).
Material
- VS Code + PlatformIO + extensão Wokwi (ESP32 simulado, sem placa física).
- O LAB IoT do
lab06-x(gerado pelogen_iot_aluno.py): nesta aula usamos o Node-RED, comnode-red-node-sqlitee o Dashboard 2.0 (@flowfuse/node-red-dashboard) já instalados na imagem. - Bibliotecas novas (baixadas pelo PlatformIO):
adafruit/Adafruit SSD1306eadafruit/Adafruit GFX Library. As do Lab 05 continuam.
O Wokwi simula o SSD1306 por I2C além do DHT22 e do Wi-Fi, então a aula roda inteira
nele. Numa placa física o firmware é o mesmo. Confira só o endereço I2C do seu módulo:
a maioria é 0x3C, alguns são 0x3D.
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/lab06-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-a/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-a.git && cd lab06-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-b/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-b.git && cd lab06-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-c/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-c.git && cd lab06-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-d/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-d.git && cd lab06-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-e/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-e.git && cd lab06-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-f/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-f.git && cd lab06-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-g/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-g.git && cd lab06-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-h/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-h.git && cd lab06-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-i/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-i.git && cd lab06-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-j/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-j.git && cd lab06-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-k/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-k.git && cd lab06-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-l/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-l.git && cd lab06-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-m/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-m.git && cd lab06-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-x/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-x.git && cd lab06-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-p/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-p.git && cd lab06-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab06-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab06-grupo-n/commits/main/
- Acessos: ACESSO-LAB06.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/lab06-grupo-n.git && cd lab06-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab06-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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- 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 06:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.
Mapa de tarefas — 6 tarefas · 100 pts
- T1 — Circuito e dependências do SSD1306 · 10 pts
- T2 — Tela local no OLED · 15 pts
- T3 — MQTT nos dois sentidos · 20 pts
- T4 — Node-RED gravando e consultando o SQLite · 20 pts
- T5 — Dashboard com a réplica do OLED · 15 pts
- T6 — Framebuffer pixel a pixel no dashboard · 20 pts
O repositório do grupo nasce do lab06-template, que já traz o firmware final do Lab 05
(com LWT) em src/main.cpp:
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-lab06.json👈 Criar Aqui
- ├── 📂evidencias
- ├── 📄t2-serial.txt👈 Criar Aqui
- ├── 📄t2-oled.png👈 Criar Aqui
- ├── 📄t3-mqtt.txt👈 Criar Aqui
- ├── 📄t4-sqlite.txt👈 Criar Aqui
- ├── 📄t5-dashboard.png👈 Criar Aqui
- ├── 📄t6-fb.txt👈 Criar Aqui
- └── 📄t6-oled.png👈 Criar Aqui
- └── 📝README.md👈 Edite Aqui
Tudo fica sob elt85b/lab06/grupo-X/. Troque o X (e o #define GRUPO) pela letra do seu grupo.
| Tópico | Sentido | Payload |
|---|---|---|
.../dht | ESP32 → broker | {"grupo":"a","seq":7,"t":24.5,"h":55.0,"uptime_ms":35210,"intervalo_s":5.0} |
.../status | ESP32 → broker | online / offline (retido, LWT) |
.../oled | ESP32 → broker | {"linhas":["LAB06 grupo a","T: 24.5 C", ...]} (T3) |
.../oled/fb | ESP32 → broker | 1024 bytes do framebuffer em base64 (T6) |
.../cmd/intervalo | broker → ESP32 | 10 (segundos, 2–60) |
Parte 1 — SSD1306 no circuito
1.1 Circuito no Wokwi
O SSD1306 do Wokwi (board-ssd1306) é um módulo I2C de 4 pinos: GND, VCC, SCL e
SDA. No ESP32, o I2C padrão usa GPIO21 = SDA e GPIO22 = SCL. Acrescente o display
ao diagram.json do Lab 05:
- └── 🔧diagram.json👈 Edite Aqui
git conferir diagram.json
{
"version": 1,
"author": "ELT85B - Lab 06",
"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" }
},
{
"type": "board-ssd1306",
"id": "oled1",
"top": 108.74,
"left": 172.23,
"attrs": { "i2cAddress": "0x3c" }
}
],
"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", []],
["oled1:VCC", "esp:3V3", "red", []],
["oled1:GND", "esp:GND.2", "black", []],
["oled1:SDA", "esp:21", "blue", []],
["oled1:SCL", "esp:22", "purple", []]
],
"dependencies": {}
}
1.2 Bibliotecas
- └── 🔧platformio.ini👈 Edite Aqui
git conferir platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
adafruit/DHT sensor library
adafruit/Adafruit Unified Sensor
knolleary/PubSubClient
adafruit/Adafruit SSD1306
adafruit/Adafruit GFX Library
A GFX é a biblioteca de desenho (texto, linhas, retângulos, círculos). A SSD1306 guarda o framebuffer e conversa com o controlador do display pelo I2C.
Circuito e dependências do SSD1306
git conferir platformio.ini diagram.json
git add platformio.ini diagram.json && git commit -m "T1: Circuito e dependências do SSD1306" && 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 — Tela local
2.1 Como o SSD1306 desenha
O display tem 128 × 64 pixels monocromáticos: 1 bit por pixel, 1024 bytes no total. A biblioteca guarda essa imagem num framebuffer na RAM do ESP32:
clearDisplay(),print(),drawRect(),fillRect()… só alteram a RAM. São rápidas e nada aparece ainda.display()envia os 1024 bytes pelo I2C para o controlador do display. Isso leva alguns milissegundos e só deve ser feito quando a imagem mudou.
Por isso usamos o mesmo padrão do temporizador do Lab 05: quem detecta a mudança só marca uma
flag, e o loop() redesenha.
2.2 Código
Acrescente ao firmware do Lab 05:
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_ADDR 0x3C
#define OLED_W 128
#define OLED_H 64
Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1); // -1 = sem pino de reset
float ultimaT = NAN, ultimaH = NAN; // última leitura válida (a tela mostra estes)
bool telaSuja = true; // redesenhar na próxima volta do loop()
// Quadradinho com letra: cheio = conectado, vazado = desconectado
void indicador(int x, const char *letra, bool ok) {
if (ok) {
oled.fillRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_BLACK);
} else {
oled.drawRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_WHITE);
}
oled.setCursor(x + 4, 1);
oled.print(letra);
oled.setTextColor(SSD1306_WHITE);
}
void desenharTela() {
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);
oled.setTextSize(1); // cabeçalho
oled.setCursor(0, 1);
oled.print("LAB06 grupo " GRUPO);
indicador(98, "W", WiFi.status() == WL_CONNECTED);
indicador(114, "M", mqtt.connected());
oled.drawFastHLine(0, 11, OLED_W, SSD1306_WHITE);
oled.setTextSize(2); // temperatura (fonte 12x16)
oled.setCursor(0, 16);
if (isnan(ultimaT)) oled.print("--.-");
else oled.printf("%4.1f", ultimaT);
oled.drawCircle(53, 18, 2, SSD1306_WHITE); // símbolo de grau
oled.setCursor(58, 16);
oled.print("C");
oled.setCursor(0, 36); // umidade + barra
if (isnan(ultimaH)) oled.print("--.-%");
else oled.printf("%4.1f%%", ultimaH);
oled.drawRect(72, 37, 56, 12, SSD1306_WHITE);
if (!isnan(ultimaH)) oled.fillRect(74, 39, (int)(52 * ultimaH / 100.0), 8, SSD1306_WHITE);
oled.setTextSize(1); // rodapé
oled.setCursor(0, 56);
oled.printf("seq %lu int %.0f s", (unsigned long)seq, INTERVALO_S);
oled.display(); // <- só aqui vai para o display
}
// em setup(), depois de dht.begin():
// Wire.begin(OLED_SDA, OLED_SCL);
// if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR))
// Serial.println("[OLED] SSD1306 nao encontrado - confira SDA/SCL/endereco");
// desenharTela();
//
// em lerEPublicar(), depois de validar t e h:
// ultimaT = t; ultimaH = h; telaSuja = true;
//
// no fim de loop():
// if (telaSuja) { telaSuja = false; desenharTela(); }
//
// em conectarMQTT(), logo depois do connect bem-sucedido:
// telaSuja = true; // o indicador "M" muda
Tela esperada depois da primeira leitura:
LAB06 grupo a [W] [M]
-------------------------------
24.5 °C
55.0% [██████████ ]
seq 1 int 5 s
As linhas de temperatura e umidade usam a fonte em tamanho 2 (12 × 16 px). [W] e [M]
aparecem cheios quando Wi-Fi e MQTT estão conectados.
- P1: por que
desenharTela()não pode ser chamada dentro deaoEstourarTemporizador()? E se ela fosse chamada em toda volta doloop(), sem a flagtelaSuja? Estime o tempo de umdisplay(): 1024 bytes a 400 kHz, com ~9 bits por byte no I2C. Pense no que acontece com omqtt.loop().
Anote as previsões e o que observou no README.md.
Evidências: salve o monitor serial com pelo menos 3 leituras em evidencias/t2-serial.txt
e uma captura do Wokwi com o display em evidencias/t2-oled.png.
- └── 📂evidencias
- ├── 📄t2-serial.txt👈 Criar Aqui
- └── 📄t2-oled.png👈 Criar Aqui
git conferir evidencias/t2-serial.txt evidencias/t2-oled.png
Tela local no OLED
git conferir src/main.cpp evidencias/t2-serial.txt evidencias/t2-oled.png
git add src/main.cpp evidencias/t2-serial.txt evidencias/t2-oled.png && git commit -m "T2: Tela local no OLED" && 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
Até aqui o ESP32 só publicava. Agora ele também assina um tópico de comando: o Node-RED (ou qualquer cliente) muda o intervalo de leitura sem regravar o firmware. E a cada redesenho o ESP32 publica o conteúdo da tela em texto, para o dashboard copiar.
3.1 O que muda
INTERVALO_Sdeixa de serconst: virafloat intervaloS, que o comando altera.- Callback
aoReceberMensagem(): o PubSubClient a chama dentro demqtt.loop(), ou seja, no contexto doloop(). Ali pode usarSeriale oTickerà vontade, ao contrário do callback do temporizador. - O payload não termina com
'\0': copie para um buffer e termine a string antes doatof(). - Valide o comando. O broker é público: qualquer pessoa pode publicar
0ouabcno seu tópico. - Client ID aleatório, como no Lab 05: no Wokwi, todos os ESP32 simulados têm o mesmo MAC (veja o aviso da T4 do Lab 05).
- Assine dentro de
conectarMQTT(): a sessão é limpa, então depois de uma reconexão o broker não lembra das assinaturas antigas. - O JSON das leituras ganha
intervalo_s, que confirma ao Node-RED o valor em uso.
3.2 Código completo até aqui
- └── 📂src
- └── 📄main.cpp👈 Edite Aqui
git conferir src/main.cpp
// ELT85B - Lab 06 (T3): DHT22 + SSD1306 + MQTT nos dois sentidos
#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <Ticker.h>
#include <DHT.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define GRUPO "a" // troque pela letra do seu grupo
#define DHT_PIN 15
#define DHT_TIPO DHT22
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_ADDR 0x3C
#define OLED_W 128
#define OLED_H 64
const char *WIFI_SSID = "Wokwi-GUEST";
const char *WIFI_SENHA = "";
const char *MQTT_HOST = "broker.hivemq.com";
const uint16_t MQTT_PORTA = 1883;
#define BASE "elt85b/lab06/grupo-" GRUPO
const char *TOPICO_DADOS = BASE "/dht";
const char *TOPICO_STATUS = BASE "/status";
const char *TOPICO_OLED = BASE "/oled"; // tela em texto (JSON)
const char *TOPICO_INTERVALO = BASE "/cmd/intervalo"; // Node-RED -> ESP32
DHT dht(DHT_PIN, DHT_TIPO);
Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
Ticker temporizador;
volatile bool leituraPendente = false;
float intervaloS = 5.0; // alterado por MQTT (2..60 s)
uint32_t seq = 0;
float ultimaT = NAN, ultimaH = NAN;
bool telaSuja = true; // redesenhar na próxima volta do loop()
char clientId[32];
void aoEstourarTemporizador() {
leituraPendente = true;
}
// ---------------------------------------------------------------------- OLED
void indicador(int x, const char *letra, bool ok) {
if (ok) {
oled.fillRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_BLACK);
} else {
oled.drawRect(x, 0, 13, 9, SSD1306_WHITE);
oled.setTextColor(SSD1306_WHITE);
}
oled.setCursor(x + 4, 1);
oled.print(letra);
oled.setTextColor(SSD1306_WHITE);
}
void desenharTela() {
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);
oled.setTextSize(1); // cabeçalho
oled.setCursor(0, 1);
oled.print("LAB06 grupo " GRUPO);
indicador(98, "W", WiFi.status() == WL_CONNECTED);
indicador(114, "M", mqtt.connected());
oled.drawFastHLine(0, 11, OLED_W, SSD1306_WHITE);
oled.setTextSize(2); // temperatura
oled.setCursor(0, 16);
if (isnan(ultimaT)) oled.print("--.-");
else oled.printf("%4.1f", ultimaT);
oled.drawCircle(53, 18, 2, SSD1306_WHITE); // símbolo de grau
oled.setCursor(58, 16);
oled.print("C");
oled.setCursor(0, 36); // umidade + barra
if (isnan(ultimaH)) oled.print("--.-%");
else oled.printf("%4.1f%%", ultimaH);
oled.drawRect(72, 37, 56, 12, SSD1306_WHITE);
if (!isnan(ultimaH)) oled.fillRect(74, 39, (int)(52 * ultimaH / 100.0), 8, SSD1306_WHITE);
oled.setTextSize(1); // rodapé
oled.setCursor(0, 56);
oled.printf("seq %lu int %.0f s", (unsigned long)seq, intervaloS);
oled.display();
}
// ------------------------------------------------------ espelho da tela (T3)
void publicarTelaTexto() {
char t[8] = "--.-", h[8] = "--.-"; // antes da 1ª leitura: sem número
if (!isnan(ultimaT)) snprintf(t, sizeof(t), "%.1f", ultimaT);
if (!isnan(ultimaH)) snprintf(h, sizeof(h), "%.1f", ultimaH);
char payload[200];
snprintf(payload, sizeof(payload),
"{\"linhas\":[\"LAB06 grupo %s\",\"T: %s C\",\"UR: %s %%\","
"\"seq %lu | %.0f s\",\"WiFi %s | MQTT %s\"]}",
GRUPO, t, h, (unsigned long)seq, intervaloS,
WiFi.status() == WL_CONNECTED ? "ok" : "--", mqtt.connected() ? "ok" : "--");
mqtt.publish(TOPICO_OLED, payload);
}
// ---------------------------------------------------------------- comandos
void aoReceberMensagem(char *topico, byte *payload, unsigned int tam) {
char txt[16];
size_t n = tam < sizeof(txt) - 1 ? tam : sizeof(txt) - 1;
memcpy(txt, payload, n);
txt[n] = '\0';
Serial.printf("[CMD] %s <- '%s'\r\n", topico, txt);
if (strcmp(topico, TOPICO_INTERVALO) == 0) {
float v = atof(txt);
if (v < 2.0 || v > 60.0) {
Serial.println("[CMD] intervalo fora de 2..60 s - ignorado");
return;
}
intervaloS = v;
temporizador.detach();
temporizador.attach(intervaloS, aoEstourarTemporizador);
Serial.printf("[CMD] novo intervalo: %.1f s\r\n", intervaloS);
telaSuja = true;
}
}
// ------------------------------------------------------------ Wi-Fi e MQTT
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, TOPICO_STATUS, 1, true, "offline")) {
Serial.println("ok");
mqtt.publish(TOPICO_STATUS, "online", true);
mqtt.subscribe(TOPICO_INTERVALO); // (re)assina a cada conexão
telaSuja = true;
} 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++;
ultimaT = t;
ultimaH = h;
char payload[160];
snprintf(payload, sizeof(payload),
"{\"grupo\":\"%s\",\"seq\":%lu,\"t\":%.1f,\"h\":%.1f,\"uptime_ms\":%lu,\"intervalo_s\":%.1f}",
GRUPO, (unsigned long)seq, t, h, (unsigned long)millis(), intervaloS);
bool ok = mqtt.publish(TOPICO_DADOS, payload);
Serial.printf("[PUB] %s %s -> %s\r\n", ok ? "ok" : "ERRO", TOPICO_DADOS, payload);
telaSuja = true;
}
void setup() {
Serial.begin(115200);
delay(200);
Serial.println("\r\n=== Lab 06 - DHT22 + SSD1306 + MQTT ===");
dht.begin();
Wire.begin(OLED_SDA, OLED_SCL);
if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
Serial.println("[OLED] SSD1306 nao encontrado - confira SDA/SCL/endereco");
}
desenharTela();
// sufixo aleatorio: no Wokwi, todos os ESP32 simulados tem o MESMO MAC
snprintf(clientId, sizeof(clientId), "lab06-%s-%04lX", GRUPO, (unsigned long)(esp_random() & 0xFFFF));
conectarWiFi();
mqtt.setServer(MQTT_HOST, MQTT_PORTA);
mqtt.setCallback(aoReceberMensagem);
conectarMQTT();
temporizador.attach(intervaloS, aoEstourarTemporizador);
}
void loop() {
if (WiFi.status() != WL_CONNECTED) conectarWiFi();
if (!mqtt.connected()) conectarMQTT();
mqtt.loop();
if (leituraPendente) {
leituraPendente = false;
lerEPublicar();
}
if (telaSuja) {
telaSuja = false;
desenharTela();
publicarTelaTexto();
}
}
3.3 Testando pelo terminal
Num terminal, assine todos os tópicos do grupo. Num segundo terminal, mande o comando:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-a/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-a/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-a/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-b/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-b/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-b/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-c/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-c/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-c/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-d/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-d/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-d/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-e/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-e/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-e/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-f/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-f/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-f/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-g/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-g/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-g/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-h/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-h/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-h/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-i/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-i/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-i/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-j/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-j/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-j/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-k/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-k/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-k/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-l/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-l/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-l/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-m/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-m/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-m/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-x/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-x/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-x/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-p/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-p/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-p/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
1. 1. Assinar:
docker run -d --name sub-lab06 eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-n/#" -v
docker logs -f sub-lab06
2. 2. Comandar:
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-n/cmd/intervalo" -m 10
docker run --rm eclipse-mosquitto mosquitto_pub -h broker.hivemq.com -t "elt85b/lab06/grupo-n/cmd/intervalo" -m 1
3. 3. Gravar e encerrar:
docker logs sub-lab06 > evidencias\t3-mqtt.txt 2>&1
type evidencias\t3-mqtt.txt
docker rm -f sub-lab06
Saída esperada (trecho; depois de umas 8 linhas, grave e encerre com o passo 3):
- └── 📂evidencias
- └── 📄t3-mqtt.txt👈 Criar Aqui
git conferir evidencias/t3-mqtt.txt
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-a/status online
elt85b/lab06/grupo-a/dht {"grupo":"a","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-a/oled {"linhas":["LAB06 grupo a","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-a/cmd/intervalo 10
elt85b/lab06/grupo-a/oled {"linhas":["LAB06 grupo a","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-a/dht {"grupo":"a","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-a/cmd/intervalo 1
elt85b/lab06/grupo-a/dht {"grupo":"a","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-b/status online
elt85b/lab06/grupo-b/dht {"grupo":"b","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-b/oled {"linhas":["LAB06 grupo b","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-b/cmd/intervalo 10
elt85b/lab06/grupo-b/oled {"linhas":["LAB06 grupo b","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-b/dht {"grupo":"b","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-b/cmd/intervalo 1
elt85b/lab06/grupo-b/dht {"grupo":"b","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-c/status online
elt85b/lab06/grupo-c/dht {"grupo":"c","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-c/oled {"linhas":["LAB06 grupo c","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-c/cmd/intervalo 10
elt85b/lab06/grupo-c/oled {"linhas":["LAB06 grupo c","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-c/dht {"grupo":"c","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-c/cmd/intervalo 1
elt85b/lab06/grupo-c/dht {"grupo":"c","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-d/status online
elt85b/lab06/grupo-d/dht {"grupo":"d","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-d/oled {"linhas":["LAB06 grupo d","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-d/cmd/intervalo 10
elt85b/lab06/grupo-d/oled {"linhas":["LAB06 grupo d","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-d/dht {"grupo":"d","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-d/cmd/intervalo 1
elt85b/lab06/grupo-d/dht {"grupo":"d","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-e/status online
elt85b/lab06/grupo-e/dht {"grupo":"e","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-e/oled {"linhas":["LAB06 grupo e","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-e/cmd/intervalo 10
elt85b/lab06/grupo-e/oled {"linhas":["LAB06 grupo e","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-e/dht {"grupo":"e","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-e/cmd/intervalo 1
elt85b/lab06/grupo-e/dht {"grupo":"e","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-f/status online
elt85b/lab06/grupo-f/dht {"grupo":"f","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-f/oled {"linhas":["LAB06 grupo f","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-f/cmd/intervalo 10
elt85b/lab06/grupo-f/oled {"linhas":["LAB06 grupo f","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-f/dht {"grupo":"f","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-f/cmd/intervalo 1
elt85b/lab06/grupo-f/dht {"grupo":"f","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-g/status online
elt85b/lab06/grupo-g/dht {"grupo":"g","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-g/oled {"linhas":["LAB06 grupo g","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-g/cmd/intervalo 10
elt85b/lab06/grupo-g/oled {"linhas":["LAB06 grupo g","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-g/dht {"grupo":"g","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-g/cmd/intervalo 1
elt85b/lab06/grupo-g/dht {"grupo":"g","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-h/status online
elt85b/lab06/grupo-h/dht {"grupo":"h","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-h/oled {"linhas":["LAB06 grupo h","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-h/cmd/intervalo 10
elt85b/lab06/grupo-h/oled {"linhas":["LAB06 grupo h","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-h/dht {"grupo":"h","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-h/cmd/intervalo 1
elt85b/lab06/grupo-h/dht {"grupo":"h","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-i/status online
elt85b/lab06/grupo-i/dht {"grupo":"i","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-i/oled {"linhas":["LAB06 grupo i","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-i/cmd/intervalo 10
elt85b/lab06/grupo-i/oled {"linhas":["LAB06 grupo i","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-i/dht {"grupo":"i","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-i/cmd/intervalo 1
elt85b/lab06/grupo-i/dht {"grupo":"i","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-j/status online
elt85b/lab06/grupo-j/dht {"grupo":"j","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-j/oled {"linhas":["LAB06 grupo j","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-j/cmd/intervalo 10
elt85b/lab06/grupo-j/oled {"linhas":["LAB06 grupo j","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-j/dht {"grupo":"j","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-j/cmd/intervalo 1
elt85b/lab06/grupo-j/dht {"grupo":"j","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-k/status online
elt85b/lab06/grupo-k/dht {"grupo":"k","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-k/oled {"linhas":["LAB06 grupo k","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-k/cmd/intervalo 10
elt85b/lab06/grupo-k/oled {"linhas":["LAB06 grupo k","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-k/dht {"grupo":"k","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-k/cmd/intervalo 1
elt85b/lab06/grupo-k/dht {"grupo":"k","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-l/status online
elt85b/lab06/grupo-l/dht {"grupo":"l","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-l/oled {"linhas":["LAB06 grupo l","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-l/cmd/intervalo 10
elt85b/lab06/grupo-l/oled {"linhas":["LAB06 grupo l","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-l/dht {"grupo":"l","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-l/cmd/intervalo 1
elt85b/lab06/grupo-l/dht {"grupo":"l","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-m/status online
elt85b/lab06/grupo-m/dht {"grupo":"m","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-m/oled {"linhas":["LAB06 grupo m","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-m/cmd/intervalo 10
elt85b/lab06/grupo-m/oled {"linhas":["LAB06 grupo m","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-m/dht {"grupo":"m","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-m/cmd/intervalo 1
elt85b/lab06/grupo-m/dht {"grupo":"m","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-x/status online
elt85b/lab06/grupo-x/dht {"grupo":"x","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-x/oled {"linhas":["LAB06 grupo x","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-x/cmd/intervalo 10
elt85b/lab06/grupo-x/oled {"linhas":["LAB06 grupo x","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-x/dht {"grupo":"x","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-x/cmd/intervalo 1
elt85b/lab06/grupo-x/dht {"grupo":"x","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-p/status online
elt85b/lab06/grupo-p/dht {"grupo":"p","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-p/oled {"linhas":["LAB06 grupo p","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-p/cmd/intervalo 10
elt85b/lab06/grupo-p/oled {"linhas":["LAB06 grupo p","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-p/dht {"grupo":"p","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-p/cmd/intervalo 1
elt85b/lab06/grupo-p/dht {"grupo":"p","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
1. Exemplo de Evidência de Saída:
elt85b/lab06/grupo-n/status online
elt85b/lab06/grupo-n/dht {"grupo":"n","seq":3,"t":24.5,"h":55.0,"uptime_ms":16288,"intervalo_s":5.0}
elt85b/lab06/grupo-n/oled {"linhas":["LAB06 grupo n","T: 24.5 C","UR: 55.0 %","seq 3 | 5 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-n/cmd/intervalo 10
elt85b/lab06/grupo-n/oled {"linhas":["LAB06 grupo n","T: 24.5 C","UR: 55.0 %","seq 3 | 10 s","WiFi ok | MQTT ok"]}
elt85b/lab06/grupo-n/dht {"grupo":"n","seq":4,"t":24.5,"h":55.0,"uptime_ms":26290,"intervalo_s":10.0}
elt85b/lab06/grupo-n/cmd/intervalo 1
elt85b/lab06/grupo-n/dht {"grupo":"n","seq":5,"t":24.5,"h":55.0,"uptime_ms":36290,"intervalo_s":10.0}
No monitor serial do Wokwi aparecem [CMD] novo intervalo: 10.0 s e, depois,
[CMD] intervalo fora de 2..60 s - ignorado.
P2: e se o comando fosse publicado com retain (mosquitto_pub -r)? O que acontece
quando o ESP32 reinicia? Isso é bom ou ruim para um "intervalo de configuração"? E se o
valor retido for inválido, como o 1? (Para apagar uma mensagem retida, publique um payload
vazio com -r -n.)
MQTT nos dois sentidos
git conferir src/main.cpp evidencias/t3-mqtt.txt
git add src/main.cpp evidencias/t3-mqtt.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 — Node-RED + SQLite
No Node-RED, crie uma aba Lab 06. As leituras que chegam pelo MQTT serão gravadas
(INSERT) num banco SQLite, e o banco será consultado (SELECT) por nós inject.
4.1 Banco e tabela
Os nós sqlite usam um nó de configuração sqlitedb: Database
/data/sqlite/lab06.sqlite, Mode Read-Write-Create. A pasta /data/sqlite já existe
na imagem do Node-RED do LAB IoT e fica no volume, então o banco sobrevive a um restart.
Crie um inject "Criar tabela" (Inject once after 0,5 s) com o SQL abaixo em msg.topic,
ligado a um sqlite com SQL Query Via msg.topic → debug:
CREATE TABLE IF NOT EXISTS leituras (
id INTEGER PRIMARY KEY AUTOINCREMENT,
recebido_em TEXT DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now', 'localtime')),
grupo TEXT NOT NULL,
seq INTEGER,
t REAL,
h REAL,
uptime_ms INTEGER,
intervalo_s REAL,
origem TEXT DEFAULT 'esp32' -- 'esp32' (MQTT) ou 'manual' (inject)
);
4.2 Gravar cada leitura (INSERT preparado)
-
mqtt in
elt85b/lab06/grupo-x/dht, Output a parsed JSON object, mesmo broker do Lab 05 (broker.hivemq.com:1883). -
function "valida e monta parâmetros":
function: valida e monta parâmetros// Leitura do ESP32 (ou injetada à mão) -> parâmetros do INSERT preparado.// Broker público: QUALQUER um pode publicar no seu tópico -> valide antes de gravar.const p = msg.payload;const num = (v) => typeof v === "number" && isFinite(v);if (!p ||typeof p !== "object" ||!num(p.t) ||!num(p.h) ||p.t < -40 ||p.t > 80 ||p.h < 0 ||p.h > 100) {node.warn("descartado (formato/faixa inválidos): " + JSON.stringify(p));return null;}msg.params = {$grupo: String(p.grupo ?? "?"),$seq: num(p.seq) ? p.seq : null,$t: p.t,$h: p.h,$uptime: num(p.uptime_ms) ? p.uptime_ms : null,$intervalo: num(p.intervalo_s) ? p.intervalo_s : null,$origem: msg.origem || "esp32",};node.status({fill: "green",shape: "dot",text: `seq ${p.seq}: ${p.t} °C ${p.h} %`,});return msg; -
sqlite "INSERT", SQL Query Prepared Statement:
sqlite: INSERT (prepared)INSERT INTO leituras (grupo, seq, t, h, uptime_ms, intervalo_s, origem)VALUES ($grupo, $seq, $t, $h, $uptime, $intervalo, $origem);
Montar o SQL concatenando strings, como em `INSERT ... VALUES (${p.t}, ...)`, funciona
até alguém publicar {"t":"0); DROP TABLE leituras; --"} no seu tópico público. No
statement preparado, os valores vão em msg.params e nunca viram código SQL.
4.3 Injetar uma leitura de teste
Injetar dados à mão é útil para testar o banco sem o ESP32. Crie um inject "Injetar leitura de teste" com duas propriedades:
msg.payload(JSON):{"grupo":"a","seq":0,"t":-12.3,"h":99.0,"uptime_ms":0,"intervalo_s":0}msg.origem(string):manual
Ligue-o à mesma function de validação. O dado de teste percorre o mesmo caminho de um dado
real, mas fica marcado como origem = 'manual'.
4.4 Consultas
Cada consulta é um inject com o SQL em msg.topic, ligado ao sqlite Via msg.topic → debug:
| inject | SQL |
|---|---|
| Últimas 10 leituras | SELECT id, recebido_em, seq, t, h, intervalo_s, origem FROM leituras ORDER BY id DESC LIMIT 10; |
| Apagar leituras manuais | DELETE FROM leituras WHERE origem = 'manual'; |
SELECT substr(recebido_em, 1, 16) AS minuto, COUNT(*) AS n, ROUND(AVG(t), 1) AS t_media,
MIN(t) AS t_min, MAX(t) AS t_max, ROUND(AVG(h), 1) AS h_media
FROM leituras WHERE origem = 'esp32'
GROUP BY minuto ORDER BY minuto DESC LIMIT 10;
SELECT recebido_em, anterior, seq,
CASE WHEN seq < anterior THEN 'ESP32 reiniciou'
ELSE (seq - anterior - 1) || ' perdida(s)' END AS diagnostico
FROM (SELECT recebido_em, seq, LAG(seq) OVER (ORDER BY id) AS anterior
FROM leituras WHERE origem = 'esp32')
WHERE seq <> anterior + 1;
SELECT seq, intervalo_s,
ROUND((julianday(recebido_em) - julianday(LAG(recebido_em) OVER (ORDER BY id))) * 86400, 1) AS dt_s
FROM leituras WHERE origem = 'esp32' ORDER BY id DESC LIMIT 10;
LAG() é uma função de janela: devolve o valor da linha anterior na ordem pedida.
É assim que o seq do Lab 05 vira diagnóstico: um salto indica mensagens perdidas, e um seq
menor que o anterior indica que o ESP32 reiniciou.
Saída esperada da consulta "Falhas na sequência", depois do experimento da P3:
▼ array[2]
▶ 0: { recebido_em: "2026-10-14 18:46:28.138", anterior: 106, seq: 113, diagnostico: "6 perdida(s)" }
▶ 1: { recebido_em: "2026-10-14 18:51:02.410", anterior: 131, seq: 1, diagnostico: "ESP32 reiniciou" }
P3: com o ESP32 rodando, pare o Node-RED por ~30 s (docker stop lab06-x-nodered) e
volte a ligá-lo (docker start lab06-x-nodered). O que a consulta "Falhas na sequência" mostra? Por que o broker não guardou
as leituras para você? Pense em QoS 0 e em sessão limpa. Depois reinicie a simulação do
Wokwi e rode a consulta de novo. Por fim, publique {"t":"quente"} e lixo no tópico .../dht
com mosquitto_pub: o que acontece em cada caso e em qual nó?
Evidências: copie do debug (ícone Copy value) a saída de "Últimas 10 leituras"
(com pelo menos uma linha manual), de "Falhas na sequência" e de "Intervalo real entre
leituras" (mostrando a troca de 5 s para 10 s) para evidencias/t4-sqlite.txt. Exporte a aba
Lab 06 em nodered/flows-lab06.json.
- ├── 📂nodered
- └── 🔧flows-lab06.json👈 Criar Aqui
- └── 📂evidencias
- └── 📄t4-sqlite.txt👈 Criar Aqui
git conferir nodered/flows-lab06.json evidencias/t4-sqlite.txt
Node-RED gravando e consultando o SQLite
git conferir nodered/flows-lab06.json evidencias/t4-sqlite.txt
git add nodered/flows-lab06.json evidencias/t4-sqlite.txt && git commit -m "T4: Node-RED gravando e consultando o SQLite" && 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 — Dashboard com a réplica do OLED
O Dashboard 2.0 já existe no LAB IoT (My Dashboard, em http://localhost/lab06-x/dashboard).
Crie nele uma página Lab 06 (caminho /lab06) com quatro grupos: Tela OLED
(SSD1306), Leituras, Histórico (SQLite) e ESP32.
5.1 Réplica do OLED em texto
mqtt in .../oled (a parsed JSON object) → ui-template (grupo Tela OLED, largura 3).
O ESP32 manda só o conteúdo, e o navegador desenha com a fonte dele:
<template>
<!-- Réplica em TEXTO: o ESP32 manda só o conteúdo (JSON) e o navegador desenha -->
<div class="oled-txt">
<div v-for="(l, i) in linhas" :key="i">{{ l }}</div>
</div>
</template>
<script>
export default {
computed: {
linhas() {
return this.msg?.payload?.linhas ?? ["(aguardando o ESP32...)"];
},
},
};
</script>
<style scoped>
.oled-txt {
background: #000;
color: #dff3ff;
font-family: "Courier New", monospace;
font-size: 14px;
line-height: 1.35;
padding: 10px 12px;
border-radius: 6px;
border: 6px solid #1c1c1c;
white-space: pre;
}
</style>
5.2 Leituras, gráfico e intervalo
mqtt in .../dht (JSON) → function "distribui" com 4 saídas:
// Uma leitura -> gauges, gráfico (ponto ao vivo) e slider do intervalo
const p = msg.payload;
if (typeof p?.t !== "number" || typeof p?.h !== "number") return null;
const agora = Date.now();
const ultimo = context.get("intervalo");
context.set("intervalo", p.intervalo_s);
return [
{ payload: p.t },
{ payload: p.h },
{
payload: [
{ ts: agora, serie: "T (°C)", valor: p.t },
{ ts: agora, serie: "UR (%)", valor: p.h },
],
},
// só atualiza o slider quando o ESP32 confirma um valor novo
ultimo === p.intervalo_s ? null : { payload: p.intervalo_s },
];
| Saída | Nó | Configuração |
|---|---|---|
| 1 | ui-gauge "Temperatura" | grupo Leituras, unidade °C, faixa −10 a 60 |
| 2 | ui-gauge "Umidade" | grupo Leituras, unidade %, faixa 0 a 100 |
| 3 | ui-chart | grupo Histórico, Line; Series = key serie; X = key ts (timescale); Y = key valor |
| 4 | ui-slider "Intervalo (s)" | grupo ESP32, 2 a 60, passo 1, Topic elt85b/lab06/grupo-x/cmd/intervalo, Output on release, pass-through desligado → mqtt out (tópico vazio: usa msg.topic) |
Com pass-through desligado, uma mensagem que chega no slider só move o cursor: ela
não sai pelo mqtt out. E a saída 4 só é emitida quando o intervalo_s confirmado pelo
ESP32 muda. Assim o slider mostra o valor em uso, e não só o último pedido.
5.3 Histórico vindo do SQLite
Ao fazer o Deploy, o gráfico começa vazio. Para ele já nascer com as últimas leituras do
banco, monte: inject (once, 2 s) → sqlite Fixed Statement
SELECT recebido_em, t, h FROM leituras WHERE origem = 'esp32' ORDER BY id DESC LIMIT 120;
→ function → o mesmo ui-chart:
// Linhas do SQLite -> pontos do gráfico (substitui o que havia)
const pontos = [];
for (const r of msg.payload.reverse()) {
// mais antigo primeiro
const ts = new Date(r.recebido_em.replace(" ", "T")).getTime();
pontos.push(
{ ts, serie: "T (°C)", valor: r.t },
{ ts, serie: "UR (%)", valor: r.h },
);
}
node.status({ text: `${msg.payload.length} leituras carregadas` });
return { payload: pontos, action: "replace" };
Complete com:
- inject a cada 10 s → sqlite Fixed Statement
SELECT strftime('%H:%M:%S', recebido_em) AS hora, seq, t, h, intervalo_s AS int_s, origem FROM leituras ORDER BY id DESC LIMIT 8;→ ui-table (colunas automáticas, action replace). - mqtt in
.../status(a String) → ui-text "ESP32" no grupo ESP32.
Abra http://localhost/lab06-x/dashboard/lab06, mova o slider para 10 s e confira:
- o rodapé do OLED no Wokwi e a réplica mudam para
int 10 s; - a tabela passa a mostrar
int_s = 10; - a consulta "Intervalo real entre leituras" passa a mostrar
dt_s ≈ 10.
Evidências: captura do dashboard em evidencias/t5-dashboard.png e o fluxo exportado de
novo em nodered/flows-lab06.json.
- ├── 📂nodered
- └── 🔧flows-lab06.json👈 Edite Aqui
- └── 📂evidencias
- └── 📄t5-dashboard.png👈 Criar Aqui
git conferir nodered/flows-lab06.json evidencias/t5-dashboard.png
Dashboard com a réplica do OLED
git conferir nodered/flows-lab06.json evidencias/t5-dashboard.png
git add nodered/flows-lab06.json evidencias/t5-dashboard.png && git commit -m "T5: Dashboard com a réplica do OLED" && 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 — framebuffer pixel a pixel
A réplica em texto da T5 não é a tela do ESP32. Ela não tem o grau desenhado com
drawCircle, a barra de umidade, os indicadores [W] [M] nem a fonte grande. Para ver
exatamente o que o display mostra, o ESP32 envia o próprio framebuffer: os 1024 bytes
que acabaram de ir para o SSD1306 pelo I2C.
Como os 1024 bytes estão organizados
O SSD1306 divide a tela em 8 páginas de 8 linhas. Cada byte é uma coluna de 8 pixels dentro de uma página, com o bit 0 em cima:
byte 0 .. 127 -> página 0 (linhas 0..7), um byte por coluna x = 0..127
byte 128 .. 255 -> página 1 (linhas 8..15)
...
byte 896 .. 1023 -> página 7 (linhas 56..63)
pixel (x, y) aceso <=> fb[(y / 8) * 128 + x] & (1 << (y % 8))
Como o MQTT/JSON é texto, os bytes viajam em base64: 3 bytes viram 4 caracteres, logo 1024 bytes viram 1368 caracteres.
Requisitos
- Firmware
- Novo tópico
elt85b/lab06/grupo-X/oled/fb. - Depois de cada
desenharTela(), codificaroled.getBuffer()(1024 bytes) em base64 e publicar nesse tópico. - Aumentar o buffer do PubSubClient, que por padrão tem 256 bytes.
- Novo tópico
- Node-RED
- mqtt in
.../oled/fb(Output: a String) → ui-template no grupo Tela OLED, ao lado da réplica em texto, que desenha os pixels num<canvas>(escala 3: 384 × 192 px). - Exporte o fluxo de novo por cima de
nodered/flows-lab06.json.
- mqtt in
- Evidências
evidencias/t6-oled.png: Wokwi e dashboard lado a lado, mostrando a mesma tela.evidencias/t6-fb.txt: tamanho de uma mensagem do framebuffer, pelo terminal:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-a/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-b/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-c/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-d/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-e/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-f/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-g/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-h/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-i/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-j/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-k/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-l/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-m/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-x/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-p/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
docker run --rm eclipse-mosquitto mosquitto_sub -h broker.hivemq.com -t "elt85b/lab06/grupo-n/oled/fb" -C 1 > fb.tmp
for %A in (fb.tmp) do @echo %~zA bytes> evidencias\t6-fb.txt
del fb.tmp
type evidencias\t6-fb.txt
1369 bytes
São 1368 caracteres base64 mais a quebra de linha que o mosquitto_sub acrescenta. O %~zA do
for é o tamanho do arquivo em bytes; o fb.tmp é apagado em seguida.
Dicas de API
#include "mbedtls/base64.h" // já vem com o core do ESP32
const char *TOPICO_OLED_FB = BASE "/oled/fb";
void publicarFramebuffer() {
static unsigned char b64[1400]; // 1368 + '\0' (static: fora da pilha)
size_t n = 0;
mbedtls_base64_encode(b64, sizeof(b64), &n, oled.getBuffer(), OLED_W * OLED_H / 8);
if (!mqtt.publish(TOPICO_OLED_FB, b64, n, false))
Serial.println("[FB] publish falhou: aumente mqtt.setBufferSize()");
}
// em setup(), antes de conectarMQTT():
// mqtt.setBufferSize(1600); // cabeçalho + tópico + 1368 de payload
<template>
<div class="fb-wrap">
<canvas ref="tela" width="384" height="192" class="oled-fb"></canvas>
</div>
</template>
<script>
export default {
watch: {
msg() {
this.desenhar();
},
}, // roda a cada mensagem nova
mounted() {
this.desenhar();
}, // e quando a página abre
methods: {
desenhar() {
const b64 = this.msg?.payload;
if (typeof b64 !== "string" || !this.$refs.tela) return;
const fb = atob(b64); // string com 1024 "bytes": fb.charCodeAt(i)
const ctx = this.$refs.tela.getContext("2d");
// 1) pinte tudo de preto
// 2) para cada página (0..7), coluna x (0..127) e bit (0..7):
// se o bit estiver aceso, pinte um quadrado 3x3 em (x*3, (pagina*8 + bit)*3)
},
},
};
</script>
<style scoped>
.oled-fb {
display: block;
width: 100%;
max-width: 384px;
aspect-ratio: 2 / 1;
image-rendering: pixelated;
background: #000;
border: 6px solid #1c1c1c;
border-radius: 6px;
}
</style>
P4: quantos bytes cada atualização da tela custa no broker em cada versão: texto (.../oled)
× framebuffer (.../oled/fb)? Qual das duas o Node-RED conseguiria gravar no SQLite e
consultar com SQL, e qual mostra fielmente o que o usuário vê no display? O que
aconteceria se você esquecesse o setBufferSize()? Onde isso apareceria: no serial, no broker
ou no dashboard?
- ├── 📂src
- └── 📄main.cpp👈 Edite Aqui
- ├── 📂nodered
- └── 🔧flows-lab06.json👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t6-fb.txt👈 Criar Aqui
- └── 📄t6-oled.png👈 Criar Aqui
git conferir src/main.cpp nodered/flows-lab06.json evidencias/t6-fb.txt evidencias/t6-oled.png
Framebuffer pixel a pixel no dashboard
git conferir src/main.cpp nodered/flows-lab06.json evidencias/t6-fb.txt evidencias/t6-oled.png
git add src/main.cpp nodered/flows-lab06.json evidencias/t6-fb.txt evidencias/t6-oled.png && git commit -m "T6: Framebuffer pixel a pixel no dashboard" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T6.
Logout do seu ambiente dev, git e gh
Para o git "esquecer" suas informações salvas:
git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
Antes de sair, faça logout para não deixar sua conta do GitHub ativa nesta máquina. Rode os comandos abaixo no Prompt de Comando (cmd), não no PowerShell.
1. Apague a credencial do GitHub salva pelo git, encerre a sessão do gh e remova seu nome e e-mail da configuração global:
(echo protocol=https&echo host=github.com) | git credential reject
gh auth logout --hostname github.com
git config --global --unset user.name
git config --global --unset user.email
Para conferir, este comando não deve mostrar nada:
cmdkey /list | findstr /i github
2. Pare os containers do lab:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
3. No navegador, saia da sua conta em github.com e feche todas as janelas.